8月32日の島

大二下計算機結構

Mon, 13 Jul 2026 00:00:00 GMT

第一章：程式效能解析與底層硬體邏輯#

1. 效能的定義與度量 (Performance)#

核心觀念辨析#

指標	定義	適用情境	改善手段
Response Time	電腦完成單一任務所需的總時間（從開始到結束）。	個人電腦、行動裝置、嵌入式系統。	提升處理器主頻、優化編譯器、改善演算法。
Throughput	電腦在單位時間內所能完成的任務總量。	資料中心、雲端伺服器、網路設備。	增加處理器核心數、引進硬體平行處理技術。

程式翻譯與抽象化層次 (Abstraction)#

高階語言 (High-Level Language)：如 C, C++, Java。人類易讀，具備高抽象度。
編譯器 (Compiler)：負責將高階語言翻譯成特定架構的組合語言 (Assembly Language)（如 RISC-V, x86）。
組譯器 (Assembler)：將組合語言翻譯成硬體唯一能讀懂的目的碼/機器語言 (Machine Language)（由二進位 0 與 1 組成）。
指令集架構 (ISA, Instruction Set Architecture)：軟體與硬體之間的底層合約介面。它定義了硬體支援的指令、暫存器個數、定址模式與資料型態，使軟體開發者與硬體設計師能各自獨立優化。

2. 計算機效能 (Performance Equations)#

效能公式#

CPU Execution Time=Instruction Count (IC)×CPI×Clock Cycle Time (Tc)\text{CPU Execution Time} = \text{Instruction Count (IC)} \times \text{CPI} \times \text{Clock Cycle Time } (T_c)CPU Execution Time=Instruction Count (IC)×CPI×Clock Cycle Time (Tc)

CPU Execution Time=Instruction Count (IC)×CPIClock Rate (f)\text{CPU Execution Time} = \frac{\text{Instruction Count (IC)} \times \text{CPI}}{\text{Clock Rate } (f)}CPU Execution Time=Clock Rate (f)Instruction Count (IC)×CPI

一、指令總數 (Instruction Count, IC)#

定義：執行完某個特定程式，CPU 總共需要執行的機械碼（機器指令）總條數。
物理意義：代表該任務的工作量大小。
決定因素：主要由軟體層面決定，包含演算法效率、原始碼寫法、程式語言特性，以及編譯器（Compiler）的優化能力。

二、每條指令平均週期數 (Cycles Per Instruction, CPI)#

定義：程式執行期間，平均每執行一條硬體指令所需要消耗的時脈週期（Clock Cycle）數量。
物理意義：反映了硬體架構執行指令的效率。
計算特性：因為不同的指令（例如整數加法與浮點數除法）其複雜度與所需週期大不相同，工程實務上必須採用加權平均法計算：平均 CPI=∑i=1n(該指令型態所需的 CPIi×該指令在程式中所佔的比例i)\text{平均 CPI} = \sum_{i=1}^{n} (\text{該指令型態所需的 CPI}_i \times \text{該指令在程式中所佔的比例}_i)平均 CPI=∑i=1n(該指令型態所需的 CPIi×該指令在程式中所佔的比例i)
決定因素：主要由指令集架構（ISA）與處理器的微架構（Microarchitecture，如管線化、快取記憶體設計、超純量等）決定。

三、時脈週期時間 (Clock Cycle Time, TcT_cTc)#

定義：處理器內部時鐘（振盪器）每跳動一下（一個電位脈衝）所花費的實際時間，通常以奈秒（nsnsns, 10−910^{-9}10−9 秒）或皮秒（pspsps, 10−1210^{-12}10−12 秒）為單位。
物理意義：代表 CPU 執行最基本硬體動作的最小時間單位（節拍）。

四、時脈頻率 / 主頻 (Clock Rate, fff)#

定義：處理器內部的時鐘在單位時間（通常為一秒）內跳動的次數，單位為赫茲（Hz），目前主流處理器多以吉赫茲（GHz, 10910^9109 Hz）度量。
物理意義與關係：時脈頻率 fff 與時脈週期時間 TcT_cTc 互為倒數關係。 f=1Tcf = \frac{1}{T_c}f=Tc1 例如：若 Tc=0.2 nsT_c = 0.2 \text{ ns}Tc=0.2 ns，則其時脈頻率 f=10.2×10−9=5×109 Hz=5 GHzf = \frac{1}{0.2 \times 10^{-9}} = 5 \times 10^9 \text{ Hz} = 5 \text{ GHz}f=0.2×10−91=5×109 Hz=5 GHz。
決定因素：由硬體電路設計、流水線切分的深度，以及半導體晶圓製程（如 3nm, 2nm 工藝）共同決定。

影響因素對照表#

下表呈現了軟硬體各層面對於效能鐵三角中三大因子的牽制關係：

影響層面	指令總數 (IC)	平均每條指令週期數 (CPI)	時脈頻率 / 週期時間 (fff / TcT_cTc)
演算法 (Algorithm)	主導影響	間接影響	無影響
程式語言 (Programming Language)	主導影響	間接影響	無影響
編譯器 (Compiler)	顯著影響	顯著影響	無影響
指令集架構 (ISA)	決定性定義	顯著影響	顯著影響
硬體微架構 (Microarchitecture)	無影響	主導影響	顯著影響
半導體製程 (IC Fabrication)	無影響	無影響	決定性影響

💡 提示 考試常見的「架構二選一」或「優化方案評估」題型，解題核心在於分別算出變更前後的 CPU 執行時間（ToldT_{\text{old}}Told 與 TnewT_{\text{new}}Tnew），再透過相除求得加速比（Speedup=ToldTnew\text{Speedup} = \frac{T_{\text{old}}}{T_{\text{new}}}Speedup=TnewTold）。切記不要只偏看單一因子的進步。

3. 動態功耗公式與功耗牆 (Power Wall)#

動態功耗公式#

Powerdynamic=Capacitive Load×Voltage2×Frequency\text{Power}_{\text{dynamic}} = \text{Capacitive Load} \times \text{Voltage}^2 \times \text{Frequency}Powerdynamic=Capacitive Load×Voltage2×Frequency

功耗牆 (Power Wall) 的成因與轉折#

成因：在過往，工程師透過提高工作頻率（Frequency）來壓榨單核心效能。然而，頻率上升迫使晶片發熱量劇增。若想壓低功耗，就必須降低電壓（Voltage）。但當電壓降至接近臨界值時，晶片會產生嚴重的靜態漏電流（Leakage Current）。
結果：電壓無法再降，導致工作頻率無法再往上突破，此物理限制稱為「功耗牆」。
對策：微處理器設計從「拉高單核心頻率」轉向「單一晶片內建多核心 (Multicore)」，透過並行處理（Parallelism）在較低頻率下獲取更高的吞吐量。

4. 阿姆達爾定律 (Amdahl’s Law)#

整體加速比公式#

Speedupoverall=1(1−F)+FS\text{Speedup}_{\text{overall}} = \frac{1}{(1 - F) + \frac{F}{S}}Speedupoverall=(1−F)+SF1

FFF (Fraction Enhanced)：程式中可以被特定優化手段加速的部分所佔的時間比例（0≤F≤10 \le F \le 10≤F≤1）。
SSS (Speedup Enhanced)：該特定優化部分自身獲得的效能提升倍率。
(1−F)(1 - F)(1−F)：程式中無法被優化、必須維持循序（Sequential）執行的瓶頸部分。

物理啟示#

系統整體的效能提升上限，受到「不可並行/不可優化」部分的嚴重制約。
當投入無限硬體資源使得該局部優化倍率趨近於無限大（S→∞S \to \inftyS→∞）時，整體的最大加速比極限為： lim⁡S→∞Speedupoverall=11−F\lim_{S \to \infty} \text{Speedup}_{\text{overall}} = \frac{1}{1-F}limS→∞Speedupoverall=1−F1

📝 實戰演練：局部加速與整體降頻#

經典考題：某處理器的浮點數運算佔總程式執行時間的 60%。你開發了一套新的硬體加速器，能讓浮點數運算變快 4 倍，但為了散熱，不得不將處理器的整體時脈頻率 (Clock Rate) 降低 10%。

請計算整個程式最終的 Speedup 是多少？

這個改良方案值得採用嗎？

【解析】#

最終整體 Speedup=純架構優化 Speedup (阿姆達爾定律)×時脈頻率變動率\text{最終整體 Speedup} = \text{純架構優化 Speedup (阿姆達爾定律)} \times \text{時脈頻率變動率}最終整體 Speedup=純架構優化 Speedup (阿姆達爾定律)×時脈頻率變動率

第一步：套用阿姆達爾定律，計算「純架構優化」的倍率 根據題目條件，提取公式參數：

可被優化的比例 F=60%=0.6F = 60\% = 0.6F=60%=0.6
該局部的加速倍率 S=4S = 4S=4

代入阿姆達爾定律公式，求出若在「頻率不變」的前提下，單靠加速器帶來的架構內在加速比：純架構 Speedup=1(1−F)+FS=1(1−0.6)+0.64=10.4+0.15=10.55\text{純架構 Speedup} = \frac{1}{(1 - F) + \frac{F}{S}} = \frac{1}{(1 - 0.6) + \frac{0.6}{4}} = \frac{1}{0.4 + 0.15} = \frac{1}{0.55}純架構 Speedup=(1−F)+SF1=(1−0.6)+40.61=0.4+0.151=0.551

第二步：乘上「整體降頻 10%」的修正因子 時脈頻率（Clock Rate）降低 10%，代表新頻率變為原來的 90%90\%90%（即 0.90.90.9 倍）。因為效能與頻率成正比，頻率變慢會對效能帶來 0.90.90.9 倍的無差別懲罰，故將第一步的結果乘以頻率變動率：

最終整體 Speedup=純架構 Speedup×新頻率比例\text{最終整體 Speedup} = \text{純架構 Speedup} \times \text{新頻率比例}最終整體 Speedup=純架構 Speedup×新頻率比例最終整體 Speedup=10.55×0.9=0.90.55=1811≈1.64 倍\text{最終整體 Speedup} = \frac{1}{0.55} \times 0.9 = \frac{0.9}{0.55} = \frac{18}{11} \approx \mathbf{1.64 \text{ 倍}}最終整體 Speedup=0.551×0.9=0.550.9=1118≈1.64 倍

5. 補充#

時間與頻率單位換算：
- 頻率單位：1 GHz=103 MHz=109 Hz1\text{ GHz} = 10^3\text{ MHz} = 10^9\text{ Hz}1 GHz=103 MHz=109 Hz
- 時間單位：1 ms=10−3 s1\text{ ms} = 10^{-3}\text{ s}1 ms=10−3 s，1 μs=10−6 s1\text{ }\mu\text{s} = 10^{-6}\text{ s}1 μs=10−6 s，1 ns=10−9 s1\text{ ns} = 10^{-9}\text{ s}1 ns=10−9 s，1 ps=10−12 s1\text{ ps} = 10^{-12}\text{ s}1 ps=10−12 s
- 核心公式：實際執行時間 (秒)=總時脈週期數時脈頻率 (Hz)\text{實際執行時間 (秒)} = \frac{\text{總時脈週期數}}{\text{時脈頻率 (Hz)}}實際執行時間 (秒)=時脈頻率 (Hz)總時脈週期數
CPI 平均計算（考題常客）：題目若給出各類指令的數量或百分比，務必使用加權平均法計算出該程式的「平均 CPI」，再代入效能鐵三角公式。
MIPS 指標的缺陷： MIPS（Millions of Instructions Per Second，每秒百萬條指令數）不能單獨作為評估兩台電腦效能的依據。因為 MIPS 忽略了指令總數（IC）的差異；不同的指令集架構跑同一個程式時需要的指令數不同，MIPS 高不代表執行時間短。
阿姆達爾定律變形題（多處優化）：若考題同時對多個獨立區塊進行硬體優化，分母應擴充為所有區塊的加總： Speedupoverall=1(1−F1−F2−… )+F1S1+F2S2+…\text{Speedup}_{\text{overall}} = \frac{1}{(1 - F_1 - F_2 - \dots) + \frac{F_1}{S_1} + \frac{F_2}{S_2} + \dots}Speedupoverall=(1−F1−F2−…)+S1F1+S2F2+…1 注意：若優化伴隨著「整體硬體降頻」，必須在計算完上述架構優化時間後，再將時間除以頻率變動率（如降頻 10% 則時間乘以 10.9\frac{1}{0.9}0.91）。

第二章：MIPS 和指令集架構 (ISA)#

1. 指令集基礎與算術運算#

知識點 1：計算機架構定義與設計原則#

觀念與公式#

核心公式： Architecture=ISA+Machine Organization\text{Architecture} = \text{ISA} + \text{Machine Organization}Architecture=ISA+Machine Organization
ISA (指令集架構)： 硬體與軟體的「合約」。規定了暫存器、指令格式、定址模式。
Organization (機組組織)： 硬體的「實現」。例如 Pipeline 長度、Cache 大小。
設計原則 1： Simplicity favors regularity\text{Simplicity favors regularity}Simplicity favors regularity (簡單源於規律性)。為了讓硬體解碼變快，MIPS 堅持指令格式必須整齊。

實戰演練#

Q：Intel i9 與 AMD Ryzen 設計不同，為何能跑同一個執行檔？ A：因為它們擁有相同的 ISA (x86-64)，即硬體接口合約相同；但它們的內部 Organization (微架構) 不同，所以效能表現有異。

知識點 2：MIPS 算術指令與語法#

觀念與公式#

語法規矩： op dst, src1, src2 (1 個操作碼，3 個運算元)。
硬體限制： 即使 C 語言寫 f = g + h + i，MIPS 也必須拆成兩行。

實戰演練#

Q：將 f = (g + h) - (i + j) 翻譯為 MIPS。 Step-by-step：

add $t0, $s1, $s2 # t0=g+ht0 = g + ht0=g+h

add $t1, $s3, $s4 # t1=i+jt1 = i + jt1=i+j

sub $s0, $t0, $t1 # f=t0−t1f = t0 - t1f=t0−t1

⚠️ 考前避坑指南：第 1 節#

陷阱： 指令順序。永遠是 目的地 在最前面，來源 在後面。
區分： 相同 ISA 的 CPU 執行結果一定一樣，但「執行時間」不一定一樣（因為 Organization 不同）。

2. 記憶體運算元 (Data Transfer)#

知識點 1：位址計算與 Byte Addressing#

觀念與公式#

門牌邏輯： MIPS 是 Byte-addressable。1 個 Word = 4 Bytes。
對齊限制 (Alignment)： Word 的地址必須是 4 的倍數。
陣列偏移公式： Effective Address=Base Register+(Index×Element Size)\text{Effective Address} = \text{Base Register} + (\text{Index} \times \text{Element Size})Effective Address=Base Register+(Index×Element Size)

實戰演練#

Q：int Arr[7]，其 Base Address 在 $s0 = 0x10008000。求 Arr[7] 的實際地址與 lw 指令。 Step-by-step：

Offset=7×4=28\text{Offset} = 7 \times 4 = 28Offset=7×4=28 (十進位)。

將 28 轉為十六進位：28=1×16+12 ⟹ 0x1C28 = 1 \times 16 + 12 \implies 0x1C28=1×16+12⟹0x1C。

實際位址=0x10008000+0x1C=0x1000801C\text{實際位址} = 0x10008000 + 0x1C = 0x1000801C實際位址=0x10008000+0x1C=0x1000801C。

指令：lw $t0, 28($s0)。

知識點 2：資料傳輸指令 lw / sw#

觀念與公式#

lw (Load Word)：Memory →\rightarrow→ Register。
sw (Store Word)：Register →\rightarrow→ Memory。
記憶口訣： lw 目的地在暫存器；sw 目的地在括號裡的記憶體。

實戰演練#

Q：翻譯 A[6] = B[3] + h; (s0=A,s1=B,s2=hs0=A, s1=B, s2=hs0=A,s1=B,s2=h) Step-by-step：

lw $t0, 12($s1) # 讀取 B[3]B[3]B[3] (3×4=123 \times 4 = 123×4=12)

add $t0, $t0, $s2 # B[3]+hB[3] + hB[3]+h

sw $t0, 24($s0) # 寫回 A[6]A[6]A[6] (6×4=246 \times 4 = 246×4=24)

⚠️ 考前避坑指南：第 2 節#

致命陷阱： 十進位與十六進位混淆。地址計算時，記得把 Offset (十進位) 轉成 Hex 再加。
對齊錯誤： lw $t0, 3($s2) 會報錯，因為地址 3 不是 4 的倍數。

3. 指令格式與機器碼編譯#

知識點 1：R-Format 與 I-Format#

觀念與公式#

R-Format (暫存器型)： 用於 add, sub, and 等。 [op:6 | rs:5 | rt:5 | rd:5 | shamt:5 | funct:6]
I-Format (立即值型)： 用於 addi, lw, sw, beq 等。 [op:6 | rs:5 | rt:5 | immediate:16]
暫存器編號： $t0–$t7 = 8–15，$s0–$s7 = 16–23。

實戰演練#

Q：將 sub $s1, $t2, $t0 轉為 Hex。(s1=17,t2=10,t0=8,op=0,funct=34s1=17, t2=10, t0=8, op=0, funct=34s1=17,t2=10,t0=8,op=0,funct=34) Step-by-step：

op=0, rs=10, rt=8, rd=17, shamt=0, funct=34

二進位：000000 01010 01000 10001 00000 100010

合併：0000 0001 0100 1000 1000 1000 0010 0010

Hex：0x01488822

⚠️ 考前避坑指南：第 3 節#

格式陷阱： 組語寫 add rd, rs, rt，但機器碼欄位是 rs, rt, rd。目的地被挪到後面了！
長度陷阱： I-format 的 immediate 只有 16 bits，範圍是 -32768 ∼\sim∼ 32767。

4. 控制流 (Branch & Jump)#

知識點 1：條件跳躍與 PC-Relative 定址#

觀念與公式#

硬體設計： 分支指令使用「相對位址」以節省空間。
核心公式： Target Address=(PC+4)+(Offset×4)\text{Target Address} = (\text{PC} + 4) + (\text{Offset} \times 4)Target Address=(PC+4)+(Offset×4)
計算 Offset 公式： Offset=Target−(PC+4)4\text{Offset} = \frac{\text{Target} - (\text{PC} + 4)}{4}Offset=4Target−(PC+4)

實戰演練#

Q：bne $t0, $zero, Loop 位於 0x40，Loop 位於 0x20。求 Offset。 Step-by-step：

PC=0x40\text{PC} = 0x40PC=0x40，PC+4=0x44\text{PC} + 4 = 0x44PC+4=0x44。

位址差=0x20−0x44=−0x24\text{位址差} = 0x20 - 0x44 = -0x24位址差=0x20−0x44=−0x24 (即十進位 -36)。

Offset=−36/4=−9\text{Offset} = -36 / 4 = -9Offset=−36/4=−9。

知識點 2：Loop 與 If-Else 最佳化#

觀念與公式#

反向邏輯： 為了跳過 code 塊，通常使用「相反的條件」來跳轉。

實戰演練#

Q：將 if (i != j) f = g + h; 優化。 A：
1
beq $s3, $s4, Exit  # 若 i == j (反向條件) 則跳過
2
add $s0, $s1, $s2   # f = g + h
3
Exit:

⚠️ 考前避坑指南：第 4 節#

最大盲點： 忘了 +4。Offset 是相對於「下一條指令」的距離！
方向： 往回跳 (Loop) 的 Offset 必為負數；往下跳 (If) 為正數。

5. 副程式與堆疊管理 (Stack)#

知識點 1：函數呼叫契約 (jal / jr)#

觀念與公式#

jal (Jump and Link)：存下回家的路到 $ra 並跳轉。
jr $ra (Jump Register)：讀取 $ra 飛回家。
暫存器約定： $a0–$a3 傳參數；$v0–$v1 傳回傳值。
J-Format (跳躍型)：** 用於無條件長距離跳躍 j (Jump) 與 jal (Jump and Link)。 [op:6 | target address:26]

知識點 2：堆疊操作 (Push / Pop)#

觀念與公式#

Stack 特性： 往 低位址 (Low Address) 生長。
Push (存檔)： addi $sp, $sp, -4 接著 sw。
Pop (還原)： lw 接著 addi $sp, $sp, 4。

實戰演練 (遞迴/非葉函數)#

Q：翻譯 res = func(a); return res + b; (a=$a0, b=$a1) A：

1
addi $sp, $sp, -8   # 騰空間
2
sw   $ra, 4($sp)    # 存 $ra (必存，因為 jal 會蓋掉它)
3
sw   $a1, 0($sp)    # 存 $a1 (因呼叫函數可能會弄髒它)
4
jal  func
5
lw   $a1, 0($sp)    # 還原 b
6
lw   $ra, 4($sp)    # 還原回家地址
7
addi $sp, $sp, 8    # 歸還空間
8
add  $v0, $v0, $a1  # res + b
9
jr   $ra

⚠️ 考前避坑指南：第 5 節#

致命失分： 呼叫別的函數前沒存 $ra。沒存 $ra 的遞迴會變成無限死迴圈。
基底： 存取 Stack 永遠是用 0($sp)、4($sp)，基底暫存器絕對是 $sp。

6. 大常數與定址模式#

知識點 1：32-bit 常數載入 (lui / ori)#

觀念與公式#

兩步走： lui 載入高 16 位，ori 載入低 16 位。

實戰演練#

Q：載入 0x12345678。 A：

lui $s0, 0x1234 # $s0 = 0x12340000

ori $s0, $s0, 0x5678 # $s0 = 0x12345678

知識點 2：五大定址模式總結#

模式	意義	範例
Immediate	資料在指令裡	`addi`
Register	資料在暫存器	`add`
Base	Reg+Offset\text{Reg} + \text{Offset}Reg+Offset	`lw`, `sw`
PC-Relative	(PC+4)+(Offset×4)(\text{PC}+4) + (\text{Offset} \times 4)(PC+4)+(Offset×4)	`beq`, `bne`
Pseudodirect	PC高4位∥(指令26位≪2)\text{PC高4位} \parallel (\text{指令26位} \ll 2)PC高4位∥(指令26位≪2)	`j`, `jal`

7. 程式生命週期 (Translation)#

核心流程與結構#

觀念與公式#

流程： C→CompilerASM→AssemblerObject→LinkerExec→LoaderMemory\text{C} \xrightarrow{\text{Compiler}} \text{ASM} \xrightarrow{\text{Assembler}} \text{Object} \xrightarrow{\text{Linker}} \text{Exec} \xrightarrow{\text{Loader}} \text{Memory}CCompilerASMAssemblerObjectLinkerExecLoaderMemory
Object Module 包含： Header, Text (Code), Data, Relocation Info, Symbol Table, Debug Info.

實戰演練#

Q：外部函數的名稱存放在哪？何時修正地址？ A：名稱存放在 Symbol Table；由 Linker 在 Relocation 階段修正地址。

⚠️ 考前避坑指南：第 7 節#

排序陷阱： 先 Link (連結別人的 code) 產生 Exec，才能被 Load (載入) 到記憶體。
Relocation： 只有絕對地址需要 Relocation，相對地址 (beq) 不需 Linker 修正。

第三章：計算機算術與底層運算邏輯 (Computer Arithmetic)#

1. ALU 設計與基本算術運算#

核心觀念與公式#

ALU 基礎設計：算術邏輯單元 (ALU) 是 CPU 的計算大腦。為了支援多種運算 (Add, Sub, AND, OR, NOR, SLT)，硬體設計採用「分而治之 (Divide and Conquer)」策略，先設計 1-bit ALU，再串聯成 32-bit ALU。
減法實作訣竅 (2’s Complement)：利用「取補數加一」將減法轉換為加法。硬體上會將 B 輸入反轉 (Bnegate)，並將最低位的進位輸入設為 1 (Cin=1C_{in} = 1Cin=1)。

A−B=A+B′+1A - B = A + B' + 1A−B=A+B′+1

溢位偵測 (Overflow Detection)：當兩個「同號」數字相加，結果卻出現「異號」時即發生溢位。硬體判斷公式為最高位元的進位輸入與進位輸出做 XOR：

Overflow=Cin[N−1]⊕Cout[N−1]\text{Overflow} = C_{in}[N-1] \oplus C_{out}[N-1]Overflow=Cin[N−1]⊕Cout[N−1]

零偵測 (Zero Detection)：將 ALU 輸出的所有 32 個位元接上一個巨大的 NOR Gate。只有全為 0 時才輸出 1（支援分支指令 beq）。

📝 實戰演練：判斷運算是否發生溢位 (Overflow)#

經典考題：給定 4-bit 系統，範圍為 −8∼7-8 \sim 7−8∼7，請計算 7+37 + 37+3 與 −4−5-4 - 5−4−5，並判斷硬體如何抓出溢位？

【解析】#

第一步：計算 7+37 + 37+3

二進位：011120111_201112 (7) + 001120011_200112 (3)
運算過程：相加後得到 101021010_210102。
判定：正數加正數，符號位變成 1（負數，數值為 -6），發生溢位！
硬體檢驗：最高位 (MSB) 的 Cin=1C_{in} = 1Cin=1，Cout=0C_{out} = 0Cout=0。1⊕0=11 \oplus 0 = 11⊕0=1 (Overflow 成立)。

第二步：計算 −4−5-4 - 5−4−5

二進位：110021100_211002 (-4) + 101121011_210112 (-5)
運算過程：相加得到 (1)01112(1)0111_2(1)01112。
判定：負數加負數，符號位變成 0（正數，數值為 7），發生溢位！
硬體檢驗：最高位 (MSB) 的 Cin=0C_{in} = 0Cin=0，Cout=1C_{out} = 1Cout=1。0⊕1=10 \oplus 1 = 10⊕1=1 (Overflow 成立)。

2. 快速加法器 (Fast Adders - CLA)#

核心觀念與公式#

直觀意義：傳統的漣波進位加法器 (Ripple Carry Adder) 必須等前一個位元算出進位 (CoutC_{out}Cout) 才能算下一個，延遲太高（O(N)O(N)O(N)）。前瞻進位加法器 (Carry Look-ahead Adder, CLA) 透過數學展開，讓各個位元的進位可以「同時/提早」算出來。
產生進位 (Generate)：該位元本身相加就會產生進位。

gi=Ai⋅Big_i = A_i \cdot B_igi=Ai⋅Bi

傳遞進位 (Propagate)：只要有低位的進位送上來，該位元就能幫忙傳遞下去。

pi=Ai+Bi(或 Ai⊕Bi)p_i = A_i + B_i \quad \text{(或 } A_i \oplus B_i \text{)}pi=Ai+Bi(或 Ai⊕Bi)

進位計算通式：

Ci+1=gi+pi⋅CiC_{i+1} = g_i + p_i \cdot C_iCi+1=gi+pi⋅Ci

📝 實戰演練：展開 CLA 的進位方程式#

經典考題：請利用 gig_igi 與 pip_ipi 寫出 C1,C2,C3C_1, C_2, C_3C1,C2,C3 的前瞻進位邏輯方程式，並說明其物理意義。

【解析】#

第一階 (C1C_1C1)：C1=g0+(p0⋅C0)C_1 = g_0 + (p_0 \cdot C_0)C1=g0+(p0⋅C0)
第二階 (C2C_2C2)：將 C1C_1C1 帶入 C2=g1+p1⋅C1C_2 = g_1 + p_1 \cdot C_1C2=g1+p1⋅C1

展開得：C2=g1+(p1⋅g0)+(p1⋅p0⋅C0)C_2 = g_1 + (p_1 \cdot g_0) + (p_1 \cdot p_0 \cdot C_0)C2=g1+(p1⋅g0)+(p1⋅p0⋅C0)

第三階 (C3C_3C3)：將 C2C_2C2 帶入 C3=g2+p2⋅C2C_3 = g_2 + p_2 \cdot C_2C3=g2+p2⋅C2

展開得：C3=g2+(p2⋅g1)+(p2⋅p1⋅g0)+(p2⋅p1⋅p0⋅C0)C_3 = g_2 + (p_2 \cdot g_1) + (p_2 \cdot p_1 \cdot g_0) + (p_2 \cdot p_1 \cdot p_0 \cdot C_0)C3=g2+(p2⋅g1)+(p2⋅p1⋅g0)+(p2⋅p1⋅p0⋅C0)

物理意義：C3C_3C3 會產生 1，代表要麼是在 Bit 2 產生進位 (g2g_2g2)；要麼是在 Bit 1 產生並由 Bit 2 傳遞 (p2⋅g1p_2 \cdot g_1p2⋅g1)；或者是更低階產生並一路暢通傳遞上來。所有因子都不依賴先前的 Carry 結果，可以直接從 A 與 B 的輸入訊號平行算出！

3. 乘法器與 Booth’s Algorithm#

核心觀念與操作規則#

直觀意義：二進位乘法本質上就是「判斷是否要加上被乘數」再「平移」。為了節省硬體，我們將一開始的 64-bit ALU 縮減為 32-bit ALU，並把「乘數」塞進「乘積 (Product)」暫存器的右半邊。
Booth’s Algorithm (有號數乘法捷徑)：遇到一長串的 1（例如 011112=1501111_2 = 15011112=15），與其做四次加法，不如把它當作 100002−00001210000_2 - 00001_2100002−000012 (16 - 1)，只需一次減法與一次加法。
算術右移 (Arithmetic Right Shift)：運算後，Product 暫存器必須做算術右移，也就是保留符號位。

Booth 操作規則表（觀察當前位元 xix_ixi 與右側位元 xi−1x_{i-1}xi−1）：

當前位元 (xix_ixi)	右側位元 (xi−1x_{i-1}xi−1)	區段狀態	執行動作
`0`	`0`	連續 0 區段的中央	不做事 (None)
`0`	`1`	連續 1 區段的結束	加被乘數 (Add)
`1`	`0`	連續 1 區段的開始	減被乘數 (Sub)
`1`	`1`	連續 1 區段的中央	不做事 (None)

image

📝 實戰演練：Booth’s Algorithm 實作#

經典考題：使用 Booth 演算法計算 2×(−3)2 \times (-3)2×(−3)。已知被乘數 (Multiplicand) 為 001020010_200102 (2)，乘數 (Multiplier) 為 110121101_211012 (-3)。

【解析】#

被乘數 M=00102M = 0010_2M=00102 (2)，−M=11102-M = 1110_2−M=11102 (-2)。 初始狀態：左半部補 0，右半部放乘數，最右方補一個隱藏位元 0 →\to→ 0000 1101 0。

Step 1：看末兩位 10 →\to→ 代表 1 的開始，執行減法 (加上 −M-M−M)。

左半部 0000 + 1110 = 1110 →\to→ Product 變為 1110 1101 0。
算術右移 1 bit →\to→ 1111 0110 1。

Step 2：看末兩位 01 →\to→ 代表 1 的結束，執行加法 (加上 MMM)。

左半部 1111 + 0010 = 0001 →\to→ Product 變為 0001 0110 1。
算術右移 1 bit →\to→ 0000 1011 0。

Step 3：看末兩位 10 →\to→ 執行減法 (加上 −M-M−M)。

左半部 0000 + 1110 = 1110 →\to→ Product 變為 1110 1011 0。
算術右移 1 bit →\to→ 1111 0101 1。

Step 4：看末兩位 11 →\to→ 不做事 (None)。

算術右移 1 bit →\to→ 1111 1010 1。

結論：結束循環，捨棄最後一個隱藏位元。最終答案前 8 bits 為 1111 1010，轉換為十進位即為 −6-6−6。完全正確！

4. 除法器演算法 (Division Algorithm)#

核心觀念與演算法#

直觀意義：除法硬體是將「被除數」放在 Remainder（餘數暫存器）中，不斷往左位移，試圖去減掉 Divisor（除數）。減得過，商數補 1；減不過，商數補 0，並把減掉的加回來（Restore）。
最佳化版本硬體 (Version 2)：只需要 32-bit ALU 與 32-bit 除數暫存器。商數與餘數共用一個 64-bit 的 Remainder 暫存器（隨著左移，右邊空出來的位元剛好用來放 Quotient 商數）。
image

📝 實戰演練：除法器最佳化演算法 (Version 2)#

經典考題：以無號數除法計算 7÷27 \div 27÷2 (即 01112/001020111_2 / 0010_201112/00102)，請追蹤 Remainder 暫存器前兩步的變化。

【解析】#

初始狀態：Divisor = 0010，Remainder = 0000 0111。

Iteration 1:

Remainder 左移 1 bit →\to→ 0000 1110。
左半部減去 Divisor (0000 - 0010 = 1110，小於 0) →\to→ 1110 1110。
發現小於 0：還原 (Restore) 加回 0010，變成 0000 1110，然後左移並將最低位置 0 (實際上是將 LSB 設為 0) →\to→ 0001 1100。

Iteration 2:

若減完 ≥0\ge 0≥0，就不須還原，且把商的位元設為 1 (依此類推)。
最終 Remainder 的左半部是真餘數 0001 (1)，右半部是商數 0011 (3)。

5. 浮點數 IEEE 754 格式#

核心觀念與結構#

直觀意義：浮點數就像是二進位版的「科學記號」，用來儲存極大、極小或小數。

IEEE 754 單精度 (Single Precision, 32-bit) 結構

欄位	位元數	定義與功能
Sign (S)	1-bit	0 為正，1 為負。
Exponent (E)	8-bit	表示指數。採用「偏差值 (Biased)」表示法，Bias = 127。實際指數 y=E−127y = E - 127y=E−127。
Significand (F)	23-bit	小數點後的值。為了省空間，對於正規劃數字，預設小數點前面必定有一個隱藏的 `1.`。

還原公式：

Value=(−1)S×(1.F)2×2(E−127)\text{Value} = (-1)^S \times (1.F)_2 \times 2^{(E - 127)}Value=(−1)S×(1.F)2×2(E−127)

📝 實戰演練：十進位轉 IEEE 754 浮點數#

經典考題一 (基礎)：將十進位 −0.75-0.75−0.75 轉換為單精度 IEEE 754 格式。

【解析】#

Sign：負數，所以 S=1S = 1S=1。
轉換為二進位科學記號：

0.75×2=1.50.75 \times 2 = 1.50.75×2=1.5 (取 1)
0.5×2=1.00.5 \times 2 = 1.00.5×2=1.0 (取 1)
科學記號表示法：−0.112×20=−1.12×2−1-0.11_2 \times 2^0 = -1.1_2 \times 2^{-1}−0.112×20=−1.12×2−1 (正規化，將 1 移到小數點前)

計算 Exponent：

實際指數為 −1-1−1。加上 Bias 127：E=−1+127=126E = -1 + 127 = 126E=−1+127=126。
126 的二進位：0111 1110。

計算 Fraction (Significand)：

取小數點後面的部分：1。補滿 23 bits：100 0000 0000 0000 0000 0000。

組合：1 01111110 10000000000000000000000。

經典考題二 (進階)：將無限循環小數 1/31/31/3 轉換為單精度 IEEE 754 格式。

【解析】#

1/3=0.333333101/3 = 0.333333_{10}1/3=0.33333310。不斷乘以 2 取整數部分，得到二進位小數為 0.01010101...20.01010101..._20.01010101...2。
正規化：0.010101...×20=1.010101...×2−20.010101... \times 2^0 = 1.010101... \times 2^{-2}0.010101...×20=1.010101...×2−2。
S=0S = 0S=0。
E=−2+127=12510=011111012E = -2 + 127 = 125_{10} = 0111 1101_2E=−2+127=12510=011111012。
Fraction = 0101 0101 0101 0101 0101 010 (截斷至 23 位)。

6. 浮點數的極限與運算#

特殊數值與運算步驟#

特殊數值 (Special Numbers) 辨析表

