Merge pull request SharingSource#789 from SharingSource/ac_oier

🌟 feat: add 1032、1129、139、1441、1620、1652、1691、1697、1760、1780、1879、654…

Author: SharingSource

LeetCode/1031-1040/1032. 字符流（困难）.md

@@ -61,7 +61,7 @@ streamChecker.query("l"); // 返回 True ，因为 'kl' 在 words 中
 
 > 一些细节：为了避免每个样例都 `new` 大数组，我们可以使用 `static` 优化。
 
-代码：
+Java 代码：
 ```Java
 class StreamChecker {
     static int N = 2010 * 200, idx = 0;
@@ -104,6 +104,48 @@ class StreamChecker {
     }
 }
 ```
+C++ 代码：
+```C++
+class StreamChecker {
+public:
+    static const int N = 2010 * 200;
+    int tr[N][26];
+    bool isEnd[N];
+    string sb;
+    int idx = 0;
+    void add(const string &s) {
+        int p = 0;
+        for (char c : s) {
+            int u = c - 'a';
+            if (tr[p][u] == 0) tr[p][u] = ++idx;
+            p = tr[p][u];
+        }
+        isEnd[p] = true;
+    }
+    bool query(int start, int end) {
+        int p = 0;
+        for (int i = start; i <= end; i++) {
+            int u = sb[i] - 'a';
+            if (tr[p][u] == 0) return false;
+            p = tr[p][u];
+        }
+        return isEnd[p];
+    }
+    StreamChecker(const vector<string>& words) {
+        memset(tr, 0, sizeof(tr));
+        memset(isEnd, 0, sizeof(isEnd));
+        for (const string &s : words) add(s);
+    }
+    bool query(char c) {
+        sb.push_back(c);
+        int n = sb.length(), min = max(0, n - 200);
+        for (int i = n - 1; i >= min; i--) {
+            if (query(i, n - 1)) return true;
+        }
+        return false;
+    }
+};
+```
 * 时间复杂度：`StreamChecker` 初始化复杂度为 $O(n)$，其中 $n$ 为 `words` 字符总数；`query` 操作复杂度为 $O(m^2)$，其中 $m = 200$ 为最大 `words[i]` 长度
 * 空间复杂度：$O(n \times C)$，其中 $n$ 为 `words` 字符总数，$C = 26$ 为字符集大小
 
