Algorithm on Bill.Lin's Notes

動態規劃入門模板：背包、LIS、編輯距離

Mon, 15 Jan 2024 00:00:00 +0800

DP 三要素

拿到任何 DP 題，先確認這三件事：

狀態定義：dp[i] 或 dp[i][j] 代表什麼？
轉移方程：當前狀態如何從子問題推導？
初始化：Base case 是什麼？遍歷方向是從前到後還是後到前？

這三點清楚後，程式碼幾乎是機械式填寫。

0/1 背包（01 Knapsack）

問題

有 N 個物品，每個有重量 weights[i] 和價值 values[i]，背包容量 W。每個物品只能拿一次，求最大價值。

2D DP（最易理解）

int knapsack01(int[] weights, int[] values, int W) {
    int n = weights.length;
    // dp[i][w] = 只考慮前 i 個物品，容量為 w 時的最大價值
    int[][] dp = new int[n + 1][W + 1];

    for (int i = 1; i <= n; i++) {
        for (int w = 0; w <= W; w++) {
            dp[i][w] = dp[i-1][w];  // 不拿第 i 個物品
            if (w >= weights[i-1]) {
                // 拿第 i 個物品
                dp[i][w] = Math.max(dp[i][w], dp[i-1][w - weights[i-1]] + values[i-1]);
            }
        }
    }
    return dp[n][W];
}

1D 滾動陣列（空間 O(W)）

int knapsack01Optimized(int[] weights, int[] values, int W) {
    int n = weights.length;
    int[] dp = new int[W + 1];  // dp[w] = 容量 w 時的最大價值

    for (int i = 0; i < n; i++) {
        // 必須從右到左（大容量先更新），防止同一物品被重複選取
        for (int w = W; w >= weights[i]; w--) {
            dp[w] = Math.max(dp[w], dp[w - weights[i]] + values[i]);
        }
    }
    return dp[W];
}

為什麼逆序：若從左到右（小容量先更新），dp[w] 更新時用到的 dp[w - weights[i]] 可能已是本輪更新的值，等同於拿了兩次第 i 個物品。

最短路三兄弟：Dijkstra / Bellman-Ford / Floyd-Warshall

Mon, 15 Jan 2024 00:00:00 +0800

問題定義

給定一個帶權圖（有向或無向），找從某點（或所有點）到其他點的最短路徑。

三種演算法各有不同的適用前提：

演算法	來源	負權重	負環偵測	時間複雜度
Dijkstra	單源	不支援	否	O((V+E) log V)
Bellman-Ford	單源	支援	是	O(VE)
Floyd-Warshall	全對	支援	是（對角線 < 0）	O(V³)

Dijkstra

原理

貪心策略 + Priority Queue。每次從未確定的節點中取出距離最小的，再用它更新鄰居的距離。前提：所有邊權重 >= 0。

實作

public int[] dijkstra(int n, int[][] edges, int src) {
    // 建立鄰接表
    Map<Integer, List<int[]>> graph = new HashMap<>();
    for (int[] e : edges) {
        graph.computeIfAbsent(e[0], k -> new ArrayList<>()).add(new int[]{e[1], e[2]});
        graph.computeIfAbsent(e[1], k -> new ArrayList<>()).add(new int[]{e[0], e[2]});
    }

    int[] dist = new int[n];
    Arrays.fill(dist, Integer.MAX_VALUE);
    dist[src] = 0;

    // [node, distance]
    PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[1]));
    pq.offer(new int[]{src, 0});

    while (!pq.isEmpty()) {
        int[] curr = pq.poll();
        int u = curr[0], d = curr[1];
        // 若取出的距離比已知更大，代表這個狀態已過時
        if (d > dist[u]) continue;

        for (int[] next : graph.getOrDefault(u, List.of())) {
            int v = next[0], w = next[1];
            if (dist[u] + w < dist[v]) {
                dist[v] = dist[u] + w;
                pq.offer(new int[]{v, dist[v]});
            }
        }
    }
    return dist;
}

關鍵細節

if (d > dist[u]) continue;：Priority Queue 可能存有同一節點的多個過時條目，這行跳過它們，是效能的關鍵。
不用 visited[] 陣列，用距離比較達到同樣效果，程式碼更簡潔。

Bellman-Ford

原理