數值類型	Exponent (E)	Fraction (F)	意義與用途
0	`0`	`0`	包含 +0+0+0 與 −0-0−0。
Denorm	`0`	≠0\neq 0=0	非正規化數。用於表示極小的數字，無隱藏的 `1.`，公式為 0.F×2−1260.F \times 2^{-126}0.F×2−126。
Infinity (∞\infty∞)	`255`	`0`	用來表示除以零等極端狀況。
NaN	`255`	≠0\neq 0=0	Not a Number。例如 0/00/00/0 或 −4\sqrt{-4}−4。

浮點數加法步驟：

對齊小數點：將指數較小的數字向右移，使其指數與較大的數字相同。
尾數相加：Mantissa 相加。
正規化結果：並檢查 Overflow / Underflow。
捨入 (Rounding)：必要時再次正規化。

📝 實戰演練：浮點數加法流程#

經典考題：計算 1.0002×2−1+(−1.1102×2−2)1.000_2 \times 2^{-1} + (-1.110_2 \times 2^{-2})1.0002×2−1+(−1.1102×2−2)，也就是十進位的 0.5+(−0.4375)0.5 + (-0.4375)0.5+(−0.4375)。

【解析】#

對齊小數點 (Align binary points)： −1>−2-1 > -2−1>−2，所以要把較小的數字的指數變成 −1-1−1。 −1.1102×2−2-1.110_2 \times 2^{-2}−1.1102×2−2 右移變成 −0.1112×2−1-0.111_2 \times 2^{-1}−0.1112×2−1。
尾數相加 (Add mantissa)： 1.0002+(−0.1112)=0.00121.000_2 + (-0.111_2) = 0.001_21.0002+(−0.1112)=0.0012。目前結果為 0.0012×2−10.001_2 \times 2^{-1}0.0012×2−1。
正規化 (Normalize)：向左移 3 位，指數減 3：1.0002×2−41.000_2 \times 2^{-4}1.0002×2−4。沒有 Over/Underflow。
捨入 (Rounding)： 1.0002×2−41.000_2 \times 2^{-4}1.0002×2−4 不需更改。此即十進位的 0.06250.06250.0625 (0.5−0.4375=0.06250.5 - 0.4375 = 0.06250.5−0.4375=0.0625)，正確。

7. 補充#

溢位 (Overflow) 與進位 (Carry) 絕對不能混為一談：無號數 (Unsigned) 看的是 CoutC_{out}Cout；有號數 (2’s Complement) 看的是 Cin⊕CoutC_{in} \oplus C_{out}Cin⊕Cout。兩個負數相加產生 CoutC_{out}Cout 不代表溢位，除非符號變正。
Booth’s Algorithm 的陷阱：在算術右移 (Arithmetic Right Shift) 時，最高位元(MSB) 必須複製保留自己原本的符號位，千萬不要補 0！另外，初始值最右邊補上的隱含位元固定為 0，第一回合比較一定是看「乘數的 LSB」與「這個補上的 0」。
IEEE 754 偏置 (Biased) 的意義：指數欄位不是使用 2 的補數表示法！使用 Biased 表示是為了讓浮點數能夠像一般整數一樣，直接用原本的 Integer ALU 進行大小比對，硬體設計更簡單。
浮點數運算「不具」結合律 (Not Associative)：程式考題常愛問 (x+y)+z(x + y) + z(x+y)+z 是否等於 x+(y+z)x + (y + z)x+(y+z)？答案是否！因為非常大的數字加非常小的數字（如 1.5×1038+1.01.5 \times 10^{38} + 1.01.5×1038+1.0）時，小的數字在對齊小數點右移時會直接被捨去。順序不同，捨去誤差就不同。
減法器設計細節：將 ALU 轉為減法模式時，控制訊號不能只翻轉 B (Bnegate)，一定要記得把 CinC_{in}Cin 設為 1 (完成二的補數中 “+1” 的動作)，這是考題最常挖洞漏寫的點。

第四章：單週期處理器設計與控制邏輯#

1. 處理器設計的五大核心步驟與時脈準則#

核心觀念辨析#

生活比喻 / 直觀意義：設計一個處理器就像蓋一座全自動化工廠。

首先要調查這座工廠要生產什麼產品（分析指令集，看支援哪些運算）。
決定工廠內部的基本機器與「工作節拍的標準」（選擇元件與建立時脈準則）。
將機器用水管、傳送帶連接起來（組裝資料路徑）。
調查每種產品生產時哪些閥門要開、哪些開關要關（分析每條指令的控制點）。
建造一間中央控制室自動控管這些開關（組裝控制邏輯）。

必背核心步驟（五部曲）：

Analyze instruction set：分析指令集，透過暫存器轉換（Register Transfers）定義指令含意。
Select components & Establish clocking methodology：選擇資料路徑元件，建立時脈控制方法。
Assemble datapath：組裝符合暫存器轉換需求的資料路徑。
Analyze control points：分析每條指令的執行，決定控制信號的設定值。
Assemble the control logic：組裝整體的控制邏輯（包含 Main Control 與 Local Control）。

時脈準則（Clocking Methodology）口訣： 🗣️ 「同一個週期內：邊緣讀出、路徑運算、邊緣寫回，絕不打結！」訊號在一條路徑上由狀態元件（如暫存器）出發，經過組合邏輯電路轉換，最後在下一個時脈上升緣（Clock Edge）存入另一個（或同一個）狀態元件。單週期不允許出現單一週期內部的硬體邏輯無窮回授（No feedback within a single cycle）。

📝 實戰演練：訊號衝突與時序行為#

經典考題 1：(段考常考頻率：⭐⭐⭐) 在單週期處理器中，若某暫存器 R1R_1R1 在同一個時脈週期內，既被讀取（Read）其數值，又將運算後的新結果寫回（Write）同一暫存器 R1R_1R1，這是否會造成訊號衝突或產生內部的邏輯無窮迴圈？請詳述原因。

【解析】#

Step 1（核心觀念）：這在單週期架構下是完全允許且不會造成衝突的。
Step 2（時序行為）：單週期架構採用的是邊緣觸發（Edge-triggered）機制。當一個時脈週期的上升緣到達時，暫存器 R1R_1R1 內部原本穩定的舊資料會被讀出到輸出端線路上。接著，這個舊資料會通過外部的組合邏輯電路（如 ALU）進行運算，並在該時脈週期中持續往後傳遞，最後到達暫存器 R1R_1R1 的輸入端。此時，輸入端的新資料只要在下一個時脈上升緣到來之前保持穩定，就會在下一個上升緣被鎖存（Write）進暫存器中。
Step 3（結論）：由於讀出的是「舊值」，寫入的是「新值」，且寫入動作要等到週期末端的下一個時脈邊緣才會發生，因此在同一個時脈週期內，讀出後又寫回同一個暫存器並不會造成干擾或回授。

💡 補充變化考法 若考試改問「若是電平觸發（Level-sensitive）而不是邊緣觸發會發生什麼事？」答案是：暫存器在整個高電平期間皆具備穿透性，只要時脈訊號一直維持在高電平，輸出與輸入就會產生不間斷的即時回授，導致訊號進入無法預測的震盪與數據破壞狀態。

2. 基本硬體元件與狀態更新邏輯 (組合 vs 序向)#

物理意義與直觀辨析#

組合邏輯元件 (Combinational Elements)：就像「算盤」或「沒有記憶的水管」。你輸入什麼，它就立刻根據功能輸出什麼，輸出只跟目前的輸入有關，不保存任何過去的痕跡。
序向 / 狀態元件 (Sequential / State Elements)：就像「筆記本」或「蓄水池」。它們可以鎖住並存儲資訊，輸出與過去儲存的狀態有關。狀態元件的更新必須由時脈訊號（Clock Signal）來控制主導。

核心元件分類與時脈依賴表#

元件名稱	類型	讀寫控制與時脈依賴度
AND 閘 / 加法器 (Adder)	組合邏輯	無時脈，隨輸入改變而立刻改變輸出。
多工器 (MUX) / ALU	組合邏輯	無時脈，依據選擇訊號/控制碼決定輸出。
暫存器 (Register)	序向邏輯	邊緣觸發。若有 Write Enable 訊號，當其為 1 且時脈邊緣觸發時才更新。
暫存器檔案 (Register File)	混合結構	讀取 (Read)：如同組合邏輯（給予暫存器編號即刻輸出資料）。
記憶體 (Ideal Memory)	混合結構	讀取：如同組合邏輯（給定地址，經過存取時間後直接輸出，無需讀取控制）。

📝 實戰演練：暫存器檔案讀寫機制#

經典考題 2：(段考常考頻率：⭐⭐⭐⭐) 關於 MIPS 的暫存器檔案（Register File），下列敘述何者正確？ (A) 讀取暫存器與寫入暫存器皆需要在時脈邊緣觸發。 (B) 讀取暫存器不依賴時脈，其行為如同組合邏輯電路；寫入則需要時脈邊緣配合寫入使能（Write Enable）。 [C] 暫存器檔案擁有兩個 32-bit 的輸入埠以及一個 32-bit 的輸出埠。 (D) 當寫入使能訊號為 0 時，暫存器的輸出會變為 0。

【解析】#

(A) 錯誤：讀取時如同組合邏輯行為，給定編號即輸出，不需要時脈邊緣觸發。
(B) 正確：讀取是組合電路行為，寫入必須在時脈邊緣抵達且 Write Enable = 1 時才會發生。
[C] 錯誤：擁有兩個 32-bit 的輸出埠（busA, busB）以及一個 32-bit 的輸入埠（busW）。
(D) 錯誤：當 Write Enable = 0 時，暫存器內數值保持不變，輸出端依然輸出原本鎖存的內容，不會變成 0。
答案：選 (B)

💡 補充變化考法 考試常結合微架構圖問：「記憶體（Memory）的 Read 控制訊號在單週期中是否為必須？」答案是：在理想單週期中，記憶體讀取被視為組合邏輯，傳入有效 Address 後 Data Out 隨後即有效，因此不需要讀取控制訊號（No need for read control）。

3. 指令集微架構分析與資料路徑 (Datapath) 的組裝#

直觀物理意義#

資料路徑是指令在 CPU 內部跑動的「物理軌道」。必須為每種類型的指令規劃專屬軌道，並利用多工器（MUX）切換，避免訊號直接接在一起而打架。

MIPS 指令格式與暫存器轉換公式統整#

R-Type (如 add, sub, and, or, slt)

格式：op(6) | rs(5) | rt(5) | rd(5) | shamt(5) | funct(6)
暫存器轉換：

R[rd]←R[rs] op R[rt];PC←PC+4R[\text{rd}] \leftarrow R[\text{rs}] \text{ op } R[\text{rt}]; \quad \text{PC} \leftarrow \text{PC} + 4R[rd]←R[rs] op R[rt];PC←PC+4

I-Type - Load (lw rt, rs, imm16)

格式：op(6) | rs(5) | rt(5) | immediate(16)
暫存器轉換：

R[rt]←Mem[R[rs]+SignExt(imm16)];PC←PC+4R[\text{rt}] \leftarrow \text{Mem}[R[\text{rs}] + \text{SignExt}(\text{imm16})]; \quad \text{PC} \leftarrow \text{PC} + 4R[rt]←Mem[R[rs]+SignExt(imm16)];PC←PC+4

I-Type - Store (sw rt, rs, imm16)

格式：op(6) | rs(5) | rt(5) | immediate(16)
暫存器轉換：

Mem[R[rs]+SignExt(imm16)]←R[rt];PC←PC+4\text{Mem}[R[\text{rs}] + \text{SignExt}(\text{imm16})] \leftarrow R[\text{rt}]; \quad \text{PC} \leftarrow \text{PC} + 4Mem[R[rs]+SignExt(imm16)]←R[rt];PC←PC+4

I-Type - Branch (beq rs, rt, imm16)

暫存器轉換：

if (R[rs]==R[rt])PC←(PC+4)+(SignExt(imm16)×4)elsePC←PC+4\text{if } (R[\text{rs}] == R[\text{rt}]) \quad \text{PC} \leftarrow (\text{PC} + 4) + (\text{SignExt}(\text{imm16}) \times 4) \quad \text{else} \quad \text{PC} \leftarrow \text{PC} + 4if (R[rs]==R[rt])PC←(PC+4)+(SignExt(imm16)×4)elsePC←PC+4

J-Type - Jump (j target)

格式：op(6) | target_address(26)
暫存器轉換：

PC←(PC+4)[31:28] ∥ (target_address×4)\text{PC} \leftarrow (\text{PC}+4)[31:28] \ \Vert \ (\text{target\_address} \times 4)PC←(PC+4)[31:28] ∥ (target_address×4)

📝 實戰演練：Branch 指令位移計算#

經典考題 3：(段考常考頻率：⭐⭐⭐⭐⭐) 請說明在 MIPS 單週期架構中，為什麼 beq 指令在計算分支目標地址時，需要將 16 位的立即數先進行「符號擴充（Sign Extend）」再「左移 2 位（Shift left 2）」？最後又是如何與 PC 結合的？

【解析】#

Step 1（符號擴充的必要性）：MIPS 立即數欄位只有 16 位元，但 CPU 內部資料路徑與主記憶體定址皆為 32 位元。為了支援正向與負向的分支偏移植，必須透過符號擴充將 16 位元填滿至 32 位元，維持正負號實質意義。
Step 2（左移 2 位的物理意義）：MIPS 架構採用字組對齊（Word Alignment），每條指令長度固定為 4 Bytes，因此記憶體起始地址最後兩個位元固定是 00。為了擴大跳躍範圍，立即數儲存的是「指令條數偏移量」。將其乘以 4（左移 2 位），就能還原為真實的位元組偏移量（Byte Offset），使跳躍能力擴大 4 倍。
Step 3（與 PC 結合）：分支目標地址是相對於下一條指令的地址（PC+4\text{PC}+4PC+4）進行偏移計算。公式為：

Branch Target Address=(PC+4)+(SignExt(imm16)×4)\text{Branch Target Address} = (\text{PC} + 4) + (\text{SignExt}(\text{imm16}) \times 4)Branch Target Address=(PC+4)+(SignExt(imm16)×4)

💡 補充變化考法 若考試考全新的指令，例如 bne（不相等時跳躍），其資料路徑與 beq 完全相同，唯一差別在於控制邏輯中，判斷 PC 軌道多工器切換的條件由 ALU Zero = 1 變成了 ALU Zero = 0。

4. 單週期控制單元與真值表設計 (Main Control & ALU Control)#

核心觀念辨析#

生活比喻：控制單元就是處理器的「大腦和神經系統」。
主控制器 (Main Control)：看一眼指令的 Opcode（前 6 位元），發出宏觀控制訊號（例如：要不要寫入暫存器？要不要讀寫記憶體？）。
ALU 控制器 (ALU Control)：地方局部控制器。當主控制器判定為 R-type 時，給 ALU 控制器丟暗號 ALUOp = 10；ALU 控制器再去細看指令末尾的 funct 欄位（後 6 位元），精準調校出 ALU 該做加法、減法、AND 還是 OR。

控制信號物理意義一覽#

RegDst：寫回暫存器的目標編號是 rt 欄位（0）還是 rd 欄位（1）。
ALUSrc：ALU 第二個輸入端來自暫存器數據（0）還是擴充後的立即數（1）。
MemtoReg：寫回暫存器檔案的資料來自 ALU 計算結果（0）還是 Data Memory 讀出的資料（1）。
RegWrite：是否允許在時脈邊緣將資料寫入暫存器檔案（1 允許，0 禁止）。
MemRead / MemWrite：主記憶體的讀取 / 寫入使能控制訊號。
Branch：是否為分支指令（與 ALU 的 Zero 訊號做運算，決定 PC 軌道的切換）。

🔥 必背！控制信號完整全真值表#

(註：真值表依據典型微架構設計標準彙整，X 代表 Don’t Care)

指令	Opcode	RegDst	ALUSrc	MemtoReg	RegWrite	MemRead	MemWrite	Branch	ALUOp
R-type	000000	1	0	0	1	0	0	0	10
lw	100011	0	1	1	1	1	0	0	00
sw	101011	X	1	X	0	0	1	0	00
beq	000100	X	0	X	0	0	0	1	01

📝 實戰演練：Stuck-at 錯誤分析#

經典考題 4：(段考常考頻率：⭐⭐⭐⭐⭐) 假設單週期處理器中，主控制器的控制線路發生硬體故障，導致 MemtoReg 訊號線路永久斷路並卡在固定的訊號值 0（Stuck-at-0 錯誤）。請問在此故障下，哪些指令依然能夠正常執行？哪些指令會發生錯誤？

【解析】#

Step 1（定位錯誤意義）：MemtoReg = 0 代表寫回暫存器檔案的 MUX 永久鎖定在「選擇 ALU 運算結果」通道。
Step 2（逐一檢視指令）：
R-type 指令：本就要求 MemtoReg = 0，故障值與期望值相符，正常執行。
Store (sw)：不寫回暫存器，RegWrite = 0。MUX 切到哪都沒差，正常執行。
Branch (beq)：同上，RegWrite = 0，正常執行。
Load (lw)：正常需設定 MemtoReg = 1。卡在 0 會導致寫回暫存器的資料變成「ALU 算出的記憶體地址」，而非真實數據，因此發生錯誤。
Step 3（結論）：
正常執行：R-type, sw, beq。
發生錯誤：lw。

💡 補充變化考法 如果是 RegWrite 發生 Stuck-at-0 錯誤呢？答案是所有需要修改暫存器內容的指令（R-type, lw）全部報銷，只有 sw 與 beq 能存活。這類 Stuck-at 題型是各大資工所必考！

5. 關鍵路徑 (Critical Path) 時序計算與單週期缺陷#

核心觀念辨析#

木桶理論：單週期處理器的時脈週期時間（TcT_cTc），取決於耗時最長（最慢）的那條指令之總延遲。
最耗時指令分析：lw（Load Word）是公認的大魔王。它必須走完所有部門：拿 PC →\rightarrow→ 翻指令記憶體 →\rightarrow→ 讀暫存器檔案 →\rightarrow→ 跑 ALU 算地址 →\rightarrow→ 翻數據記憶體 →\rightarrow→ 走多工器寫回暫存器。

關鍵路徑公式 (lwlwlw 延遲公式)#

Tc≥Tclk-to-q+TI-Mem+TRegRead+TALU+TD-Mem+TMUX+TSetupT_c \ge T_{\text{clk-to-q}} + T_{\text{I-Mem}} + T_{\text{RegRead}} + T_{\text{ALU}} + T_{\text{D-Mem}} + T_{\text{MUX}} + T_{\text{Setup}}Tc≥Tclk-to-q+TI-Mem+TRegRead+TALU+TD-Mem+TMUX+TSetup

單週期設計的致命弱點 (Drawback of Single-Cycle)#

時脈週期長，效率極低：時脈週期必須去遷就最慢的 lw。即使是執行極快、不需存取記憶體的指令（如 add, beq），也被迫等待一樣長的時間，白白浪費 CPU 資源。

📝 實戰演練：時鐘週期與閒置時間計算#

經典考題 5：(段考常考頻率：⭐⭐⭐⭐⭐) 假設某處理器元件延遲如下：

指令記憶體 (TI-MemT_{\text{I-Mem}}TI-Mem)：250 ps

資料記憶體 (TD-MemT_{\text{D-Mem}}TD-Mem)：300 ps

暫存器讀取/寫入 (TRegT_{\text{Reg}}TReg)：150 ps

ALU 運算 (TALUT_{\text{ALU}}TALU)：200 ps

多工器 (TMUXT_{\text{MUX}}TMUX)：30 ps 請計算最小時脈週期時間與最高主頻。若有一條 add 指令，它實際只需多少時間？會被分配多少時間？帶來什麼缺點？

【解析】#

Step 1（最差時序路徑）：代入 lw 路徑：Fetch →\rightarrow→ RegRead →\rightarrow→ MUX →\rightarrow→ ALU →\rightarrow→ D-Mem →\rightarrow→ MUX →\rightarrow→ RegWrite。

Tc=250 ps+150 ps+30 ps+200 ps+300 ps+30 ps+150 psT_c = 250\text{ ps} + 150\text{ ps} + 30\text{ ps} + 200\text{ ps} + 300\text{ ps} + 30\text{ ps} + 150\text{ ps}Tc=250 ps+150 ps+30 ps+200 ps+300 ps+30 ps+150 ps

Tc=1110 ps=1.11 nsT_c = 1110\text{ ps} = 1.11\text{ ns}Tc=1110 ps=1.11 ns

最高主頻：

f=1Tc=11.11×10−9 s≈900.9 MHzf = \frac{1}{T_c} = \frac{1}{1.11 \times 10^{-9}\text{ s}} \approx 900.9\text{ MHz}f=Tc1=1.11×10−9 s1≈900.9 MHz

Step 2（add 指令時間分析）：
add 實際路徑：Fetch (250 ps) →\rightarrow→ RegRead (150 ps) →\rightarrow→ MUX (30 ps) →\rightarrow→ ALU (200 ps) →\rightarrow→ MUX (30 ps) →\rightarrow→ RegWrite (150 ps)。
實際所需時間 = 810 ps。
被分配時間：強行分配 1110 ps。
Step 3（缺點總結）：這導致 add 指令在 810 ps 時就做完事情了，但在接下來的 300 ps 內，整個硬體電路只能處於閒置狀態，浪費晶片效能。

6. 補充#

J-type 立即數左移位元陷阱：計算 Jump 指令目標地址時，target 欄位只有 26 位元。左移 2 位變成 28 位元後，剩下最高的 4 位元是直接借用 (PC+4)(\text{PC}+4)(PC+4) 的最高 4 位元，千萬別誤寫成全部補 0。
多工器 (MUX) 訊號選擇張冠李戴：

RegDst = 1 時，目標是寫入 rd（第 11-15 位元）；為 0 時寫入 rt（第 16-20 位元）。
MemtoReg = 1 時，選取的是記憶體（Memory）；為 0 時選取的是 ALU 結果。

暫存器檔案讀寫時序混淆：切記「讀是組合、寫是序向」！在計算時序關鍵路徑（Critical Path）時，讀取時間（RegRead）發生在週期前半段，寫回建立時間（Setup Time）發生在末尾，兩者必須分別計入公式，不可混為一談。

第五章：管線化處理器架構與資料路徑 (Pipelining)#

1. 管線化基礎與效能度量 (Pipelining Basics)#

觀念與公式#

直觀意義：如同自助洗衣店的「洗衣服 (Laundry)」過程 (洗、烘、摺)。若循序執行，每個人都要等前一個人全部做完才能開始，極度沒效率。管線化就是「只要機器 (硬體資源) 一空出來，下一道指令立刻無縫接軌」。
物理意義：管線化無法減少「單一指令的執行時間 (Latency)」，但能大幅提升「整體系統的吞吐量 (Throughput)」。管線的最高速率受限於「最慢的那個管線階段 (Pipeline Stage)」。
必背公式：
- Potential Speedup=Number of pipe stages\text{Potential Speedup} = \text{Number of pipe stages}Potential Speedup=Number of pipe stages (理想加速倍率 = 管線階數)
- Tpipeline=Tsingle_cycleNumber of stagesT_{pipeline} = \frac{T_{single\_cycle}}{\text{Number of stages}}Tpipeline=Number of stagesTsingle_cycle
- NNN 個指令的總執行時間 = (Stages+N−1)×Cycle Time(\text{Stages} + N - 1) \times \text{Cycle Time}(Stages+N−1)×Cycle Time

實戰演練（題型大全）#

[題型 1: Single-cycle vs. Pipeline Performance]

題目：假設 Single-cycle 的 Tc=800psT_c = 800psTc=800ps，切分為 IF, ID, EX, MEM, WB 五個階段，各耗時 200ps。請求出連續執行 3 個 lw 指令在 Single-cycle 與 Pipelined 架構下的總耗時。
Step-by-step 解答：
1. Single-cycle：每個 lw 獨佔整個 Datapath，需 800ps800ps800ps。3 個 lw =3×800=2400ps= 3 \times 800 = 2400ps=3×800=2400ps。
2. Pipelined：時脈週期 TcT_cTc 決定於最慢的階段，即 200ps200ps200ps。
3. 利用公式：時間 =(5+3−1)×200ps=7×200ps=1400ps= (5 + 3 - 1) \times 200ps = 7 \times 200ps = 1400ps=(5+3−1)×200ps=7×200ps=1400ps。
常考頻率：★★★★☆
重要程度：★★★★☆ (期中考極愛考這類計算，若考題加上不平均的 stage times，請務必挑「最慢的 stage」作為 TcT_cTc)

2. 五級管線化資料路徑 (5-Stage Pipelined Datapath)#

觀念與公式#

直觀意義：把 CPU 切成五個分工明確的部門，並在部門之間設立「收發匣 (Pipeline Registers)」。
核心知識點：
1. IF (Instruction Fetch)：透過 PC 拿指令，並計算 PC+4PC+4PC+4。
2. ID (Instruction Decode)：解碼指令，從暫存器檔案 (Register File) 讀取資料。
3. EX (Execution)：ALU 執行運算或計算記憶體位址。
4. MEM (Memory Access)：對 Data Memory 進行讀/寫。
5. WB (Write Back)：將結果寫回 Register File。
捷徑口訣：資料只能「往前流」，唯一倒流的機會只有 Write Back (寫回 Register) 以及 PC 的更新。每個階段間的 Latches 分別為 IF/ID, ID/EX, EX/MEM, MEM/WB。

實戰演練（題型大全）#

[題型 2: 管線化狀態追蹤 (Pipeline Registers Tracking)]

題目：給定指令序列 lw $10, 20($1) 緊接著 sub $11, $2, $3，請問在 Clock 4 時，各個 Pipeline Registers 裡面存著什麼？
Step-by-step 解答：
1. 推導時間軸：lw 在 Clock 1 進 IF，Clock 4 會抵達 MEM。sub 在 Clock 2 進 IF，Clock 4 抵達 EX。
2. EX/MEM Latch (屬於 lw 的產出)：儲存 ALU 算出的位址 (20 + \1)以及準備寫入暫存器的目標編號(‘) 以及準備寫入暫存器的目標編號 (`)以及準備寫入暫存器的目標編號(‘10`)。
3. ID/EX Latch (屬於 sub 的產出)：儲存 $2 與 $3 的值，以及 ALUOp 設為 sub 等控制訊號。
常考頻率：★★★☆☆
重要程度：★★★☆☆ (通常配合作圖題考出，確認你是否知道每個 Stage 當下在做什麼)

3. 資料危險與解法 (Data Hazards: Forwarding & Stalling)#

觀念與公式#

直觀意義：學弟 (後面的指令) 需要學長 (前面的指令) 的筆記 (運算結果)，但學長還沒把筆記寫進資料庫 (Register File)。
Data Hazard 分類：在 MIPS 5-stage 中，主要且唯一會發生的是 RAW (Read After Write)。WAR 與 WAW 均不會發生 (因為永遠在 Stage 2 讀，Stage 5 寫)。
解法 1：Forwarding (Bypassing)
- 直接從 EX/MEM (剛算完) 或 MEM/WB (剛讀完) 把資料「抄捷徑」導回 ALU 輸入端。
- EX Hazard 條件：EX/MEM.RegWrite 且 EX/MEM.RegRd != 0 且 EX/MEM.RegRd == ID/EX.RegRs (或 RegRt)。
- MEM Hazard 條件：MEM/WB.RegWrite 且 MEM/WB.RegRd != 0 且 MEM/WB.RegRd == ID/EX.RegRs (或 RegRt)。
解法 2：Stalling (Load-Use Hazard)
- 當前一個指令是 lw，而下一個指令立刻需要它的值，此時就算 Forwarding 也來不及 (因為 MEM 階段才拿到資料，但下一步的 EX 已經要用了)。
- Stall 條件：ID/EX.MemRead 且 (ID/EX.RegisterRt == IF/ID.RegisterRs) 或 (ID/EX.RegisterRt == IF/ID.RegisterRt)。
- 處理方式：塞入一個 Bubble (NOP)，凍結 PC 與 IF/ID 一週期。

實戰演練（題型大全）#

[題型 3: 找尋所有 Data Hazards 並畫出 Forwarding 路徑]

題目：給定以下指令序列，指出哪些地方發生 Hazard，並說明由哪個 Forwarding Unit 解決。
1. sub $2, $1, $3
2. and $12, $2, $5
3. or $13, $6, $2
4. add $14, $2, $2
5. sw $15, 100($2)
Step-by-step 解答：
1. sub 把結果寫入 $2。
2. and 依賴 $2。在 and 進入 EX 時，sub 剛進 MEM。這是 EX Hazard。解答：由 EX/MEM forwarding 到 ALU 輸入。
3. or 依賴 $2。在 or 進入 EX 時，sub 剛進 WB。這是 MEM Hazard。解答：由 MEM/WB forwarding 到 ALU 輸入。
4. add 依賴 $2。sub 此時已經寫回，加上暫存器「前半週期寫入、後半週期讀出」的硬體特性，No Hazard，直接讀取即可。
5. sw 也是正常讀取，No Hazard。
常考頻率：★★★★★
重要程度：★★★★★ (佔分極重，請務必熟練)

[題型 4: Load-Use Hazard 判斷]

題目：lw $2, 20($1) 緊接 and $4, $2, $5。
Step-by-step 解答：
1. lw 在 EX 階段 (ID/EX.MemRead=1) 時，發現目標暫存器 $2 和下一道指令 (and) 在 ID 階段的需求衝突。
2. 觸發 Hazard Detection Unit：凍結 PC 與 IF/ID，並把 EX 控制訊號設為 0 (產生 Bubble)。
3. 延遲一週期後，lw 抵達 WB，再透過 Forwarding 將讀到的資料送給 and 的 EX 階段。
變化考法：考題若將 lw 和 and 中間安插一個無關指令，Stall 就不會發生，因為距離被拉開了！

4. 控制危險與分支預測 (Control Hazards & Branch Prediction)#

觀念與公式#

直觀意義：遇到 beq 分支指令，不知道要不要跳，但後面的指令已經排隊進來了。
解法 1：Flush (Flush on Branch)：預設不跳 (Predict-not-taken)。如果事後發現要跳，就把剛抓進來的錯誤指令清除 (IF.Flush 變 NOP)。
解法 2：提前判斷 (Moving Branch Execution Earlier)：把 Branch Address 運算跟 Register 比對 (XOR) 從 EX 提早到 ID 階段。這樣猜錯的懲罰 (Penalty) 就能從 3 cycles 降到 1 cycle。
進階預測：Dynamic Branch Prediction：使用 Branch History Table (BHT) 記錄過去跳或不跳，猜錯才 Flush 並翻轉預測位元。
編譯器優化：Delayed Branch：把「無論如何都該執行的指令」搬到 Branch 後面的 Delay Slot，這樣就完全 0 Penalty (MIPS 早期經典做法)。

實戰演練（題型大全）#

[題型 5: Branch Penalty 計算]

題目：若分支判斷放在 MEM 階段，預測不跳卻跳了，會產生多少 Penalty？若提早到 ID 階段呢？
Step-by-step 解答：
1. 若在 MEM 階段才決定 (第 4 階段)：代表 IF, ID, EX 抓進來的 3 個指令全部作廢，Penalty = 3 cycles。
2. 若在 ID 階段決定 (第 2 階段)：IF 階段抓進來的 1 個指令作廢，Penalty = 1 cycle。
常考頻率：★★★★☆
重要程度：★★★★☆ (重點在評估「提早判斷硬體成本」與「效能提升」的 trade-off)

5. 例外與指令級平行化 (Exceptions & ILP)#

觀念與公式#

Exceptions (例外)：來自 CPU 內部 (如 Overflow, Undefined Opcode)。
Interrupts (中斷)：來自外部 I/O。
處理機制：停止執行，紀錄問題指令位址於 EPC (Exception Program Counter)，紀錄原因於 Cause Register，把出問題指令之後的指令全數 Flush，跳轉至 OS Handler 8000 00180。
ILP (Instruction-Level Parallelism)：超純量架構 (Superscalar)。
- Static Multiple Issue：編譯器將指令兩兩打包 (例如：一個 ALU + 一個 Load/Store) 送入管線。
- Loop Unrolling (迴圈展開)：複製迴圈主體，並使用 Register Renaming (換不同暫存器名字) 來消除假性資料相依 (Name Dependence/Anti-dependence)。

實戰演練（題型大全）#

[題型 6: Loop Unrolling & Scheduling]

題目：針對 Dual-issue MIPS 進行迴圈排程，消除 Load-Use Hazard，並計算展開後的 IPC。
Step-by-step 解答：
1. 原始迴圈有 lw 接 addu 的 Load-use hazard 導致 Stall。
2. 展開迴圈 4 次，將 4 個獨立的 lw 集中排在最前面，接著排 4 個 addu，最後排 4 個 sw。
3. 利用編譯器重新配置位移量 (Offset: 0, 4, 8, 12)。
4. 計算執行時間：8 個 cycles 完成 14 個指令。IPC = 14/8=1.7514 / 8 = 1.7514/8=1.75 (逼近峰值 2.0)。
常考頻率：★★★☆☆
重要程度：★★★★☆ (這是鑑別度極高、用來拉開分數差距的進階題型)

6. 補充#

盲點 1：算總執行時間忘記減一。計算連續 NNN 個指令的執行時間，公式是 (Stages+N−1)(Stages + N - 1)(Stages+N−1)！如果有 Stall，直接在後面加上 Stall cycles 的數量即可。
盲點 2：Load-use Stall 忽略凍結。看到 lw 寫入某暫存器，下一行馬上要用，請毫不猶豫加入 1 cycle stall (Bubble)。很多學生以為 Forwarding 萬能，但在 Load-use 時 Forwarding 必須伴隨 Stall 才來得及。
盲點 3：暫存器前半寫後半讀的硬體神技。如果是「隔了一行」的指令 (例如：第一行寫入 $1，第四行要讀取 $1)，此時不需要 Forwarding！因為 Register File 具有「前半週期寫入、後半週期讀取」的特性，直接讀就是最新的資料。
盲點 4：Double Data Hazard (連環車禍)。當連續三個指令操作同一個暫存器 (如 add $1 -> add $1 -> add $1)，EX Hazard 和 MEM Hazard 條件會同時成立。此時 Forwarding 必須優先取最新 (EX Hazard) 的值！撰寫控制邏輯時，MEM Hazard 條件必須加上 (EX/MEM.RegRd != ID/EX.RegRs) 確保不被較舊的值覆蓋。這是手寫題超級常錯的死穴！
盲點 5：Branch 提早到 ID 的隱藏代價。把 Branch 提早到 ID 階段判斷，會導致「需要的資料必須提早準備好」。如果剛好前一道指令是 ALU 運算且會影響 Branch 條件，原本在 EX 判斷來得及 Forwarding 的，現在可能被迫必須塞 Stall 才能在 ID 階段進行 XOR 比較。審題時務必看清楚「Branch 在哪一階段執行」。

第六章：記憶體階層架構深度解析（Memory Hierarchy）#

1. 快取缺失大歸類與寫入策略 (3C Miss Model & Write Strategy)#

觀念與公式#

(1) 快取缺失三元模型 (3C Miss Model)#

快取缺失（Cache Miss）依其底層硬體成因，可精準分類為以下三種模型（常考於觀念情境辨析）：

