✨feat: add 1129、1669、1798、1976、393、396

Author: SharingSource

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

@@ -0,0 +1,185 @@
+### 题目描述
+
+这是 LeetCode 上的 **[1129. 颜色交替的最短路径]()** ，难度为 **中等**。
+
+Tag : 「BFS」、「最短路」
+
+
+
+在一个有向图中，节点分别标记为 `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`。
+
+示例 1：
+```
+输入：n = 3, red_edges = [[0,1],[1,2]], blue_edges = []
+
+输出：[0,1,-1]
+```
+示例 2：
+```
+输入：n = 3, red_edges = [[0,1]], blue_edges = [[2,1]]
+
+输出：[0,1,-1]
+```
+示例 3：
+```
+输入：n = 3, red_edges = [[1,0]], blue_edges = [[2,1]]
+
+输出：[0,-1,-1]
+```
+示例 4：
+```
+输入：n = 3, red_edges = [[0,1]], blue_edges = [[1,2]]
+
+输出：[0,1,2]
+```
+示例 5：
+```
+输入：n = 3, red_edges = [[0,1],[0,2]], blue_edges = [[1,0]]
+
+输出：[0,1,1]
+```
+
+提示：
+* `1 <= n <= 100`
+* `red_edges.length <= 400`
+* `blue_edges.length <= 400`
+* `red_edges[i].length = blue_edges[i].length = 2`
+* `0 <= red_edges[i][j], blue_edges[i][j] < n`
+
+---
+
+### 朴素 BFS
+
+为了方便，将 `redEdges` 记为 `rs`，将 `blueEdges` 记为 `bs`。
+
+使用两数组进行建图，利用点数和边数关系（稀疏图），使用「邻接表」方式进行建图。
+
+将所有红色有向边权值记为 `1`，将所有蓝色有向边权值记为 `-1`。注意这里的权重仅表示该边的颜色，并非代表经过该边的真实成本。
+
+也正是经过所有边的成本均相同，对于原问题「从 `0` 号节点进行出发，求到所有点的颜色交替的最短路径」，我们容易想到使用 `BFS`  进行求解。
+
+`BFS`  过程中将三元组 $(point, last, step)$ 进行入队：
+
+* `point` 代表当前所在点编号
+* `last` 代表到达 `point` 所使用的边的颜色，默认为 `0` 代表不需要经过任何边到达起点
+* `step` 代表到达 `point` 所使用的步数
+
+利用数据范围不大（点数为 $100$，边数为 $800$），可以直接对每个点进行一次独立的 `BFS`  来求最短路。由于图存在重边和自环，因此在求解最短路的过程需要对边进行去重。
+
+代码：
+```Java
+class Solution {
+    static int N = 110, M = 810, idx = 0;
+    static int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];
+    void add(int a, int b, int c) {
+        e[idx] = b;
+        w[idx] = c;
+        ne[idx] = he[a];
+        he[a] = idx++;
+    }
+    public int[] shortestAlternatingPaths(int n, int[][] rs, int[][] bs) {
+        idx = 0;
+        Arrays.fill(he, -1);
+        for (int[] e : rs) add(e[0], e[1], 1);
+        for (int[] e : bs) add(e[0], e[1], -1);
+        int[] ans = new int[n];
+        boolean[] vis = new boolean[rs.length + bs.length];
+        out:for (int k = 1; k < n; k++) {
+            ans[k] = -1;
+            Arrays.fill(vis, false);
+            Deque<int[]> d = new ArrayDeque<>();
+            d.addLast(new int[]{0, 0, 0}); // point, last, step
+            while (!d.isEmpty()) {
+                int[] info = d.pollFirst();
+                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;
+                            continue out;
+                        } else {
+                            d.addLast(new int[]{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)$
+
+---
+
+### 优化
+
+实际上，我们并没有对每个点进行独立 `BFS`  的必要。
+
+为了获取所有从节点 `0` 出发的最短路，可直接从节点 `0` 进行出发（对边进行去重），所有能够从节点 `0` 沿交替路径到达的节点必然都会被访问到，且节点首次被访问到时必然是最短路径。
+
+因此我们只需要初始化所有的 `ans[i] = -1`，并从节点 `0` 开始进行一次 `BFS`  即可。
+
+代码：
+```Java
+class Solution {
+    static int N = 110, M = 810, idx = 0;
+    static int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];
+    void add(int a, int b, int c) {
+        e[idx] = b;
+        w[idx] = c;
+        ne[idx] = he[a];
+        he[a] = idx++;
+    }
+    public int[] shortestAlternatingPaths(int n, int[][] rs, int[][] bs) {
+        idx = 0;
+        Arrays.fill(he, -1);
+        for (int[] e : rs) add(e[0], e[1], 1);
+        for (int[] e : bs) add(e[0], e[1], -1);
+        int[] ans = new int[n];
+        Arrays.fill(ans, -1);
+        ans[0] = 0;
+        boolean[] vis = new boolean[rs.length + bs.length];
+        Arrays.fill(vis, false);
+        Deque<int[]> d = new ArrayDeque<>();
+        d.addLast(new int[]{0, 0, 0}); // point, last, step
+        while (!d.isEmpty()) {
+            int[] info = d.pollFirst();
+            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 : Math.min(ans[j], step + 1);
+                    d.addLast(new int[]{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 道题目，部分是有锁题，我们将先把所有不带锁的题目刷完。
+
+在这个系列文章里面，除了讲解解题思路以外，还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
+
+为了方便各位同学能够电脑上进行调试和提交代码，我建立了相关的仓库：https://github.com/SharingSource/LogicStack-LeetCode 。
+
+在仓库地址里，你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。
+

LeetCode/1661-1670/1669. 合并两个链表（中等）.md

@@ -0,0 +1,102 @@
+### 题目描述
+
+这是 LeetCode 上的 **[1669. 合并两个链表](/)** ，难度为 **中等**。
+
+Tag : 「链表」、「模拟」
+
+
+
+
+给你两个链表 `list1` 和 `list2`，它们包含的元素分别为 `n` 个和 `m` 个。
+
+请你将 `list1` 中下标从 `a` 到 `b` 的全部节点都删除，并将 `list2` 接在被删除节点的位置。
+
+下图中蓝色边和节点展示了操作后的结果：
+
+![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/11/28/fig1.png)
+
+请你返回结果链表的头指针。
+
+
+
+示例 1：
+![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/11/28/merge_linked_list_ex1.png)
+
+```
+输入：list1 = [0,1,2,3,4,5], a = 3, b = 4, list2 = [1000000,1000001,1000002]
+
+输出：[0,1,2,1000000,1000001,1000002,5]
+
+解释：我们删除 list1 中下标为 3 和 4 的两个节点，并将 list2 接在该位置。上图中蓝色的边和节点为答案链表。
+```
+示例 2：
+![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/11/28/merge_linked_list_ex2.png)
+```
+输入：list1 = [0,1,2,3,4,5,6], a = 2, b = 5, list2 = [1000000,1000001,1000002,1000003,1000004]
+
+输出：[0,1,1000000,1000001,1000002,1000003,1000004,6]
+
+解释：上图中蓝色的边和节点为答案链表。
+```
+
+提示：
+* $3 <= list1.length <= 10^4$
+* $1 <= a <= b < list1.length - 1$
+* $1 <= list2.length <= 10^4$
+
+---
+
+### 模拟
+
+根据题意进行模拟即可。
+
+使用两个变量 `A` 和 `B` 分别指向 `list1` 中两个断联的位置，分别将 `A`  指向 `list2` 的开头，将 `list2` 的 `next` 指针指向 `B`。
+
+
+Java 代码：
+```Java 
+class Solution {
+    public ListNode mergeInBetween(ListNode list1, int a, int b, ListNode list2) {
+        ListNode ans = list1;
+        ListNode A = null, B = null;
+        while (--a > 0 && --b > 0) list1 = list1.next;
+        A = list1;
+        while (b-- > 0) list1 = list1.next;
+        B = list1;
+        A.next = list2;
+        while (list2.next != null) list2 = list2.next;
+        list2.next = B.next;
+        return ans;
+    }
+} 
+```
+TypeScript 代码：
+```TypeScript 
+function mergeInBetween(list1: ListNode | null, a: number, b: number, list2: ListNode | null): ListNode | null {
+    const ans = list1
+    let A = null, B = null
+    while (--a > 0 && --b > 0) list1 = list1.next
+    A = list1
+    while (b-- > 0) list1 = list1.next
+    B = list1
+    A.next = list2
+    while (list2.next != null) list2 = list2.next
+    list2.next = B.next
+    return ans
+}
+```
+* 时间复杂度：$O(n + m)$
+* 空间复杂度：$O(1)$
+
+---
+
+### 最后
+
+这是我们「刷穿 LeetCode」系列文章的第 `No.1699` 篇，系列开始于 2021/01/01，截止于起始日 LeetCode 上共有 1916 道题目，部分是有锁题，我们将先把所有不带锁的题目刷完。
+
+在这个系列文章里面，除了讲解解题思路以外，还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
+
+为了方便各位同学能够电脑上进行调试和提交代码，我建立了相关的仓库：https://github.com/SharingSource/LogicStack-LeetCode 。
+
+在仓库地址里，你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。
+