動態規劃思維。最短路最多經過 V-1 條邊（若存在更短路，必有負環）。對所有邊 relax V-1 次。

鏈表反轉（Reverse Linked List）完整解析

Wed, 28 Sep 2022 21:19:26 +0800

概述

鏈表反轉是數據結構與演算法中的經典問題，要求將單向鏈表的指向關係完全反轉。這個問題看似簡單，但涉及到指標操作的細節，是考驗編程基本功的重要題型。

問題定義

給定一個單向鏈表，將其反轉並回傳新的頭節點。

範例：

1
2

輸入：1 -> 2 -> 3 -> 4 -> 5 -> NULL
輸出：5 -> 4 -> 3 -> 2 -> 1 -> NULL

鏈表節點定義

public class ListNode {
    int val;
    ListNode next;
    
    ListNode() {}
    ListNode(int val) { this.val = val; }
    ListNode(int val, ListNode next) { 
        this.val = val; 
        this.next = next; 
    }
}

解法一：迭代實作

基本思路

使用三個指標 prev、current、next 來逐步改變每個節點的指向關係。

並查集（Union-Find）演算法完整指南

Mon, 26 Sep 2022 22:15:44 +0800

概述

並查集（Union-Find）又稱為不相交集合（Disjoint Set），是一種用來處理不相交集合的合併和查詢問題的數據結構。它支援兩種主要操作：

Find：查找元素所屬的集合（返回集合的代表元素）
Union：合併兩個不同的集合

並查集在圖論演算法中應用廣泛，特別適用於解決連通性問題。

基本原理

核心概念

並查集將每個集合表示為一棵樹，樹的根節點作為該集合的代表元素。初始狀態下，每個元素都是獨立的集合（自己是自己的父節點）。

初始狀態：
0   1   2   3   4
↓   ↓   ↓   ↓   ↓
0   1   2   3   4

合併 0 和 1 後：
  0       2   3   4
 ↙        ↓   ↓   ↓
1         2   3   4

合併 2 和 3 後：
  0     2     4
 ↙     ↙      ↓
1     3       4

基本實作

public class UnionFind {
    private int[] parent;  // parent[i] 表示元素 i 的父節點
    private int[] rank;    // rank[i] 表示以 i 為根的樹的高度
    private int components; // 連通分量的數量
    
    public UnionFind(int n) {
        parent = new int[n];
        rank = new int[n];
        components = n;
        
        // 初始化：每個元素都是獨立的集合
        for (int i = 0; i < n; i++) {
            parent[i] = i;  // 自己是自己的父節點
            rank[i] = 0;    // 初始高度為 0
        }
    }
    
    /**
     * 查找元素 x 所屬集合的代表元素
     */
    public int find(int x) {
        if (parent[x] != x) {
            // 路徑壓縮：將路徑上所有節點直接連接到根節點
            parent[x] = find(parent[x]);
        }
        return parent[x];
    }
    
    /**
     * 合併元素 x 和 y 所屬的集合
     */
    public boolean union(int x, int y) {
        int rootX = find(x);
        int rootY = find(y);
        
        // 如果已經在同一個集合中，返回 false
        if (rootX == rootY) {
            return false;
        }
        
        // 按秩合併：將較矮的樹合併到較高的樹下
        if (rank[rootX] < rank[rootY]) {
            parent[rootX] = rootY;
        } else if (rank[rootX] > rank[rootY]) {
            parent[rootY] = rootX;
        } else {
            parent[rootY] = rootX;
            rank[rootX]++;  // 高度相同時，合併後高度加 1
        }
        
        components--;  // 連通分量減 1
        return true;
    }
    
    /**
     * 檢查兩個元素是否在同一個集合中
     */
    public boolean connected(int x, int y) {
        return find(x) == find(y);
    }
    
    /**
     * 獲取連通分量的數量
     */
    public int getComponentCount() {
        return components;
    }
}

優化技巧

1. 路徑壓縮（Path Compression）

在 find 操作中，將查找路徑上的所有節點直接連接到根節點，使樹變得更加扁平。

回溯演算法（Backtracking）完整指南

Tue, 10 May 2022 23:34:53 +0800

概述

回溯演算法（Backtracking）是一種透過試錯來尋找問題解決方案的算法策略。它系統性地搜尋所有可能的候選解，當發現候選解不可能完成有效解時，會放棄該候選解並「回溯」到上一步。