強制性缺失 (Compulsory Miss / Cold-start Miss)：當程式剛啟動或首次存取某個記憶體區塊時，該資料從未進入過快取，因而必然發生的第一次缺失。
容量性缺失 (Capacity Miss)：當程式在某段時間內頻繁存取的工作集（Working Set）體積，大於快取的總容量時。即使快取採用完全相聯（Fully-Associative）完美擺放，資料仍會因空間不足被輪流踢出而導致缺失。
衝突性缺失 (Conflict Miss / Collision Miss)：專門發生在直接映射（Direct-Mapped）或組相聯（Set-Associative）快取中。當多個不同的記憶體位址因餘數映射公式，同時爭奪同一個快取組（Set），導致彼此瘋狂交替踢走對方，此時快取的其餘空間可能多數仍是空的。

(2) 寫入策略與缺失分配 (Write Strategy)#

當 CPU 執行寫入指令（如 sw）時，硬體必須權衡速度與資料一致性：

寫透策略 (Write-Through)：不論快取是否命中，資料同時且立刻寫入快取與主記憶體。缺點是每次寫入都要同步忍受慢速的 DRAM 延遲。
黃金搭檔：寫繞過 (No-Write Allocate)。當寫入缺失時，直接繞過快取去修改主記憶體，不把區塊搬上快取，省下頻寬。
寫回策略 (Write-Back)：寫入命中時，只將新資料更新到快取中，並將該列快取線（Cache Line）標記為 Dirty bit = 1（髒污位元），不立刻修改主記憶體。只有當這列資料未來被 LRU 演算法選中、準備被踢出（Evict）時，硬體才會檢查 Dirty bit 並將其整條寫回主記憶體。
黃金搭檔：寫分配 (Write Allocate)。當寫入缺失時，大費周章將該 Block 從主記憶體載入到快取，隨後再執行快取寫入。核心理念是利用時間局部性，打賭未來對該區塊的無數次讀寫都能在快取中以 1 cycle 爆發命中。

(3) 架構師的硬體權衡參數 (Cache Trade-offs)#

固定總容量，放大區塊大小 (Block Size ↑\uparrow↑)：
強大的空間局部性使 Compulsory Miss 下降。
但根據公式：總格數 (Blocks)=Cache 總容量Block Size\text{總格數 (Blocks)} = \frac{\text{Cache 總容量}}{\text{Block Size}}總格數 (Blocks)=Block SizeCache 總容量

當總容量固定，Block Size 放大，快取內部的總格數（或總組數）反而會大幅縮水。這會造成嚴重的「沙發效能陷阱」，導致 Conflict Miss 劇烈上升。

固定總容量與區塊，提升相聯度 (Associativity ↑\uparrow↑)：
擺放極度靈活，使得 Conflict Miss 顯著下降。
對 Capacity Miss 完全沒有影響（容量缺失只與 Cache 總容量大小有關）。
致命硬體代價：由於多個 Way 需要平行比對，硬體內部需要成倍增加比較器（Comparator），導致晶片面積增大、功耗與成本爆炸。同時，後面串接的大型多路複用器（MUX）會拉長電路延遲，造成 Hit Time（命中時間）變長。

實戰演練#

題目一：3C Miss Model 情境微觀辨析（精準歸類）#

假設有一個 32 位元系統，內建一個容量為 64 KB64\text{ KB}64 KB、Block Size 為 64 Bytes64\text{ Bytes}64 Bytes 的 2-way Set-Associative Cache。請判斷下列三種獨立發生的記憶體存取缺失，分別屬於 3C Miss 中的哪一種，並簡述其原因：

(1) 電腦剛開機，CPU 執行第一行核心指令時發生的 Cache Miss。
(2) 程式要處理一個大小為 2 MB2\text{ MB}2 MB 的大型影像矩陣，由於陣列連續存取所需的空間遠大於 64 KB64\text{ KB}64 KB，導致在迴圈後段存取時，先前載入的資料早已被全部剔除而發生的 Miss（假設此時排除排擠問題）。
(3) 某段迴圈在極短時間內，交替讀取主記憶體實體位址 0x00001000 與 0x00011000。經硬體計算發現，這兩個位址因為 Modulo 公式，剛好都會被映射到 Set 64。因為它們瘋狂交替踢走對方，導致這個迴圈每次存取都發生 Miss，但此時整個 Cache 其實還有超過 90% 的空間是空的。

【Step-by-step 詳細解析】

(1) 答案：Compulsory Miss
解析：電腦剛開機執行第一行指令，該記憶體位址是生涯第一次被讀取，快取內為空（Valid bit = 0），此為典型的冷啟動缺失。
(2) 答案：Capacity Miss
解析：工作集資料體積（2 MB2\text{ MB}2 MB）遠遠碾壓了快取的總容納極限（64 KB64\text{ KB}64 KB），即使快取設計得再完美也放不下，因容量耗盡被輪替踢出，故歸類為容量缺失。
(3) 答案：Conflict Miss
解析：關鍵特徵在於「整個 Cache 還有 90% 的空間是空的」。這代表缺失絕非因為總容量不夠（非 Capacity），而是因為 0x00001000 與 0x00011000 這兩個特定的高頻存取位址，倒楣地映射到了同一個格子（Set 64），在局部發生了嚴重的排擠衝突。

題目二：Write Strategy 硬體運作流程#

現有一台處理器，其 L1 Data Cache 採用 Write-Back（寫回策略） 搭配 Write Allocate（寫分配），且替換演算法採用 LRU。

(1) 當 CPU 執行一個 sw（寫入資料）指令且 Cache Hit 時，硬體內部會做出什麼動作？此時會立刻去修改 Main Memory 的資料嗎？
(2) 承上題，如果此時不幸發生了 Read Miss（讀取缺失），且經 LRU 算過後，被選中要被踢出（Evict）的那一列 Cache Line 的 **Dirty bit 為 1**。請詳細寫出硬體此時必須依序執行的底層運存步驟。
(3) 為什麼在業界設計中，Write-Through 通常固定搭配 No-Write Allocate，而 Write-Back 則固定搭配 Write Allocate？請從效能工程的角度解釋原因。

【Step-by-step 詳細解析】

(1) 答案：
硬體動作：硬體會直接將新資料寫入到 L1 Data Cache 對應的欄位中，並**將該快取列的 Dirty bit 標記為 1**。
是否修改 Main Memory：絕對不會。這正是 Write-Back 的精髓，將慢速的記憶體寫入動作延遲到區塊被淘汰之時，以此節省寶貴的 CPU 時間。
(2) 答案（標準硬體狀態鏈流動順序）：

寫回髒污區塊 (Write Back)：快取控制器偵測到被 LRU 挑出的 Victim（犧牲者）區塊之 Dirty bit 為 1，代表其內容已被修改、與記憶體不一致。硬體會率先將此整條 Cache Block 寫回主記憶體（DRAM）對應的實體位址。
載入全新區塊 (Fetch)：當髒污區塊清空後，快取控制器向主記憶體發出讀取請求，將 CPU 當前真正需要讀取的全新實體區塊完整搬運（Fetch）上來，填入該清空的位置。
重設狀態標籤：將這一格的 **Dirty bit 清除為 0**（因為剛從記憶體搬上來，兩邊資料完全一致），並將 **Valid bit 設為 1**。
交付資料：最後把目標資料透過內部匯流排完美交付給 CPU，完成本次讀取任務。

(3) 答案：
Write-Through + No-Write Allocate：因為 Write-Through 無論如何都必須同步將資料寫進主記憶體。既然在快取沒命中，最省時的做法就是直接寫去主記憶體（DRAM）即可，不需要大費周章再把整條區塊搬上快取，這能有效保護快取空間不被污染，並節省匯流排頻寬。
Write-Back + Write Allocate：Write-Back 的核心目的是讓未來的讀寫都在超高速的快取中爆發命中。雖然這次 Miss 必須多花時間從主記憶體分配並載入區塊，但只要成功搬上來，接下來對這個區塊的連續無數次寫入就通通只要 1 cycle 就能在快取搞定。高回報率完全值得初次的搬運代價。

2. 多階快取架構與記憶體頻寬優化 (Multilevel Caches & Memory Optimization)#

觀念與公式#

(1) 多階快取的階層式權衡 (Architect’s Goals)#

為了解決「處理器-記憶體效能鴻溝（Processor-Memory Performance Gap）」，現代架構設計了多層防線：

L1 Cache（第一線戰場）：
核心目標：極致的快（Minimize Hit Time）。
設計特徵：緊貼 CPU 核心，容量極小（16 KB∼64 KB16\text{ KB} \sim 64\text{ KB}16 KB∼64 KB），相聯度極低（通常 2-way 或 Direct-Mapped），確保在 1 個 cycle 內做出回應。
L2/L3 Cache（第二/三道防線）：
核心目標：極低的缺失率（Minimize Miss Rate），死命攔截住任何企圖外流到主記憶體的存取。
設計特徵：容量巨大（256 KB∼8 MB+256\text{ KB} \sim 8\text{ MB}+256 KB∼8 MB+），相聯度極高（8-way ∼\sim∼ 32-way），雖然 Hit Time 稍慢（10~30 cycles），但比起去 Main Memory 等幾百個 cycles，依然是天壤之別。

(2) 雙層快取 AMAT 終極結算公式#

當引入 L2 快取後，平均記憶體存取時間（AMAT）展開為三層聯動公式：

AMAT=Hit TimeL1+Miss RateL1×Miss PenaltyL1\text{AMAT} = \text{Hit Time}_{L1} + \text{Miss Rate}_{L1} \times \text{Miss Penalty}_{L1}AMAT=Hit TimeL1+Miss RateL1×Miss PenaltyL1

而 L1 的 Miss Penalty，實質上就是去 L2 尋找資料的平均時間：

Miss PenaltyL1=Hit TimeL2+Local Miss RateL2×Miss PenaltyL2\text{Miss Penalty}_{L1} = \text{Hit Time}_{L2} + \text{Local Miss Rate}_{L2} \times \text{Miss Penalty}_{L2}Miss PenaltyL1=Hit TimeL2+Local Miss RateL2×Miss PenaltyL2

【🚨 缺失率名詞大陷阱】：

Local Miss Rate（局部缺失率）： Local Miss RateL2=L2 Miss 總數進入 L2 的存取總數 (即 L1 Miss 數)\text{Local Miss Rate}_{L2} = \frac{\text{L2 Miss 總數}}{\text{進入 L2 的存取總數 (即 L1 Miss 數)}}Local Miss RateL2=進入 L2 的存取總數 (即 L1 Miss 數)L2 Miss 總數

一般計組題目若無特別說明，「L2 快取缺失率」預設皆為此項。 2. Global Miss Rate（全域缺失率）： Global Miss RateL2=L2 Miss 總數CPU 發出的總存取數=Miss RateL1×Local Miss RateL2\text{Global Miss Rate}_{L2} = \frac{\text{L2 Miss 總數}}{\text{CPU 發出的總存取數}} = \text{Miss Rate}_{L1} \times \text{Local Miss Rate}_{L2}Global Miss RateL2=CPU 發出的總存取數L2 Miss 總數=Miss RateL1×Local Miss RateL2

(3) 主記憶體（DRAM）頻寬優化策略#

當快取全數失守、必須去 DRAM 搬運一整條 Block（假設大小為 NNN 個 Words）時，有三種硬體組織架構：

單字寬度組織 (One-word-wide)：記憶體與匯流排寬度皆為 1 Word1\text{ Word}1 Word。每次搬運都必須獨立重複執行「送位址 + DRAM啟動 + 傳輸 1 Word」的完整流程，速度最慢。
加寬組織 (Wide Memory)：直接加寬記憶體與匯流排。路多寬，資料就能併排跑多大。可以一次送出位址、一次讀取並同時打包傳輸一整條 Block。
Total Miss Penalty=傳送位址時間+DRAM 存取時間+1 次打包傳輸時間\text{Total Miss Penalty} = \text{傳送位址時間} + \text{DRAM 存取時間} + \text{1 次打包傳輸時間}Total Miss Penalty=傳送位址時間+DRAM 存取時間+1 次打包傳輸時間
交錯式儲存組織 (Interleaved Memory)：【期末考最愛考！】 內部拆成多個獨立的 Memory Banks。可以平行（同時）啟動多個 Bank 讀取，等一次 DRAM 時間，所有資料就在門口準備好了。但為了省錢，與主機連接的資料匯流排寬度維持窄小的 1 Word1\text{ Word}1 Word，因此傳輸時必須排成一縱隊依序過馬路。
Total Miss Penalty=傳送位址時間+DRAM 存取時間+(N×單字傳輸時間)\text{Total Miss Penalty} = \text{傳送位址時間} + \text{DRAM 存取時間} + (N \times \text{單字傳輸時間})Total Miss Penalty=傳送位址時間+DRAM 存取時間+(N×單字傳輸時間)

實戰演練#

題目一：雙層快取（L1/L2）AMAT 與 CPI 聯動地獄計算題#

現有一台高時脈處理器，運作時脈為 2.5 GHz2.5\text{ GHz}2.5 GHz（意即 1 cycle=0.4 ns1\text{ cycle} = 0.4\text{ ns}1 cycle=0.4 ns），在理想快取狀態下的 Base CPI=2.0\text{Base CPI} = 2.0Base CPI=2.0。所有指令中，有 40%40\%40% 的指令是資料存取指令（Load 或 Store）。系統配備了兩級快取，參數如下：

L1 I-Cache：Miss Rate=2%\text{Miss Rate} = 2\%Miss Rate=2%，Hit Time=1 cycle\text{Hit Time} = 1\text{ cycle}Hit Time=1 cycle。
L1 D-Cache：Miss Rate=5%\text{Miss Rate} = 5\%Miss Rate=5%，Hit Time=1 cycle\text{Hit Time} = 1\text{ cycle}Hit Time=1 cycle。
L2 Unified Cache：Local Miss Rate=20%\text{Local Miss Rate} = 20\%Local Miss Rate=20%，Hit Time=8 cycles\text{Hit Time} = 8\text{ cycles}Hit Time=8 cycles。
主記憶體（Main Memory）：存取一次需要固定的時間 60 ns60\text{ ns}60 ns。

請詳細解答下列問題：

(1) 請問主記憶體存取一次，對這台 CPU 而言是多少個 Penalty Cycles？
(2) 請問 L2 D-Cache 的 Global Miss Rate（全域缺失率）是多少？
(3) 當 L1 Data Cache 發生 Miss 時，平均需要花多少個 Cycles（L1 Miss Penalty）才能從下層系統（L2 + Memory）取回資料？
(4) 這台處理器在執行該程式時，最終實際的總 CPI 是多少？

【Step-by-step 詳細解析】

(1) 解答：150 cycles
計算： Memory Penalty Cycles=記憶體固定延遲CPU 週期時間=60 ns0.4 ns=150 cycles\text{Memory Penalty Cycles} = \frac{\text{記憶體固定延遲}}{\text{CPU 週期時間}} = \frac{60\text{ ns}}{0.4\text{ ns}} = 150\text{ cycles}Memory Penalty Cycles=CPU 週期時間記憶體固定延遲=0.4 ns60 ns=150 cycles
(2) 解答：1% (或 0.01)
計算： Global Miss RateL2=L1 D-Cache Miss Rate×L2 Local Miss Rate=5%×20%=0.01=1%\text{Global Miss Rate}_{L2} = \text{L1 D-Cache Miss Rate} \times \text{L2 Local Miss Rate} = 5\% \times 20\% = 0.01 = 1\%Global Miss RateL2=L1 D-Cache Miss Rate×L2 Local Miss Rate=5%×20%=0.01=1%
(3) 解答：38 cycles
計算：帶入雙層 Penalty 公式。當 L1 缺失時，一定要先花 8 cycles8\text{ cycles}8 cycles 檢查 L2。如果 L2 沒中（機率 20%20\%20%），才需要外流去 Main Memory 等 150 cycles150\text{ cycles}150 cycles：

L1 Data Miss Penalty=Hit TimeL2+Local Miss RateL2×Mem Penalty=8+0.20×150=8+30=38 cycles\text{L1 Data Miss Penalty} = \text{Hit Time}_{L2} + \text{Local Miss Rate}_{L2} \times \text{Mem Penalty} = 8 + 0.20 \times 150 = 8 + 30 = 38\text{ cycles}L1 Data Miss Penalty=Hit TimeL2+Local Miss RateL2×Mem Penalty=8+0.20×150=8+30=38 cycles

(4) 解答：3.52
計算：由於 L2 是統一快取（Unified），不論是指令（I）還是資料（D）只要漏出 L1，去 L2 + Memory 撈資料的懲罰都是相同的 38 cycles38\text{ cycles}38 cycles。
計算 Instruction Stall： I-Stall=1×2% (I-Cache Miss Rate)×38=0.76 cycles\text{I-Stall} = 1 \times 2\% \text{ (I-Cache Miss Rate)} \times 38 = 0.76\text{ cycles}I-Stall=1×2% (I-Cache Miss Rate)×38=0.76 cycles

（每條指令都有 1 次抓取指令的動作）

計算 Data Stall： D-Stall=40% (Data 指令佔比)×5% (D-Cache Miss Rate)×38=0.76 cycles\text{D-Stall} = 40\% \text{ (Data 指令佔比)} \times 5\% \text{ (D-Cache Miss Rate)} \times 38 = 0.76\text{ cycles}D-Stall=40% (Data 指令佔比)×5% (D-Cache Miss Rate)×38=0.76 cycles
結算實際總 CPI： Total CPI=Base CPI+I-Stall+D-Stall=2.0+0.76+0.76=3.52\text{Total CPI} = \text{Base CPI} + \text{I-Stall} + \text{D-Stall} = 2.0 + 0.76 + 0.76 = 3.52Total CPI=Base CPI+I-Stall+D-Stall=2.0+0.76+0.76=3.52

題目二：主記憶體組織（Memory Organizations）與週期計算大題#

假設目前系統要從 DRAM 搬回一個大小為 4 個 Words 的 Cache Block。已知主記憶體與匯流排的硬體延遲參數如下：

傳送位址時間：固定花費 1 cycle1\text{ cycle}1 cycle。
DRAM 存取時間（Latency）：每啟動一次讀取，DRAM 內部晶片需要花費 30 cycles30\text{ cycles}30 cycles 才能把資料準備好。
資料傳輸時間：匯流排每傳送 1 Word1\text{ Word}1 Word 的資料，需要花費 2 cycles2\text{ cycles}2 cycles。

請分別計算在以下三種不同的主記憶體組織架構下，CPU 發生一次 Miss 所需付出的總缺失懲罰（Total Miss Penalty，單位為 cycles）：

架構 (A)：單字寬度儲存組織（One-word-wide Memory Organization）
架構 (B)：加寬儲存組織（Wide Memory Organization，寬度加寬為 4 Words）
架構 (C)：四路交錯式儲存組織（4-bank Interleaved Memory Organization，匯流排維持 1 Word 寬）

【Step-by-step 詳細解析】

架構 (A) 解答：132 cycles
解析：因為每次只能定址傳輸 1 個 Word，整套動作必須重複 4 次。
單次循環=1 (傳位址)+30 (DRAM存取)+2 (傳輸)=33 cycles\text{單次循環} = 1\text{ (傳位址)} + 30\text{ (DRAM存取)} + 2\text{ (傳輸)} = 33\text{ cycles}單次循環=1 (傳位址)+30 (DRAM存取)+2 (傳輸)=33 cycles
總時間=33×4 (個Words)=132 cycles\text{總時間} = 33 \times 4\text{ (個Words)} = 132\text{ cycles}總時間=33×4 (個Words)=132 cycles
架構 (B) 解答：33 cycles
解析：路加寬了 4 倍，記憶體一次吐出 4 個 Words，超寬的匯流排還能把這 4 個 Words 綁成一大捆，在「1 次傳輸時間內（即 2 cycles）」一口氣通通運回 CPU。
總時間=1 (傳位址)+30 (DRAM存取)+2 (超寬頻一次傳完)=33 cycles\text{總時間} = 1\text{ (傳位址)} + 30\text{ (DRAM存取)} + 2\text{ (超寬頻一次傳完)} = 33\text{ cycles}總時間=1 (傳位址)+30 (DRAM存取)+2 (超寬頻一次傳完)=33 cycles
架構 (C) 解答：39 cycles
解析：記憶體內部拆成 4 個 Banks，所以可以同時平行啟動 DRAM 存取，我們只需要等 1 次 30 cycles30\text{ cycles}30 cycles，4 個 Words 就都在各自的 Bank 門口準備好了。但由於匯流排寬度維持窄小的 1 Word，這 4 個 Words 沒辦法並排跑，必須排成一縱隊，一個接一個傳過馬路（傳輸時間需累加）。
總時間=1 (傳位址)+30 (4個Bank平行存取)+[4 (個Words)×2 (傳輸)]=1+30+8=39 cycles\text{總時間} = 1\text{ (傳位址)} + 30\text{ (4個Bank平行存取)} + [4\text{ (個Words)} \times 2\text{ (傳輸)}] = 1 + 30 + 8 = 39\text{ cycles}總時間=1 (傳位址)+30 (4個Bank平行存取)+[4 (個Words)×2 (傳輸)]=1+30+8=39 cycles

3. 虛擬記憶體與分頁機制 (Virtual Memory & Paging)#

觀念與公式#

(1) 虛擬記憶體的終極定位 (The Illusion)#

虛擬記憶體是硬體與作業系統（OS）聯手打造的宏大魔術。它為每個獨立的進程（Process）提供了一個「私有、連續、從零開始」的虛擬位址空間（Virtual Address Space）。此時，主記憶體（DRAM）本質上變成了次級儲存裝置（硬碟/SSD）的「快取（Cache）」。

(2) 快取 vs 虛擬記憶體之名詞對照表#

為了讓觀念無縫平移，架構師將名詞做了一對一的對照：

快取架構 (Cache)	虛擬記憶體架構 (Virtual Memory)
Cache Block (快取區塊)	Page (分頁)
Cache Frame (快取格)	Page Frame (實體分頁框)
Cache Miss (快取缺失)	Page Fault (分頁錯誤)

(3) 由「恐怖懲罰」逼出的四項架構設計抉擇#

一旦發生 Page Fault，CPU 必須去慢速的硬碟（Disk/SSD）搬資料，這會付出高達數百萬個時脈週期的極致懲罰。為了死命降低 Page Fault 的機率，虛擬記憶體做出了與 Cache 截然不同的設計：

分頁體積做得很巨（Page Size 大）：通常是 4KB 甚至更大。透過極強的空間局部性，攤提每次啟動硬碟讀取的高昂時間。
採用全關聯式擺放 (Fully Associative)：任何虛擬分頁都可以自由存放到實體記憶體的任何角落，這樣能使用最靈活的演算法（如 LRU）把 Page Fault 的機率壓到最低。
遺失由軟體（OS Handler）全權處理：既然 Page Fault 要等數百萬 cycles，硬體花十幾個 cycle 呼叫 OS 軟體根本無傷大雅。OS 會在此時進行進程上下文切換（Context Switch），把 CPU 讓給別的程式使用，免得處理器原地白白發呆。
強制使用寫回策略 (Write-Back)：每次寫入都要同步改硬碟（Write-Through）會直接卡死系統。硬體只有當分頁要被踢出實體記憶體時，才檢查 Dirty bit 寫回硬碟。

(4) 位址翻譯與分頁表 (Address Translation)#

為了解決 Fully Associative 找不到資料的定位問題，OS 在 DRAM 中建立了一個索引地圖，稱為分頁表（Page Table）。 CPU 發出的虛擬位址（Virtual Address, VA）會被拆成兩部分：

Virtual Page Number (VPN，虛擬分頁編號)：作為 Page Table 的陣列索引（Index）。
Page Offset (分頁偏移量)：代表資料在該分頁內的確切位置（不參與翻譯，直接照抄）。

透過 VPN 索引查表後，若該條目（Page Table Entry, PTE）的 Valid bit 為 1，代表分頁待在實體記憶體中，此時會吐出 Physical Page Number (PPN，實體分頁編號)，並與 Page Offset 拼接成實體位址（Physical Address, PA）；若 Valid bit 為 0，則代表觸發 Page Fault。

(5) 分頁表拆分核心公式#

Page Offset 位元數=log⁡2(Page Size 單位為 Bytes)\text{Page Offset 位元數} = \log_2(\text{Page Size 單位為 Bytes})Page Offset 位元數=log2(Page Size 單位為 Bytes)

VPN 位元數=虛擬位址總位元數 (VA)−Page Offset 位元數\text{VPN 位元數} = \text{虛擬位址總位元數 (VA)} - \text{Page Offset 位元數}VPN 位元數=虛擬位址總位元數 (VA)−Page Offset 位元數

分頁表總條目數 (PTEs)=2VPN 位元數\text{分頁表總條目數 (PTEs)} = 2^{\text{VPN 位元數}}分頁表總條目數 (PTEs)=2VPN 位元數

實戰演練#

題目一：虛擬記憶體軟硬體處理機制辨析#

為什麼處理 Cache Miss 需要「純硬體線路（Hardware）」控制，而處理 Page Fault 卻可以容忍跳躍到作業系統的「軟體（Software OS Handler）」來處理？

【Step-by-step 詳細解析】

Cache Miss 的情境：快取缺失的懲罰非常低（通常僅有幾十個 cycles），如果此時跳入作業系統執行軟體中斷處理，光是保護暫存器現場（Context Overhead）就要花費數百個 cycles，完全是因小失大。因此，Cache Miss 必須用純硬體線路以極速完成。
Page Fault 的情境：分頁錯誤去磁碟讀取資料的懲罰高達數百萬個 cycles。與這段漫長的等待時間相比，OS 軟體中斷處理所帶來的幾百個 cycle 開銷根本微不足道。容忍跳入軟體，能讓 OS 有機會執行 Context Switch 切換到其他進程工作，大幅拉高 CPU 的整體整體吞吐量（Throughput）。

題目二：分頁位址拆分與大小結算#

假設某電腦系統採用虛擬記憶體架構，虛擬位址（VA）為 32 位元，實體位址（PA）為 30 位元，每個 Page 的大小為 8KB。請精準計算出：

(a) Page Offset 需要多少位元（bits）？
(b) Virtual Page Number (VPN) 有多少位元？
(c) Page Table 中總共包含多少個 Page Table Entries (PTEs)？

【Step-by-step 詳細解析】

(a) 解答：13 bits
計算：先將 Page Size 換算為 2 的次方： 8 KB=8×1024 Bytes=8192 Bytes=213 Bytes8\text{ KB} = 8 \times 1024\text{ Bytes} = 8192\text{ Bytes} = 2^{13}\text{ Bytes}8 KB=8×1024 Bytes=8192 Bytes=213 Bytes

因此，需要 13 bits13\text{ bits}13 bits 的 Page Offset 來對分頁內的每個 Byte 進行定址。

(b) 解答：19 bits
計算：虛擬位址由 VPN 與 Page Offset 組成：

VPN Bits=VA Bits−Page Offset Bits=32−13=19 bits\text{VPN Bits} = \text{VA Bits} - \text{Page Offset Bits} = 32 - 13 = 19\text{ bits}VPN Bits=VA Bits−Page Offset Bits=32−13=19 bits

(c) 解答：2192^{19}219 個 (或 524,288 個)
計算：分頁表必須涵蓋所有的虛擬分頁編號可能性：

PTE 總數=2VPN Bits=219 個條目\text{PTE 總數} = 2^{\text{VPN Bits}} = 2^{19}\text{ 個條目}PTE 總數=2VPN Bits=219 個條目

4. TLB 翻譯旁路緩衝器與快取終極大融合 (TLB & Cache Integration)#

觀念與公式#

(1) 救速神器：TLB (Translation Lookaside Buffer)#

由於 Page Table 存放在慢速的 DRAM 中，導致 CPU 每次想拿一個資料，都必須先去 DRAM 讀一次 Page Table 翻譯，再讀一次實體位址，存取時間直接變為兩倍。為了消除這個致命缺點，架構師在 CPU 內部的 MMU（記憶體管理單元）中建立了一個專門用來快取「分頁表條目（PTE）」的超高速小快取，稱為 TLB。CPU 翻譯位址時會先問 TLB，若 TLB Hit，只需 0.5 ∼\sim∼ 1 cycle 就能瞬間拿到實體位址（PA）。

(2) 四合一系統聯動狀態之「可能與不可能」矩陣#

當 TLB、Page Table、Cache、DRAM 全數交織在一起時，期末考最常考的便是判斷某種硬體組合是否存在矛盾：

組合狀態	是否可能發生？	硬體底層真相原理解析
TLB Miss + Page Hit + Cache Miss	可能 (Possible)	最經典的冷啟動或跨大步記憶體存取。資料確實待在 DRAM 中（Page Hit），只是其翻譯地圖剛剛好不在 TLB 內（TLB Miss），且資料也尚未被搬移上快取（Cache Miss）。
TLB Miss + Page Hit + Cache Hit	可能 (Possible)	翻譯地圖在 TLB 中剛好被擠掉（TLB Miss），但實體資料早已透過別的別名或前一次存取安穩地躺在 Cache 中（Cache Hit）。
TLB Hit + Page Fault	❌ 絕對不可能	世紀矛盾！ TLB 能夠命中（TLB Hit）的前提，是裡面裝有合法且 Valid = 1 的實體位址。既然翻譯地圖有效，代表資料百分之百安穩地躺在實體記憶體中，絕對不可能觸發 Page Fault（去硬碟找資料）。
Cache Hit + Page Fault	❌ 絕對不可能	世紀矛盾！ Cache 裡面裝的只不過是實體記憶體的「局部拷貝」。如果都發生了 Page Fault（代表實體記憶體中根本沒有這個分頁），Cache 裡面絕對不可能憑空變出這筆資料。

實戰演練#

題目一：終極四合一聯動追蹤大題#

假設某系統同時配備了 TLB、Page Table 與 Cache。現在 CPU 發出了一個記憶體讀取請求，但很不幸地，這個請求在硬體中依序發生了：TLB Miss →\rightarrow→ Page Table Hit →\rightarrow→ Cache Miss。請詳細寫出底層硬體與系統接下來必須依序執行的「4 個核心步驟」。

【Step-by-step 詳細解析（標準晶片規範書規範寫法）】

Step 1：去 DRAM 走訪分頁表（修補地圖）
由於 TLB Miss，MMU 無法在第一時間完成翻譯。硬體被迫手持虛擬分頁編號（VPN）為索引，走訪位於 DRAM 中的 Page Table。因為 Page Table Hit（Valid bit = 1），硬體順利讀出對應的實體分頁編號（PPN）。
Step 2：組裝並更新地圖（更新 TLB）
MMU 將讀出的 PPN 與原本的 Page Offset 完美拼接，產生最終的實體位址（PA）。同時，為了確保下一次存取不用再跑去遙遠的 DRAM 查表，硬體會將這筆新翻譯好的對應關係立刻寫入（更新）TLB。
Step 3：持實體位址查 Cache（搬移 Block）
硬體拿著剛出爐的實體位址（PA）去查 Cache。然而不幸發生 Cache Miss。此時快取控制器被迫再次啟動主記憶體（DRAM），將包含該目標資料的一整個實體區塊（Cache Block）從 DRAM 搬運（Fetch）上來，載入並更新到 Cache 中。
Step 4：快取命中，交付 CPU（完美收工）
當資料成功入駐 Cache 後，CPU 再次存取該位址時便會觸發 Cache Hit，快取立刻將 CPU 真正想要的那個 Word 資料透過內部匯流排交付給暫存器，順利恢復指令的執行！

5.補充#

「固定總容量下 Block 放大」的 Conflict 飆升陷阱

學生的直覺錯誤：Block 變大，格數變多，所以 Conflict 變少？
考前救命真相：完全顛倒！ 當總容量固定，你把每個 Block 的體積放大，Cache 內部能放的總格數反而會急劇縮水（例如大沙發擠掉小課桌）。格子變少，不同的記憶體位址映射到同一個格子的爭奪戰就會變得極度殘烈，因為搬資料一次就要搬一整個block，Conflict Miss 會不降反升！

AMAT 公式帶入時的 Local vs Global 混淆點

學生的直覺錯誤：在計算 AMAT=HTL1+MRL1×(HTL2+MRL2×Memory Penalty)\text{AMAT} = \text{HT}_{L1} + \text{MR}_{L1} \times (\text{HT}_{L2} + \text{MR}_{L2} \times \text{Memory Penalty})AMAT=HTL1+MRL1×(HTL2+MRL2×Memory Penalty) 時，直接將題目給的 L2 缺失率帶入最內層的 MRL2\text{MR}_{L2}MRL2。
考前救命真相：公式最內層與 Memory Penalty\text{Memory Penalty}Memory Penalty 相乘的，必須是 Local Miss Rate（代表漏出 L1 的那群人中，有多少比例又漏出了 L2）。如果題目陰險地給了你 Global Miss Rate，你必須先透過公式 Global MR=MRL1×Local MRL2\text{Global MR} = \text{MR}_{L1} \times \text{Local MR}_{L2}Global MR=MRL1×Local MRL2 進行反推換算，才能帶入 AMAT 公式！

DRAM 頻寬優化計算中的「馬路寬度與排隊」地獄

學生的直覺錯誤：分不清 Wide Memory 與 Interleaved Memory 的時間公式，通通加在一起。
考前救命真相：
Wide Memory：馬路超寬。DRAM 存取完 4 個 Words 後，4 個 Words 可以並排在 1 次傳輸時間內一口氣通通傳完（傳輸時間算 1 次）。
Interleaved Memory：馬路很窄（匯流排維持 1 Word 寬）。多個 Bank 雖然能平行同時啟動存取（存取延遲只算 1 次），但吐出 4 個 Words 後馬路太窄無法並排，這 4 個 Words 必須乖乖排成一縱隊，一隻隻依序傳過馬路（傳輸時間必須乘以 444 倍）。

TLB 與 Cache 的「時空矛盾狀態」判定

學生的直覺錯誤：在期末考是非填空題中，勾選「TLB Hit 且 Page Fault」為可能發生。
考前救命真相：這是絕對的硬體悖論！ 只要記住一個黃金鐵則：「地圖在，人就一定在；人不在，拷貝就絕對不可能憑空出現。」 TLB 命中代表地圖有效 →\rightarrow→ 分頁一定在實體記憶體中 →\rightarrow→ 絕不可能 Page Fault。Cache 命中代表快取有拷貝 →\rightarrow→ 實體記憶體一定早就載入了該分頁 →\rightarrow→ 絕不可能 Page Fault。任何 Hit 與 Page Fault 組合在一起的選項，直接判定 Impossible 秒殺拿分！

大二下機率論

Wed, 10 Jun 2026 00:00:00 GMT

第一章：機率公理與集合論 (Axioms and Set Theory)#

知識點 1：Kolmogorov 機率三大公理#

非負性：對於任意事件 EEE，其機率 P(E)≥0P(E) \ge 0P(E)≥0。
正規化：整個樣本空間 SSS 的總機率 P(S)=1P(S) = 1P(S)=1。
可數可加性：若事件 E1,E2,…E_1, E_2, \dotsE1,E2,… 彼此兩兩互斥（即當 i≠ji \neq ji=j 時，Ei∩Ej=∅E_i \cap E_j = \emptysetEi∩Ej=∅），則其聯集的機率等於各自機率之和：

P(⋃i=1∞Ei)=∑i=1∞P(Ei)P\left(\bigcup_{i=1}^\infty E_i \right) = \sum_{i=1}^\infty P(E_i)P(⋃i=1∞Ei)=∑i=1∞P(Ei)

實戰演練：不公正骰子常數求解 [題目] 假設有一顆不公正的骰子，擲出點數 iii 的機率與點數成正比，即 P({i})=c⋅iP(\{i\}) = c \cdot iP({i})=c⋅i（其中 i=1,…,6i = 1, \dots, 6i=1,…,6）。求常數 ccc 之值，以及擲出偶數點的機率。 [解答]

依據公理二與公理三，所有基本點數互斥且機率總和必須為 1：

