docs(algorithm): update walk algorithm from DAG to Viterbi (#777)

Replace the DAG shortest-path algorithm documentation with the Viterbi
implementation merged in #777. The new section documents the linear
lattice forward pass, relaxation, and backward path reconstruction.

- Replace 4-step DAG section with 2-step Viterbi (forward + backward)
- Update code reference table: remove TopologicalSort/Relax rows
- Update references: Jurafsky & Martin + vene.ro lattice Viterbi
- Fix TOC link to match new heading
- Bump version to 1.3

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: tianjianjiang

algorithm.md

@@ -27,7 +27,7 @@
     - [演算法流程](#演算法流程)
       - [插入注音時的處理](#插入注音時的處理)
       - [節點更新機制](#節點更新機制)
-      - [最佳路徑演算法：DAG 最短路徑](#最佳路徑演算法dag-最短路徑)
+      - [最佳路徑演算法：Viterbi](#最佳路徑演算法viterbi)
     - [實際範例](#實際範例)
   - [語言模型架構](#語言模型架構)
     - [McBopomofoLM：統一介面](#mcbopomofolm統一介面)
@@ -209,108 +209,69 @@ void ReadingGrid::update() {
 }
 ```
 
-#### 最佳路徑演算法：DAG 最短路徑
+#### 最佳路徑演算法：Viterbi
 
-`walk()` 方法使用 **有向無環圖（DAG）最短路徑演算法** 找出分數最高的路徑（`reading_grid.cpp:216`）：
+`walk()` 方法使用 **Viterbi 演算法** 找出分數最高的路徑（`reading_grid.cpp`）。
 
-**步驟 1：建立 DAG**
+Reading Grid 本身是一個線性格架（lattice）：每個位置只能連接到更後方的位置，構成天然的拓撲順序。因此不需要額外的拓撲排序，直接按位置順序前向掃描即可。
 
-```cpp
-ReadingGrid::WalkResult ReadingGrid::walk() {
-    // 1. 將所有 Node 轉換為圖的 Vertex（頂點）
-    std::vector<VertexSpan> vspans(spans_.size());
-    for (size_t i = 0; i < spans_.size(); i++) {
-        const Span& span = spans_[i];
-        for (size_t j = 1; j <= span.maxLength(); j++) {
-            NodePtr node = span.nodeOf(j);
-            if (node != nullptr) {
-                vspans[i].emplace_back(Vertex(node));
-            }
-        }
-    }
+演算法使用一個動態規劃（DP）表格，每個 entry 記錄到達該位置的最大累計分數和回溯指標：
 
-    // 2. 建立邊（Edge）：連接相鄰節點
-    for (size_t i = 0; i < vspans.size(); i++) {
-        for (Vertex& v : vspans[i]) {
-            size_t nextPos = i + v.node->spanningLength();
-            // 連接到下一個位置的所有節點
-            for (Vertex& nv : vspans[nextPos]) {
-                v.edges.push_back(&nv);
-            }
-        }
-    }
+```cpp
+struct State {
+    size_t fromIndex = 0;
+    ReadingGrid::NodePtr fromNode = nullptr;
+    double maxScore = -std::numeric_limits<double>::infinity();
+};
 ```
 
-**步驟 2：拓撲排序**
+**步驟 1：前向傳遞（Forward Pass）**
 
-使用非遞迴的深度優先搜尋（DFS）進行拓撲排序（`reading_grid.cpp:166`）：
+從位置 0 開始，依序掃描每個位置。對於每個位置上所有可能的候選詞節點，計算「到達該詞末端位置」的累計分數，並執行鬆弛（relaxation）：
 
 ```cpp
-std::vector<Vertex*> TopologicalSort(Vertex* root) {
-    std::vector<Vertex*> result;
-    std::stack<State> stack;
-    stack.emplace(root);
-
-    while (!stack.empty()) {
-        State& state = stack.top();
-        Vertex* v = state.v;
-
-        if (state.edgeIter != v->edges.end()) {
-            Vertex* nv = *state.edgeIter;
-            ++state.edgeIter;
-            if (!nv->topologicallySorted) {
-                stack.emplace(nv);
-                continue;
-            }
+const size_t readingLen = readings_.size();
+std::vector<State> viterbi(readingLen + 1);
+viterbi[0].maxScore = 0.0;
+
+for (size_t i = 0; i < readingLen; ++i) {
+    const ReadingGrid::Span& span = spans_[i];
+    const size_t maxSpanLen = span.maxLength();
+
+    for (size_t spanLen = 1; spanLen <= maxSpanLen; ++spanLen) {
+        const ReadingGrid::NodePtr& node = span.nodeOf(spanLen);
+        if (node == nullptr) {
+            continue;
         }
 
-        v->topologicallySorted = true;
-        result.push_back(v);
-        stack.pop();
+        // 鬆弛操作：若經由目前節點到達目標位置的分數更高，則更新
+        double score = viterbi[i].maxScore + node->score();
+        State& target = viterbi[i + spanLen];
+        if (score > target.maxScore) {
+            target.maxScore = score;
+            target.fromNode = node;
+            target.fromIndex = i;
+        }
     }
-    return result;
 }
 ```
 
-**步驟 3：鬆弛演算法（Relaxation）**
-
-對拓撲排序後的頂點依序執行鬆弛操作，找出最大權重路徑（`reading_grid.cpp:134`）：
+核心觀察：因為使用對數機率（log probability），分數越大代表機率越高，所以鬆弛操作使用 `>` 而非 `<`。
 
-```cpp
-void Relax(Vertex* u, Vertex* v) {
-    double w = v->node->score();  // 獲取節點的對數機率
+**步驟 2：回溯路徑（Backward Pass）**
 
-    // 因為我們要找最大權重，所以用 > 而非 <
-    if (v->distance < u->distance + w) {
-        v->distance = u->distance + w;
-        v->prev = u;  // 記錄前驅節點
-    }
-}
+從 DP 表格的末端回溯，透過 `fromIndex` 和 `fromNode` 指標重建最佳路徑：
 
-// 主流程
-std::vector<Vertex*> ordered = TopologicalSort(&root);
-for (auto it = ordered.rbegin(); it != ordered.rend(); ++it) {
-    Vertex* u = *it;
-    for (Vertex* v : u->edges) {
-        Relax(u, v);
-    }
+```cpp
+for (size_t curr = readingLen; curr > 0; curr = viterbi[curr].fromIndex) {
+    result.nodes.emplace_back(std::move(viterbi[curr].fromNode));
 }
+std::reverse(result.nodes.begin(), result.nodes.end());
 ```
 
-**步驟 4：回溯路徑**
-
-從終點回溯找出完整路徑：
+**複雜度與效能**
 
-```cpp
-std::vector<NodePtr> walked;
-Vertex* it = &terminal;
-while (it->prev != nullptr) {
-    walked.push_back(it->prev->node);
-    it = it->prev;
-}
-// 反轉得到正確順序
-result.nodes = std::vector<NodePtr>(walked.rbegin() + 1, walked.rend());
-```
+演算法的時間複雜度為 O(V+E)，其中 V 是可達的格架位置數，E 是候選詞轉移數。由於省去了圖的建構（Vertex/Edge）、拓撲排序等步驟，實測在 8001 個注音的壓力測試中，從原本 DAG 版本的約 8ms 降至約 1ms，提升約 8 倍。
 
 ### 實際範例
 
@@ -878,9 +839,7 @@ LC_ALL=C sort -o phrase.occ phrase.occ
 | Reading Grid 主邏輯 | `Source/Engine/gramambular2/reading_grid.h` | `ReadingGrid` |
 | 插入注音處理 | `Source/Engine/gramambular2/reading_grid.cpp:51` | `insertReading()` |
 | 節點更新 | `Source/Engine/gramambular2/reading_grid.cpp:417` | `update()` |
-| 最佳路徑演算法 | `Source/Engine/gramambular2/reading_grid.cpp:216` | `walk()` |
-| 拓撲排序 | `Source/Engine/gramambular2/reading_grid.cpp:166` | `TopologicalSort()` |
-| 鬆弛演算法 | `Source/Engine/gramambular2/reading_grid.cpp:134` | `Relax()` |
+| 最佳路徑演算法（Viterbi） | `Source/Engine/gramambular2/reading_grid.cpp` | `walk()` |
 
 ### 語言模型
 
@@ -929,10 +888,11 @@ LC_ALL=C sort -o phrase.occ phrase.occ
 - [Wiki: Gramambular 演算法](https://github.com/openvanilla/McBopomofo/wiki/程式架構_Gramambular)
 - [Wiki: 詞庫開發說明](https://github.com/openvanilla/McBopomofo/wiki/詞庫開發說明)
 - [X/Twitter 演算法說明串](https://x.com/McBopomofo/status/1559356063622631424)
-- DAG 最短路徑演算法：Cormen et al., *Introduction to Algorithms*, 3rd Edition
+- Viterbi 演算法：Jurafsky & Martin, *Speech and Language Processing*, 3rd Edition, Chapter 8
+- 格架上的 Viterbi：[vene.ro/blog/shortest-paths-in-lattices](https://vene.ro/blog/shortest-paths-in-lattices.html)
 
 ---
 
-**文件版本**：1.2
-**最後更新**：2025-10-12T13:12:00+08:00
+**文件版本**：1.3
+**最後更新**：2026-02-14T22:49:00+08:00
 **適用版本**：McBopomofo 2.x 及以上