基本原理

回溯演算法遵循三個核心步驟：

選擇（Choose）：從當前狀態的可選項中做出選擇
探索（Explore）：Recursion地探索這個選擇的後果
撤銷（Un-choose）：撤銷選擇，恢復到選擇前的狀態

演算法模板

void backtrack(路徑, 選擇列表) {
    if (滿足結束條件) {
        result.add(路徑);
        return;
    }
    
    for (選擇 : 選擇列表) {
        做選擇;           // Choose
        backtrack(路徑, 選擇列表);  // Explore
        撤銷選擇;         // Un-choose
    }
}

時間複雜度

一般情況下，回溯演算法的時間複雜度為 O(b^d)，其中：

拓撲排序（Topological Sort）演算法詳解

Sun, 26 Dec 2021 12:53:14 +0800

概述

拓撲排序（Topological Sort）是對**有向無環圖（DAG, Directed Acyclic Graph）**進行排序的演算法。排序結果是一個線性序列，使得對於圖中任意有向邊 (u, v)，在排序結果中 u 都出現在 v 之前。

基本概念

應用場景

課程排課：某些課程有先修課程的要求
編譯依賴：程式模組間的編譯順序
任務調度：有依賴關係的任務執行順序
Makefile 建構：檔案間的依賴關係

前提條件

圖必須是有向無環圖（DAG）
如果圖中存在環，則無法進行拓撲排序

演算法實作

方法一：Kahn 演算法（BFS 基礎）

基本思路

計算所有節點的入度
將入度為 0 的節點加入佇列
不斷從佇列中取出節點，並減少其相鄰節點的入度
如果相鄰節點的入度變為 0，則加入佇列
重複直到佇列為空

實作代碼

public class TopologicalSort {
    public List<Integer> topologicalSort(int numNodes, List<List<Integer>> edges) {
        // 建立鄰接表和入度陣列
        List<List<Integer>> graph = new ArrayList<>();
        int[] indegree = new int[numNodes];
        
        for (int i = 0; i < numNodes; i++) {
            graph.add(new ArrayList<>());
        }
        
        // 建構圖並計算入度
        for (List<Integer> edge : edges) {
            int from = edge.get(0);
            int to = edge.get(1);
            graph.get(from).add(to);
            indegree[to]++;
        }
        
        // 將入度為 0 的節點加入佇列
        Queue<Integer> queue = new LinkedList<>();
        for (int i = 0; i < numNodes; i++) {
            if (indegree[i] == 0) {
                queue.offer(i);
            }
        }
        
        List<Integer> result = new ArrayList<>();
        
        // BFS 處理
        while (!queue.isEmpty()) {
            int node = queue.poll();
            result.add(node);
            
            // 減少相鄰節點的入度
            for (int neighbor : graph.get(node)) {
                indegree[neighbor]--;
                if (indegree[neighbor] == 0) {
                    queue.offer(neighbor);
                }
            }
        }
        
        // 檢查是否存在環
        if (result.size() != numNodes) {
            return new ArrayList<>();  // 存在環，無法拓撲排序
        }
        
        return result;
    }
}

方法二：DFS 基礎

基本思路

對每個未訪問的節點進行 DFS
在 DFS 回溯時將節點加入結果
反轉結果得到拓撲排序

實作代碼

public class TopologicalSortDFS {
    private static final int WHITE = 0;  // 未訪問
    private static final int GRAY = 1;   // 正在訪問
    private static final int BLACK = 2;  // 已完成
    
    public List<Integer> topologicalSort(int numNodes, List<List<Integer>> edges) {
        // 建立鄰接表
        List<List<Integer>> graph = new ArrayList<>();
        for (int i = 0; i < numNodes; i++) {
            graph.add(new ArrayList<>());
        }
        
        for (List<Integer> edge : edges) {
            graph.get(edge.get(0)).add(edge.get(1));
        }
        
        int[] color = new int[numNodes];
        Stack<Integer> stack = new Stack<>();
        
        // 對每個未訪問的節點進行 DFS
        for (int i = 0; i < numNodes; i++) {
            if (color[i] == WHITE) {
                if (!dfs(graph, i, color, stack)) {
                    return new ArrayList<>();  // 存在環
                }
            }
        }
        
        // 反轉結果
        List<Integer> result = new ArrayList<>();
        while (!stack.isEmpty()) {
            result.add(stack.pop());
        }
        
        return result;
    }
    