P(S)=∑i=16P({i})=c(1+2+3+4+5+6)=21c=1 ⟹ c=121P(S) = \sum_{i=1}^6 P(\{i\}) = c(1 + 2 + 3 + 4 + 5 + 6) = 21c = 1 \implies \mathbf{c = \frac{1}{21}}P(S)=∑i=16P({i})=c(1+2+3+4+5+6)=21c=1⟹c=211

偶數事件 E={2,4,6}E = \{2, 4, 6\}E={2,4,6}，各基本事件互斥，依公理三：

P(E)=P({2})+P({4})+P({6})=2+4+621=1221=47P(E) = P(\{2\}) + P(\{4\}) + P(\{6\}) = \frac{2+4+6}{21} = \mathbf{\frac{12}{21} = \frac{4}{7}}P(E)=P({2})+P({4})+P({6})=212+4+6=2112=74

知識點 2：排容原理與布林不等式#

排容原理（處理非互斥事件的聯集機率）：

P(A∪B)=P(A)+P(B)−P(A∩B)P(A \cup B) = P(A) + P(B) - P(A \cap B)P(A∪B)=P(A)+P(B)−P(A∩B)

布林不等式 (Union Bound)（在計算機科學演算法錯誤率分析中極為常用，用於估算最壞情況的機率上限）：

P(⋃i=1nEi)≤∑i=1nP(Ei)P\left(\bigcup_{i=1}^n E_i\right) \le \sum_{i=1}^n P(E_i)P(⋃i=1nEi)≤∑i=1nP(Ei)

實戰演練：系統故障率與上界估計 [題目] 機房中，硬體故障機率 P(A)=0.3P(A)=0.3P(A)=0.3，軟體故障機率 P(B)=0.4P(B)=0.4P(B)=0.4。 (1) 若已知「軟硬體至少有一個出錯」的機率 P(A∪B)=0.6P(A \cup B)=0.6P(A∪B)=0.6，求僅有硬體故障的機率？ (2) 若不知道兩者交集機率，請利用布林不等式給出「至少有一個出錯」的機率上限。 [解答]

先利用排容原理求交集機率： 0.6=0.3+0.4−P(A∩B) ⟹ P(A∩B)=0.10.6 = 0.3 + 0.4 - P(A \cap B) \implies P(A \cap B) = 0.10.6=0.3+0.4−P(A∩B)⟹P(A∩B)=0.1。僅硬體故障之事件可表示為 A∩BcA \cap B^cA∩Bc，其機率為： P(A∩Bc)=P(A)−P(A∩B)=0.3−0.1=0.2P(A \cap B^c) = P(A) - P(A \cap B) = 0.3 - 0.1 = \mathbf{0.2}P(A∩Bc)=P(A)−P(A∩B)=0.3−0.1=0.2。

依據布林不等式估算聯集上界： P(A∪B)≤P(A)+P(B)=0.3+0.4=0.7P(A \cup B) \le P(A) + P(B) = 0.3 + 0.4 = \mathbf{0.7}P(A∪B)≤P(A)+P(B)=0.3+0.4=0.7。

第二章：條件機率與獨立性 (Conditional Probability & Independence)#

知識點 1：條件機率與貝氏定理#

條件機率定義：在已知事件 BBB 發生的前提下，事件 AAA 發生的機率。

P(A∣B)=P(A∩B)P(B),其中 P(B)>0P(A \mid B) = \frac{P(A \cap B)}{P(B)}, \quad \text{其中 } P(B) > 0P(A∣B)=P(B)P(A∩B),其中 P(B)>0

全機率定理 (Law of Total Probability)：若 B1,B2,…,BnB_1, B_2, \dots, B_nB1,B2,…,Bn 形成樣本空間 SSS 的一組分割（Partition，即兩兩互斥且聯集為 SSS），則對任意事件 AAA：

P(A)=∑i=1nP(A∣Bi)P(Bi)P(A) = \sum_{i=1}^n P(A \mid B_i) P(B_i)P(A)=∑i=1nP(A∣Bi)P(Bi)

貝氏定理 (Bayes’ Theorem)：結合條件機率與全機率定理，用於「由果推因」的後驗機率（Posterior Probability）計算。
推導簡述：由乘法法則可知 P(A∩Bk)=P(A∣Bk)P(Bk)=P(Bk∣A)P(A)P(A \cap B_k) = P(A \mid B_k)P(B_k) = P(B_k \mid A)P(A)P(A∩Bk)=P(A∣Bk)P(Bk)=P(Bk∣A)P(A)，移項後並將分母 P(A)P(A)P(A) 以全機率定理展開：

P(Bk∣A)=P(A∣Bk)P(Bk)∑i=1nP(A∣Bi)P(Bi)P(B_k \mid A) = \frac{P(A \mid B_k) P(B_k)}{\sum_{i=1}^n P(A \mid B_i) P(B_i)}P(Bk∣A)=∑i=1nP(A∣Bi)P(Bi)P(A∣Bk)P(Bk)

實戰演練：分散式系統日誌追蹤 [題目] 某系統中伺服器 A 處理 40% 的請求（錯誤率 1%），伺服器 B 處理 60% 的請求（錯誤率 2%）。系統隨機抽查一筆請求發現「發生錯誤」，求該請求是由伺服器 A 處理的機率？ [解答] 設 EEE 為錯誤事件。已知 P(A)=0.4,P(B)=0.6P(A)=0.4, P(B)=0.6P(A)=0.4,P(B)=0.6；條件機率 P(E∣A)=0.01,P(E∣B)=0.02P(E\vert{}A)=0.01, P(E\vert{}B)=0.02P(E∣A)=0.01,P(E∣B)=0.02。

計算總錯誤率（全機率）： P(E)=P(E∣A)P(A)+P(E∣B)P(B)=(0.01)(0.4)+(0.02)(0.6)=0.004+0.012=0.016P(E) = P(E \mid A)P(A) + P(E \mid B)P(B) = (0.01)(0.4) + (0.02)(0.6) = 0.004 + 0.012 = 0.016P(E)=P(E∣A)P(A)+P(E∣B)P(B)=(0.01)(0.4)+(0.02)(0.6)=0.004+0.012=0.016

利用貝氏定理求後驗機率： P(A∣E)=P(E∣A)P(A)P(E)=0.0040.016=0.25P(A \mid E) = \frac{P(E \mid A)P(A)}{P(E)} = \frac{0.004}{0.016} = \mathbf{0.25}P(A∣E)=P(E)P(E∣A)P(A)=0.0160.004=0.25

第三章：離散型隨機變數 (Discrete Random Variables)#

知識點 1：期望值與變異數運算性質#

期望值 (Expected Value)：E[X]=∑xx⋅p(x)E[X] = \sum_x x \cdot p(x)E[X]=∑xx⋅p(x)，其中 p(x)p(x)p(x) 為機率質量函數 (PMF)。
變異數 (Variance)：定義為隨機變數偏離其平均值的平方期望值 Var(X)=E[(X−μ)2]Var(X) = E[(X - \mu)^2]Var(X)=E[(X−μ)2]，其中 μ=E[X]\mu = E[X]μ=E[X]。
變異數捷徑公式推導：

Var(X)=E[(X−μ)2]=E[X2−2μX+μ2]Var(X) = E[(X - \mu)^2] = E[X^2 - 2\mu X + \mu^2]Var(X)=E[(X−μ)2]=E[X2−2μX+μ2]

利用期望值的線性性質展開：

Var(X)=E[X2]−2μE[X]+μ2=E[X2]−2μ2+μ2=E[X2]−μ2Var(X) = E[X^2] - 2\mu E[X] + \mu^2 = E[X^2] - 2\mu^2 + \mu^2 = E[X^2] - \mu^2Var(X)=E[X2]−2μE[X]+μ2=E[X2]−2μ2+μ2=E[X2]−μ2

故得核心計算公式：

Var(X)=E[X2]−(E[X])2Var(X) = E[X^2] - (E[X])^2Var(X)=E[X2]−(E[X])2

實戰演練：網路封包延遲轉換 [題目] 某封包傳輸時間 XXX（毫秒）的 PMF 為：P(X=1)=0.5,P(X=2)=0.3,P(X=3)=0.2P(X=1)=0.5, P(X=2)=0.3, P(X=3)=0.2P(X=1)=0.5,P(X=2)=0.3,P(X=3)=0.2。若實際處理成本與傳輸時間的線性關係為 Y=4X−2Y = 4X - 2Y=4X−2，求 E[Y]E[Y]E[Y] 與 Var(Y)Var(Y)Var(Y)。 [解答]

先求 XXX 的一階與二階動差： E[X]=(1)(0.5)+(2)(0.3)+(3)(0.2)=1.7E[X] = (1)(0.5) + (2)(0.3) + (3)(0.2) = 1.7E[X]=(1)(0.5)+(2)(0.3)+(3)(0.2)=1.7 E[X2]=(12)(0.5)+(22)(0.3)+(32)(0.2)=0.5+1.2+1.8=3.5E[X^2] = (1^2)(0.5) + (2^2)(0.3) + (3^2)(0.2) = 0.5 + 1.2 + 1.8 = 3.5E[X2]=(12)(0.5)+(22)(0.3)+(32)(0.2)=0.5+1.2+1.8=3.5

求 XXX 的變異數： Var(X)=E[X2]−(E[X])2=3.5−(1.7)2=3.5−2.89=0.61Var(X) = E[X^2] - (E[X])^2 = 3.5 - (1.7)^2 = 3.5 - 2.89 = 0.61Var(X)=E[X2]−(E[X])2=3.5−(1.7)2=3.5−2.89=0.61

利用期望值與變異數的線性轉換性質求 YYY： E[Y]=4E[X]−2=4(1.7)−2=4.8E[Y] = 4E[X] - 2 = 4(1.7) - 2 = \mathbf{4.8}E[Y]=4E[X]−2=4(1.7)−2=4.8 Var(Y)=42⋅Var(X)=16(0.61)=9.76Var(Y) = 4^2 \cdot Var(X) = 16(0.61) = \mathbf{9.76}Var(Y)=42⋅Var(X)=16(0.61)=9.76

知識點 2：三大經典離散分佈#

在計算機科學與網路工程中，以下三種分佈最為常見：

二項分佈 (Binomial Distribution, X∼Bin(n,p)X \sim Bin(n, p)X∼Bin(n,p))

定義：執行 nnn 次獨立的白努利實驗（Bernoulli trial），成功的總次數。
PMF: P(X=k)=(nk)pk(1−p)n−kP(X = k) = \binom{n}{k} p^k (1-p)^{n-k}P(X=k)=(kn)pk(1−p)n−k
性質: E[X]=npE[X] = npE[X]=np, Var(X)=np(1−p)Var(X) = np(1-p)Var(X)=np(1−p)

幾何分佈 (Geometric Distribution, X∼Geo(p)X \sim Geo(p)X∼Geo(p))

定義：獨立重複白努利實驗，直到第一次成功時所需的總實驗次數。
PMF: P(X=k)=(1−p)k−1pP(X = k) = (1-p)^{k-1}pP(X=k)=(1−p)k−1p
性質: E[X]=1pE[X] = \frac{1}{p}E[X]=p1, Var(X)=1−pp2Var(X) = \frac{1-p}{p^2}Var(X)=p21−p

帕松分佈 (Poisson Distribution, X∼Poi(λ)X \sim Poi(\lambda)X∼Poi(λ))

定義：在特定的單位時間或空間內，某隨機事件發生的次數（常應用於網路封包抵達率、伺服器請求量分析）。
PMF: P(X=k)=λke−λk!P(X = k) = \frac{\lambda^k e^{-\lambda}}{k!}P(X=k)=k!λke−λ
性質: 其期望值與變異數相等，E[X]=λE[X] = \lambdaE[X]=λ, Var(X)=λVar(X) = \lambdaVar(X)=λ

實戰演練：伺服器 Error Log 分析 (Poisson) [題目] 伺服器每分鐘平均收到 3 個錯誤日誌，假設其發生的次數服從帕松分佈。求在特定的一分鐘內，收到至少 2 個錯誤日誌的機率。 [解答] 設 X∼Poi(3)X \sim Poi(3)X∼Poi(3)，即 λ=3\lambda = 3λ=3。利用餘事性求解：P(X≥2)=1−P(X<2)=1−(P(X=0)+P(X=1))P(X \ge 2) = 1 - P(X < 2) = 1 - (P(X = 0) + P(X = 1))P(X≥2)=1−P(X<2)=1−(P(X=0)+P(X=1)) 代入帕松分佈 PMF： P(X≥2)=1−(30e−30!+31e−31!)=1−(e−3+3e−3)=1−4e−3P(X \ge 2) = 1 - \left( \frac{3^0 e^{-3}}{0!} + \frac{3^1 e^{-3}}{1!} \right) = 1 - (e^{-3} + 3e^{-3}) = \mathbf{1 - 4e^{-3}}P(X≥2)=1−(0!30e−3+1!31e−3)=1−(e−3+3e−3)=1−4e−3

第四章：連續型隨機變數 (Continuous Random Variables)#

知識點 1：指數分佈與無記憶性#

指數分佈 (X∼Exp(λ)X \sim Exp(\lambda)X∼Exp(λ))：常用於建模隨機事件發生的等待時間或電子元件的壽命。

PDF:f(x)=λe−λx,CDF:F(x)=1−e−λx(x≥0)PDF: f(x) = \lambda e^{-\lambda x}, \quad CDF: F(x) = 1 - e^{-\lambda x} \quad (x \ge 0)PDF:f(x)=λe−λx,CDF:F(x)=1−e−λx(x≥0)

超尾機率 (Tail Probability)：P(X>x)=1−F(x)=e−λxP(X > x) = 1 - F(x) = e^{-\lambda x}P(X>x)=1−F(x)=e−λx

無記憶性 (Memoryless Property)：已知某事件已等待了 sss 時間，其需要再多等待 ttt 時間的條件機率，等同於從零開始重新等待 ttt 時間的機率。
數學證明：

P(X>s+t∣X>s)=P(X>s+t∩X>s)P(X>s)P(X > s + t \mid X > s) = \frac{P(X > s + t \cap X > s)}{P(X > s)}P(X>s+t∣X>s)=P(X>s)P(X>s+t∩X>s)

因為若 X>s+tX > s + tX>s+t，必然滿足 X>sX > sX>s，故分子交集部分即為 X>s+tX > s + tX>s+t：

=P(X>s+t)P(X>s)=e−λ(s+t)e−λs=e−λt=P(X>t)= \frac{P(X > s + t)}{P(X > s)} = \frac{e^{-\lambda(s+t)}}{e^{-\lambda s}} = e^{-\lambda t} = P(X > t)=P(X>s)P(X>s+t)=e−λse−λ(s+t)=e−λt=P(X>t)

實戰演練：路由器壽命預測 [題目] 某型號路由器壽命服從指數分佈，平均壽命為 5 年。若某台路由器目前已經正常運作了 10 年，求它能「再多運作至少 3 年」的機率？ [解答] 指數分佈平均壽命 E[X]=1/λ=5 ⟹ λ=0.2E[X] = 1/\lambda = 5 \implies \lambda = 0.2E[X]=1/λ=5⟹λ=0.2。根據指數分佈的無記憶性，過去運作的時間不影響未來的壽命機率： P(X>10+3∣X>10)=P(X>3)=e−0.2×3=e−0.6P(X > 10 + 3 \mid X > 10) = P(X > 3) = e^{-0.2 \times 3} = \mathbf{e^{-0.6}}P(X>10+3∣X>10)=P(X>3)=e−0.2×3=e−0.6

知識點 2：常態分佈與標準化#

常態分佈 (X∼N(μ,σ2)X \sim N(\mu, \sigma^2)X∼N(μ,σ2))：誤差分析與統計學中核心的分佈。
標準化 (Standardization)：由於一般常態分佈的機率密度函數無法透過初等函數求得積分解析解，計算時必須利用線性轉換，將其轉換為標準常態分佈 Z∼N(0,1)Z \sim N(0, 1)Z∼N(0,1) 以查表求解：

Z=X−μσZ = \frac{X - \mu}{\sigma}Z=σX−μ

實戰演練：資料庫查詢時間估算 [題目] 資料庫查詢時間 X∼N(100,400)X \sim N(100, 400)X∼N(100,400)（單位：毫秒）。求單次查詢時間介於 80ms 到 140ms 之間的機率？（已知標準常態分佈累積函數值 Φ(1)=0.8413,Φ(2)=0.9772\Phi(1)=0.8413, \Phi(2)=0.9772Φ(1)=0.8413,Φ(2)=0.9772） [解答] 已知平均數 μ=100\mu = 100μ=100，變異數 σ2=400 ⟹ \sigma^2 = 400 \impliesσ2=400⟹ 標準差 σ=20\sigma = 20σ=20。

將邊界值進行標準化轉換： Zlower=80−10020=−1Z_{lower} = \frac{80 - 100}{20} = -1Zlower=2080−100=−1 Zupper=140−10020=2Z_{upper} = \frac{140 - 100}{20} = 2Zupper=20140−100=2

轉換為標準常態機率計算： P(80<X<140)=P(−1<Z<2)=Φ(2)−Φ(−1)P(80 < X < 140) = P(-1 < Z < 2) = \Phi(2) - \Phi(-1)P(80<X<140)=P(−1<Z<2)=Φ(2)−Φ(−1) 利用標準常態的對稱性 Φ(−1)=1−Φ(1)=1−0.8413=0.1587\Phi(-1) = 1 - \Phi(1) = 1 - 0.8413 = 0.1587Φ(−1)=1−Φ(1)=1−0.8413=0.1587 故所求機率為：0.9772−0.1587=0.81850.9772 - 0.1587 = \mathbf{0.8185}0.9772−0.1587=0.8185

第五章：聯合機率分佈 (Joint Probability Distributions)#

知識點 1：邊際/條件分佈與定義域邊界#

邊際機率密度函數 (Marginal PDF)：對聯合分佈對另一變數進行全範圍積分以消去該變數。

fX(x)=∫−∞∞f(x,y)dyf_X(x) = \int_{-\infty}^{\infty} f(x, y) dyfX(x)=∫−∞∞f(x,y)dy

條件機率密度函數 (Conditional PDF)：

fY∣X(y∣x)=f(x,y)fX(x),當 fX(x)>0f_{Y\vert{}X}(y \mid x) = \frac{f(x, y)}{f_X(x)}, \quad \text{當 } f_X(x) > 0fY∣X(y∣x)=fX(x)f(x,y),當 fX(x)>0

獨立性判定：若 XXX 與 YYY 獨立，則聯合密度必可拆分 f(x,y)=fX(x)fY(y)f(x,y) = f_X(x) f_Y(y)f(x,y)=fX(x)fY(y)。在幾何上，獨立變數的定義域（Support）必然為矩形。若定義域的邊界包含變數相依的限制（例如 0<y<x<10 < y < x < 10<y<x<1），則兩者必定不獨立。

實戰演練：二維聯合機率邊界處理 [題目] 設隨機變數 X,YX, YX,Y 的聯合 PDF 為 f(x,y)=8xyf(x, y) = 8xyf(x,y)=8xy，其有效定義域範圍為 0<y<x<10 < y < x < 10<y<x<1。 (1) 求 XXX 的邊際分佈 fX(x)f_X(x)fX(x)？ (2) 若已知 X=1/2X = 1/2X=1/2，求 YYY 的條件 PDF 及其對應的新定義域？ [解答]

求邊際 fX(x)f_X(x)fX(x)：對 yyy 進行積分，注意由範圍 0<y<x<10 < y < x < 10<y<x<1 可知 yyy 的積分上限受限於 xxx。

fX(x)=∫0x8xy dy=4x[y2]0x=4x3,範圍為 (0<x<1)f_X(x) = \int_{0}^{x} 8xy \, dy = 4x \left[ y^2 \right]_0^x = \mathbf{4x^3}, \quad \text{範圍為 } (0 < x < 1)fX(x)=∫0x8xydy=4x[y2]0x=4x3,範圍為 (0<x<1)

求條件 PDF fY∣Xf_{Y\vert{}X}fY∣X 並更新變數邊界：

fY∣X(y∣1/2)=f(1/2,y)fX(1/2)=8(1/2)y4(1/2)3=4y0.5=8yf_{Y\vert{}X}(y \mid 1/2) = \frac{f(1/2, y)}{f_X(1/2)} = \frac{8(1/2)y}{4(1/2)^3} = \frac{4y}{0.5} = \mathbf{8y}fY∣X(y∣1/2)=fX(1/2)f(1/2,y)=4(1/2)38(1/2)y=0.54y=8y
更新邊界定義域：原本範圍為 0<y<x0 < y < x0<y<x，在給定條件 x=1/2x=1/2x=1/2 後，該條件 PDF 的新有效定義域縮減為 0<y<1/20 < y < 1/20<y<1/2。

第六章：共變異數與極限定理 (Covariance and Limit Theorems)#

知識點 1：共變異數與相依性檢驗#

共變異數 (Covariance)：用以衡量兩個隨機變數之間的線性相關程度。
定義與推導：

Cov(X,Y)=E[(X−μX)(Y−μY)]=E[XY−μXY−μYX+μXμY]Cov(X, Y) = E[(X - \mu_X)(Y - \mu_Y)] = E[XY - \mu_X Y - \mu_Y X + \mu_X \mu_Y]Cov(X,Y)=E[(X−μX)(Y−μY)]=E[XY−μXY−μYX+μXμY]

利用期望值線性性質展開：

=E[XY]−μXE[Y]−μYE[X]+μXμY=E[XY]−μXμY= E[XY] - \mu_X E[Y] - \mu_Y E[X] + \mu_X \mu_Y = E[XY] - \mu_X \mu_Y=E[XY]−μXE[Y]−μYE[X]+μXμY=E[XY]−μXμY

計算捷徑公式： Cov(X,Y)=E[XY]−E[X]E[Y]Cov(X, Y) = E[XY] - E[X]E[Y]Cov(X,Y)=E[XY]−E[X]E[Y]
兩變數和的變異數： Var(X+Y)=Var(X)+Var(Y)+2Cov(X,Y)Var(X + Y) = Var(X) + Var(Y) + 2Cov(X, Y)Var(X+Y)=Var(X)+Var(Y)+2Cov(X,Y)

核心觀念釐清：零相關不等於獨立 若 X,YX, YX,Y 兩隨機變數獨立 ⟹ Cov(X,Y)=0\implies Cov(X,Y) = 0⟹Cov(X,Y)=0（即零相關）。 然而反之不成立：Cov(X,Y)=0Cov(X,Y) = 0Cov(X,Y)=0 僅代表變數間沒有「線性」相關關係，它們仍可能存在高度的非線性相依性（例如當 Y=X2Y = X^2Y=X2，且 XXX 的分佈關於原點對稱時，Cov(X,Y)Cov(X,Y)Cov(X,Y) 為 0，但兩者顯然高度相依）。

實戰演練：離散聯合分佈共變異數 [題目] 已知 E[X]=2,E[Y]=3,E[XY]=6E[X]=2, E[Y]=3, E[XY]=6E[X]=2,E[Y]=3,E[XY]=6。求 Cov(X,Y)Cov(X,Y)Cov(X,Y)？這是否足以證明 X,YX,YX,Y 相互獨立？ [解答]

代入捷徑公式：Cov(X,Y)=E[XY]−E[X]E[Y]=6−(2×3)=0Cov(X,Y) = E[XY] - E[X]E[Y] = 6 - (2 \times 3) = \mathbf{0}Cov(X,Y)=E[XY]−E[X]E[Y]=6−(2×3)=0。

不能證明獨立。Cov(X,Y)=0Cov(X,Y)=0Cov(X,Y)=0 僅代表「零相關（無線性關係）」，無法排除兩者間存在非線性相依關係的可能性。

知識點 2：機率不等式估計 (Bounds)#

在無法得知確切分佈函數的情況下，僅利用期望值與變異數來估算機率的範圍上界，是計算機理論與演算法分析的重要工具。

馬可夫不等式 (Markov’s Inequality)：若 XXX 為非負隨機變數，則對任意常數 a>0a > 0a>0：

P(X≥a)≤E[X]aP(X \ge a) \le \frac{E[X]}{a}P(X≥a)≤aE[X]

柴比雪夫不等式 (Chebyshev’s Inequality)：衡量隨機變數偏離其平均值超過特定距離的機率上限。對任意常數 k>0k > 0k>0：

P(∣X−μ∣≥k)≤Var(X)k2P(\vert{}X - \mu\vert{} \ge k) \le \frac{Var(X)}{k^2}P(∣X−μ∣≥k)≤k2Var(X)

實戰演練：Chebyshev 演算法效能評估 [題目] 某 API 的響應時間平均值 μ=10\mu = 10μ=10 毫秒，標準差 σ=2\sigma = 2σ=2 毫秒。在不假設任何分佈的前提下，估計該 API 響應時間超過 16 毫秒或低於 4 毫秒的機率上限。 [解答] 題目所述範圍（X≥16X \ge 16X≥16 或 X≤4X \le 4X≤4）等價於偏離平均值至少 6 毫秒的事件，即 P(∣X−10∣≥6)P(\vert{}X - 10\vert{} \ge 6)P(∣X−10∣≥6)。利用柴比雪夫不等式，令 k=6k = 6k=6，且變異數 Var(X)=σ2=22=4Var(X) = \sigma^2 = 2^2 = 4Var(X)=σ2=22=4：
P(∣X−10∣≥6)≤Var(X)62=436=19P(\vert{}X - 10\vert{} \ge 6) \le \frac{Var(X)}{6^2} = \frac{4}{36} = \mathbf{\frac{1}{9}}P(∣X−10∣≥6)≤62Var(X)=364=91

知識點 3：中央極限定理 (CLT)#

中央極限定理 (Central Limit Theorem)：設 X1,X2,…,XnX_1, X_2, \dots, X_nX1,X2,…,Xn 為一組獨立且同分佈 (i.i.d.) 的隨機變數，其各自的期望值為 μ\muμ，變異數為 σ2\sigma^2σ2。當樣本數 nnn 夠大時（通常經驗法則要求 n≥30n \ge 30n≥30），其隨機變數總和 Sn=∑XiS_n = \sum X_iSn=∑Xi 或樣本平均值 Xˉ\bar{X}Xˉ 的抽樣分佈會趨近於常態分佈：

Sn∼N(nμ,nσ2)S_n \sim N(n\mu, n\sigma^2)Sn∼N(nμ,nσ2)

標準化公式應用：

Z=Sn−nμnσ∼N(0,1)Z = \frac{S_n - n\mu}{\sqrt{n}\sigma} \sim N(0, 1)Z=nσSn−nμ∼N(0,1)

實戰演練：大流量系統請求加總 [題目] 系統收到 100 筆獨立請求，單筆請求處理時間 X∼Exp(λ=0.1)X \sim Exp(\lambda=0.1)X∼Exp(λ=0.1) 秒。求處理完這 100 筆請求的總時間超過 1200 秒的機率？（已知標準常態分佈累積函數值 Φ(2)=0.9772\Phi(2)=0.9772Φ(2)=0.9772） [解答]

單一隨機變數的參數（指數分佈）：μ=1λ=10\mu = \frac{1}{\lambda} = 10μ=λ1=10 秒，σ2=1λ2=100\sigma^2 = \frac{1}{\lambda^2} = 100σ2=λ21=100。

計算 100 筆請求加總後的總體參數：總平均數 nμ=100×10=1000n\mu = 100 \times 10 = 1000nμ=100×10=1000 總變異數 nσ2=100×100=10000 ⟹ n\sigma^2 = 100 \times 100 = 10000 \impliesnσ2=100×100=10000⟹ 總標準差 nσ2=100\sqrt{n\sigma^2} = 100nσ2=100

依據中央極限定理進行標準化轉換：

P(S100>1200)=P(Z>1200−1000100)=P(Z>2)P(S_{100} > 1200) = P\left(Z > \frac{1200 - 1000}{100}\right) = P(Z > 2)P(S100>1200)=P(Z>1001200−1000)=P(Z>2)
利用標準常態分佈表換算機率：1−Φ(2)=1−0.9772=0.02281 - \Phi(2) = 1 - 0.9772 = \mathbf{0.0228}1−Φ(2)=1−0.9772=0.0228

期末考核心重點快速衝刺表#

1. 基礎機率與排容原理快速複習#

狄摩根定律：(A∪B)c=Ac∩Bc;(A∩B)c=Ac∪Bc(A \cup B)^c = A^c \cap B^c \quad ; \quad (A \cap B)^c = A^c \cup B^c(A∪B)c=Ac∩Bc;(A∩B)c=Ac∪Bc
排容原理：P(A∪B)=P(A)+P(B)−P(A∩B)P(A \cup B) = P(A) + P(B) - P(A \cap B)P(A∪B)=P(A)+P(B)−P(A∩B)
差集公式：P(A∩Bc)=P(A)−P(A∩B)P(A \cap B^c) = P(A) - P(A \cap B)P(A∩Bc)=P(A)−P(A∩B)
布林不等式：P(A∪B)≤P(A)+P(B)P(A \cup B) \le P(A) + P(B)P(A∪B)≤P(A)+P(B)

重要觀念：互斥 vs 獨立（觀念選擇題常考）

互斥 (Mutually Exclusive)：A∩B=∅ ⟹ P(A∩B)=0A \cap B = \emptyset \implies P(A \cap B) = 0A∩B=∅⟹P(A∩B)=0

獨立 (Independent)：P(A∩B)=P(A)⋅P(B)P(A \cap B) = P(A) \cdot P(B)P(A∩B)=P(A)⋅P(B)

定理：在事件機率皆大於零的前提下，「互斥事件必不獨立，獨立事件必不互斥」。

2. 條件機率與貝氏定理核心#

條件機率定義：P(A∣B)=P(A∩B)P(B)P(A \mid B) = \frac{P(A \cap B)}{P(B)}P(A∣B)=P(B)P(A∩B)
乘法連鎖律：P(A∩B∩C)=P(A)⋅P(B∣A)⋅P(C∣A∩B)P(A \cap B \cap C) = P(A) \cdot P(B \mid A) \cdot P(C \mid A \cap B)P(A∩B∩C)=P(A)⋅P(B∣A)⋅P(C∣A∩B)
全機率定理：P(A)=∑P(A∣Bi)⋅P(Bi)P(A) = \sum P(A \mid B_i) \cdot P(B_i)P(A)=∑P(A∣Bi)⋅P(Bi)
貝氏定理：P(Bk∣A)=P(A∣Bk)⋅P(Bk)P(A)P(B_k \mid A) = \frac{P(A \mid B_k) \cdot P(B_k)}{P(A)}P(Bk∣A)=P(A)P(A∣Bk)⋅P(Bk)

3. 隨機變數核心運算性質#

期望值 E[X]E[X]E[X]：離散型為 ∑x⋅p(x)\sum x \cdot p(x)∑x⋅p(x)；連續型為 ∫x⋅f(x)dx\int x \cdot f(x) dx∫x⋅f(x)dx
變異數核心公式：Var(X)=E[X2]−(E[X])2Var(X) = E[X^2] - (E[X])^2Var(X)=E[X2]−(E[X])2
線性轉換公式：
E[aX+b]=aE[X]+bE[aX + b] = aE[X] + bE[aX+b]=aE[X]+b
Var(aX+b)=a2⋅Var(X)Var(aX + b) = a^2 \cdot Var(X)Var(aX+b)=a2⋅Var(X) （注意：常態平移量 bbb 不影響波動度，倍數 aaa 提出需平方）

4. 必考機率分佈神表#

🎲 離散型分佈 (Discrete)#

分佈名稱	參數	機率質量函數 (PMF) P(X=k)P(X=k)P(X=k)	期望值 E[X]E[X]E[X]	變異數 Var(X)Var(X)Var(X)
二項分佈 (BinBinBin)	n,pn, pn,p	(nk)pk(1−p)n−k\binom{n}{k} p^k (1-p)^{n-k}(kn)pk(1−p)n−k	npnpnp	np(1−p)np(1-p)np(1−p)
幾何分佈 (GeoGeoGeo)	ppp	(1−p)k−1p(1-p)^{k-1} p(1−p)k−1p	1p\frac{1}{p}p1	1−pp2\frac{1-p}{p^2}p21−p
帕松分佈 (PoiPoiPoi)	λ\lambdaλ	λke−λk!\frac{\lambda^k e^{-\lambda}}{k!}k!λke−λ	λ\lambdaλ	λ\lambdaλ

📈 連續型分佈 (Continuous)#

分佈名稱	機率密度函數 (PDF) f(x)f(x)f(x)	期望值 E[X]E[X]E[X]	變異數 Var(X)Var(X)Var(X)	核心考點特性
均勻分佈 U(a,b)U(a,b)U(a,b)	1b−a\frac{1}{b-a}b−a1	a+b2\frac{a+b}{2}2a+b	(b−a)212\frac{(b-a)^2}{12}12(b−a)2	其 CDF 為 x−ab−a\frac{x-a}{b-a}b−ax−a
指數分佈 Exp(λ)Exp(\lambda)Exp(λ)	λe−λx\lambda e^{-\lambda x}λe−λx	1λ\frac{1}{\lambda}λ1	1λ2\frac{1}{\lambda^2}λ21	超尾機率 P(X>x)=e−λxP(X > x) = e^{-\lambda x}P(X>x)=e−λx；具無記憶性。
常態分佈 N(μ,σ2)N(\mu, \sigma^2)N(μ,σ2)	形式略	μ\muμ	σ2\sigma^2σ2	利用 Z=X−μσZ = \frac{X-\mu}{\sigma}Z=σX−μ 進行標準化與對稱查表。

5. 多變數與聯合分佈重要公式#

邊際 PDF（消去 yyy 保留 xxx）：fX(x)=∫−∞∞f(x,y)dyf_X(x) = \int_{-\infty}^{\infty} f(x,y) dyfX(x)=∫−∞∞f(x,y)dy
條件 PDF：fY∣X(y∣x)=f(x,y)fX(x)f_{Y\vert{}X}(y \mid x) = \frac{f(x,y)}{f_X(x)}fY∣X(y∣x)=fX(x)f(x,y) （計算時務必依據條件限制更新變數的積分邊界範圍）
獨立性簡單判定：若變數的幾何定義域邊界不是一個標準的矩形，兩變數絕對不獨立。
共變異數計算：Cov(X,Y)=E[XY]−E[X]E[Y]Cov(X,Y) = E[XY] - E[X]E[Y]Cov(X,Y)=E[XY]−E[X]E[Y]
線性組合之變異數：Var(X±Y)=Var(X)+Var(Y)±2Cov(X,Y)Var(X \pm Y) = Var(X) + Var(Y) \pm 2Cov(X,Y)Var(X±Y)=Var(X)+Var(Y)±2Cov(X,Y) （若 X,YX, YX,Y 獨立，則 Cov(X,Y)=0Cov(X,Y)=0Cov(X,Y)=0，變異數可直接相加）

6. 進階定理與不等式估計#

疊代期望值定理 (Tower Property)：E[Y]=E[E[Y∣X]]E[Y] = E[E[Y \mid X]]E[Y]=E[E[Y∣X]]
條件變異數公式 (Eve’s Law)：Var(Y)=E[Var(Y∣X)]+Var(E[Y∣X])Var(Y) = E[Var(Y \mid X)] + Var(E[Y \mid X])Var(Y)=E[Var(Y∣X)]+Var(E[Y∣X])
馬可夫不等式（適用於非負隨機變數，且 a>0a > 0a>0）：P(X≥a)≤E[X]aP(X \ge a) \le \frac{E[X]}{a}P(X≥a)≤aE[X]
柴比雪夫不等式：P(∣X−μ∣≥k)≤Var(X)k2P(\vert{}X-\mu\vert{} \ge k) \le \frac{Var(X)}{k^2}P(∣X−μ∣≥k)≤k2Var(X)
中央極限定理 (CLT)（當樣本數 n≥30n \ge 30n≥30 時）：總和的標準化隨機變數 Z=Sn−nμnσ∼N(0,1)Z = \frac{S_n - n\mu}{\sqrt{n}\sigma} \sim N(0,1)Z=nσSn−nμ∼N(0,1)