@@ -123,7 +165,7 @@ class StreamChecker {
 
 同理，我们可以利用最大的 `words[i]` 长度为 $200$ 来控制从 $s[n - 1]$ 开始往回找的最远距离，同时利用当某个短后缀不在 `Trie` 中，则其余长度更大的后缀必然不在 `Trie` 中进行剪枝操作。
 
-代码：
+Java 代码：
 ```Java 
 class StreamChecker {
     static int N = 2010 * 200, idx = 0;
@@ -160,6 +202,47 @@ class StreamChecker {
     }
 }
 ```
+C++ 代码：
+```C++
+class StreamChecker {
+public:
+    static const int N = 2010 * 200;
+    static const int ALPHABET_SIZE = 26;
+    vector<vector<int>> tr;
+    vector<bool> isEnd;
+    string sb;
+    int idx = 0;
+    void add(const string &s) {
+        int p = 0;
+        for (int i = s.length() - 1; i >= 0; i--) {
+            int u = s[i] - 'a';
+            if (tr[p].size() <= u) tr[p].resize(u + 1, 0);
+            if (tr[p][u] == 0) tr[p][u] = ++idx;
+            p = tr[p][u];
+        }
+        isEnd[p] = true;
+    }
+    StreamChecker(const vector<string>& words) {
+        tr.resize(N);
+        isEnd.resize(N);
+        fill(isEnd.begin(), isEnd.end(), false);
+        for (const auto &s : words) {
+            add(s);
+        }
+    }
+    bool query(char c) {
+        sb.push_back(c);
+        int n = sb.length(), min = max(0, n - 200), p = 0;
+        for (int i = n - 1; i >= min; i--) {
+            if (isEnd[p]) return true;
+            int u = sb[i] - 'a';
+            if (tr[p].size() <= u || tr[p][u] == 0) return false;
+            p = tr[p][u];
+        }
+        return isEnd[p];
+    }
+};
+```
 * 时间复杂度：`StreamChecker` 初始化复杂度为 $O(n)$，其中 $n$ 为 `words` 字符总数；`query` 操作复杂度为 $O(m)$，其中 $m = 200$ 为最大 `words[i]` 长度
 * 空间复杂度：$O(n \times C)$，其中 $n$ 为 `words` 字符总数，$C = 26$ 为字符集大小
 

LeetCode/1221-1230/1129. 颜色交替的最短路径（中等）.md

@@ -6,11 +6,17 @@ Tag : 「BFS」、「最短路」
 
 
 
-在一个有向图中，节点分别标记为 `0, 1, ..., n-1`。图中每条边为红色或者蓝色，且存在自环或平行边。
+在一个有向图中，节点分别标记为 `0, 1, ..., n-1`。
 
-`red_edges` 中的每一个 `[i, j]` 对表示从节点 `i` 到节点 `j` 的红色有向边。类似地，`blue_edges` 中的每一个 `[i, j]` 对表示从节点 `i` 到节点 `j` 的蓝色有向边。
+图中每条边为红色或者蓝色，且存在自环或平行边。
 
-返回长度为 `n` 的数组 `answer`，其中 `answer[X]` 是从节点 `0` 到节点 `X` 的红色边和蓝色边交替出现的最短路径的长度。如果不存在这样的路径，那么 `answer[x] = -1`。
+`red_edges` 中的每一个 `[i, j]` 对表示从节点 `i` 到节点 `j` 的红色有向边。
+
+类似地，`blue_edges` 中的每一个 `[i, j]` 对表示从节点 `i` 到节点 `j` 的蓝色有向边。
+
+返回长度为 `n` 的数组 `answer`，其中 `answer[X]` 是从节点 `0` 到节点 `X` 的红色边和蓝色边交替出现的最短路径的长度。
+
+如果不存在这样的路径，那么 `answer[x] = -1`。
 
 示例 1：
 ```
@@ -70,7 +76,7 @@ Tag : 「BFS」、「最短路」
 
 利用数据范围不大（点数为 $100$，边数为 $800$），可以直接对每个点进行一次独立的 `BFS`  来求最短路。由于图存在重边和自环，因此在求解最短路的过程需要对边进行去重。
 
-代码：
+Java 代码：
 ```Java
 class Solution {
     static int N = 110, M = 810, idx = 0;
@@ -115,6 +121,54 @@ class Solution {
     }
 }
 ```
+C++ 代码：
+```C++
+class Solution {
+public:
+    int he[110], e[810], ne[810], w[810], idx = 0;
+    void add(int a, int b, int c) {
+        e[idx] = b;
+        w[idx] = c;
+        ne[idx] = he[a];
+        he[a] = idx++;
+    }
+    vector<int> shortestAlternatingPaths(int n, vector<vector<int>>& rs, vector<vector<int>>& bs) {
+        idx = 0;
+        fill(he, he + n, -1);
+        for (auto& e : rs) add(e[0], e[1], 1);
+        for (auto& e : bs) add(e[0], e[1], -1);
+        vector<int> ans(n);
+        vector<bool> vis(rs.size() + bs.size());
+        for (int k = 1; k < n; k++) {
+            ans[k] = -1;
+            fill(vis.begin(), vis.end(), false);
+            queue<vector<int>> q;
+            q.push({ 0, 0, 0 }); // point, last, step
+            bool out = false;
+            while (!q.empty()) {
+                if (out) break;
+                vector<int> info = q.front(); q.pop();
+                int p = info[0], last = info[1], step = info[2];
+                for (int i = he[p]; i != -1; i = ne[i]) {
+                    int j = e[i], c = w[i];
+                    if (vis[i]) continue;
+                    if (c + last == 0 || last == 0) {
+                        if (j == k) {
+                            ans[k] = step + 1;
+                            out = true;
+                            break;
+                        } else {
+                            q.push({ j, c, step + 1 });
+                            vis[i] = true;
+                        }
+                    }
+                }
+            }
+        }
+        return ans;
+    }
+};
+```
 * 时间复杂度：将点数记为 `n` ，边数记为 `m`。建图复杂度为 $O(m)$；构造答案复杂度为 $O(n \times (n + m))$。整体复杂度为 $O(n \times (n + m))$
 * 空间复杂度：$O(n + m)$
 
@@ -128,7 +182,7 @@ class Solution {
 
 因此我们只需要初始化所有的 `ans[i] = -1`，并从节点 `0` 开始进行一次 `BFS`  即可。
 
-代码：
+Java 代码：
 ```Java
 class Solution {
     static int N = 110, M = 810, idx = 0;
@@ -168,14 +222,53 @@ class Solution {
     }
 }
 ```
+C++ 代码：
+```C++
+class Solution {
+public:
+    int he[110], e[810], ne[810], w[810], idx = 0;
+    void add(int a, int b, int c) {
+        e[idx] = b;
+        w[idx] = c;
+        ne[idx] = he[a];
+        he[a] = idx++;
+    }
+    vector<int> shortestAlternatingPaths(int n, vector<vector<int>>& rs, vector<vector<int>>& bs) {
+        idx = 0;
+        fill(he, he + n, -1);
+        for (auto& e : rs) add(e[0], e[1], 1);
+        for (auto& e : bs) add(e[0], e[1], -1);
+        vector<int> ans(n, -1);
+        ans[0] = 0;
+        vector<bool> vis(rs.size() + bs.size(), false);
+        deque<vector<int>> d;
+        d.push_back({0, 0, 0}); // point, last, step
+        while (!d.empty()) {
+            vector<int> info = d.front();
+            d.pop_front();
+            int p = info[0], last = info[1], step = info[2];
+            for (int i = he[p]; i != -1; i = ne[i]) {
+                if (vis[i]) continue;
+                int j = e[i], c = w[i];
+                if (c + last == 0 || last == 0) {
+                    ans[j] = ans[j] == -1 ? step + 1 : min(ans[j], step + 1);
+                    d.push_back({j, c, step + 1});
+                    vis[i] = true;
+                }
+            }
+        }
+        return ans;
+    }
+};
+```
 * 时间复杂度：将点数记为 `n` ，边数记为 `m`。建图复杂度为 $O(m)$；构造答案复杂度为 $O(n + m)$。整体复杂度为 $O(n + m)$
 * 空间复杂度：$O(n + m)$
 
 ---
 
 ### 最后
 
-这是我们「刷穿 LeetCode」系列文章的第 `No.1224` 篇，系列开始于 2021/01/01，截止于起始日 LeetCode 上共有 1916 道题目，部分是有锁题，我们将先把所有不带锁的题目刷完。
+这是我们「刷穿 LeetCode」系列文章的第 `No.1129` 篇，系列开始于 2021/01/01，截止于起始日 LeetCode 上共有 1916 道题目，部分是有锁题，我们将先把所有不带锁的题目刷完。
 
 在这个系列文章里面，除了讲解解题思路以外，还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
 

LeetCode/131-140/139. 单词拆分（中等）.md

@@ -74,21 +74,27 @@ class Solution {
     }
 }
 ```
-TypeScript 代码：
-```TypeScript
-function wordBreak(s: string, wordDict: string[]): boolean {
-    const ss = new Set<string>(wordDict)
-    const n = s.length
-    const f = new Array<boolean>(n + 10).fill(false)
-    f[0] = true
-    for (let i = 1; i <= n; i++) {
-        for (let j = i; j >= 1 && !f[i]; j--) {
-            const sub = s.substring(j - 1, i)
-            if (ss.has(sub)) f[i] = f[j - 1]
+C++ 代码：
+```C++
+class Solution {
+public:
+    bool wordBreak(string s, vector<string>& wordDict) {
+        unordered_set<string> set;
+        for (const string& word : wordDict) {
+            set.insert(word);
         }
+        int n = s.length();
+        vector<bool> f(n + 10, false);
+        f[0] = true;
+        for (int i = 1; i <= n; ++i) {
+            for (int j = 1; j <= i && !f[i]; ++j) {
+                string sub = s.substr(j - 1, i - j + 1);
+                if (set.find(sub) != set.end()) f[i] = f[j - 1] || f[i];
+            }
+        }
+        return f[n];
     }
-    return f[n]
-}
+};
 ```
 Python 代码：
 ```Python
@@ -107,6 +113,22 @@ class Solution:
                 j -= 1
         return f[n]
 ```
+TypeScript 代码：
+```TypeScript
+function wordBreak(s: string, wordDict: string[]): boolean {
+    const ss = new Set<string>(wordDict)
+    const n = s.length
+    const f = new Array<boolean>(n + 10).fill(false)
+    f[0] = true
+    for (let i = 1; i <= n; i++) {
+        for (let j = i; j >= 1 && !f[i]; j--) {
+            const sub = s.substring(j - 1, i)
+            if (ss.has(sub)) f[i] = f[j - 1]
+        }
+    }
+    return f[n]
+}
+```
 * 时间复杂度：将 `wordDict` 转存在 `Set` 复杂度为 $O(m)$；`DP` 过程复忽裁剪子串和查询 `Set` 结构的常数，复杂度为 $O(n^2)$
 * 空间复杂度：$O(n + m)$