1. nums[i] = 站在index i時，最多可以往右跳幾格。

2. Time O(n)->for最多把nums的每個index看一次；
   Space O(1)->不管nums多大，都只多用farthest、current這幾個固定變數。

3. 不是平行處理：farthest 會一路依賴前面掃描結果，標準解是單一路徑線性掃描。它快的原因是「每個元素只看一次」，不是因為 parallelism（平行化）

4.compare最小的 O(n²)：

for (int i = 0; i < n; ++i) {
    for (int j = 0; j < n; ++j) {
        // work
    }
}

若 n = 3：
i=0 → j=0,1,2 → 3 次
i=1 → j=0,1,2 → 3 次
i=2 → j=0,1,2 → 3 次 總共 3 × 3 = 9 次 -> n × n = n² 每一個元素，又把全部元素重新看一次。

Complexity n=3 的直覺工作量
O(1) 1 直接取一次
O(log n) 約2 每次砍一半，Binary Search
O(n) 3 全部走一次，優先追求
O(n log n) 約5 常見於高效排序 如下
O(n²) 9 每個元素又掃全部，盡量避免

5.Merge Sort（合併排序） 很典型就是 O(n log n)。[4, 1, 3, 2]先一直切半：
→ [4,1] [3,2]
→ [4] [1] [3] [2]
每次都砍一半，層數大約是：log₂4 = 2;每一層合併時，全部元素大約都會被看一次
每層O(n)×總共 log n 層=O(n log n)
所以大約4 × 2 = 8 次量級。之後Merge Sort、Heap Sort 再細拆就好。

6.log₂4 = 2 裡：
底數2：代表每次切成 2 份／每次除以 2
4是原本有4個元素
答案 2 是：要切幾次才會從 4 變成 1
4 → 2 → 1
1 2

7.每層 O(n)：這一輪總共要處理4個元素
總共log n層：這種「處理全部元素的一輪」要做 幾輪

第 1 層：處理 4 個→ [4,1] [3,2]
第 2 層：還是總共處理 4 個→ [4] [1] [3] [2]

每層處理量 = n = 4;層數 = log₂4 = 2
n = 每一輪有多少東西要處理；log n = 總共要做幾輪。