大一上離散數學

Wed, 13 May 2026 00:00:00 GMT

第一章：離散數學基礎與證明邏輯#

1. 命題邏輯與等價關係 (Propositional Logic)#

觀念與公式

直觀意義： 命題就像是一個開關，只能是「絕對的真 (True)」或「絕對的假 (False)」，不能模稜兩可。當我們用邏輯運算子（如 AND, OR, NOT）把多個命題串起來時，就像是在設計電路，透過真值表可以窮舉所有可能的結果。

必背公式與定律：

條件語句 (Conditional Statement): p→q≡¬p∨qp \rightarrow q \equiv \neg p \vee qp→q≡¬p∨q
雙條件語句 (Bi-conditional Statement): p↔q≡(p→q)∧(q→p)p \leftrightarrow q \equiv (p \rightarrow q) \wedge (q \rightarrow p)p↔q≡(p→q)∧(q→p)
笛摩根定律 (De Morgan’s Laws): ¬(p∨q)≡¬p∧¬q\neg (p \vee q) \equiv \neg p \wedge \neg q¬(p∨q)≡¬p∧¬q 以及 ¬(p∧q)≡¬p∨¬q\neg (p \wedge q) \equiv \neg p \vee \neg q¬(p∧q)≡¬p∨¬q
逆反命題 (Contrapositive): p→q≡¬q→¬pp \rightarrow q \equiv \neg q \rightarrow \neg pp→q≡¬q→¬p

實戰演練（題型大全）

【題型一：基本真值表判斷】（常考頻率：高）

題目： 證明 (p∧q)→(p∨q)(p \wedge q) \rightarrow (p \vee q)(p∧q)→(p∨q) 是一個恆真句 (Tautology)。

Step-by-step 解答：

將條件語句轉換為 OR 形式：¬(p∧q)∨(p∨q)\neg(p \wedge q) \vee (p \vee q)¬(p∧q)∨(p∨q) (透過 p→q≡¬p∨qp \rightarrow q \equiv \neg p \vee qp→q≡¬p∨q)。
套用笛摩根定律：(¬p∨¬q)∨(p∨q)(\neg p \vee \neg q) \vee (p \vee q)(¬p∨¬q)∨(p∨q)。
使用結合律與交換律重新分組：(¬p∨p)∨(¬q∨q)(\neg p \vee p) \vee (\neg q \vee q)(¬p∨p)∨(¬q∨q)。
套用否定律：T0∨T0≡T0T_0 \vee T_0 \equiv T_0T0∨T0≡T0 (恆真)。

【題型二：邏輯推理謎題】（重要程度：中）

題目： 在一個島上有兩種人：一種只說真話，一種只說謊話。你遇到 A 和 B 兩人。A 說：「B 總是說真話。」B 說：「我們是不同種類的人。」請問 A 和 B 分別是哪種人？

Step-by-step 解答：

假設 A 是說真話的人，那麼 B 也必須是說真話的人。
如果 B 也是說真話的人，B 說的「我們是不同種類的人」就變成假話，這與前提矛盾。
因此 A 必然是說謊話的人。
既然 A 說謊，A 說「B 說真話」是假的，代表 B 實際上也是說謊話的人。
B 說「我們是不同種類的人」是謊話，符合兩人都說謊（同種類）的事實。結論：兩人皆為說謊者。

2. 述詞與量詞 (Predicate Calculus)#

觀念與公式

直觀意義： 述詞就像是一個「填空題」P(x)P(x)P(x)，單看述詞並不知道真假；而量詞則是規定了「範圍」。全稱量詞 (∀\forall∀) 代表「每一個都要滿足條件」，存在量詞 (∃\exists∃) 代表「只要找到一個符合的即可」。

必背公式與定律：

量詞的笛摩根定律: ¬∀xP(x)≡∃x¬P(x)\neg \forall x P(x) \equiv \exists x \neg P(x)¬∀xP(x)≡∃x¬P(x) 以及 ¬∃xP(x)≡∀x¬P(x)\neg \exists x P(x) \equiv \forall x \neg P(x)¬∃xP(x)≡∀x¬P(x)

實戰演練（題型大全）

【題型一：量詞真偽判斷與反例】（常考頻率：高）

題目： 判斷 ∀x(x2≥x)\forall x (x^2 \ge x)∀x(x2≥x) 在不同論域 (Domain) 下的真偽：(a) 所有實數 (b) 所有整數。

Step-by-step 解答：

(a) 在實數領域中為 False。反例 (counter-example)：取 x=0.5x = 0.5x=0.5，0.52=0.250.5^2 = 0.250.52=0.25，並不 ≥0.5\ge 0.5≥0.5。
(b) 在整數領域中為 True。因為 x2≥x⇔x(x−1)≥0⇔x≤0x^2 \ge x \Leftrightarrow x(x-1) \ge 0 \Leftrightarrow x \le 0x2≥x⇔x(x−1)≥0⇔x≤0 或 x≥1x \ge 1x≥1。在整數中，不存在 0<x<10 < x < 10<x<1 的數字，故永遠成立。

【題型二：日常語句翻譯成邏輯符號】（常考頻率：極高）

題目： 將「每個人都恰好有一個最要好的朋友」轉換為邏輯表示式。令 B(x,y)B(x, y)B(x,y) 為「yyy 是 xxx 的最要好朋友」。

Step-by-step 解答：

「每個人 xxx」：∀x\forall x∀x。
「存在一個朋友 yyy」：∃y\exists y∃y。
「恰好只有這一個 yyy」：除了 yyy 之外的任何 zzz，如果也是好朋友，那麼 zzz 必定等於 yyy。
結合上述條件，推導邏輯表示法：∀x∃y(B(x,y)∧∀z(B(x,z)→z=y))\forall x \exists y (B(x,y) \wedge \forall z (B(x,z) \rightarrow z=y))∀x∃y(B(x,y)∧∀z(B(x,z)→z=y))。

3. 推理規則 (Rules of Inference)#

觀念與公式

直觀意義： 這是偵探辦案的標準流程。如果我們知道某些前提（線索）為真，就可以按照特定的套路（規則）推導出新的結論。最常用的招式是「若 A 則 B，現在 A 發生了，所以 B 一定會發生」。

必背公式與定律：

Modus Ponens (肯定前件): p,p→q⊢qp, p \rightarrow q \vdash qp,p→q⊢q
Modus Tollens (否定後件): ¬q,p→q⊢¬p\neg q, p \rightarrow q \vdash \neg p¬q,p→q⊢¬p
Hypothetical Syllogism (三段論): p→q,q→r⊢p→rp \rightarrow q, q \rightarrow r \vdash p \rightarrow rp→q,q→r⊢p→r
Disjunctive Syllogism (選言三段論): ¬p,p∨q⊢q\neg p, p \vee q \vdash q¬p,p∨q⊢q

實戰演練（題型大全）

【題型一：複合邏輯推理證明】（重要程度：高）

題目： 已知前提：(1) 如果你寄電子郵件給我，我就會寫完程式。(2) 如果你沒寄電子郵件給我，我就會早點睡覺。(3) 如果我早點睡覺，我就會神清氣爽地醒來。請證明結論：「如果我沒寫完程式，我就會神清氣爽地醒來」。

Step-by-step 解答：

定義變數：ppp = 你寄信、qqq = 我寫完程式、rrr = 我早睡、sss = 我神清氣爽。
前提列式：p→qp \rightarrow qp→q, ¬p→r\neg p \rightarrow r¬p→r, r→sr \rightarrow sr→s。目標結論：¬q→s\neg q \rightarrow s¬q→s。
利用 p→qp \rightarrow qp→q 的逆反命題：¬q→¬p\neg q \rightarrow \neg p¬q→¬p。
利用假言三段論結合 ¬q→¬p\neg q \rightarrow \neg p¬q→¬p 與 ¬p→r\neg p \rightarrow r¬p→r：得出 ¬q→r\neg q \rightarrow r¬q→r。
利用假言三段論結合 ¬q→r\neg q \rightarrow r¬q→r 與 r→sr \rightarrow sr→s：得出 ¬q→s\neg q \rightarrow s¬q→s，證明完畢。

4. 證明方法與策略 (Methods of Proving)#

觀念與公式

直觀意義： 面對數學命題的攻擊策略。「直接證明」是正面直拳擊破；「反證法 (Contradiction)」是先假裝對手是對的，然後找出邏輯漏洞自相矛盾；「對偶證明 (Contraposition)」則是閃避正面，從背後（否定結論）攻擊。

實戰演練（題型大全）

【題型一：對偶證明法 Contraposition】（常考頻率：高）

題目： 證明：如果 3n+23n+23n+2 是奇數，則 nnn 是奇數。

Step-by-step 解答：

假設結論的反面：nnn 是偶數。
這表示存在某個整數 kkk 使得 n=2kn = 2kn=2k。
代入原式：3n+2=3(2k)+2=6k+2=2(3k+1)3n+2 = 3(2k)+2 = 6k+2 = 2(3k+1)3n+2=3(2k)+2=6k+2=2(3k+1)。
因為 2(3k+1)2(3k+1)2(3k+1) 必定是偶數，代表 3n+23n+23n+2 是偶數。因為結論的否定推導出前提的否定，故原命題成立。

【題型二：反證法 Contradiction】（常考頻率：極高）

題目： 證明 2\sqrt{2}2 是無理數。

Step-by-step 解答：

假設 2\sqrt{2}2 是有理數，則它可以表示為兩個最簡整數比 a/ba/ba/b (b≠0b \neq 0b=0，且 a,ba,ba,b 互質)。
平方得到 2=a2/b22 = a^2 / b^22=a2/b2，移項得 a2=2b2a^2 = 2b^2a2=2b2。這代表 a2a^2a2 是偶數，推導出 aaa 也必須是偶數。
令 a=2ca = 2ca=2c，代回得 (2c)2=2b2⇒4c2=2b2⇒b2=2c2(2c)^2 = 2b^2 \Rightarrow 4c^2 = 2b^2 \Rightarrow b^2 = 2c^2(2c)2=2b2⇒4c2=2b2⇒b2=2c2。
這代表 b2b^2b2 是偶數，推導出 bbb 也是偶數。
若 a,ba, ba,b 皆為偶數，它們有公因數 2，與前提「最簡整數比」矛盾！故假設錯誤，2\sqrt{2}2 必為無理數。

【題型三：無效證明與邏輯謬誤】（重要程度：高）

題目： 找出證明 1=21=21=2 的謬誤。證明步驟為：a=b⇒a2=ab⇒a2−b2=ab−b2⇒(a−b)(a+b)=b(a−b)⇒a+b=b⇒2b=b⇒2=1a=b \Rightarrow a^2=ab \Rightarrow a^2-b^2=ab-b^2 \Rightarrow (a-b)(a+b)=b(a-b) \Rightarrow a+b=b \Rightarrow 2b=b \Rightarrow 2=1a=b⇒a2=ab⇒a2−b2=ab−b2⇒(a−b)(a+b)=b(a−b)⇒a+b=b⇒2b=b⇒2=1。

Step-by-step 解答：

錯誤發生在 (a−b)(a+b)=b(a−b)(a-b)(a+b)=b(a-b)(a−b)(a+b)=b(a−b) 轉換到 a+b=ba+b=ba+b=b 的這一步。
因為我們初始假設 a=ba=ba=b，所以 (a−b)=0(a-b) = 0(a−b)=0。
在等式兩邊同除以 (a−b)(a-b)(a−b) 等同於「除以 0」，這在數學上是不允許且無效的操作。

5. 數學歸納法 (Mathematical Induction)#

觀念與公式

直觀意義： 推骨牌效應。你要確保第一張骨牌會倒 (Basic Step, 基礎步 P(1)P(1)P(1))，並且證明「只要第 kkk 張骨牌倒下，就一定能推倒第 k+1k+1k+1 張」(Inductive Step, 歸納步 P(k)→P(k+1)P(k) \rightarrow P(k+1)P(k)→P(k+1))。全部成立後，所有骨牌都會倒下。

必背公式與定律：

標準歸納法核心： P(1)∧∀k(P(k)→P(k+1))⇒∀nP(n)P(1) \wedge \forall k (P(k) \rightarrow P(k+1)) \Rightarrow \forall n P(n)P(1)∧∀k(P(k)→P(k+1))⇒∀nP(n)
強歸納法核心： ∀n((P(1)∧P(2)∧...∧P(n))→P(n+1))\forall n ((P(1) \wedge P(2) \wedge ... \wedge P(n)) \rightarrow P(n+1))∀n((P(1)∧P(2)∧...∧P(n))→P(n+1))

實戰演練（題型大全）

【題型一：數列總和證明】（常考頻率：極高）

題目： 證明前 nnn 個正奇數的總和為 n2n^2n2。

Step-by-step 解答：

基礎步 (Basic Step)： 當 n=1n=1n=1 時，前 1 個正奇數為 1，其總和等於 12=11^2 = 112=1，成立。
歸納步 (Inductive Step)： 假設 P(k)P(k)P(k) 為真，即 1+3+...+(2k−1)=k21+3+...+(2k-1) = k^21+3+...+(2k−1)=k2。
我們要證明 P(k+1)P(k+1)P(k+1) 也為真。將 P(k)P(k)P(k) 加上下一個奇數 (2k+1)(2k+1)(2k+1)：1+3+...+(2k−1)+(2k+1)=k2+(2k+1)1+3+...+(2k-1)+(2k+1) = k^2 + (2k+1)1+3+...+(2k−1)+(2k+1)=k2+(2k+1)。
化簡等式右邊：k2+2k+1=(k+1)2k^2 + 2k + 1 = (k+1)^2k2+2k+1=(k+1)2。故得證。

【題型二：歸納法的經典錯誤】（常考頻率：中）

題目： 證明所有貓的顏色都一樣 (P(n)P(n)P(n) = 任意 nnn 隻貓顏色相同)。假設 P(k)P(k)P(k) 成立，當有 k+1k+1k+1 隻貓時，移走其中一隻 yyy，剩下的 kkk 隻貓顏色一樣。再把 yyy 換回來並移走另一隻貓，剩下的 kkk 隻貓顏色也一樣，因此所有貓顏色一樣。這個證明哪裡錯了？

Step-by-step 解答：

這個證明的漏洞在於歸納步從 P(1)P(1)P(1) 推向 P(2)P(2)P(2) 時失效。
當 k+1=2k+1 = 2k+1=2 隻貓時，移走一隻貓 yyy，剩下 1 隻貓 (顏色當然自己跟自己一樣)。
但當你把 yyy 換回來並移走另一隻時，這「兩組」剩下的貓（各只有一隻）之間，完全沒有交集 (Overlap) 的貓可以作為顏色相同的橋樑。
推論中斷，歸納失敗。

6. 鴿籠原理 (Pigeonhole Principle)#

觀念與公式

直觀意義： 如果你有 10 隻鴿子，但只有 9 個籠子，晚上鴿子回籠時，絕對「至少有一個籠子會擠兩隻以上的鴿子」。

必背公式與定律：

廣義鴿籠原理 (Generalized Pigeonhole Principle): 若將 NNN 個物件放入 kkk 個箱子中，至少會有一個箱子包含 ⌈N/k⌉\lceil N/k \rceil⌈N/k⌉ 個（或以上）的物件。

實戰演練（題型大全）

【題型一：同月出生問題】（常考頻率：高）

題目： 證明在 80 位以上的學生中，至少有 7 人在同一個月份出生。

Step-by-step 解答：

將「學生」當作鴿子 (N=80N = 80N=80)，將「月份」當作籠子 (k=12k = 12k=12)。
套用廣義鴿籠原理公式：⌈N/k⌉=⌈80/12⌉\lceil N/k \rceil = \lceil 80 / 12 \rceil⌈N/k⌉=⌈80/12⌉。
80/12=6.66...80 / 12 = 6.66...80/12=6.66...，無條件進位得到 7。
因此至少有 7 人在同一個月出生，證明完畢。

【題型二：棋盤上的城堡問題】（常考頻率：中）

題目： 證明若將 33 個城堡 (Rooks) 放在標準 8×88\times88×8 棋盤上，至少有 5 個城堡無法互相攻擊。

Step-by-step 解答：

城堡的攻擊模式為同行或同列。我們可以在棋盤上標記數字來建立「不互攻」的集合。
將棋盤劃分成對角線位移的標記區塊（例如對角線依序標上 1~8），同一數字的格子絕不會處於同行或同列。這產生了 8 個彼此獨立的箱子 (k=8k=8k=8)。
共有 33 個城堡 (N=33N=33N=33)。
根據鴿籠原理：⌈33/8⌉=⌈4.125⌉=5\lceil 33 / 8 \rceil = \lceil 4.125 \rceil = 5⌈33/8⌉=⌈4.125⌉=5。至少有 5 個城堡落在同一個標記區域，它們必定無法互相攻擊。

⚠️ 第一章考前避坑指南#

命題邏輯的陷阱： 絕對不要把條件語句 p→qp \rightarrow qp→q 和它的逆命題 (Converse) q→pq \rightarrow pq→p 搞混，兩者的真值完全不相等！
量詞的轄域 (Scope) 盲點： 使用全稱或存在量詞時，必須非常明確定義「論域 (Domain)」。同一個命題在整數論域為 True，在實數論域可能就是 False。
歸納法的虛假安全感： 不要因為 P(1)P(1)P(1) 成立，且代了 P(2),P(3)P(2), P(3)P(2),P(3) 發現好像對了，就直接下結論。歸納法的靈魂在於嚴謹推導 P(k)→P(k+1)P(k) \rightarrow P(k+1)P(k)→P(k+1)，且必須注意前後集合重疊的盲點（如前述貓咪顏色的謬誤）。
證明的除零謬誤： 使用直接證明法操作等式時，要相消或除以代數，務必檢查該代數是否為 0，否則會推導出 1=21=21=2 的荒謬結論。

第二章：離散數學核心——計數法則、排列與組合#

1. 加法與乘法原理 (Rule of Sum & Product)#

觀念與公式： 計數的最底層邏輯在於事件是否獨立與互斥。這如同在 AtCoder 或 Codeforces 等平台上分析演算法時，並列的迴圈時間複雜度相加，而巢狀迴圈的時間複雜度則相乘。

加法原理 (Rule of Sum)：處理「互斥事件」（OR 邏輯）。若事件 A 有 mmm 種方法，事件 B 有 nnn 種方法，兩者不能同時發生，則總方法數為 m+nm + nm+n。
乘法原理 (Rule of Product)：處理「連續或獨立事件」（AND 邏輯）。若事件 A 有 mmm 種方法，接著事件 B 有 nnn 種方法，則總方法數為 m×nm \times nm×n。

實戰演練（題型大全）：

【題型一：因數個數計算】（常考頻率：高）

題目：請問 1400 共有多少個正因數？

Step-by-step 解答：

進行質因數分解：1400=23×52×71400 = 2^3 \times 5^2 \times 71400=23×52×7。
每個質因數的次方數加 1 後相乘（代表取 0 次到最大次方的選擇）：(3+1)×(2+1)×(1+1)=24(3+1) \times (2+1) \times (1+1) = 24(3+1)×(2+1)×(1+1)=24 個因數。

【題型二：多類別物件選擇】（常考頻率：中）

題目：有 5 本中文書、7 本英文書、10 本法文書，要從中挑選兩本「不同語言」的書，有幾種選法？

Step-by-step 解答：

分為三種互斥情況：中英、中法、英法。
應用乘法與加法原理：5×7+5×10+7×10=1555 \times 7 + 5 \times 10 + 7 \times 10 = 1555×7+5×10+7×10=155 種。

2. 排斥原理與樹狀圖 (Inclusion-Exclusion & Tree Diagrams)#

觀念與公式：

排斥原理 (Principle of Inclusion-Exclusion)：當計算兩組事件的方法數時，為避免重複計算交集的部分，必須將其扣除。公式為 ∣A∪B∣=∣A∣+∣B∣−∣A∩B∣|A \cup B| = |A| + |B| - |A \cap B|∣A∪B∣=∣A∣+∣B∣−∣A∩B∣。
樹狀圖 (Tree Diagrams)：適合用來窮舉並視覺化有條件限制的連續選擇，類似演算法中的深度優先搜尋 (DFS) 遍歷狀態樹。

實戰演練（題型大全）：

【題型一：字串條件聯集】（常考頻率：極高）

題目：長度為 8 的位元字串中，有多少個是「以 1 開頭」或「以 00 結尾」？

Step-by-step 解答：

以 1 開頭的字串數：剩下的 7 個位元可任意填，共 27=1282^7 = 12827=128 種。
以 00 結尾的字串數：前面的 6 個位元可任意填，共 26=642^6 = 6426=64 種。
同時以 1 開頭且以 00 結尾的字串數：中間 5 個位元可任意填，共 25=322^5 = 3225=32 種。
總數 =128+64−32=160= 128 + 64 - 32 = 160=128+64−32=160 種。

【題型二：反向扣除法】（常考頻率：高）

題目：350 位求職者中，220 位主修 CS，147 位主修商業，51 位雙主修 CS 與商業。請問有多少位「既沒有主修 CS 也沒有主修商業」？

Step-by-step 解答：

先算出有主修其中至少一項的人數：220+147−51=316220 + 147 - 51 = 316220+147−51=316。
總人數扣除上述人數：350−316=34350 - 316 = 34350−316=34 位。

3. 排列與組合 (Permutations and Combinations)#

觀念與公式：

排列 (Permutation)：從 nnn 個相異物件中選出 rrr 個並考慮順序。公式：P(n,r)=n!(n−r)!P(n,r) = \frac{n!}{(n-r)!}P(n,r)=(n−r)!n!。
組合 (Combination)：從 nnn 個相異物件中選出 rrr 個，不考慮順序。公式：C(n,r)=n!r!(n−r)!C(n,r) = \frac{n!}{r!(n-r)!}C(n,r)=r!(n−r)!n!。
核心關聯：P(n,r)=P(r,r)×C(n,r)P(n,r) = P(r,r) \times C(n,r)P(n,r)=P(r,r)×C(n,r)。

實戰演練（題型大全）：

【題型一：不可區分物件排列（同物排列）】（常考頻率：極高）

題目：重新排列單字 “SUCCESS” 的字母，能產生多少種不同的字串？

Step-by-step 解答：

“SUCCESS” 共 7 個字母，若全相異則有 7!7!7! 種排列。
處理不可區分的物件：其中有 2 個 ‘C’ 和 3 個 ‘S’ 是不可區分的。
根據公式 n!n1!n2!...nk!\frac{n!}{n_1! n_2! ... n_k!}n1!n2!...nk!n!，答案為 7!2!3!\frac{7!}{2!3!}2!3!7! 種。

4. 重複組合與隔板法 (Combinations with Repetitions)#

觀念與公式： 當從 nnn 種不同的物件中選出 rrr 個，且不考慮順序、每種物件有無限供應時，此即為重複組合。

隔板法 (Stars and Bars)：等價於從 (n−1+r)(n-1+r)(n−1+r) 個位置中選出 rrr 個位置放球，即 C(n−1+r,r)C(n-1+r, r)C(n−1+r,r)。

實戰演練（題型大全）：

【題型一：方程式非負整數解】（常考頻率：極高）

題目：方程式 x+y+z=11x+y+z=11x+y+z=11 中，若 x,y,zx, y, zx,y,z 皆為非負整數，共有幾組解？

Step-by-step 解答：

將 11 視為 r=11r=11r=11 顆相同的球，變數 x,y,zx, y, zx,y,z 視為 n=3n=3n=3 個不同的箱子。
代入隔板法公式 C(n−1+r,r)=C(3−1+11,11)=C(13,11)C(n-1+r, r) = C(3-1+11, 11) = C(13, 11)C(n−1+r,r)=C(3−1+11,11)=C(13,11) 組解。

5. 經典恆等式與二項式定理 (Identities and Binomial Theorem)#

觀念與公式：

Pascal 恆等式：C(n,r)=C(n−1,r)+C(n−1,r−1)C(n,r) = C(n-1, r) + C(n-1, r-1)C(n,r)=C(n−1,r)+C(n−1,r−1)。
二項式定理：(x+y)n=∑r=0nC(n,r)xn−ryr(x+y)^n = \sum_{r=0}^n C(n,r) x^{n-r} y^r(x+y)n=∑r=0nC(n,r)xn−ryr。
Vandermonde 恆等式：C(m+n,r)=∑k=0rC(m,r−k)C(n,k)C(m+n, r) = \sum_{k=0}^r C(m, r-k) C(n, k)C(m+n,r)=∑k=0rC(m,r−k)C(n,k)。

實戰演練（題型大全）：

【題型一：利用 Vandermonde 簡化級數】（常考頻率：高）

題目：化簡 ∑k=0nC(n,k)2\sum_{k=0}^n C(n,k)^2∑k=0nC(n,k)2。

Step-by-step 解答：

將平方拆解，並利用組合對稱性：∑k=0nC(n,k)2=∑k=0nC(n,n−k)C(n,k)\sum_{k=0}^n C(n,k)^2 = \sum_{k=0}^n C(n,n-k)C(n,k)∑k=0nC(n,k)2=∑k=0nC(n,n−k)C(n,k)。
對照 Vandermonde 恆等式，令 m=nm=nm=n、r=nr=nr=n，即可將原式化簡為 C(2n,n)C(2n, n)C(2n,n)。

⚠️ 第二章考前避坑指南#

「排列」與「組合」的誤用：看見題目先問自己「順序互換是否代表不同結果？」，若不影響絕對是組合 (CCC)。
同物排列忘記除掉階乘：計算密碼或字串時，若出現相同的字元，最後總排列數務必除以重複字元個數的階乘。
「至少」題型未用反向扣除：題目若出現「至少包含一個」這類字眼，正面窮舉極易遺漏情況，請立刻切換為「全部情況 −-− 完全沒有的情況」。

第三章：離散數學底層邏輯——集合、函數與關係#

1. 集合論、勢與排容原理 (Sets, Cardinality & Inclusion-Exclusion)#

觀念與公式： 集合（Set）是無序的物件集合，在資訊工程中，無論是資料庫查詢還是演算法的狀態空間，皆建立在集合操作之上。

冪集 (Power Set)： 集合 AAA 的所有子集所構成的集合 2A2^A2A。若 ∣A∣=n|A| = n∣A∣=n，則 ∣2A∣=2n|2^A| = 2^n∣2A∣=2n。
排容原理推廣： 用於精準計算聯集大小。奇數個集合的交集為正號，偶數個集合的交集為負號。

實戰演練（題型大全）：

【題型一：排容原理應用】

題目： 請問在 1 到 250 之間的整數中，有多少個數字可以被 2, 3, 5, 或 7 整除？

Step-by-step 解答：

定義 A2,A3,A5,A7A_2, A_3, A_5, A_7A2,A3,A5,A7 分別為 1 到 250 之間能被 2, 3, 5, 7 整除的集合。
計算單一集合大小：∣A2∣=⌊250/2⌋=125|A_2| = \lfloor 250/2 \rfloor = 125∣A2∣=⌊250/2⌋=125，∣A3∣=83|A_3| = 83∣A3∣=83，∣A5∣=50|A_5| = 50∣A5∣=50，∣A7∣=35|A_7| = 35∣A7∣=35。
計算兩兩交集（取最小公倍數）：∣A2∩A3∣=⌊250/6⌋=41|A_2 \cap A_3| = \lfloor 250/6 \rfloor = 41∣A2∩A3∣=⌊250/6⌋=41，依序計算出所有 C24=6C^4_2 = 6C24=6 種組合。
計算三個交集：∣A2∩A3∩A5∣=⌊250/30⌋=8|A_2 \cap A_3 \cap A_5| = \lfloor 250/30 \rfloor = 8∣A2∩A3∩A5∣=⌊250/30⌋=8，依序計算出所有 C34=4C^4_3 = 4C34=4 種組合。
計算四個交集：∣A2∩A3∩A5∩A7∣=⌊250/210⌋=1|A_2 \cap A_3 \cap A_5 \cap A_7| = \lfloor 250/210 \rfloor = 1∣A2∩A3∩A5∩A7∣=⌊250/210⌋=1。
套用公式：(125+83+50+35)−(41+25+17+16+11+7)+(8+5+3+2)−1=193(125+83+50+35) - (41+25+17+16+11+7) + (8+5+3+2) - 1 = 193(125+83+50+35)−(41+25+17+16+11+7)+(8+5+3+2)−1=193。

2. 函數映射與高斯符號 (Functions, Floor & Ceiling)#

觀念與公式：

核心映射關係：
Injective (單射)： f(a)=f(b) ⟹ a=bf(a) = f(b) \implies a = bf(a)=f(b)⟹a=b。
Surjective (滿射)： 對應域等於值域 (Range)。
Bijective (雙射)： 同時滿足單射與滿射。
高斯符號運算定律 (已知 nnn 為整數)：
⌊−x⌋=−⌈x⌉\lfloor -x \rfloor = -\lceil x \rceil⌊−x⌋=−⌈x⌉
⌊x+n⌋=⌊x⌋+n\lfloor x+n \rfloor = \lfloor x \rfloor + n⌊x+n⌋=⌊x⌋+n
⌈x+y⌉≠⌈x⌉+⌈y⌉\lceil x+y \rceil \neq \lceil x \rceil + \lceil y \rceil⌈x+y⌉=⌈x⌉+⌈y⌉

實戰演練（題型大全）：

【題型一：高斯符號的代數證明】

題目： 證明 ⌊2x⌋=⌊x⌋+⌊x+0.5⌋\lfloor 2x \rfloor = \lfloor x \rfloor + \lfloor x + 0.5 \rfloor⌊2x⌋=⌊x⌋+⌊x+0.5⌋ 對所有實數 xxx 皆成立。

Step-by-step 解答：

令小數部分 {x}=x−⌊x⌋\{x\} = x - \lfloor x \rfloor{x}=x−⌊x⌋。
左式 (LHS) =⌊2⌊x⌋+2{x}⌋=2⌊x⌋+⌊2{x}⌋= \lfloor 2\lfloor x \rfloor + 2\{x\} \rfloor = 2\lfloor x \rfloor + \lfloor 2\{x\} \rfloor=⌊2⌊x⌋+2{x}⌋=2⌊x⌋+⌊2{x}⌋。
Case 1： 0≤{x}<0.5 ⟹ 0≤2{x}<10 \le \{x\} < 0.5 \implies 0 \le 2\{x\} < 10≤{x}<0.5⟹0≤2{x}<1。左式 =2⌊x⌋+0= 2\lfloor x \rfloor + 0=2⌊x⌋+0。右式 =⌊x⌋+⌊x+0.5⌋=⌊x⌋+⌊x⌋=2⌊x⌋= \lfloor x \rfloor + \lfloor x + 0.5 \rfloor = \lfloor x \rfloor + \lfloor x \rfloor = 2\lfloor x \rfloor=⌊x⌋+⌊x+0.5⌋=⌊x⌋+⌊x⌋=2⌊x⌋。左式 = 右式。
Case 2： 0.5≤{x}<1 ⟹ 1≤2{x}<20.5 \le \{x\} < 1 \implies 1 \le 2\{x\} < 20.5≤{x}<1⟹1≤2{x}<2。左式 =2⌊x⌋+1= 2\lfloor x \rfloor + 1=2⌊x⌋+1。右式 =⌊x⌋+(⌊x⌋+1)=2⌊x⌋+1= \lfloor x \rfloor + (\lfloor x \rfloor + 1) = 2\lfloor x \rfloor + 1=⌊x⌋+(⌊x⌋+1)=2⌊x⌋+1。左式 = 右式。

3. 二元關係與遞移閉包 (Binary Relations & Closures)#

觀念與公式： 二元關係直接對應到有向圖的結構。

四大核心性質： 反身性 (Reflexive)、對稱性 (Symmetric)、反對稱性 (Antisymmetric)、遞移性 (Transitive)。在離散數學中，二元關係（Binary Relation）如果定義在一個集合 AAA 上，我們可以用有向圖（Directed Graph）來完美視覺化：
集合中的元素就是圖上的頂點（Vertices）。
如果元素 aaa 和 bbb 有關係（即 (a,b)∈R(a, b) \in R(a,b)∈R），就在圖上畫一條從 aaa 指向 bbb 的有向邊（Edge）。

1. 反身性 (Reflexive)#

數學定義： 對於集合中的每一個元素 aaa，(a,a)(a, a)(a,a) 都必須在關係中。
圖形特徵： 圖上的每一個頂點，都必須有一條指向自己的「自環」（Loop）。只要有一個頂點漏掉，就不是反身。
生活實例： 「等於（===）」、「大於等於（≥\ge≥）」、「實數 a,ba, ba,b 滿足 a×b≥0a \times b \ge 0a×b≥0」。
例子： 每一個數字都等於自己（5=55 = 55=5），所以「等於」具備反身性。

2. 對稱性 (Symmetric)#

數學定義： 如果 (a,b)(a, b)(a,b) 在關係中，那麼顛倒過來的 (b,a)(b, a)(b,a) 也必須在關係中。
圖形特徵： 圖上只要有從 aaa 到 bbb 的單向箭頭，就必定同時存在一條從 bbb 到 aaa 的回頭箭頭。換句話說，所有頂點之間的連線要嘛不連，要連就一定是「雙向道」。
生活實例： 「兄弟姊妹關係」、「同學關係」、「距離小於 5 公里」。
例子： 如果甲是乙的同學，乙就一定是甲的同學。

3. 反對稱性 (Antisymmetric)#

數學定義： 如果 (a,b)(a, b)(a,b) 在關係中，且 (b,a)(b, a)(b,a) 也在關係中，那麼 aaa 和 bbb 必須是同一個元素（即 a=ba = ba=b）。
白話文： 絕對不允許出現不同頂點之間的「雙向道」。
圖形特徵： 任意兩個不同的頂點之間，最多只能有「單向道」，或者完全沒連線。唯一的雙向道只能發生在頂點自己指自己的「自環」上。
生活實例： 「小於等於（≤\le≤）」、「包含於（⊆\subseteq⊆）」。
例子： 如果數字 x≤yx \le yx≤y 且 y≤xy \le xy≤x，這兩個數字唯一的可能就是 x=yx = yx=y。

4. 遞移性 (Transitive)#

數學定義： 如果 (a,b)(a, b)(a,b) 在關係中，且 (b,c)(b, c)(b,c) 也在關係中，那麼起點到終點的 (a,c)(a, c)(a,c) 也必須在關係中。
圖形特徵： 如果圖上有一條路徑可以從 aaa 走到 bbb，再從 bbb 走到 ccc，那麼圖上就必須存在一條「捷徑」直接從 aaa 指向 ccc。
生活實例： 「大於（>>>）」、「等於（===）」、「祖先關係」。
例子： 如果張三比李四高（a>ba > ba>b），李四又比王五高（b>cb > cb>c），那張三一定比王五高（a>ca > ca>c）。

這四個性質是後續衍生出兩個離散數學超級大考點的基石：

等價關係 (Equivalence Relation)： 同時具備 反身、對稱、遞移（就像「等於」）。
偏序關係 (Partial Order Relation)： 同時具備 反身、反對稱、遞移（就像「小於等於」）。

遞移閉包演算法： 包含原關係的「最小」遞移關係。在競賽中常使用 Floyd-Warshall 演算法，時間複雜度為 O(n3)O(n^3)O(n3)。