    private boolean dfs(List<List<Integer>> graph, int node, int[] color, Stack<Integer> stack) {
        color[node] = GRAY;  // 標記為正在訪問
        
        for (int neighbor : graph.get(node)) {
            if (color[neighbor] == GRAY) {
                return false;  // 發現後向邊，存在環
            }
            if (color[neighbor] == WHITE && !dfs(graph, neighbor, color, stack)) {
                return false;
            }
        }
        
        color[node] = BLACK;  // 標記為已完成
        stack.push(node);     // 後序遍歷順序
        
        return true;
    }
}

實際應用題型

1. 課程安排（LeetCode 207 & 210）

問題 207：判斷是否可以完成所有課程。

GraphAccountMerge - 圖論帳戶合併深度解析與企業應用

Mon, 29 Nov 2021 22:24:03 +0800

問題描述

LeetCode 721 - Accounts Merge

給定 accounts 列表，每個帳號是一個字串陣列 [name, email1, email2, ...]。若兩個帳號有共同的 email，則屬於同一人（可以傳遞：A=B 且 B=C 則 A=B=C）。合併所有屬於同一人的帳號，輸出格式：[name, email1, email2, ...]（emails 排序）。

輸入：
[["John","john@mail","john_r@mail"],
 ["John","johnr@mail","john@mail"],   ← 與第一個共用 john@mail
 ["Mary","mary@mail"]]

輸出：
[["John","john@mail","john_r@mail","johnr@mail"],
 ["Mary","mary@mail"]]

解法：Union-Find

建模：把每個 email 視為圖中的節點，同一帳號內的 emails union 在一起。

class Solution {
    public List<List<String>> accountsMerge(List<List<String>> accounts) {
        Map<String, String> parent = new HashMap<>();  // email -> root email
        Map<String, String> owner = new HashMap<>();   // email -> name

        // 初始化：每個 email 的 parent 是自己
        for (List<String> account : accounts) {
            String name = account.get(0);
            for (int i = 1; i < account.size(); i++) {
                parent.putIfAbsent(account.get(i), account.get(i));
                owner.put(account.get(i), name);
            }
        }

        // Union：同一帳號內的所有 email union 到第一個 email
        for (List<String> account : accounts) {
            String first = account.get(1);
            for (int i = 2; i < account.size(); i++) {
                union(parent, first, account.get(i));
            }
        }

        // 分組：用 root email 作 key 收集所有同組 email
        Map<String, TreeSet<String>> groups = new HashMap<>();
        for (String email : parent.keySet()) {
            String root = find(parent, email);
            groups.computeIfAbsent(root, k -> new TreeSet<>()).add(email);
        }

        // 組裝結果
        List<List<String>> result = new ArrayList<>();
        for (Map.Entry<String, TreeSet<String>> entry : groups.entrySet()) {
            List<String> merged = new ArrayList<>();
            merged.add(owner.get(entry.getKey()));  // 加姓名
            merged.addAll(entry.getValue());         // emails 已 TreeSet 排序
            result.add(merged);
        }
        return result;
    }

    private String find(Map<String, String> parent, String x) {
        if (!parent.get(x).equals(x)) {
            parent.put(x, find(parent, parent.get(x)));  // path compression
        }
        return parent.get(x);
    }

    private void union(Map<String, String> parent, String x, String y) {
        String rx = find(parent, x);
        String ry = find(parent, y);
        if (!rx.equals(ry)) {
            parent.put(rx, ry);
        }
    }
}

複雜度：

二元樹遍歷（Binary Tree Traversal）完整指南

Sun, 21 Nov 2021 20:11:03 +0800

概述

二元樹遍歷是資料結構與演算法中的基本概念，主要有三種遍歷方式：前序遍歷（PreOrder）、中序遍歷（InOrder）、後序遍歷（PostOrder）。每種遍歷方式都有其特定的應用場景和優勢。

基本概念

考慮以下二元樹結構：

三種遍歷方式的順序