實戰演練（題型大全）：

【題型一：遞移閉包的構造】

題目： 尋找關係 R={(1,1),(1,2),(2,3),(2,4),(3,4),(4,2)}R = \{(1,1), (1,2), (2,3), (2,4), (3,4), (4,2)\}R={(1,1),(1,2),(2,3),(2,4),(3,4),(4,2)} 的遞移閉包 (Transitive Closure)。

Step-by-step 解答：

建立初始有向圖與矩陣 R1=RR^1 = RR1=R。
計算 R2R^2R2 (走兩步可達的點對)：因為 (1,2)(1,2)(1,2) 與 (2,3)(2,3)(2,3)，新增 (1,3)(1,3)(1,3)。因為 (1,2)(1,2)(1,2) 與 (2,4)(2,4)(2,4)，新增 (1,4)(1,4)(1,4)。因為 (3,4)(3,4)(3,4) 與 (4,2)(4,2)(4,2)，新增 (3,2)(3,2)(3,2) 等等。
計算 R3R^3R3 直到沒有新邊加入為止。
最終檢查圖中任何一條長度大於 1 的路徑，確保起終點間皆有直接連線，即為遞移閉包矩陣。

4. 等價關係、偏序集與格 (Equivalence Relations, Posets & Lattices)#

觀念與公式：

等價關係： 同時具備反身性、對稱性、遞移性。它會將集合切割成數個互不相交的「等價類」。
偏序集 (Poset)： 同時具備反身性、反對稱性、遞移性。
Hasse Diagram (哈斯圖)： 去除自環、省略遞移邊，統一朝上簡化的圖形。
格 (Lattice)： 在偏序集中，若任意兩元素都有唯一的「最小上界 (LUB)」與「最大下界 (GLB)」，則該偏序集稱為格。

實戰演練（題型大全）：

【題型一：Hasse Diagram 與格的判斷】

題目： 給定偏序集 ({1,2,3,4,6,8,12},∣)(\{1,2,3,4,6,8,12\}, |)({1,2,3,4,6,8,12},∣)，其中 ∣|∣ 代表整除關係。請建構 Hasse Diagram 並判斷它是否為 Lattice。

Step-by-step 解答：

建構哈斯圖： 最底層放置 111。上一層放置 2,32, 32,3。再上一層放置 4,64, 64,6。最上層放置 8,128, 128,12。依照整除關係連線並隱藏遞移邊。
尋找極端值： 極大值 (Maximal) 為頂端沒有對外連線的節點：8,128, 128,12。極小值 (Minimal) 為底端：111。
Lattice 判斷： 考慮點 888 與 121212。它們的 LUB 應該是 24，但在集合 {1,2,3,4,6,8,12}\{1,2,3,4,6,8,12\}{1,2,3,4,6,8,12} 中不存在共同的上界，因此該偏序集不是格 (Lattice)。

⚠️ 第三章考前避坑指南#

空集的陷阱： ∅⊆A\emptyset \subseteq A∅⊆A 永遠成立，但 ∅∈A\emptyset \in A∅∈A 不一定成立。務必分清「子集」與「元素」的符號差異。
反對稱 ≠\neq= 不對稱： Antisymmetric 絕對不是 Symmetric 的相反詞！一個關係可以同時是對稱且反對稱的。
等價類互斥定律： 任意兩個等價類要嘛完全相等，要嘛交集為空，絕對不可能出現「部分重疊」的狀況。

第四章：圖論 (Graph Theory)#

1. 圖的基礎定義與術語 (Graph Basics & Terminology)#

觀念與公式#

直觀意義：圖 (Graph) 是用來描述物件之間「關聯性」的數學結構。想像節點 (Vertices) 是城市，邊 (Edges) 是連接城市的公路。若公路是單行道，則是「有向圖 (Directed Graph)」；若雙向皆可通行，則是「無向圖 (Undirected Graph)」。

圖的正式定義：G=(V,E)G = (V, E)G=(V,E)，其中 VVV 是非空頂點集合，EEE 是邊集合。
簡單圖 (Simple Graph)：沒有自我環 (Self-loop，即起點與終點相同的邊)，且兩節點間最多只有一條邊的圖。
分支度 (Degree)：deg⁡(v)\deg(v)deg(v) 代表連接到頂點 vvv 的邊數。注意：一個自我環 (Loop) 對該頂點的 deg⁡(v)\deg(v)deg(v) 會貢獻 2 次。
有向圖分支度：分為入分支度 deg⁡−(v)\deg^-(v)deg−(v) (箭頭指向 vvv) 與出分支度 deg⁡+(v)\deg^+(v)deg+(v) (箭頭離開 vvv)。

實戰演練（題型大全）#

基礎考題 1：圖的最大邊數極限 假設有一個具備 nnn 個頂點的簡單圖 GGG。請問在 (1) GGG 是無向圖 (2) GGG 是有向圖的情況下，最多可以包含幾條邊？

【Step-by-step 解析】

(1) 無向簡單圖：每兩個不同的頂點之間最多只能存在一條邊，且沒有自我環。這是高中排列組合的經典問題：從 nnn 個頂點中任選 2 個頂點連線，共有 C(n,2)C(n, 2)C(n,2) 種可能。

Max Edges (Undirected)=(n2)=n(n−1)2\text{Max Edges (Undirected)} = \binom{n}{2} = \frac{n(n-1)}{2}Max Edges (Undirected)=(2n)=2n(n−1)

(2) 有向簡單圖：每兩個頂點 u,vu, vu,v 之間，可以有 u→vu \to vu→v 以及 v→uv \to uv→u 兩條邊。因此邊數是無向圖的兩倍。

Max Edges (Directed)=2×(n2)=n(n−1)\text{Max Edges (Directed)} = 2 \times \binom{n}{2} = n(n-1)Max Edges (Directed)=2×(2n)=n(n−1)

2. 握手定理 (Handshaking Theorem)#

觀念與公式#

直觀意義：一場派對中，每發生一次「握手」(一條邊)，必然會有「兩個人」(兩個頂點) 參與。因此，所有人握手的總次數，一定是實際發生握手事件數量的兩倍。

無向圖握手定理：

∑v∈Vdeg⁡(v)=2m\sum_{v \in V} \deg(v) = 2m∑v∈Vdeg(v)=2m

(其中 mmm 為總邊數。每條邊必貢獻 2 個分支度)

有向圖握手定理：一條有向邊必然有一個起點和一個終點，故總入分支度必定等於總出分支度，且等於總邊數 mmm。

∑v∈Vdeg⁡−(v)=∑u∈Vdeg⁡+(u)=m\sum_{v \in V} \deg^-(v) = \sum_{u \in V} \deg^+(u) = m∑v∈Vdeg−(v)=∑u∈Vdeg+(u)=m

必背推論 (Corollary)：任何無向圖中，「奇數分支度的頂點」之總數量必定是偶數。這在證明題中極度常考！

實戰演練（題型大全）#

經典證明題：奇數點數量的限制 證明：「在任何無向圖中，奇數分支度 (odd degree) 的頂點個數必定為偶數。」

【Step-by-step 解析】

將所有頂點集合 VVV 拆分為兩個子集：偶數分支度頂點集合 VevenV_{even}Veven 與奇數分支度頂點集合 VoddV_{odd}Vodd。
根據握手定理：

2m=∑v∈Vdeg⁡(v)=∑v∈Vevendeg⁡(v)+∑v∈Vodddeg⁡(v)2m = \sum_{v \in V} \deg(v) = \sum_{v \in V_{even}} \deg(v) + \sum_{v \in V_{odd}} \deg(v)2m=∑v∈Vdeg(v)=∑v∈Vevendeg(v)+∑v∈Vodddeg(v)

觀察等式：左式 2m2m2m 是一個偶數；右式第一項 ∑v∈Vevendeg⁡(v)\sum_{v \in V_{even}} \deg(v)∑v∈Vevendeg(v) 因為每個項都是偶數，加總必為偶數。
因此，右式第二項 ∑v∈Vodddeg⁡(v)\sum_{v \in V_{odd}} \deg(v)∑v∈Vodddeg(v) 也必須是偶數。
由於 VoddV_{odd}Vodd 中每個頂點的分支度都是奇數，要讓一堆奇數相加成為偶數，這些奇數的「個數」必須是偶數。故得證。

3. 特殊簡單圖與二分圖 (Special Simple Graphs & Bipartite Graphs)#

觀念與公式#

熟悉以下幾種標準積木，它們是建構複雜題目的基礎：

完全圖 (Complete Graph, KnK_nKn)：nnn 個頂點，任兩點間皆有連線。
環狀圖 (Cycle, CnC_nCn, n≥3n \ge 3n≥3)：nnn 個頂點排成一個圈。
輪狀圖 (Wheel, WnW_nWn, n≥3n \ge 3n≥3)：在 CnC_nCn 中間加上一個「軸心」頂點，並與外圈 nnn 個點全部連線。總頂點數為 n+1n+1n+1。
NNN 維方塊圖 (n-cube, QnQ_nQn)：擁有 2n2^n2n 個頂點。可想成二進位字串，若兩個頂點的字串只有「1個 bit」不同，則存在一條邊。
二分圖 (Bipartite Graph)：頂點可完美劃分為兩個互不相交的集合 VVV 與 WWW，使得圖中所有的邊都只跨越這兩個集合之間（集合內部絕對沒有邊）。

完全二分圖 (Km,nK_{m,n}Km,n)：集合 VVV 有 mmm 個頂點，集合 WWW 有 nnn 個頂點，兩集合間「所有可能的連線」都存在。

實戰演練（題型大全）#

常考判斷題：二分圖的著色判別法 說明如何演算法化地檢查一個連通圖是否為二分圖？

【Step-by-step 解析】

定理：一個圖是二分圖 ⟺ \iff⟺ 可以使用「2 種顏色」對所有頂點進行著色，且相鄰頂點顏色不同。
檢驗演算法 (BFS/DFS 著色法)：

挑選任意起始點 uuu，塗上「白色」。
將 uuu 的所有鄰居塗成「黑色」。
將所有「黑色」鄰居的鄰居塗成「白色」，依此類推，直到所有相連點都塗色。
驗收：檢查圖中是否有任何邊的兩個端點是「同色」。若有同色邊，則回報 NO (非二分圖)；若無，回報 YES (是二分圖)。 (補充：圖中若存在「奇數長度的環 (Odd Cycle)」，則絕對不是二分圖，必定著色失敗)

4. 尤拉路徑與迴路 (Euler Paths & Circuits)#

觀念與公式#

直觀意義：「一筆畫問題」。想像你在玩連連看，你要走過所有的邊，且每條邊只能走過一次。

尤拉路徑 (Euler Path)：經過所有邊恰好一次的路徑。
尤拉迴路 (Euler Circuit)：經過所有邊恰好一次，且「起點等於終點」的路徑。
存在性充要條件 (若 GGG 為連通圖)：
尤拉迴路 ⟺ \iff⟺ 圖中每個頂點的分支度皆為偶數 (even degree)。
尤拉路徑 (但非迴路) ⟺ \iff⟺ 圖中恰好有 2 個頂點的分支度為奇數 (這兩點即為起點與終點)。

實戰演練（題型大全）#

觀念證明題：尤拉迴路定理的必要性證明 證明：若連通圖 GGG 具有尤拉迴路，則所有頂點的分支度必為偶數。

【Step-by-step 解析】

假設圖 GGG 存在一條尤拉迴路。
當我們沿著這條尤拉迴路走訪邊時，對於任意一個頂點 vvv，我們每一次「進入」該頂點，必然會立刻接著「離開」該頂點。
也就是說，每經過一次頂點 vvv，都會消耗掉相連於 vvv 的 222 條邊 (一進一出)。
因為尤拉迴路會精準涵蓋圖上的「每一條邊」恰好一次，且最終回到起點，所以對任何頂點 vvv 而言，總進入次數必等於總離開次數。
因此，頂點 vvv 身上連接著的總邊數 (即分支度) 必然是 222 的倍數。得證所有頂點的分支度皆為偶數。

5. 漢密爾頓路徑與迴路 (Hamilton Paths & Circuits)#

觀念與公式#

直觀意義：「推銷員問題」。推銷員必須拜訪每個城市，但他不在乎是否走過每一條公路。條件是：每個「頂點」必須恰好走過一次。

Hamilton Path / Circuit：恰好走訪每個頂點一次的路徑/迴路。
難度陷阱：不像尤拉路徑有簡單的充要條件判斷，漢密爾頓迴路問題是 NP-Complete，目前不存在多項式時間的高效演算法。
充分條件 (Sufficient Conditions)：如果圖的「邊夠密集」，就能保證有漢密爾頓迴路。

Dirac’s Theorem：若每個頂點的 deg⁡(v)≥n/2\deg(v) \ge n/2deg(v)≥n/2，必有漢密爾頓迴路。
Ore’s Theorem：對任意「不相鄰」的兩頂點 u,vu, vu,v，只要 deg⁡(u)+deg⁡(v)≥n\deg(u) + \deg(v) \ge ndeg(u)+deg(v)≥n，必有漢密爾頓迴路。
Bondy-Chvátal Theorem：圖 GGG 擁有漢密爾頓迴路 ⟺ \iff⟺ GGG 的 Hamilton Closure 擁有漢密爾頓迴路。(Hamilton Closure 的作法：若兩不相鄰點度數和 ≥n\ge n≥n，則補上一條邊，遞迴進行直到不能補為止。)

實戰演練（題型大全）#

操作題：Hamilton Closure 求法 試描述尋找 Hamilton Closure 的演算法，並解釋如何藉此判斷迴路存在性。

【Step-by-step 解析】

掃描圖中所有「尚未有邊相連 (non-adjacent)」的點對 (u,v)(u, v)(u,v)。
檢查它們的分支度之和：如果 deg⁡(u)+deg⁡(v)≥n\deg(u) + \deg(v) \ge ndeg(u)+deg(v)≥n (其中 nnn 為總點數)，則在此兩點間強制「加上一條邊」。
由於加上新邊會導致 uuu 和 vvv 的度數增加，這可能觸發其他原本度數不夠的點對達標。因此，必須遞迴且反覆執行步驟 1 與 2，直到沒有任何一對不相鄰點滿足該條件為止。
最終產生出來的圖即為 Hamilton Closure。
結論推演：如果最終得到的 Closure 是一個完全圖 KnK_nKn (當 n≥3n \ge 3n≥3 時完全圖必有漢密爾頓迴路)，我們就能保證原本的圖 GGG 也必然有漢密爾頓迴路。

6. 平面圖與尤拉公式 (Planar Graphs & Euler’s Formula)#

觀念與公式#

直觀意義：電路板佈線問題。一堆節點要在二維平面上連線，能不能做到「任何兩條線都不會交叉」？如果可以，這張圖就是平面圖 (Planar Graph)。

尤拉平面公式 (Euler’s Planar Formula)：對於任何連通平面圖，令 VVV 為節點數，EEE 為邊數，FFF 為平面被切割出的區域數 (Regions，務必包含最外面那圈無限大的區域 Infinite Region)：

V+F=E+2V + F = E + 2V+F=E+2

平面圖的極限邊數 (必要條件)：若 V≥3V \ge 3V≥3，每一個區域 (包含無限區域) 至少由 3 條邊圍成。推導得出極大邊數不等式：

E≤3V−6E \le 3V - 6E≤3V−6

(注意：若圖是二分圖，則沒有奇數環，區域最少由 4 條邊圍成，公式縮緊為 E≤2V−4E \le 2V - 4E≤2V−4)

實戰演練（題型大全）#

經典證明題 1：證明 K5K_5K5 與 K3,3K_{3,3}K3,3 不是平面圖 這兩張圖是平面圖的兩大「地雷」，請用尤拉不等式嚴格證明它們無法畫在平面上。

【Step-by-step 解析】

證明 K5K_5K5 (5個頂點的完全圖) 非平面圖：

K5K_5K5 的節點數 V=5V = 5V=5。因為是完全圖，邊數 E=(52)=10E = \binom{5}{2} = 10E=(25)=10。
代入極限邊數不等式檢驗：3V−6=3(5)−6=93V - 6 = 3(5) - 6 = 93V−6=3(5)−6=9。
發現 E(10)≰3V−6(9)E (10) \not\le 3V - 6 (9)E(10)≤3V−6(9)，矛盾！故 K5K_5K5 絕對不可能是平面圖。

證明 K3,3K_{3,3}K3,3 (兩個集合各3點的完全二分圖) 非平面圖：

K3,3K_{3,3}K3,3 的節點數 V=6V = 6V=6，邊數 E=3×3=9E = 3 \times 3 = 9E=3×3=9。
第一眼檢查 3V−6=18−6=123V - 6 = 18 - 6 = 123V−6=18−6=12，9≤129 \le 129≤12 似乎通過了？不，我們有更緊的不等式！
因為 K3,3K_{3,3}K3,3 是二分圖，內部絕對不可能存在長度為 3 的三角形環。所以如果它是平面圖，它切割出的每一個區域 FFF，至少都要由 4 條邊包圍。
邊與區域的關係式為：4F≤2E ⟹ F≤⌊2E/4⌋=⌊18/4⌋=44F \le 2E \implies F \le \lfloor 2E/4 \rfloor = \lfloor 18/4 \rfloor = 44F≤2E⟹F≤⌊2E/4⌋=⌊18/4⌋=4。
但尤拉公式告訴我們 F=E−V+2=9−6+2=5F = E - V + 2 = 9 - 6 + 2 = 5F=E−V+2=9−6+2=5。
發現公式要求 F=5F=5F=5，但邊數限制 F≤4F \le 4F≤4，矛盾！故 K3,3K_{3,3}K3,3 非平面圖。

經典證明題 2：柏拉圖立體 (Platonic Solids) 的數量極限 為什麼正多面體 (所有面都是全等正多邊形、所有頂點連接相同邊數) 在三維宇宙中「恰好只有 5 種」？

【Step-by-step 解析】

將多面體壓扁成 2D 視為平面圖。令每個面由 nnn 條邊組成，每個頂點連接 mmm 條邊。立體圖要求 n≥3n \ge 3n≥3 且 m≥3m \ge 3m≥3。
計算總邊數：每個面有 nnn 條邊，共 FFF 個面，每條邊被兩個面共用 ⟹ nF=2E\implies nF = 2E⟹nF=2E。同理，頂點數 ⟹ mV=2E\implies mV = 2E⟹mV=2E。
代入尤拉公式 V+F=E+2V + F = E + 2V+F=E+2：

2Em+2En=E+2\frac{2E}{m} + \frac{2E}{n} = E + 2m2E+n2E=E+2

同除以 2E2E2E：

1m+1n=12+1E\frac{1}{m} + \frac{1}{n} = \frac{1}{2} + \frac{1}{E}m1+n1=21+E1

因為 E>0E > 0E>0，所以右邊大於 12\frac{1}{2}21。這代表 1m+1n>12\frac{1}{m} + \frac{1}{n} > \frac{1}{2}m1+n1>21。
已知 m,n≥3m, n \ge 3m,n≥3。如果兩者都 ≥4\ge 4≥4，則 14+14=12\frac{1}{4} + \frac{1}{4} = \frac{1}{2}41+41=21，不等式無法成立！這意味著 m,nm, nm,n 之中必然至少有一個等於 3。
窮舉可能解：

若 n=3n = 3n=3 (面是正三角形)：mmm 可以是 3,4,53, 4, 53,4,5 (分別對應正四面體、正八面體、正二十面體)。
若 m=3m = 3m=3 (每個頂點連三條邊)：nnn 可以是 3,4,53, 4, 53,4,5 (分別對應正四面體、正六面體/立方體、正十二面體)。

結論：宇宙中僅存在這 5 組整數解，對應恰好 5 種柏拉圖立體！

7. 庫拉托夫斯基定理與著色問題 (Kuratowski’s Theorem & Coloring)#

觀念與公式#

直觀意義：如何從一張極度複雜的圖中，一眼看穿它「註定會發生線條交叉」(即非平面圖)？

庫拉托夫斯基定理 (Kuratowski’s Theorem)：一個圖是「非平面圖」 ⟺ \iff⟺ 它裡面隱藏了 (包含子圖同構於) K5K_5K5 或 K3,3K_{3,3}K3,3 的結構。 (同構 Homeomorphic 定義：兩張圖可藉由反覆「在一條邊中間插入一個新節點」或反向消除節點而變得完全一樣)。
圖著色 (Graph Coloring)：給予相鄰頂點不同顏色的過程。
五色定理 (Five Color Theorem)：任何平面圖，絕對可以用「最多 5 種顏色」完成合法塗色。 (著名的四色定理 Appel-Haken 證明極其複雜，需要電腦驗證近兩千種 Case，故考試頂多考五色定理的建構)。
對偶圖 (Dual Graph)：針對地圖塗色問題，可以將地圖的「每一個區域 (Region)」轉化為一個「頂點 (Vertex)」。若兩個區域相鄰，則在兩頂點間連一條邊。地圖的合法塗色，等價於對偶圖的合法頂點著色。

實戰演練（題型大全）#

證明題：五色定理 (Five Color Theorem) 證明策略 證明所有平面圖都能以 5 色合法著色。

【Step-by-step 解析】

數學歸納法：假設頂點數為 n−1n-1n−1 的所有平面圖都能 5 色著色。現在要證明 nnn 個頂點的圖也可以。
由前述公式 E≤3V−6E \le 3V - 6E≤3V−6 推導總分支度 2E≤6V−122E \le 6V - 122E≤6V−12。這表示平均分支度嚴格小於 6。換句話說，圖中必然存在至少一個頂點 vvv，其分支度 deg⁡(v)≤5\deg(v) \le 5deg(v)≤5。
暫時將頂點 vvv 從圖中拔除。剩下的圖有 n−1n-1n−1 個頂點，依據歸納法假設，可以合法塗上 5 種顏色。
現在把 vvv 放回來。我們觀察 vvv 的鄰居顏色：

情況一：若 vvv 的鄰居使用的顏色總數 ≤4\le 4≤4 色。那麼 5 種顏色中必有剩下第 5 種沒被用到的顏色，直接塗給 vvv 即可，收工！
情況二：若 vvv 剛好有 5 個鄰居，且分別塗滿了紅、藍、黃、綠、橘 5 種不同的顏色。

Kempe Chain 切換法 (Switching Path) 解決情況二：

我們試著將其中一個鄰居 (例如黃色鄰居) 強制換成另一個顏色 (例如藍色)。
為了保持圖的合法性，如果黃鄰居變藍，那原本連著它的藍點就要變黃，引發「藍黃交替」的連鎖反應路徑 (Kempe Chain)。
如果這條「藍黃交替路徑」沒有連到 vvv 另一側原本的藍色鄰居，我們就可以成功完成這串顏色的對調，把原本的黃鄰居變成藍色，此時 vvv 旁邊就空出了黃色可以塗，收工！
萬一「藍黃路徑」不幸連通了 (形成一堵牆) 怎麼辦？因為平面圖的邊「不可交叉」性質，這道藍黃牆會把內外的綠色和橘色鄰居物理性隔絕。
此時我們改對綠色與橘色鄰居進行「綠橘交替」連鎖反應。因為路徑被藍黃牆擋住，綠橘路徑絕對不可能連通，所以綠橘交替必定能成功完成切換。
切換後，vvv 旁空出了綠色或橘色，著色成功！得證。

⚠️ 考前避坑指南 (Exam Pitfall Guide)#

Self-loop 的度數計算極易錯：當你手算總分支度或判定尤拉迴路時，如果圖中有一條自我環 (Loop)，該頂點的 Degree 要 +2+2+2，千萬不要只加 1。
握手定理適用對象：無論無向圖還是有向圖，定理等式兩側的意涵不同。證明題中極愛考「奇數度頂點數量必為偶數」，這是從 2m=Even+Odd2m = \text{Even} + \text{Odd}2m=Even+Odd 移項得來的觀念，必考倒扣。
尤拉 vs 漢密爾頓的判定邏輯差異：

尤拉迴路：看「邊」(Edges)。充要條件為「全為偶數度」。條件是「若且唯若 (iff)」，看到奇數點直接判死刑。
漢密爾頓迴路：看「頂點」(Vertices)。Dirac 和 Ore 定理只給了「充分條件 (Sufficient)」。如果題目給的圖不滿足這兩個定理（例如每個點度數都小於 n/2n/2n/2），不代表它沒有漢密爾頓迴路！(例如一個正方形 C4C_4C4，不滿足充分條件，但明明就有漢密爾頓迴路) 選擇題極容易在這邊埋陷阱，反推必錯。

尤拉公式中的 Region 計算：在代入 V+F=E+2V + F = E + 2V+F=E+2 運算或是看圖數區域時，永遠記得包含最外側的無限區域 (Infinite Region)，漏算 FFF 就會少 1 導致公式不平。
平面圖的不等式誤用：E≤3V−6E \le 3V - 6E≤3V−6 (或二分圖的 E≤2V−4E \le 2V - 4E≤2V−4) 只是平面圖的「必要條件 (Necessary)」。

若 E>3V−6E > 3V - 6E>3V−6，則必定「非平面圖」。
若 E≤3V−6E \le 3V - 6E≤3V−6，不能保證它是平面圖！如果要證明它是，請乖乖畫出來；如果要證明不是，請找庫拉托夫斯基的子圖 K5K_5K5 或 K3,3K_{3,3}K3,3。

第五章：樹 (Trees)#

1. 樹的基礎性質與節點計算 (Properties of Trees)#

觀念與公式#

樹 (Tree) 的直觀意義就是一個「沒有迴圈的連通網路」——想像家族族譜或是水系分佈，任何兩點之間必然只有唯一一條簡單路徑可達。若圖中包含多個不相連的樹，則稱為森林 (Forest)。

對於將每個分支嚴格限制數量的 m 元樹 (m-ary tree)，特別是當每個內部節點都恰好有 mmm 個子節點時（稱為 Full m-ary tree），我們可以利用以下必背公式快速秒殺節點計算題：

邊數公式：任何擁有 nnn 個節點的樹，必定剛好有 n−1n-1n−1 條邊。
總節點公式：具備 iii 個內部節點的 Full m-ary tree，總節點數為 mi+1mi + 1mi+1。
葉節點公式：具備 iii 個內部節點的 Full m-ary tree，葉節點數量為 mi−i+1mi - i + 1mi−i+1。
樹高與葉節點極限：高度為 hhh 的 m-ary tree 最多擁有 mhm^hmh 個葉節點。
平衡樹高度公式：若一棵 Full m-ary tree 是平衡的（所有葉節點都在 hhh 或 h−1h-1h−1 層）且有 xxx 個葉節點，其樹高 h=⌈log⁡mx⌉h = \lceil \log_m x \rceilh=⌈logmx⌉。

實戰演練（題型大全）#

【題型 1：連鎖信件計算問題】

常考頻率：⭐⭐⭐⭐
重要程度：高（常作為基礎送分題，考驗對葉節點與內部節點的代數轉換）
題目：Peter 發起了一封連鎖信。每個收到信的人被要求轉寄給其他 4 個人。有些人照做了，有些人沒有。現在已知有 100 個人收到了信但「沒有」轉寄出去。假設沒有人收到超過一封信，請問總共有多少人轉寄了這封信？
Step-by-step 解答：

將問題轉化為樹的結構：寄信人是內部節點 (iii)，收到信但不轉寄的人是葉節點 (xxx)。
由於每個人規定要轉寄給 4 個人，這是一棵 Full 4-ary tree (m=4m = 4m=4)。
已知葉節點數 x=100x = 100x=100。
代入葉節點公式：x=mi−i+1x = mi - i + 1x=mi−i+1。
100=4i−i+1100 = 4i - i + 1100=4i−i+1。
99=3i99 = 3i99=3i，解得內部節點 i=33i = 33i=33。
答案：共有 33 個人轉寄了信件。

2. 決策樹 (Decision Trees) 與複雜度下界#

觀念與公式#

決策樹將「解決問題的連續決策過程」具象化。每一個內部節點代表一次「判斷或決策」，而它的子節點代表該決策的「可能結果」。最底層的葉節點就是最終的解答。

排序比較下界公式：在最壞的情況下，使用比較法對 nnn 個相異數字進行排序，至少需要 ⌈log⁡2n!⌉\lceil \log_2 n! \rceil⌈log2n!⌉ 次比較。

實戰演練（題型大全）#

【題型 1：假幣秤重問題】

常考頻率：⭐⭐⭐
重要程度：中（經典邏輯題，考驗決策樹構建）
題目：有 6 枚重量相同的真幣，以及 1 枚重量較輕的假幣。如果這 7 枚硬幣混在一起，如何使用天平在「兩次」秤重內找出假幣？
Step-by-step 解答：

將 7 枚硬幣編號為 1 到 7。
第一次決策 (Root)：將 {1, 2, 3} 放在左秤，{4, 5, 6} 放在右秤。
結果分支 A (左 < 右)：代表假幣在 {1, 2, 3} 中。

第二次決策：秤 {1} 與 {2}。若 1 輕，假幣為 1；若 2 輕，假幣為 2；若相等，假幣為未秤的 3。

結果分支 B (左 = 右)：代表天平上的都是真幣，假幣是未放上天平的 7。
結果分支 C (左 > 右)：代表假幣在 {4, 5, 6} 中。

第二次決策：秤 {4} 與 {5}。若 4 輕，假幣為 4；若 5 輕，假幣為 5；若相等，假幣為未秤的 6。

【題型 2：排序比較次數分析】

常考頻率：⭐⭐⭐⭐
重要程度：高（連結資料結構中 Sorting 複雜度的底層證明）
題目：欲排序 3 個與 4 個相異數字，分別保證充分的最少比較次數為何？
Step-by-step 解答：

利用下界公式評估 3 個數字：⌈log⁡23!⌉=⌈log⁡26⌉=3\lceil \log_2 3! \rceil = \lceil \log_2 6 \rceil = 3⌈log23!⌉=⌈log26⌉=3 次。
利用下界公式評估 4 個數字：⌈log⁡24!⌉=⌈log⁡224⌉=5\lceil \log_2 4! \rceil = \lceil \log_2 24 \rceil = 5⌈log24!⌉=⌈log224⌉=5 次。
4 個數字的具體排法 (A, B, C, D)：

Step 1：用 3 次比較將 A, B, C 排序好 (假設結果為 A < B < C)。
Step 2：將 D 與中間的 B 進行比較 (第 4 次)。
Step 3：根據 Step 2 的結果，將 D 拿去與 A 或 C 比較 (第 5 次)，即可確定 D 的最終位置。

3. 最佳前綴碼與霍夫曼樹 (Optimal Prefix Code)#

觀念與公式#

為了節省儲存空間，我們希望出現頻率高的字元使用較短的編碼，頻率低的字元使用較長的編碼（變長編碼）。為了避免解碼時產生歧義（例如編碼 0 和 01 同時存在會造成混淆），我們規定「任何字元的編碼都不能是其他字元編碼的前綴」，這就是 Prefix Code。

霍夫曼樹兩大黃金定律：

在最佳前綴碼樹中，每一個內部節點必定有「兩個」子節點。
出現頻率最低的兩個字元，必定是樹中最深處的兄弟葉節點 (Sibling leaves farthest from the root)。

實戰演練（題型大全）#

【題型 1：建構 Optimal Prefix Code Tree】

常考頻率：⭐⭐⭐⭐⭐
重要程度：極高（必考大題，嚴格要求演算法執行步驟正確）
題目：已知字元的相對頻率為 A: 40, B: 20, C: 15, D: 50, E: 25，請建構對應的最佳前綴碼樹。
Step-by-step 解答：

列出目前所有節點的頻率：{A:40, B:20, C:15, D:50, E:25}。
找出頻率最低的兩個節點：B(20) 與 C(15)。將它們合併為一個父節點，頻率為 35。
更新節點池：{A:40, D:50, E:25, BC:35}。
找出頻率最低的兩個節點：E(25) 與 BC(35)。將它們合併為一個父節點，頻率為 60。
更新節點池：{A:40, D:50, EBC:60}。
找出頻率最低的兩個節點：A(40) 與 D(50)。將它們合併為一個父節點，頻率為 90。
更新節點池：{EBC:60, AD:90}。
將最後兩個節點合併，形成 Root，總頻率為 150。左子樹為 AD(90)，右子樹為 EBC(60)。

4. 生成樹與 Prüfer Code (Spanning Trees & Prüfer Codes)#

觀念與公式#

生成樹 (Spanning Tree) 是一個保留原圖所有節點、但刪除多餘邊直到剛好形成「樹」的子圖。證明圖是否連通的等價條件，就是看它是否存在生成樹。

Prüfer Code 則是一種神奇的數學映射，它能將任何一棵帶有編號的生成樹，唯一對應到一串長度為 n−2n-2n−2 的數字序列。

公式 1：凱萊公式 (Cayley’s formula) 指出，包含 nnn 個節點的完全圖 KnK_nKn，總共可以產生 nn−2n^{n-2}nn−2 種不同的生成樹。
公式 2：對應 nnn 個節點的 Prüfer code 序列，其長度必定剛好是 n−2n-2n−2。

實戰演練（題型大全）#

【題型 1：由 Tree 產生 Prüfer Code】

常考頻率：⭐⭐⭐⭐
重要程度：高（手動模擬題型，需極度細心）
題目：給定一棵樹，邊連接為 (1,2), (2,4), (3,4), (2,5)，請寫出其 Prüfer Code。
Step-by-step 解答：

觀察目前所有的葉節點為：1, 3, 5。
回合 1：找出編號最小的葉節點「1」。記錄它的唯一鄰居「2」。將節點 1 移除。序列目前為：2。
觀察剩餘樹的葉節點為：3, 5。
回合 2：找出編號最小的葉節點「3」。記錄它的唯一鄰居「4」。將節點 3 移除。序列目前為：2, 4。
觀察剩餘樹的葉節點為：4, 5。
回合 3：找出編號最小的葉節點「4」。記錄它的唯一鄰居「2」。將節點 4 移除。序列目前為：2, 4, 2。
由於樹中只剩下 2 個節點 (2, 5)，演算法停止。
答案：Prüfer Code 為 2, 4, 2。

【題型 2：由 Prüfer Code 還原 Tree】

常考頻率：⭐⭐⭐⭐
重要程度：高（逆向工程，失分率極高的題型）
題目：給定 Prüfer Code 為 2, 4, 2，已知 n=5n=5n=5，請還原其生成樹的連接邊。
Step-by-step 解答：

準備所有節點列表：{1, 2, 3, 4, 5}。
回合 1：目前序列為 2, 4, 2。找出「未出現在序列中」且「未被連線」的最小節點，即為「1」。將 1 連接到序列的第一個數字「2」。將 1 標記為已連線，並劃掉序列第一個 2。
回合 2：目前序列為 4, 2。未被連線且未出現在序列的最節點為「3」。將 3 連接到序列第一個數字「4」。將 3 標記為已連線，劃掉序列第一個 4。
回合 3：目前序列為 2。未被連線且未出現在序列的最小節點為「4」。將 4 連接到序列第一個數字「2」。將 4 標記為已連線，劃掉序列第一個 2。
序列空了。將最後剩下的兩個未標記節點「2」和「5」直接相連。
答案：連線邊為 (1,2), (3,4), (4,2), (2,5)。

⚠️ 考前避坑指南#

不要混淆 Tree 與 Binary Tree 的公式：在計算 m-ary tree 的節點數時，切記 mmm 不一定是 2。遇到 x=mi−i+1x = mi - i + 1x=mi−i+1 時，一定要先確認題目規定的 mmm 是多少。
建構 Huffman Tree 絕對不能排錯順序：每次合併完產生「新的內部節點頻率」後，必須重新將其放回候選池中參與下一次的「取最小兩個」的比較。很多學生會忘記把剛合併的數字與原本剩餘的節點重新排序，導致樹的結構完全錯誤。
Prüfer Code 的致命盲點：

產生 Code 時：每次刪除的是當前編號最小的葉節點，不是隨便挑一個葉節點。
還原 Tree 時：尋找配對節點的條件是「未出現在『當前剩餘』序列中」的最小可用數字。如果某個數字前面被劃掉了，但在剩餘序列中已不存在，它就有資格被選為葉節點。
停止條件：當節點數剩下 2 個時就必須停止，切勿將最後兩個節點也寫進 Code 裡！Code 的長度永遠死守 n−2n-2n−2。

特殊選才心得彙整

Sun, 18 Jan 2026 00:00:00 GMT

前言#

其實我比較想讀的是電機系，但客觀來說，我的經歷更偏向資工，因此在報名時，除了電機系之外，也另外報了幾間資工系，尤其是頂大。

我並不是那種從國中就一路參加競賽、經歷滿滿的電神，而是到了高中中後期，才慢慢找到自己真正有興趣、也願意投入的方向。

以下是我特選主要的經歷:

Verification#

項目	等級 / 分數	取得時間	備註
APCS 程式能力檢定	實作 5級分	2024.06	PR 99

Projects#

年份	專題・比賽	技術棧	成果・備註
2025	FRC 全球機器人大賽	Java + WPILib + OpenCV	視覺射擊命中率 ~100%
2024	全地形探測車程式開發	C++ + Arduino	科展
2024	雙擺系統物理模擬	Python + VPython	滿分課程專題
2024	學校行事曆網站（全端）	React + Express	前後端主負責人
2024	1A2B 猜數字遊戲	C++ + Arduino	硬體結合程式

Experiences#

社團 / 工作	身分	時間	備註
資訊研究社	社長/講師	2023.09~2024.06	規劃活動、教導python、出題者
FRC全球機器人大賽程式組	組長	2023.09~2024.06	專攻JAVA、OpenCV ∙ PhotonVision
FRC全球機器人大賽程式組	顧問 / 講師	2024.09~2025.06	專攻PID、Swerve Drive、培訓JAVA

還有一些競程相關的比賽，不過太多了就沒有放。

整體來說，我算是競程、專案、AI、電機、社團等領域都有接觸，但最核心、也最有深度的仍然是競程相關。

在報名前，我有對照過歷屆學長姐的資料，評估後認為自己的落點大概在「中字輩」左右，因此也有報考師大作為保底。

結果總表#

有些資料因為時間較久，紀錄不太完整，因此標示為未知；之後如果有機會，可能會再補上書審或面試分數、實際備取人數等資訊。

學校	系所	結果	備註
清華大學	資工系	備取三	最終選擇
陽明交通大學	資工系	備取十以內?	—
中央大學	電機系	備取?	—
中山大學	資工系	備取?	—
中興大學	資工系	未進面試	—
中興大學	電資學士班	備取?	—
中興大學	電機系	未進面試	—
臺灣師範大學	電機系	備取一	—
臺灣師範大學	資工系	備取五	—

整體結果大致符合我原本對自己落點的評估，但也能明顯感受到不同學校、不同系所對背景的偏好差異。相較之下，資工系普遍較重視演算法、專案與競賽經歷；而部分電機系則更在意硬體背景或相關實作，這也反映在各校的篩選結果上。

各校面試心得#

之後補希望啦

特選心得#

老實說，我能踏上特殊選才這條路，回頭看連自己都覺得有些不可思議。

在上高中以前，我完全沒有接觸過程式；國中會考時也幾乎是在「混」，最後就讀的是社區高中，而不是前三志願或數資班，因此能接觸到的資源相較之下其實非常有限。

直到高二上，我才逐漸發現自己在程式方面似乎真的有天賦。加入 FRC 之後，我開始認真投入程式競賽的準備。這段過程中，很幸運地遇到許多願意支持我、提供資源的老師，也認識了一群可以一起學習、互相刺激的夥伴，讓我能夠持續走在這條路上。

一路走到現在，某種程度上，我其實還滿佩服自己能夠撐過來，並走到這一步。

建議#

在目前的升學管道中，我個人認為難度最高的是繁星，其次就是特殊選才。

特選是一條非常耗時、也相對麻煩的路，需要投入大量時間準備書審與面試；同時，在放榜之前，往往還得一邊準備學測，心理壓力並不小。

因此，我會建議盡量 all in 一條主要路線，並同時準備一所自己能接受的保底學校，避免讓自己承受過高的風險與壓力。

另外就是，有些學校被刷了也不要灰心，因為我覺得有些大學的標準蠻奇特的。

Contact#

想聊競程、機器人、網頁、特殊選才都歡迎～
信箱 → pimail307@gmail.com

React 筆記

Sun, 13 Apr 2025 00:00:00 GMT

筆記影片來源：https://youtu.be/aBTiZfShe-4

建立專案#

用 Vite 建立 React 專案（比 Create React App 快很多）：

Terminal window

1
npm create vite@latest my-react-app
2
# 選 React
3
# 選 JavaScript
4
cd my-react-app
5
npm install
6
npm run dev

打開 http://localhost:5173 就能看到畫面了。

專案結構#

1
my-react-app/
2
├── src/               # 主要寫程式的地方
3
│   ├── App.jsx       # 根組件
4
│   ├── main.jsx      # 進入點
5
│   └── App.css       # 樣式
6
├── public/            # 靜態檔案（圖片之類的）
7
├── index.html         # HTML 模板
8
└── package.json       # 專案設定

index.html 裡面有一個 <div id="root"></div>，React 會把整個應用程式掛載到這裡。

main.jsx 是程式的進入點：

1
import React from 'react'
2
import ReactDOM from 'react-dom/client'
3
import App from './App.jsx'
4
import './index.css'
5

6
ReactDOM.createRoot(document.getElementById('root')).render(
7
  <React.StrictMode>
8
    <App />
9
  </React.StrictMode>,
10
)

React 基礎概念#

Component（組件）#

React 的核心就是組件，把 UI 拆成一個個可重用的小單位。

1
function Header() {
2
  return (
3
    <header>
4
      <h1>我的網站</h1>
5
      <nav>首頁 | 關於</nav>
6
    </header>
7
  )
8
}
9

10
function App() {
11
  return (
12
    <div>
13
      <Header />
14
      <main>內容區塊</main>
15
    </div>
16
  )
17
}

展開收起

注意：

組件名稱要大寫開頭（Header，不是 header）
組件就是一個 function，回傳 JSX
使用時寫成 <Header /> 這種標籤形式
建議一個檔案只放一個組件

JSX 語法#

JSX 看起來像 HTML，但其實是 JavaScript。

1
const user = {
2
  name: '小明',
3
  age: 25
4
}
5

6
function UserCard() {
7
  return (
8
    <div className="card">  {/* 注意是 className 不是 class */}
9
      <h2>{user.name}</h2>
10
      <p>年齡：{user.age}</p>
11
      <p>{user.age >= 18 ? '成年' : '未成年'}</p>
12
    </div>
13
  )
14
}

在 JSX 裡面用 {} 可以執行 JavaScript：

{變數}
{函數()}
{條件 ? 值A : 值B}

style 屬性要傳物件：

1
<div style={{
2
  color: 'red',
3
  fontSize: '20px',
4
  marginTop: '10px'  // CSS 屬性要用駝峰式
5
}}>
6
  紅色大字
7
</div>

如果不想多包一層 div，可以用 Fragment：

1
function List() {
2
  return (
3
    <>
4
      <li>項目 1</li>
5
      <li>項目 2</li>
6
      <li>項目 3</li>
7
    </>
8
  )
9
}

Props（屬性）#

Props 讓你可以從父組件傳資料給子組件。

1
// 父組件
2
function App() {
3
  return (
4
    <div>
5
      <Greeting name="小華" age={20} />
6
      <Greeting name="小美" age={22} />
7
    </div>
8
  )
9
}
10

11
// 子組件接收 props
12
function Greeting(props) {
13
  return <h1>哈囉 {props.name}，你 {props.age} 歲</h1>
14
}
15

16
// 更常見的寫法：直接解構
17
function Greeting({ name, age }) {
18
  return <h1>哈囉 {name}，你 {age} 歲</h1>
19
}

展開收起

傳遞各種類型的資料：

1
<Component
2
  text="字串直接寫"
3
  number={123}
4
  boolean={true}
5
  array={[1, 2, 3]}
6
  object={{ key: 'value' }}
7
  function={() => console.log('hi')}
8
/>

State（狀態）#

State 是組件的記憶體，當 state 改變時，React 會自動重新渲染畫面。

1
import { useState } from 'react'
2

3
function Counter() {
4
  // useState 回傳 [當前值, 更新函數]
5
  const [count, setCount] = useState(0)
6

7
  const increment = () => {
8
    setCount(count + 1)  // 用 setCount 更新
9
  }
10

11
  const decrement = () => {
12
    setCount(count - 1)
13
  }
14

15
  return (
16
    <div>
17
      <h2>計數器：{count}</h2>
18
      <button onClick={increment}>+1</button>
19
      <button onClick={decrement}>-1</button>
20
      <button onClick={() => setCount(0)}>重置</button>
21
    </div>
22
  )
23
}

展開收起

重要觀念：

永遠用 setState 更新，不要直接改 count = count + 1（這樣不會觸發重新渲染）
useState(0) 的 0 是初始值
可以有多個 state：

1
function Form() {
2
  const [name, setName] = useState('')
3
  const [email, setEmail] = useState('')
4
  const [age, setAge] = useState(0)
5

6
  // ...
7
}

事件處理#

1
function Form() {
2
  const [text, setText] = useState('')
3

4
  const handleSubmit = (e) => {
5
    e.preventDefault()  // 防止表單送出重新整理頁面
6
    console.log('送出：', text)
7
    setText('')  // 清空輸入框
8
  }
9

10
  const handleChange = (e) => {
11
    setText(e.target.value)  // 取得輸入框的值
12
  }
13

14
  return (
15
    <form onSubmit={handleSubmit}>
16
      <input
17
        type="text"
18
        value={text}
19
        onChange={handleChange}
20
        placeholder="輸入文字"
21
      />
22
      <button type="submit">送出</button>
23
    </form>
24
  )
25
}

展開收起

常見事件：

onClick
onChange
onSubmit
onKeyDown
onMouseEnter / onMouseLeave

注意是 onClick 不是 onclick，要用駝峰式。

條件渲染#

根據條件決定要顯示什麼。

1
function LoginButton({ isLoggedIn, username }) {
2
  // 方法 1：三元運算子
3
  return (
4
    <div>
5
      {isLoggedIn ? (
6
        <p>歡迎回來，{username}！</p>
7
      ) : (
8
        <button>登入</button>
9
      )}
10
    </div>
11
  )
12
}
13

14
function Notification({ count }) {
15
  // 方法 2：&& 運算子（只有 true 才顯示）
16
  return (
17
    <div>
18
      {count > 0 && <span className="badge">{count}</span>}
19
    </div>
20
  )
21
}
22

23
function Dashboard({ user }) {
24
  // 方法 3：提早 return
25
  if (!user) {
26
    return <p>請先登入</p>
27
  }
28

29
  return (
30
    <div>
31
      <h1>儀表板</h1>
32
      <p>用戶：{user.name}</p>
33
    </div>
34
  )
35
}

展開收起

列表渲染#

用 map() 把陣列轉成 JSX。

1
function TodoList() {
2
  const todos = [
3
    { id: 1, text: '寫程式', done: false },
4
    { id: 2, text: '吃飯', done: true },
5
    { id: 3, text: '睡覺', done: false }
6
  ]
7

8
  return (
9
    <ul>
10
      {todos.map(todo => (
11
        <li key={todo.id}>
12
          <span style={{
13
            textDecoration: todo.done ? 'line-through' : 'none'
14
          }}>
15
            {todo.text}
16
          </span>
17
        </li>
18
      ))}
19
    </ul>
20
  )
21
}

展開收起

key 很重要！

每個項目都要有唯一的 key
通常用 id，不要用 index（會有效能問題）
React 用 key 來追蹤哪些項目改變了

Todo App 實作#

現在來做一個完整的 Todo App，會用到上面所有概念。

安裝圖示套件#

Terminal window

1
npm install react-icons

這個套件有超多圖示可以用：

1
import { MdDelete, MdEdit, MdCheck, MdAdd } from 'react-icons/md'
2
import { FaTrash, FaEdit } from 'react-icons/fa'

基本結構#

1
import { useState } from 'react'
2
import { MdDelete, MdEdit, MdCheck } from 'react-icons/md'
3
import './App.css'
4

5
function App() {
6
  const [todos, setTodos] = useState([
7
    { id: 1, text: '學習 React', isCompleted: false },
8
    { id: 2, text: '做專案', isCompleted: false }
9
  ])
10
  const [input, setInput] = useState('')
11

12
  return (
13
    <div className="container">
14
      <h1>待辦清單</h1>
15
      {/* 新增表單 */}
16
      {/* 待辦列表 */}
17
    </div>
18
  )
19
}
20

21
export default App

展開收起

新增待辦#

1
const addTodo = (e) => {
2
  e.preventDefault()
3

4
  // 檢查是否為空
5
  if (input.trim() === '') {
6
    alert('請輸入待辦事項')
7
    return
8
  }
9

10
  // 建立新的 todo 物件
11
  const newTodo = {
12
    id: Date.now(),  // 用時間戳當 id
13
    text: input,
14
    isCompleted: false
15
  }
16

17
  // 更新 state（加到陣列最前面）
18
  setTodos([newTodo, ...todos])
19

20
  // 清空輸入框
21
  setInput('')
22
}
23

24
// JSX
25
<form onSubmit={addTodo}>
26
  <input
27
    type="text"
28
    value={input}
29
    onChange={(e) => setInput(e.target.value)}
30
    placeholder="輸入新的待辦事項..."
31
  />
32
  <button type="submit">新增</button>
33
</form>

展開收起

顯示待辦列表#

1
<ul className="todo-list">
2
  {todos.length === 0 ? (
3
    <p className="empty">目前沒有待辦事項</p>
4
  ) : (
5
    todos.map(todo => (
6
      <li key={todo.id} className={todo.isCompleted ? 'completed' : ''}>
7
        <div className="todo-content">
8
          <input
9
            type="checkbox"
10
            checked={todo.isCompleted}
11
            onChange={() => toggleComplete(todo.id)}
12
          />
13
          <span>{todo.text}</span>
14
        </div>
15
        <div className="todo-actions">
16
          <button onClick={() => deleteTodo(todo.id)} className="delete-btn">
17
            <MdDelete />
18
          </button>
19
        </div>
20
      </li>
21
    ))
22
  )}
23
</ul>

展開收起

刪除待辦#

1
const deleteTodo = (id) => {
2
  // 用 filter 過濾掉要刪除的項目
3
  const newTodos = todos.filter(todo => todo.id !== id)
4
  setTodos(newTodos)
5
}
6

7
// 或是更簡潔的寫法
8
const deleteTodo = (id) => {
9
  setTodos(todos.filter(todo => todo.id !== id))
10
}

切換完成狀態#

1
const toggleComplete = (id) => {
2
  // 用 map 找到對應的 todo，切換它的 isCompleted
3
  const newTodos = todos.map(todo => {
4
    if (todo.id === id) {
5
      return { ...todo, isCompleted: !todo.isCompleted }
6
    }
7
    return todo
8
  })
9
  setTodos(newTodos)
10
}
11

12
// 更簡潔的寫法
13
const toggleComplete = (id) => {
14
  setTodos(todos.map(todo =>
15
    todo.id === id
16
      ? { ...todo, isCompleted: !todo.isCompleted }
17
      : todo
18
  ))
19
}

展開收起

這裡用到展開運算子 ...todo，它會複製整個物件，然後只改變 isCompleted。

編輯待辦#

編輯功能比較複雜，需要多一個 state 來記錄正在編輯哪一個。

1
const [editingId, setEditingId] = useState(null)
2
const [editText, setEditText] = useState('')
3

4
const startEdit = (todo) => {
5
  setEditingId(todo.id)
6
  setEditText(todo.text)
7
}
8

9
const saveEdit = (id) => {
10
  if (editText.trim() === '') {
11
    alert('待辦事項不能是空的')
12
    return
13
  }
14

15
  setTodos(todos.map(todo =>
16
    todo.id === id
17
      ? { ...todo, text: editText }
18
      : todo
19
  ))
20

21
  setEditingId(null)
22
  setEditText('')
23
}
24

25
const cancelEdit = () => {
26
  setEditingId(null)
27
  setEditText('')
28
}

展開收起

在 JSX 裡判斷是否正在編輯：

1
<li key={todo.id}>
2
  {editingId === todo.id ? (
3
    // 編輯模式
4
    <div className="edit-mode">
5
      <input
6
        type="text"
7
        value={editText}
8
        onChange={(e) => setEditText(e.target.value)}
9
        autoFocus
10
      />
11
      <button onClick={() => saveEdit(todo.id)}>儲存</button>
12
      <button onClick={cancelEdit}>取消</button>
13
    </div>
14
  ) : (
15
    // 一般模式
16
    <div className="todo-content">
17
      <input
18
        type="checkbox"
19
        checked={todo.isCompleted}
20
        onChange={() => toggleComplete(todo.id)}
21
      />
22
      <span>{todo.text}</span>
23
      <button onClick={() => startEdit(todo)}>
24
        <MdEdit />
25
      </button>
26
      <button onClick={() => deleteTodo(todo.id)}>
27
        <MdDelete />
28
      </button>
29
    </div>
30
  )}
31
</li>

展開收起

完整程式碼#

1
import { useState } from 'react'
2
import { MdDelete, MdEdit, MdCheck } from 'react-icons/md'
3
import './App.css'
4

5
function App() {
6
  const [todos, setTodos] = useState([])
7
  const [input, setInput] = useState('')
8
  const [editingId, setEditingId] = useState(null)
9
  const [editText, setEditText] = useState('')
10

11
  // 新增
12
  const addTodo = (e) => {
13
    e.preventDefault()
14
    if (input.trim() === '') return
15

16
    setTodos([{
17
      id: Date.now(),
18
      text: input,
19
      isCompleted: false
20
    }, ...todos])
21

22
    setInput('')
23
  }
24

25
  // 刪除
26
  const deleteTodo = (id) => {
27
    setTodos(todos.filter(todo => todo.id !== id))
28
  }
29

30
  // 切換完成
31
  const toggleComplete = (id) => {
32
    setTodos(todos.map(todo =>
33
      todo.id === id
34
        ? { ...todo, isCompleted: !todo.isCompleted }
35
        : todo
36
    ))
37
  }
38

39
  // 編輯相關
40
  const startEdit = (todo) => {
41
    setEditingId(todo.id)
42
    setEditText(todo.text)
43
  }
44

45
  const saveEdit = (id) => {
46
    if (editText.trim() === '') return
47

48
    setTodos(todos.map(todo =>
49
      todo.id === id
50
        ? { ...todo, text: editText }
51
        : todo
52
    ))
53

54
    setEditingId(null)
55
  }
56

57
  const cancelEdit = () => {
58
    setEditingId(null)
59
  }
60

61
  // 統計
62
  const totalTodos = todos.length
63
  const completedTodos = todos.filter(t => t.isCompleted).length
64
  const activeTodos = totalTodos - completedTodos
65

66
  return (
67
    <div className="app">
68
      <div className="container">
69
        <h1>📝 待辦清單</h1>
70

71
        <div className="stats">
72
          <span>全部：{totalTodos}</span>
73
          <span>未完成：{activeTodos}</span>
74
          <span>已完成：{completedTodos}</span>
75
        </div>
76

77
        <form onSubmit={addTodo} className="add-form">
78
          <input
79
            type="text"
80
            value={input}
81
            onChange={(e) => setInput(e.target.value)}
82
            placeholder="輸入新的待辦事項..."
83
          />
84
          <button type="submit">新增</button>
85
        </form>
86

87
        <ul className="todo-list">
88
          {todos.length === 0 ? (
89
            <p className="empty-message">還沒有待辦事項，開始新增吧！</p>
90
          ) : (
91
            todos.map(todo => (
92
              <li
93
                key={todo.id}
94
                className={todo.isCompleted ? 'completed' : ''}
95
              >
96
                {editingId === todo.id ? (
97
                  <div className="edit-mode">
98
                    <input
99
                      type="text"
100
                      value={editText}
101
                      onChange={(e) => setEditText(e.target.value)}
102
                      onKeyDown={(e) => {
103
                        if (e.key === 'Enter') saveEdit(todo.id)
104
                        if (e.key === 'Escape') cancelEdit()
105
                      }}
106
                      autoFocus
107
                    />
108
                    <button onClick={() => saveEdit(todo.id)}>
109
                      <MdCheck />
110
                    </button>
111
                    <button onClick={cancelEdit}>取消</button>
112
                  </div>
113
                ) : (
114
                  <>
115
                    <div className="todo-content">
116
                      <input
117
                        type="checkbox"
118
                        checked={todo.isCompleted}
119
                        onChange={() => toggleComplete(todo.id)}
120
                      />
121
                      <span onClick={() => toggleComplete(todo.id)}>
122
                        {todo.text}
123
                      </span>
124
                    </div>
125
                    <div className="todo-actions">
126
                      <button
127
                        onClick={() => startEdit(todo)}
128
                        className="edit-btn"
129
                      >
130
                        <MdEdit />
131
                      </button>
132
                      <button
133
                        onClick={() => deleteTodo(todo.id)}
134
                        className="delete-btn"
135
                      >
136
                        <MdDelete />
137
                      </button>
138
                    </div>
139
                  </>
140
                )}
141
              </li>
142
            ))
143
          )}
144
        </ul>
145
      </div>
146
    </div>
147
  )
148
}
149

150
export default App

展開收起

基本樣式#

1
* {
2
  margin: 0;
3
  padding: 0;
4
  box-sizing: border-box;
5
}
6

7
body {
8
  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
9
  background: #f5f5f5;
10
}
11

12
.app {
13
  min-height: 100vh;
14
  padding: 40px 20px;
15
}
16

17
.container {
18
  max-width: 600px;
19
  margin: 0 auto;
20
  background: white;
21
  padding: 30px;
22
  border-radius: 12px;
23
  box-shadow: 0 2px 10px rgba(0,0,0,0.1);
24
}
25

26
h1 {
27
  text-align: center;
28
  margin-bottom: 20px;
29
  color: #333;
30
}
31

32
.stats {
33
  display: flex;
34
  justify-content: space-around;
35
  margin-bottom: 20px;
36
  padding: 15px;
37
  background: #f8f9fa;
38
  border-radius: 8px;
39
}
40

41
.stats span {
42
  font-size: 14px;
43
  color: #666;
44
}
45

46
.add-form {
47
  display: flex;
48
  gap: 10px;
49
  margin-bottom: 20px;
50
}
51

52
.add-form input {
53
  flex: 1;
54
  padding: 12px 16px;
55
  border: 2px solid #e0e0e0;
56
  border-radius: 8px;
57
  font-size: 16px;
58
}
59

60
.add-form input:focus {
61
  outline: none;
62
  border-color: #4CAF50;
63
}
64

65
.add-form button {
66
  padding: 12px 24px;
67
  background: #4CAF50;
68
  color: white;
69
  border: none;
70
  border-radius: 8px;
71
  cursor: pointer;
72
  font-size: 16px;
73
  font-weight: 600;
74
}
75

76
.add-form button:hover {
77
  background: #45a049;
78
}
79

80
.todo-list {
81
  list-style: none;
82
}
83

84
.todo-list li {
85
  display: flex;
86
  align-items: center;
87
  justify-content: space-between;
88
  padding: 15px;
89
  border-bottom: 1px solid #e0e0e0;
90
}
91

92
.todo-list li:last-child {
93
  border-bottom: none;
94
}
95

96
.todo-content {
97
  display: flex;
98
  align-items: center;
99
  gap: 12px;
100
  flex: 1;
101
}
102

103
.todo-content input[type="checkbox"] {
104
  width: 20px;
105
  height: 20px;
106
  cursor: pointer;
107
}
108

109
.todo-content span {
110
  flex: 1;
111
  cursor: pointer;
112
  user-select: none;
113
}
114

115
.completed span {
116
  text-decoration: line-through;
117
  color: #999;
118
}
119

120
.todo-actions {
121
  display: flex;
122
  gap: 8px;
123
}
124

125
.todo-actions button {
126
  padding: 8px 12px;
127
  background: transparent;
128
  border: none;
129
  cursor: pointer;
130
  font-size: 18px;
131
  color: #666;
132
  transition: color 0.2s;
133
}
134

135
.edit-btn:hover {
136
  color: #2196F3;
137
}
138

139
.delete-btn:hover {
140
  color: #f44336;
141
}
142

143
.edit-mode {
144
  display: flex;
145
  gap: 8px;
146
  width: 100%;
147
}
148

149
.edit-mode input {
150
  flex: 1;
151
  padding: 8px 12px;
152
  border: 2px solid #2196F3;
153
  border-radius: 4px;
154
}
155

156
.edit-mode button {
157
  padding: 8px 16px;
158
  border: none;
159
  border-radius: 4px;
160
  cursor: pointer;
161
  background: #2196F3;
162
  color: white;
163
}
164

165
.empty-message {
166
  text-align: center;
167
  color: #999;
168
  padding: 40px 0;
169
}

展開收起

進階技巧#

LocalStorage 持久化#

讓資料重新整理後不會消失：

1
import { useState, useEffect } from 'react'
2

3
function App() {
4
  // 從 localStorage 讀取初始資料
5
  const [todos, setTodos] = useState(() => {
6
    const saved = localStorage.getItem('todos')
7
    return saved ? JSON.parse(saved) : []
8
  })
9

10
  // 當 todos 改變時，存到 localStorage
11
  useEffect(() => {
12
    localStorage.setItem('todos', JSON.stringify(todos))
13
  }, [todos])
14

15
  // ... 其他程式碼
16
}

展開收起

過濾功能#

顯示全部/未完成/已完成：

1
const [filter, setFilter] = useState('all') // 'all', 'active', 'completed'
2

3
const filteredTodos = todos.filter(todo => {
4
  if (filter === 'active') return !todo.isCompleted
5
  if (filter === 'completed') return todo.isCompleted
6
  return true
7
})
8

9
// JSX
10
<div className="filters">
11
  <button
12
    className={filter === 'all' ? 'active' : ''}
13
    onClick={() => setFilter('all')}
14
  >
15
    全部 ({todos.length})
16
  </button>
17
  <button
18
    className={filter === 'active' ? 'active' : ''}
19
    onClick={() => setFilter('active')}
20
  >
21
    未完成 ({activeTodos})
22
  </button>
23
  <button
24
    className={filter === 'completed' ? 'active' : ''}
25
    onClick={() => setFilter('completed')}
26
  >
27
    已完成 ({completedTodos})
28
  </button>
29
</div>
30

31
<ul>
32
  {filteredTodos.map(todo => (
33
    // ...
34
  ))}
35
</ul>

展開收起

清除已完成#

1
const clearCompleted = () => {
2
  setTodos(todos.filter(todo => !todo.isCompleted))
3
}
4

5
<button onClick={clearCompleted}>
6
  清除已完成項目
7
</button>

常見問題#

Q: 為什麼不能直接改 state？

1
// ❌ 錯誤
2
todos.push(newTodo)
3
setTodos(todos)
4

5
// ✅ 正確
6
setTodos([...todos, newTodo])

因為 React 是比較記憶體位址來判斷有沒有改變，直接修改陣列不會改變位址，所以 React 不會重新渲染。

Q: 為什麼 key 不能用 index？

1
// ❌ 不好
2
{todos.map((todo, index) => (
3
  <Todo key={index} todo={todo} />
4
))}
5

6
// ✅ 好
7
{todos.map(todo => (
8
  <Todo key={todo.id} todo={todo} />
9
))}

當你刪除中間的項目時，index 會重新排列，React 會誤以為是不同的項目，造成錯誤或效能問題。

Q: useState 可以放物件嗎？

可以，但更新時要注意：

1
const [user, setUser] = useState({
2
  name: '小明',
3
  age: 25
4
})
5

6
// ❌ 這樣只會改變 name，age 會消失
7
setUser({ name: '小華' })
8

9
// ✅ 用展開運算子保留其他屬性
10
setUser({ ...user, name: '小華' })
11

12
// ✅ 或是用函數式更新
13
setUser(prev => ({ ...prev, name: '小華' }))

Q: 事件處理函數要不要加括號？

1
// ❌ 會立刻執行
2
<button onClick={deleteTodo(todo.id)}>刪除</button>
3

4
// ✅ 用箭頭函數包起來
5
<button onClick={() => deleteTodo(todo.id)}>刪除</button>
6

7
// ✅ 如果不需要傳參數，可以直接傳
8
<button onClick={handleClick}>點我</button>

下一步學習#

這個 Todo App 已經包含 React 最基礎的概念了。接下來可以學：

useEffect
處理副作用，像是 API 呼叫、訂閱、計時器等。

1
useEffect(() => {
2
  // 做一些事情
3

4
  return () => {
5
    // 清理（如果需要）
6
  }
7
}, [依賴項目])

Custom Hooks
把重複的邏輯抽出來變成自己的 Hook。

1
function useTodos() {
2
  const [todos, setTodos] = useState([])
3

4
  const addTodo = (text) => {
5
    // ...
6
  }
7

8
  return { todos, addTodo }
9
}

React Router
多頁面路由。

Context API
跨組件傳遞資料，不用一層層傳 props。

其他工具

TypeScript：加上型別檢查
Tailwind CSS：快速寫樣式
Zustand / Redux：狀態管理
React Query：管理 API 資料

先把基礎打好，這些東西之後都會簡單很多。

HTML & CSS 基礎筆記

Wed, 19 Mar 2025 00:00:00 GMT

第一個 HTML 範例#

1
<!DOCTYPE html>
2
<html>
3
<head>
4
    <title>我的第一個網頁</title>
5
</head>
6
<body>
7
    Hello HTML!
8
</body>
9
</html>

優化開發流程#

將編輯器和瀏覽器並排，方便即時查看修改
安裝 Live Server 擴充功能，自動重新載入網頁
- 在 HTML 檔案中按右鍵，選擇 “Open with Live Server”

HTML 基本結構與元素#

基本結構#

1
<!DOCTYPE html>
2
<html>
3
<head>
4
    <title>網頁標題</title>
5
    <!-- meta 資訊、CSS 連結等放在 head 中 -->
6
</head>
7
<body>
8
    <!-- 網頁的實際內容放在 body 中 -->
9
</body>
10
</html>

標題元素#

1
<h1>一級標題</h1>
2
<h2>二級標題</h2>
3
<h3>三級標題</h3>
4
<h4>四級標題</h4>
5
<h5>五級標題</h5>
6
<h6>六級標題</h6>

段落與換行#

1
<p>這是一個段落。</p>
2
<p>這是另一個段落。</p>
3

4
<!-- 換行 -->
5
一行文字<br>換到下一行

註解#

1
<!-- 這是 HTML 註解，不會顯示在網頁上 -->

在 VS Code 中使用 Ctrl + / (Windows) 或 Cmd + / (Mac) 快速添加/移除註解

空格處理#

HTML 中多個連續空格只會顯示為一個空格
使用特殊字元   來顯示多個空格

列表#

無序列表 (圓點列表)#

1
<ul>
2
    <li>項目一</li>
3
    <li>項目二</li>
4
    <li>項目三</li>
5
</ul>

有序列表 (編號列表)#

1
<ol>
2
    <li>第一步</li>
3
    <li>第二步</li>
4
    <li>第三步</li>
5
</ol>

表格#

1
<table>
2
    <tr>
3
        <th>標題 1</th>
4
        <th>標題 2</th>
5
    </tr>
6
    <tr>
7
        <td>資料 1</td>
8
        <td>資料 2</td>
9
    </tr>
10
</table>

超連結#

1
<!-- 基本連結 -->
2
<a href="https://www.example.com">連結文字</a>
3

4
<!-- 在新分頁開啟 -->
5
<a href="https://www.example.com" target="_blank">在新分頁開啟</a>
6

7
<!-- 連結到自己的頁面 -->
8
<a href="./page2.html">前往第二頁</a>
9

10
<!-- 電子郵件連結 -->
11
<a href="mailto:example@example.com">寄信給我</a>

錨點 (頁內連結)#

1
<!-- 先定義錨點 -->
2
<h2 id="section1">第一節</h2>
3

4
<!-- 連結到錨點 -->
5
<a href="#section1">跳到第一節</a>

圖片#

1
<!-- 基本圖片 -->
2
<img src="./images/photo.jpg" alt="風景照片">
3

4
<!-- 設定寬高 -->
5
<img src="./dog.jpg" alt="狗狗" width="300" height="200">
6

7
<!-- 圖片作為連結 -->
8
<a href="https://www.example.com">
9
    <img src="./logo.png" alt="Logo">
10
</a>

表單#

1
<form action="/submit" method="post">
2
    <!-- 文字輸入 -->
3
    <label for="username">用戶名:</label>
4
    <input type="text" id="username" name="username"><br>
5

6
    <!-- Email 輸入 -->
7
    <label for="email">電子郵件:</label>
8
    <input type="email" id="email" name="email"><br>
9

10
    <!-- 日期選擇器 -->
11
    <label for="birthdate">生日:</label>
12
    <input type="date" id="birthdate" name="birthdate"><br>
13

14
    <!-- 數字輸入 -->
15
    <label for="age">年齡:</label>
16
    <input type="number" id="age" name="age" min="1" max="120"><br>
17

18
    <!-- 多行文字 -->
19
    <label for="message">留言:</label><br>
20
    <textarea id="message" name="message" rows="4" cols="50"></textarea><br>
21

22
    <!-- 核取方塊 -->
23
    <input type="checkbox" id="subscribe" name="subscribe" value="yes">
24
    <label for="subscribe">訂閱電子報</label><br>
25

26
    <!-- 下拉選單 -->
27
    <label for="country">國家:</label>
28
    <select id="country" name="country">
29
        <option value="tw">台灣</option>
30
        <option value="jp">日本</option>
31
        <option value="us">美國</option>
32
    </select><br>
33

34
    <!-- 提交按鈕 -->
35
    <input type="submit" value="送出">
36
</form>

展開收起

Meta 元素#

1
<head>
2
    <!-- 字符集 -->
3
    <meta charset="UTF-8">
4

5
    <!-- 視口設定，對響應式網頁很重要 -->
6
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
7

8
    <!-- 網頁描述 -->
9
    <meta name="description" content="這是一個描述網頁內容的簡短摘要">
10

11
    <!-- 關鍵字 -->
12
    <meta name="keywords" content="HTML, CSS, 網頁設計">
13

14
    <!-- Open Graph 標籤，用於社交媒體分享 -->
15
    <meta property="og:title" content="網頁標題">
16
    <meta property="og:description" content="網頁描述">
17
    <meta property="og:image" content="https://example.com/image.jpg">
18
</head>

展開收起

特殊字元 (字元實體)#

  - 空格
< - 小於符號 (<)
> - 大於符號 (>)
& - 和符號 (&)
" - 雙引號 (”)
' - 單引號 (’)
© - 版權符號 (©)
™ - 商標符號 (™)

文字格式化#

1
<!-- 加粗 -->
2
<b>粗體文字</b>
3
<strong>重要文字</strong> <!-- 語義上更強調重要性 -->
4

5
<!-- 斜體 -->
6
<i>斜體文字</i>
7
<em>強調文字</em> <!-- 語義上表示強調 -->

iframe 元素#