前序遍歷（PreOrder）：中 → 左 → 右
- 遍歷順序：4 → 2 → 1 → 3 → 6 → 5 → 7
中序遍歷（InOrder）：左 → 中 → 右
- 遍歷順序：1 → 2 → 3 → 4 → 5 → 6 → 7
- 對於二元搜尋樹，中序遍歷可得到有序序列
後序遍歷（PostOrder）：左 → 右 → 中
- 遍歷順序：1 → 3 → 2 → 5 → 7 → 6 → 4

遍歷實作

1. 中序遍歷（InOrder Traversal）

中序遍歷在二元搜尋樹中特別有用，因為它會按升序訪問所有節點。

MergeSort - 合併排序算法深度解析與企業應用

Mon, 28 Jun 2021 19:57:24 +0800

核心概念

Merge Sort 是基於分治法（Divide and Conquer）的排序演算法：

Divide：將陣列從中點分成兩半
Conquer：遞迴排序兩個子陣列
Combine：合併兩個已排序的子陣列

時間複雜度：所有情況均為 O(n log n) 空間複雜度：O(n)（標準 out-of-place），O(1) 輔助空間（in-place 版本代價高） 穩定排序：是（stable sort，相同元素的相對順序不變）

graph TD
    A["[5, 3, 8, 1, 9, 2]"] --> B["[5, 3, 8]"]
    A --> C["[1, 9, 2]"]
    B --> D["[5]"]
    B --> E["[3, 8]"]
    C --> F["[1]"]
    C --> G["[9, 2]"]
    E --> H["[3]"]
    E --> I["[8]"]
    G --> J["[9]"]
    G --> K["[2]"]
    H & I --> L["[3, 8]"]
    D & L --> M["[3, 5, 8]"]
    J & K --> N["[2, 9]"]
    F & N --> O["[1, 2, 9]"]
    M & O --> P["[1, 2, 3, 5, 8, 9]"]

Java 實作

public class MergeSort {
    public static void sort(int[] arr) {
        if (arr.length <= 1) return;
        int mid = arr.length / 2;
        int[] left = Arrays.copyOfRange(arr, 0, mid);
        int[] right = Arrays.copyOfRange(arr, mid, arr.length);
        sort(left);
        sort(right);
        merge(arr, left, right);
    }

    private static void merge(int[] arr, int[] left, int[] right) {
        int i = 0, j = 0, k = 0;
        while (i < left.length && j < right.length) {
            // 穩定排序的關鍵：相等時優先取左邊
            if (left[i] <= right[j]) {
                arr[k++] = left[i++];
            } else {
                arr[k++] = right[j++];
            }
        }
        while (i < left.length)  arr[k++] = left[i++];
        while (j < right.length) arr[k++] = right[j++];
    }
}

為什麼說 Merge Sort 是「穩定」排序

「穩定」指的是：相同值的元素，排序後保持原始相對順序。

Algorithm on Bill.Lin's Notes

動態規劃入門模板：背包、LIS、編輯距離

DP 三要素

0/1 背包（01 Knapsack）

問題

2D DP（最易理解）

1D 滾動陣列（空間 O(W)）

最短路三兄弟：Dijkstra / Bellman-Ford / Floyd-Warshall

問題定義

Dijkstra

原理

實作

關鍵細節

相關 LeetCode

Bellman-Ford

原理

鏈表反轉（Reverse Linked List）完整解析

概述

問題定義

鏈表節點定義

解法一：迭代實作

基本思路

並查集（Union-Find）演算法完整指南

概述

基本原理

核心概念

基本實作

優化技巧

1. 路徑壓縮（Path Compression）

回溯演算法（Backtracking）完整指南

概述

基本原理

演算法模板

時間複雜度

拓撲排序（Topological Sort）演算法詳解

概述

基本概念

應用場景

前提條件

演算法實作

方法一：Kahn 演算法（BFS 基礎）

基本思路

實作代碼

方法二：DFS 基礎

基本思路

實作代碼

實際應用題型

1. 課程安排（LeetCode 207 & 210）

GraphAccountMerge - 圖論帳戶合併深度解析與企業應用

問題描述

解法：Union-Find

二元樹遍歷（Binary Tree Traversal）完整指南

概述

基本概念

三種遍歷方式的順序

遍歷實作

1. 中序遍歷（InOrder Traversal）

MergeSort - 合併排序算法深度解析與企業應用

核心概念

Java 實作

為什麼說 Merge Sort 是「穩定」排序