1
<!-- 嵌入其他網頁 -->
2
<iframe src="https://www.example.com" width="600" height="400"></iframe>
3

4
<!-- 嵌入 YouTube 影片 -->
5
<iframe width="560" height="315" src="https://www.youtube.com/embed/VIDEO_ID" frameborder="0" allowfullscreen></iframe>

音訊元素#

1
<audio controls>
2
    <source src="music.mp3" type="audio/mpeg">
3
    您的瀏覽器不支援音訊元素。
4
</audio>

div 和 span 元素#

1
<!-- div 是區塊級元素 -->
2
<div>這是一個區塊</div>
3

4
<!-- span 是行內元素 -->
5
<p>這段文字中的<span>這部分</span>可以單獨設定樣式。</p>

按鈕元素#

1
<!-- 基本按鈕 -->
2
<button>點我</button>
3

4
<!-- 帶有 JavaScript 事件的按鈕 -->
5
<button onclick="alert('Hello!')">點我顯示提醒</button>
6

7
<!-- 作為連結的按鈕 -->
8
<a href="https://www.example.com">
9
    <button>前往網站</button>
10
</a>

語義化標籤#

1
<header>
2
    <h1>網站標題</h1>
3
    <nav>
4
        <ul>
5
            <li><a href="#">首頁</a></li>
6
            <li><a href="#">關於我們</a></li>
7
            <li><a href="#">聯絡我們</a></li>
8
        </ul>
9
    </nav>
10
</header>
11

12
<main>
13
    <article>
14
        <h2>文章標題</h2>
15
        <p>文章內容...</p>
16
    </article>
17

18
    <aside>
19
        <h3>相關資訊</h3>
20
        <p>側邊欄內容...</p>
21
    </aside>
22
</main>
23

24
<footer>
25
    <p>&copy; 2025 我的網站</p>
26
</footer>

展開收起

CSS 基礎#

CSS 的基本觀念#

CSS 用於描述 HTML 元素如何在螢幕上呈現

CSS 規則由選擇器和聲明區塊組成：

1
選擇器 {
2
  屬性: 值;
3
  屬性: 值;
4
}

CSS 使用方式#

行內樣式#

1
<p style="color: blue; font-size: 16px;">這是藍色文字。</p>

內部樣式表#

1
<head>
2
    <style>
3
        p {
4
            color: blue;
5
            font-size: 16px;
6
        }
7
    </style>
8
</head>

外部樣式表 (推薦)#

1
<head>
2
    <link rel="stylesheet" href="styles.css">
3
</head>

styles.css

1
p {
2
    color: blue;
3
    font-size: 16px;
4
}

CSS 顏色單位#

1
/* 顏色名稱 */
2
color: red;
3

4
/* RGB 值 */
5
color: rgb(255, 0, 0);  /* 紅色 */
6
color: rgb(0, 255, 0);  /* 綠色 */
7
color: rgb(0, 0, 255);  /* 藍色 */
8

9
/* 十六進制顏色代碼 */
10
color: #ff0000;  /* 紅色 */
11
color: #00ff00;  /* 綠色 */
12
color: #0000ff;  /* 藍色 */
13

14
/* HSL (色相、飽和度、亮度) */
15
color: hsl(0, 100%, 50%);    /* 紅色 */
16
color: hsl(120, 100%, 50%);  /* 綠色 */
17
color: hsl(240, 100%, 50%);  /* 藍色 */

展開收起

CSS 字體#

1
/* 指定字體 */
2
font-family: Arial, Helvetica, sans-serif;
3

4
/* 使用 Google Fonts */
5
/* 先在 HTML 的 head 中添加: */
6
<link href="https://fonts.googleapis.com/css2?family=Roboto&display=swap" rel="stylesheet">
7

8
/* 然後在 CSS 中使用: */
9
font-family: 'Roboto', sans-serif;
10

11
/* 自定義字體 */
12
@font-face {
13
    font-family: 'MyCustomFont';
14
    src: url('fonts/custom-font.woff2') format('woff2');
15
}
16

17
font-family: 'MyCustomFont', Arial, sans-serif;

展開收起

CSS 邊框#

1
/* 單獨設定各屬性 */
2
border-width: 2px;
3
border-style: solid;
4
border-color: black;
5

6
/* 縮寫 */
7
border: 2px solid black;
8

9
/* 圓角邊框 */
10
border-radius: 5px;
11

12
/* 單獨設定各邊 */
13
border-top: 1px solid red;
14
border-right: 2px dashed green;
15
border-bottom: 3px dotted blue;
16
border-left: 4px double yellow;

展開收起

CSS 背景#

1
/* 背景顏色 */
2
background-color: #f0f0f0;
3

4
/* 背景圖片 */
5
background-image: url('background.jpg');
6

7
/* 背景重複 */
8
background-repeat: no-repeat;  /* 不重複 */
9
background-repeat: repeat-x;   /* 水平重複 */
10
background-repeat: repeat-y;   /* 垂直重複 */
11

12
/* 背景尺寸 */
13
background-size: cover;    /* 覆蓋整個容器 */
14
background-size: contain;  /* 確保整張圖片可見 */
15
background-size: 200px 100px;  /* 指定寬高 */
16

17
/* 背景位置 */
18
background-position: center;
19
background-position: top left;
20
background-position: 50% 25%;
21

22
/* 縮寫 */
23
background: #f0f0f0 url('background.jpg') no-repeat center / cover;

展開收起

CSS 浮動排版#

1
/* 向左浮動 */
2
float: left;
3

4
/* 向右浮動 */
5
float: right;
6

7
/* 清除浮動 */
8
clear: both;

CSS Overflow#

1
/* 預設值，內容超出容器會顯示 */
2
overflow: visible;
3

4
/* 內容超出容器會被隱藏 */
5
overflow: hidden;
6

7
/* 總是顯示捲軸 */
8
overflow: scroll;
9

10
/* 需要時才顯示捲軸 */
11
overflow: auto;

CSS Display#

1
/* 區塊元素 */
2
display: block;
3

4
/* 行內元素 */
5
display: inline;
6

7
/* 行內區塊元素 */
8
display: inline-block;
9

10
/* 隱藏元素 */
11
display: none;
12

13
/* Flex 容器 */
14
display: flex;
15

16
/* Grid 容器 */
17
display: grid;

展開收起

CSS 寬度和高度#

1
/* 固定值 */
2
width: 300px;
3
height: 200px;
4

5
/* 百分比 */
6
width: 50%;
7
height: 100%;
8

9
/* 視窗寬高百分比 */
10
width: 50vw;  /* 視窗寬度的 50% */
11
height: 50vh; /* 視窗高度的 50% */
12

13
/* 最小最大值 */
14
min-width: 100px;
15
max-width: 500px;
16
min-height: 100px;
17
max-height: 500px;

展開收起

CSS 定位#

1
/* 靜態定位（預設） */
2
position: static;
3

4
/* 相對定位（相對於自己的原始位置） */
5
position: relative;
6
top: 10px;
7
left: 20px;
8

9
/* 絕對定位（相對於最近的已定位祖先） */
10
position: absolute;
11
top: 0;
12
right: 0;
13

14
/* 固定定位（相對於視窗） */
15
position: fixed;
16
bottom: 20px;
17
right: 20px;
18

19
/* 黏性定位 */
20
position: sticky;
21
top: 0;  /* 滾動到頂部時會固定 */

展開收起

CSS 盒模型#

1
/* 內容區域 */
2
width: 300px;
3
height: 200px;
4

5
/* 內邊距 */
6
padding: 20px;  /* 四邊都是 20px */
7
padding: 10px 20px;  /* 上下 10px，左右 20px */
8
padding: 10px 20px 30px 40px;  /* 上右下左 */
9

10
/* 邊框 */
11
border: 1px solid black;
12

13
/* 外邊距 */
14
margin: 10px;  /* 四邊都是 10px */
15
margin: 10px auto;  /* 上下 10px，左右自動居中 */
16
margin: 10px 20px 30px 40px;  /* 上右下左 */
17

18
/* 改變盒模型計算方式 */
19
box-sizing: border-box;  /* 寬高包含 padding 和 border */

展開收起

CSS 選擇器#

1
/* 元素選擇器 */
2
p {
3
    color: blue;
4
}
5

6
/* ID 選擇器 */
7
#header {
8
    background-color: black;
9
}
10

11
/* 類別選擇器 */
12
.highlight {
13
    background-color: yellow;
14
}
15

16
/* 通用選擇器 */
17
* {
18
    margin: 0;
19
    padding: 0;
20
}
21

22
/* 群組選擇器 */
23
h1, h2, h3 {
24
    font-family: Arial, sans-serif;
25
}

展開收起

CSS 選擇器組合器#

1
/* 後代選擇器 */
2
article p {  /* article 內的所有 p */
3
    color: gray;
4
}
5

6
/* 子選擇器 */
7
article > p {  /* article 的直接子元素 p */
8
    color: blue;
9
}
10

11
/* 相鄰兄弟選擇器 */
12
h2 + p {  /* 緊跟在 h2 後的第一個 p */
13
    font-weight: bold;
14
}
15

16
/* 一般兄弟選擇器 */
17
h2 ~ p {  /* h2 後的所有同層級 p */
18
    color: green;
19
}

展開收起

CSS 屬性選擇器#

1
/* 具有特定屬性的元素 */
2
[class] {
3
    color: blue;
4
}
5

6
/* 屬性值等於指定值的元素 */
7
[type="email"] {
8
    border: 1px solid blue;
9
}
10

11
/* 屬性值以指定值開頭的元素 */
12
[href^="https"] {
13
    color: green;
14
}
15

16
/* 屬性值以指定值結尾的元素 */
17
[href$=".pdf"] {
18
    color: red;
19
}
20

21
/* 屬性值包含指定值的元素 */
22
[title*="hello"] {
23
    font-weight: bold;
24
}

展開收起

CSS 偽類別#

1
/* 連結狀態 */
2
a:link {  /* 未訪問的連結 */
3
    color: blue;
4
}
5
a:visited {  /* 已訪問的連結 */
6
    color: purple;
7
}
8
a:hover {  /* 滑鼠懸停的連結 */
9
    text-decoration: underline;
10
}
11
a:active {  /* 點擊中的連結 */
12
    color: red;
13
}
14

15
/* 元素狀態 */
16
input:focus {  /* 獲得焦點的輸入框 */
17
    border: 2px solid blue;
18
}
19
button:disabled {  /* 禁用的按鈕 */
20
    opacity: 0.5;
21
}
22

23
/* 結構偽類 */
24
li:first-child {  /* 第一個子元素 */
25
    font-weight: bold;
26
}
27
li:last-child {  /* 最後一個子元素 */
28
    color: red;
29
}
30
li:nth-child(odd) {  /* 奇數位置的子元素 */
31
    background-color: #f0f0f0;
32
}
33
li:nth-child(even) {  /* 偶數位置的子元素 */
34
    background-color: #e0e0e0;
35
}
36
p:empty {  /* 沒有內容的元素 */
37
    display: none;
38
}
39

40
/* 否定偽類 */
41
:not(.highlight) {  /* 不具有 highlight 類別的元素 */
42
    color: gray;
43
}

展開收起

CSS 偽元素#

1
/* 第一個字母 */
2
p::first-letter {
3
    font-size: 2em;
4
    font-weight: bold;
5
}
6

7
/* 第一行 */
8
p::first-line {
9
    color: blue;
10
}
11

12
/* 選中的文字 */
13
::selection {
14
    background-color: yellow;
15
    color: black;
16
}
17

18
/* 在元素內容前插入 */
19
.info::before {
20
    content: "⚠️ ";
21
}
22

23
/* 在元素內容後插入 */
24
.external-link::after {
25
    content: " 🔗";
26
}
27

28
/* 列表項目符號 */
29
li::marker {
30
    color: red;
31
}

展開收起

CSS 權重 (Specificity)#

權重從低到高:

元素、偽元素選擇器: p, div, ::before (權值: 001)
類別、屬性、偽類選擇器: .class, [type="text"], :hover (權值: 010)
ID 選擇器: #id (權值: 100)
行內樣式: style="..." (權值: 1000)
!important: color: red !important; (最高權重)

CSS 過渡 (Transitions)#

1
/* 單獨設定 */
2
transition-property: background-color;  /* 要過渡的屬性 */
3
transition-duration: 0.3s;              /* 過渡時間 */
4
transition-timing-function: ease-in-out; /* 過渡速度曲線 */
5
transition-delay: 0.1s;                 /* 延遲時間 */
6

7
/* 縮寫 */
8
transition: background-color 0.3s ease-in-out 0.1s;
9

10
/* 多個屬性過渡 */
11
transition: color 0.3s, background-color 0.5s;
12

13
/* 所有可過渡屬性 */
14
transition: all 0.3s;

CSS 動畫 (Animations)#

1
/* 定義關鍵影格 */
2
@keyframes slide-in {
3
    0% {
4
        transform: translateX(-100%);
5
        opacity: 0;
6
    }
7
    100% {
8
        transform: translateX(0);
9
        opacity: 1;
10
    }
11
}
12

13
/* 應用動畫 */
14
.box {
15
    /* 單獨設定 */
16
    animation-name: slide-in;           /* 動畫名稱 */
17
    animation-duration: 1s;             /* 動畫時間 */
18
    animation-timing-function: ease;    /* 速度曲線 */
19
    animation-delay: 0.5s;              /* 延遲時間 */
20
    animation-iteration-count: 3;       /* 重複次數 */
21
    animation-direction: alternate;     /* 播放方向 */
22
    animation-fill-mode: forwards;      /* 結束後保持最後狀態 */
23

24
    /* 縮寫 */
25
    animation: slide-in 1s ease 0.5s 3 alternate forwards;
26
}

展開收起

Font Awesome 使用#

1
<!-- 在 head 中添加 Font Awesome -->
2
<head>
3
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css">
4
</head>
5

6
<!-- 使用 Font Awesome 圖示 -->
7
<i class="fas fa-star"></i>           <!-- 實心星星 -->
8
<i class="far fa-star"></i>           <!-- 空心星星 -->
9
<i class="fab fa-twitter"></i>        <!-- Twitter 圖示 -->
10

11
<!-- 調整大小 -->
12
<i class="fas fa-star fa-lg"></i>     <!-- 大一點 -->
13
<i class="fas fa-star fa-2x"></i>     <!-- 兩倍大 -->

響應式網頁設計 (RWD)#

1
/* 媒體查詢 */
2
@media screen and (max-width: 600px) {
3
    /* 小螢幕的樣式 */
4
    .container {
5
        width: 100%;
6
    }
7
    .sidebar {
8
        display: none;
9
    }
10
}
11

12
@media screen and (min-width: 601px) and (max-width: 1024px) {
13
    /* 中型螢幕的樣式 */
14
    .container {
15
        width: 80%;
16
    }
17
}
18

19
@media screen and (min-width: 1025px) {
20
    /* 大螢幕的樣式 */
21
    .container {
22
        width: 1000px;
23
    }
24
}
25

26
/* 響應式圖片 */
27
img {
28
    max-width: 100%;
29
    height: auto;
30
}

展開收起

CSS Flexbox#

1
/* 容器設定 */
2
.container {
3
  display: flex;
4

5
  /* 主軸方向 */
6
  flex-direction: row; /* 水平排列 (默認) */
7
  /* flex-direction: row-reverse; */ /* 水平反向排列 */
8
  /* flex-direction: column; */ /* 垂直排列 */
9
  /* flex-direction: column-reverse; */ /* 垂直反向排列 */
10

11
  /* 換行設定 */
12
  flex-wrap: nowrap; /* 不換行 (默認) */
13
  /* flex-wrap: wrap; */ /* 換行 */
14
  /* flex-wrap: wrap-reverse; */ /* 反向換行 */
15

16
  /* 縮寫: flex-direction + flex-wrap */
17
  /* flex-flow: row wrap; */
18

19
  /* 主軸對齊 */
20
  justify-content: flex-start; /* 靠左/靠上 (默認) */
21
  /* justify-content: flex-end; */ /* 靠右/靠下 */
22
  /* justify-content: center; */ /* 居中 */
23
  /* justify-content: space-between; */ /* 兩端對齊 */
24
  /* justify-content: space-around; */ /* 均勻分布 (項目周圍) */
25
  /* justify-content: space-evenly; */ /* 均勻分布 (所有間距相等) */
26

27
  /* 交叉軸對齊 */
28
  align-items: stretch; /* 拉伸填滿 (默認) */
29
  /* align-items: flex-start; */ /* 靠上/靠左 */
30
  /* align-items: flex-end; */ /* 靠下/靠右 */
31
  /* align-items: center; */ /* 居中 */
32
  /* align-items: baseline; */ /* 基線對齊 */
33

34
  /* 多行對齊 (需設定 flex-wrap: wrap) */
35
  align-content: stretch; /* 拉伸填滿 (默認) */
36
  /* align-content: flex-start; */ /* 靠上 */
37
  /* align-content: flex-end; */ /* 靠下 */
38
  /* align-content: center; */ /* 居中 */
39
  /* align-content: space-between; */ /* 兩端對齊 */
40
  /* align-content: space-around; */ /* 均勻分布 */
41
}
42

43
/* 項目設定 */
44
.item {
45
  /* 排序 */
46
  order: 0; /* 預設值 (數字越小越靠前) */
47

48
  /* 放大比例 */
49
  flex-grow: 0; /* 預設不放大 */
50

51
  /* 縮小比例 */
52
  flex-shrink: 1; /* 預設會等比縮小 */
53

54
  /* 初始大小 */
55
  flex-basis: auto; /* 預設大小 */
56

57
  /* 縮寫: flex-grow + flex-shrink + flex-basis */
58
  flex: 0 1 auto; /* 默認值 */
59
  /* flex: 1; */ /* 等同於 flex: 1 1 0%; (常用於均分空間) */
60

61
  /* 個別交叉軸對齊 (覆蓋容器的 align-items) */
62
  align-self: auto; /* 跟隨容器設定 (默認) */
63
  /* align-self: flex-start; */ /* 靠上/靠左 */
64
  /* align-self: flex-end; */ /* 靠下/靠右 */
65
  /* align-self: center; */ /* 居中 */
66
  /* align-self: stretch; */ /* 拉伸填滿 */
67
}

展開收起

Flexbox 實例應用#

1
/* 基本導航欄 */
2
.navbar {
3
  display: flex;
4
  justify-content: space-between; /* 項目間均勻分布 */
5
  align-items: center; /* 垂直居中 */
6
  padding: 1rem;
7
  background-color: #333;
8
}
9

10
/* 均等分布的卡片容器 */
11
.card-container {
12
  display: flex;
13
  flex-wrap: wrap; /* 允許卡片換行 */
14
  gap: 20px; /* 卡片間距 */
15
}
16

17
.card {
18
  flex: 1 1 300px; /* 放大比例1, 縮小比例1, 基本寬度300px */
19
  min-width: 300px; /* 最小寬度 */
20
  padding: 20px;
21
  border: 1px solid #ddd;
22
}
23

24
/* 聖杯布局 (Header, Sidebar, Main, Footer) */
25
.holy-grail {
26
  display: flex;
27
  flex-direction: column;
28
  min-height: 100vh; /* 至少佔滿整個視窗高度 */
29
}
30

31
.header, .footer {
32
  background-color: #f0f0f0;
33
  padding: 20px;
34
}
35

36
.content-container {
37
  display: flex;
38
  flex: 1; /* 佔用所有可用空間 */
39
}
40

41
.sidebar {
42
  flex: 0 0 200px; /* 不放大, 不縮小, 固定寬度200px */
43
  background-color: #e0e0e0;
44
  padding: 20px;
45
}
46

47
.main-content {
48
  flex: 1; /* 佔用所有剩餘空間 */
49
  padding: 20px;
50
}
51

52
/* 響應式布局: 在小螢幕上改變排列方向 */
53
@media (max-width: 768px) {
54
  .content-container {
55
    flex-direction: column; /* 改為垂直排列 */
56
  }
57

58
  .sidebar {
59
    flex-basis: auto; /* 重置固定寬度 */
60
  }
61
}

展開收起

CSS Grid 布局#

1
/* 容器設定 */
2
.grid-container {
3
  display: grid;
4

5
  /* 定義網格列 */
6
  grid-template-columns: 200px 1fr 2fr; /* 三列: 固定寬度, 1份剩餘空間, 2份剩餘空間 */
7
  /* grid-template-columns: repeat(3, 1fr); */ /* 三列等寬 */
8
  /* grid-template-columns: minmax(100px, 1fr) 2fr 1fr; */ /* 第一列最小100px, 最大1fr */
9

10
  /* 定義網格行 */
11
  grid-template-rows: 100px auto 100px; /* 三行: 固定高度, 自動高度, 固定高度 */
12
  /* grid-template-rows: repeat(3, minmax(100px, auto)); */ /* 三行最小高度100px */
13

14
  /* 網格間距 */
15
  gap: 20px; /* 行和列間距都是20px */
16
  /* column-gap: 20px; */ /* 僅列間距 */
17
  /* row-gap: 10px; */ /* 僅行間距 */
18

19
  /* 簡寫: 區域命名 */
20
  grid-template-areas:
21
    "header header header"
22
    "sidebar main main"
23
    "footer footer footer";
24

25
  /* 項目對齊 (水平方向) */
26
  justify-items: stretch; /* 拉伸填滿 (默認) */
27
  /* justify-items: start; */ /* 靠左 */
28
  /* justify-items: end; */ /* 靠右 */
29
  /* justify-items: center; */ /* 居中 */
30

31
  /* 項目對齊 (垂直方向) */
32
  align-items: stretch; /* 拉伸填滿 (默認) */
33
  /* align-items: start; */ /* 靠上 */
34
  /* align-items: end; */ /* 靠下 */
35
  /* align-items: center; */ /* 居中 */
36

37
  /* 整體內容對齊 (當網格大小小於容器) */
38
  justify-content: start; /* 靠左 (默認) */
39
  /* justify-content: end; */ /* 靠右 */
40
  /* justify-content: center; */ /* 居中 */
41
  /* justify-content: space-between; */ /* 兩端對齊 */
42
  /* justify-content: space-around; */ /* 均勻分布 */
43

44
  align-content: start; /* 靠上 (默認) */
45
  /* align-content: end; */ /* 靠下 */
46
  /* align-content: center; */ /* 居中 */
47
  /* align-content: space-between; */ /* 兩端對齊 */
48
  /* align-content: space-around; */ /* 均勻分布 */
49
}
50

51
/* 項目設定 */
52
.grid-item {
53
  /* 指定項目位置 (基於網格線編號) */
54
  grid-column-start: 1;
55
  grid-column-end: 3; /* 或 span 2 (橫跨2列) */
56
  grid-row-start: 1;
57
  grid-row-end: 2;
58

59
  /* 縮寫 */
60
  grid-column: 1 / 3; /* 從第1條列線到第3條列線 */
61
  /* grid-column: 1 / span 2; */ /* 從第1條列線開始橫跨2列 */
62
  grid-row: 1 / 2; /* 從第1條行線到第2條行線 */
63

64
  /* 更簡潔的縮寫: grid-row-start / grid-column-start / grid-row-end / grid-column-end */
65
  grid-area: 1 / 1 / 2 / 3;
66

67
  /* 使用命名區域 */
68
  grid-area: header;
69

70
  /* 個別項目對齊 */
71
  justify-self: stretch; /* 水平拉伸 (默認) */
72
  /* justify-self: start; */ /* 靠左 */
73
  /* justify-self: end; */ /* 靠右 */
74
  /* justify-self: center; */ /* 水平居中 */
75

76
  align-self: stretch; /* 垂直拉伸 (默認) */
77
  /* align-self: start; */ /* 靠上 */
78
  /* align-self: end; */ /* 靠下 */
79
  /* align-self: center; */ /* 垂直居中 */
80
}

展開收起

CSS Grid 實例應用#

1
/* 照片牆布局 */
2
.gallery {
3
  display: grid;
4
  grid-template-columns: repeat(auto-fill, minmax(250px, 1fr)); /* 自動填充, 每列最小250px */
5
  gap: 15px;
6
  padding: 20px;
7
}
8

9
.gallery-item {
10
  overflow: hidden;
11
  border-radius: 8px;
12
}
13

14
.gallery-item img {
15
  width: 100%;
16
  height: 100%;
17
  object-fit: cover;
18
}
19

20
/* 經典網頁布局 */
21
.page-layout {
22
  display: grid;
23
  grid-template-areas:
24
    "header header header"
25
    "nav content sidebar"
26
    "footer footer footer";
27
  grid-template-columns: 200px 1fr 200px;
28
  grid-template-rows: auto 1fr auto;
29
  min-height: 100vh;
30
}
31

32
.header { grid-area: header; }
33
.nav { grid-area: nav; }
34
.content { grid-area: content; }
35
.sidebar { grid-area: sidebar; }
36
.footer { grid-area: footer; }
37

38
/* 響應式布局 */
39
@media (max-width: 768px) {
40
  .page-layout {
41
    grid-template-areas:
42
      "header"
43
      "nav"
44
      "content"
45
      "sidebar"
46
      "footer";
47
    grid-template-columns: 1fr; /* 單列 */
48
  }
49
}
50

51
/* 網格中的網格 (嵌套網格) */
52
.nested-grid {
53
  display: grid;
54
  grid-template-columns: repeat(3, 1fr);
55
  gap: 10px;
56
}
57

58
.nested-item {
59
  display: grid;
60
  grid-template-columns: 1fr 1fr;
61
  grid-template-rows: auto 1fr;
62
  gap: 5px;
63
}

展開收起

CSS 動畫與過渡#

1
/* 過渡效果 */
2
.transition-element {
3
  width: 100px;
4
  height: 100px;
5
  background-color: blue;
6

7
  /* 單一屬性過渡 */
8
  transition: background-color 0.5s ease;
9

10
  /* 多屬性過渡 */
11
  /* transition: background-color 0.5s ease, transform 0.3s ease-in-out; */
12

13
  /* 所有可過渡屬性 */
14
  /* transition: all 0.5s ease; */
15

16
  /* 延遲過渡 */
17
  /* transition: background-color 0.5s ease 0.2s; */ /* 延遲0.2秒 */
18
}
19

20
.transition-element:hover {
21
  background-color: red;
22
  transform: scale(1.2); /* 放大1.2倍 */
23
}
24

25
/* 動畫 */
26
@keyframes slide-in {
27
  0% {
28
    transform: translateX(-100%);
29
    opacity: 0;
30
  }
31
  100% {
32
    transform: translateX(0);
33
    opacity: 1;
34
  }
35
}
36

37
.animated-element {
38
  animation-name: slide-in; /* 動畫名稱 */
39
  animation-duration: 1s; /* 持續時間 */
40
  animation-timing-function: ease-out; /* 時間函數 */
41
  animation-delay: 0s; /* 延遲 */
42
  animation-iteration-count: 1; /* 重複次數 (infinite為無限重複) */
43
  animation-direction: normal; /* 方向 (normal, reverse, alternate, alternate-reverse) */
44
  animation-fill-mode: forwards; /* 結束後保持最後一幀 */
45

46
  /* 縮寫 */
47
  /* animation: slide-in 1s ease-out 0s 1 normal forwards; */
48
}
49

50
/* 多步驟動畫 */
51
@keyframes pulse {
52
  0% {
53
    transform: scale(1);
54
  }
55
  50% {
56
    transform: scale(1.2);
57
  }
58
  100% {
59
    transform: scale(1);
60
  }
61
}
62

63
.pulse-element {
64
  animation: pulse 2s infinite ease-in-out;
65
}

展開收起

CSS 變數 (自定義屬性)#

1
/* 全局變數定義 */
2
:root {
3
  --primary-color: #007bff;
4
  --secondary-color: #6c757d;
5
  --padding-standard: 15px;
6
  --border-radius: 8px;
7
  --font-main: 'Roboto', sans-serif;
8
}
9

10
/* 使用變數 */
11
.button {
12
  background-color: var(--primary-color);
13
  padding: var(--padding-standard);
14
  border-radius: var(--border-radius);
15
  font-family: var(--font-main);
16
  color: white;
17
}
18

19
.button-secondary {
20
  background-color: var(--secondary-color);
21
}
22

23
/* 作用域變數 */
24
.card {
25
  --card-padding: 20px;
26
  padding: var(--card-padding);
27
}
28

29
/* 變數計算與備用值 */
30
.element {
31
  margin: calc(var(--padding-standard) * 2);
32
  color: var(--text-color, #333); /* 如果--text-color未定義, 使用#333 */
33
}

展開收起

k652. 二元搜尋樹復原 (BST) 題解

Sun, 13 Oct 2024 00:00:00 GMT

題目連結

問題敘述#

給定一棵二元搜尋樹 (BST) 的後序走訪序列，請重建這棵樹，並輸出每個節點的值 Ui 及其父節點 Fi（根為 -1），輸出時按 Ui 遞增排序。

BST 定義：

左子樹所有值 < 根
右子樹所有值 > 根
左右子樹也為 BST

後序走訪：左 → 右 → 根

範例:

alt text

輸入格式#

第一行：正整數 N (1≤N≤2×105)N \ (1 \leq N \leq 2 \times 10^5)N (1≤N≤2×105)，節點數量
第二行：NNN 個互不相同的正整數 P1,P2,…,PN (1≤Pi≤109)P_1, P_2, \dots, P_N \ (1 \leq P_i \leq 10^9)P1,P2,…,PN (1≤Pi≤109)，為後序走訪序列

輸出格式#

輸出 NNN 行，第 iii 行為兩個整數 UiU_iUi FiF_iFi：

UiU_iUi：節點值（保證 U1<U2<⋯<UNU_1 < U_2 < \dots < U_NU1<U2<⋯<UN）
FiF_iFi：UiU_iUi 的父節點值，若為根節點則輸出 -1

範例輸入 1#

1
8
2
2 1 6 3 15 19 12 7

範例輸出 1#

範例輸入 2#

1
7
2
7 3 1 9 15 20 16

範例輸出 2#

範例輸入 3#

範例輸出 3#

1
2 -1

解法思路#

後序序列最後為根，因此我們可以從右到左處理序列，利用堆疊 (stack) 來維護「右子樹路徑」，從而找出每個節點的父節點。

核心邏輯#

後序走訪的最後一個是根，設為 -1（沒有父節點）
由右往左掃：
- 若當前值小於堆疊頂端，代表它在左子樹
- 若當前值大於堆疊頂端，pop 直到找到合適位置（右子樹邊界）
- 根據 pop 結果或堆疊頂端確定父節點

複雜度分析#

時間：O(N log N)（最後 map 排序）
空間：O(N)

完整程式碼（C++）#

1
#include <bits/stdc++.h>
2
using namespace std;
3

4
int main() {
5
    int n;
6
    cin >> n;
7
    vector<int> post_order(n);
8
    for (int i = 0; i < n; i++) {
9
        cin >> post_order[i];
10
    }
11

12
    map<int, int> parent_map;
13
    stack<int> st;
14

15
    // 最後一個是根
16
    parent_map[post_order[n - 1]] = -1;
17
    st.push(post_order[n - 1]);
18

19
    for (int i = n - 2; i >= 0; i--) {
20
        int current = post_order[i];
21
        int parent = -1;
22

23
        while (!st.empty() && st.top() < current) {  // BST: 左小右大
24
            parent = st.top();
25
            st.pop();
26
        }
27

28
        if (parent == -1 && !st.empty()) {
29
            parent = st.top();
30
        } else if (parent == -1) {
31
            assert(false); // 理論上不會發生
32
        }
33

34
        parent_map[current] = parent;
35
        st.push(current);
36
    }
37

38
    for (const auto &entry : parent_map) {
39
        cout << entry.first << " " << entry.second << '\n';
40
    }
41

42
    return 0;
43
}

展開收起

範例驗證#

以範例 1：

1
2 1 6 3 15 19 12 7

根 = 7

右子樹 = [12, 19, 15]

左子樹 = [2, 1, 6, 3]

重建後輸出與範例一致 ✅

結語#

這題結合了 BST 性質與堆疊建樹技巧，重點在於掌握「從右往左還原」的過程。在 N = 2×10⁵ 的限制下，O(N log N) 的 map 排序仍可輕鬆通過。此解法不僅簡潔，也適合應用於其他樹結構重建問題。

文章加密

Fri, 02 Jan 1970 00:00:00 GMT

這是一篇密碼保護的範例文章，用於示範文章加密功能。

8月32日の島

大二下計算機結構

第一章：程式效能解析與底層硬體邏輯#

1. 效能的定義與度量 (Performance)#

核心觀念辨析#

程式翻譯與抽象化層次 (Abstraction)#

2. 計算機效能 (Performance Equations)#

效能公式#

一、 指令總數 (Instruction Count, IC)#

二、 每條指令平均週期數 (Cycles Per Instruction, CPI)#

三、 時脈週期時間 (Clock Cycle Time, TcT_cTc​)#

四、 時脈頻率 / 主頻 (Clock Rate, fff)#

影響因素對照表#

3. 動態功耗公式與功耗牆 (Power Wall)#

動態功耗公式#

功耗牆 (Power Wall) 的成因與轉折#

4. 阿姆達爾定律 (Amdahl’s Law)#

整體加速比公式#

物理啟示#

📝 實戰演練：局部加速與整體降頻#

【解析】#

5. 補充#

第二章：MIPS 和指令集架構 (ISA)#

1. 指令集基礎與算術運算#

知識點 1：計算機架構定義與設計原則#

觀念與公式#

實戰演練#

知識點 2：MIPS 算術指令與語法#

觀念與公式#

實戰演練#

⚠️ 考前避坑指南：第 1 節#

2. 記憶體運算元 (Data Transfer)#

知識點 1：位址計算與 Byte Addressing#

觀念與公式#

實戰演練#

知識點 2：資料傳輸指令 lw / sw#

觀念與公式#

實戰演練#

⚠️ 考前避坑指南：第 2 節#

3. 指令格式與機器碼編譯#

知識點 1：R-Format 與 I-Format#

觀念與公式#

實戰演練#

⚠️ 考前避坑指南：第 3 節#

4. 控制流 (Branch & Jump)#

知識點 1：條件跳躍與 PC-Relative 定址#

觀念與公式#

實戰演練#

知識點 2：Loop 與 If-Else 最佳化#

觀念與公式#

實戰演練#

⚠️ 考前避坑指南：第 4 節#

5. 副程式與堆疊管理 (Stack)#

知識點 1：函數呼叫契約 (jal / jr)#

觀念與公式#

知識點 2：堆疊操作 (Push / Pop)#

觀念與公式#

實戰演練 (遞迴/非葉函數)#

⚠️ 考前避坑指南：第 5 節#

6. 大常數與定址模式#

知識點 1：32-bit 常數載入 (lui / ori)#

觀念與公式#

實戰演練#

知識點 2：五大定址模式總結#

7. 程式生命週期 (Translation)#

核心流程與結構#

觀念與公式#

實戰演練#

⚠️ 考前避坑指南：第 7 節#

第三章：計算機算術與底層運算邏輯 (Computer Arithmetic)#

1. ALU 設計與基本算術運算#

核心觀念與公式#

📝 實戰演練：判斷運算是否發生溢位 (Overflow)#

【解析】#

2. 快速加法器 (Fast Adders - CLA)#

核心觀念與公式#

📝 實戰演練：展開 CLA 的進位方程式#

【解析】#

3. 乘法器與 Booth’s Algorithm#

核心觀念與操作規則#

一、指令總數 (Instruction Count, IC)#

二、每條指令平均週期數 (Cycles Per Instruction, CPI)#

三、時脈週期時間 (Clock Cycle Time, TcT_cTc)#

四、時脈頻率 / 主頻 (Clock Rate, fff)#