feat: add solutions to lcci problems: No.08.10~08.12 (#2691)

Author: yanglbme

lcci/08.10.Color Fill/README.md

@@ -31,11 +31,9 @@ sr = 1, sc = 1, newColor = 2
 
 ## 解法
 
-### 方法一：Flood fill 算法
+### 方法一：DFS
 
-Flood fill 算法是从一个区域中提取若干个连通的点与其他相邻区域区分开（或分别染成不同颜色）的经典算法。因为其思路类似洪水从一个区域扩散到所有能到达的区域而得名。
-
-最简单的实现方法是采用 DFS 的递归方法，也可以采用 BFS 的迭代来实现。
+我们设计一个函数 $dfs(i, j)$，表示从 $(i, j)$ 开始填充颜色。如果 $(i, j)$ 不在图像范围内，或者 $(i, j)$ 的颜色不是原来的颜色，或者 $(i, j)$ 的颜色已经被填充成新的颜色，就返回。否则，将 $(i, j)$ 的颜色填充成新的颜色，然后递归搜索 $(i, j)$ 的上下左右四个方向。
 
 时间复杂度 $O(m \times n)$，空间复杂度 $O(m \times n)$。其中 $m$ 和 $n$ 分别为图像的行数和列数。
 
@@ -135,6 +133,32 @@ func floodFill(image [][]int, sr int, sc int, newColor int) [][]int {
 }
 ```
 
+```ts
+function floodFill(image: number[][], sr: number, sc: number, newColor: number): number[][] {
+    const dfs = (i: number, j: number): void => {
+        if (i < 0 || i >= m) {
+            return;
+        }
+        if (j < 0 || j >= n) {
+            return;
+        }
+        if (image[i][j] !== oc || image[i][j] === nc) {
+            return;
+        }
+        image[i][j] = nc;
+        for (let k = 0; k < 4; ++k) {
+            dfs(i + dirs[k], j + dirs[k + 1]);
+        }
+    };
+    const dirs: number[] = [-1, 0, 1, 0, -1];
+    const [m, n] = [image.length, image[0].length];
+    const oc = image[sr][sc];
+    const nc = newColor;
+    dfs(sr, sc);
+    return image;
+}
+```
+
 ```rust
 impl Solution {
     fn dfs(i: usize, j: usize, target: i32, new_color: i32, image: &mut Vec<Vec<i32>>) {
@@ -170,7 +194,11 @@ impl Solution {
 
 <!-- tabs:end -->
 
-### 方法二
+### 方法二：BFS
+
+我们可以使用广度优先搜索的方法，从起始点开始，将起始点的颜色填充成新的颜色，然后将起始点加入队列。每次从队列中取出一个点，然后将其上下左右四个方向的点加入队列，直到队列为空。
+
+时间复杂度 $O(m \times n)$，空间复杂度 $O(m \times n)$。其中 $m$ 和 $n$ 分别为图像的行数和列数。
 
 <!-- tabs:start -->
 
@@ -274,6 +302,29 @@ func floodFill(image [][]int, sr int, sc int, newColor int) [][]int {
 }
 ```
 
+```ts
+function floodFill(image: number[][], sr: number, sc: number, newColor: number): number[][] {
+    if (image[sr][sc] === newColor) {
+        return image;
+    }
+    const q: number[][] = [[sr, sc]];
+    const oc = image[sr][sc];
+    image[sr][sc] = newColor;
+    const dirs: number[] = [-1, 0, 1, 0, -1];
+    while (q.length) {
+        const [i, j] = q.pop()!;
+        for (let k = 0; k < 4; ++k) {
+            const [x, y] = [i + dirs[k], j + dirs[k + 1]];
+            if (x >= 0 && x < image.length && y >= 0 && y < image[0].length && image[x][y] === oc) {
+                q.push([x, y]);
+                image[x][y] = newColor;
+            }
+        }
+    }
+    return image;
+}
+```
+
 <!-- tabs:end -->
 
 <!-- end -->

lcci/08.10.Color Fill/README_EN.md

@@ -38,13 +38,11 @@ to the starting pixel.</pre>
 
 ## Solutions
 
-### Solution 1: Flood Fill Algorithm
+### Solution 1: DFS
 
-The Flood Fill algorithm is a classic algorithm used to extract several connected points from a region and distinguish them from other adjacent regions (or color them differently). It is named for its strategy, which is similar to a flood spreading from one area to all reachable areas.
+We design a function $dfs(i, j)$ to start filling color from $(i, j)$. If $(i, j)$ is not within the image range, or the color of $(i, j)$ is not the original color, or the color of $(i, j)$ has been filled with the new color, then return. Otherwise, fill the color of $(i, j)$ with the new color, and then recursively search the four directions: up, down, left, and right of $(i, j)$.
 
-The simplest implementation method is to use the recursive method of DFS, or it can be implemented iteratively using BFS.
-
-The time complexity is $O(m \times n)$, and the space complexity is $O(m \times n)$. Here, $m$ and $n$ are the number of rows and columns of the image, respectively.
+The time complexity is $O(m \times n)$, and the space complexity is $O(m \times n)$. Where $m$ and $n$ are the number of rows and columns in the image, respectively.
 
 <!-- tabs:start -->
 
@@ -142,6 +140,32 @@ func floodFill(image [][]int, sr int, sc int, newColor int) [][]int {
 }
 ```
 
+```ts
+function floodFill(image: number[][], sr: number, sc: number, newColor: number): number[][] {
+    const dfs = (i: number, j: number): void => {
+        if (i < 0 || i >= m) {
+            return;
+        }
+        if (j < 0 || j >= n) {
+            return;
+        }
+        if (image[i][j] !== oc || image[i][j] === nc) {
+            return;
+        }
+        image[i][j] = nc;
+        for (let k = 0; k < 4; ++k) {
+            dfs(i + dirs[k], j + dirs[k + 1]);
+        }
+    };
+    const dirs: number[] = [-1, 0, 1, 0, -1];
+    const [m, n] = [image.length, image[0].length];
+    const oc = image[sr][sc];
+    const nc = newColor;
+    dfs(sr, sc);
+    return image;
+}
+```
+
 ```rust
 impl Solution {
     fn dfs(i: usize, j: usize, target: i32, new_color: i32, image: &mut Vec<Vec<i32>>) {
@@ -177,7 +201,11 @@ impl Solution {
 
 <!-- tabs:end -->
 
-### Solution 2
+### Solution 2: BFS
+
+We can use the method of breadth-first search. Starting from the initial point, fill the color of the initial point with the new color, and then add the initial point to the queue. Each time a point is taken from the queue, the points in the four directions: up, down, left, and right are added to the queue, until the queue is empty.
+
+The time complexity is $O(m \times n)$, and the space complexity is $O(m \times n)$. Where $m$ and $n$ are the number of rows and columns in the image, respectively.
 
 <!-- tabs:start -->
 
@@ -281,6 +309,29 @@ func floodFill(image [][]int, sr int, sc int, newColor int) [][]int {
 }
 ```
 
+```ts
+function floodFill(image: number[][], sr: number, sc: number, newColor: number): number[][] {
+    if (image[sr][sc] === newColor) {
+        return image;
+    }
+    const q: number[][] = [[sr, sc]];
+    const oc = image[sr][sc];
+    image[sr][sc] = newColor;
+    const dirs: number[] = [-1, 0, 1, 0, -1];
+    while (q.length) {
+        const [i, j] = q.pop()!;
+        for (let k = 0; k < 4; ++k) {
+            const [x, y] = [i + dirs[k], j + dirs[k + 1]];
+            if (x >= 0 && x < image.length && y >= 0 && y < image[0].length && image[x][y] === oc) {
+                q.push([x, y]);
+                image[x][y] = newColor;
+            }
+        }
+    }
+    return image;
+}
+```
+
 <!-- tabs:end -->
 
 <!-- end -->

lcci/08.10.Color Fill/Solution.ts

@@ -0,0 +1,23 @@
+function floodFill(image: number[][], sr: number, sc: number, newColor: number): number[][] {
+    const dfs = (i: number, j: number): void => {
+        if (i < 0 || i >= m) {
+            return;
+        }
+        if (j < 0 || j >= n) {
+            return;
+        }
+        if (image[i][j] !== oc || image[i][j] === nc) {
+            return;
+        }
+        image[i][j] = nc;
+        for (let k = 0; k < 4; ++k) {
+            dfs(i + dirs[k], j + dirs[k + 1]);
+        }
+    };
+    const dirs: number[] = [-1, 0, 1, 0, -1];
+    const [m, n] = [image.length, image[0].length];
+    const oc = image[sr][sc];
+    const nc = newColor;
+    dfs(sr, sc);
+    return image;
+}

lcci/08.10.Color Fill/Solution2.ts

@@ -0,0 +1,20 @@
+function floodFill(image: number[][], sr: number, sc: number, newColor: number): number[][] {
+    if (image[sr][sc] === newColor) {
+        return image;
+    }
+    const q: number[][] = [[sr, sc]];
+    const oc = image[sr][sc];
+    image[sr][sc] = newColor;
+    const dirs: number[] = [-1, 0, 1, 0, -1];
+    while (q.length) {
+        const [i, j] = q.pop()!;
+        for (let k = 0; k < 4; ++k) {
+            const [x, y] = [i + dirs[k], j + dirs[k + 1]];
+            if (x >= 0 && x < image.length && y >= 0 && y < image[0].length && image[x][y] === oc) {
+                q.push([x, y]);
+                image[x][y] = newColor;
+            }
+        }
+    }
+    return image;
+}

lcci/08.11.Coin/README.md

@@ -63,8 +63,6 @@ $$
 
 时间复杂度 $O(C \times n)$，空间复杂度 $O(C \times n)$，其中 $C$ 为硬币的种类数。
 
-我们注意到，$f[i][j]$ 的计算只与 $f[i−1][..]$ 有关，因此我们可以去掉第一维，将空间复杂度优化到 $O(n)$。
-
 <!-- tabs:start -->
 
 ```python
@@ -149,9 +147,7 @@ func waysToChange(n int) int {
 function waysToChange(n: number): number {
     const mod = 10 ** 9 + 7;
     const coins: number[] = [25, 10, 5, 1];
-    const f: number[][] = Array(5)
-        .fill(0)
-        .map(() => Array(n + 1).fill(0));
+    const f: number[][] = Array.from({ length: 5 }, () => Array(n + 1).fill(0));
     f[0][0] = 1;
     for (let i = 1; i <= 4; ++i) {
         for (let j = 0; j <= n; ++j) {
@@ -167,7 +163,9 @@ function waysToChange(n: number): number {
 
 <!-- tabs:end -->
 
-### 方法二
+### 方法二：动态规划（空间优化）
+
+我们注意到，$f[i][j]$ 的计算只与 $f[i−1][..]$ 有关，因此我们可以去掉第一维，将空间复杂度优化到 $O(n)$。
 
 <!-- tabs:start -->
 

lcci/08.11.Coin/README_EN.md

@@ -75,8 +75,6 @@ The final answer is $f[4][n]$.
 
 The time complexity is $O(C \times n)$, and the space complexity is $O(C \times n)$, where $C$ is the number of types of coins.
 
-We notice that the calculation of $f[i][j]$ is only related to $f[i−1][..]$, so we can remove the first dimension and optimize the space complexity to $O(n)$.
-
 <!-- tabs:start -->
 
 ```python
@@ -161,9 +159,7 @@ func waysToChange(n int) int {
 function waysToChange(n: number): number {
     const mod = 10 ** 9 + 7;
     const coins: number[] = [25, 10, 5, 1];
-    const f: number[][] = Array(5)
-        .fill(0)
-        .map(() => Array(n + 1).fill(0));
+    const f: number[][] = Array.from({ length: 5 }, () => Array(n + 1).fill(0));
     f[0][0] = 1;
     for (let i = 1; i <= 4; ++i) {
         for (let j = 0; j <= n; ++j) {
@@ -179,7 +175,9 @@ function waysToChange(n: number): number {
 
 <!-- tabs:end -->
 
-### Solution 2
+### Solution 2: Dynamic Programming (Space Optimization)
+
+We notice that the calculation of $f[i][j]$ is only related to $f[i−1][..]$. Therefore, we can remove the first dimension and optimize the space complexity to $O(n)$.
 
 <!-- tabs:start -->
 

lcci/08.11.Coin/Solution.ts

@@ -1,9 +1,7 @@
 function waysToChange(n: number): number {
     const mod = 10 ** 9 + 7;
     const coins: number[] = [25, 10, 5, 1];
-    const f: number[][] = Array(5)
-        .fill(0)
-        .map(() => Array(n + 1).fill(0));
+    const f: number[][] = Array.from({ length: 5 }, () => Array(n + 1).fill(0));
     f[0][0] = 1;
     for (let i = 1; i <= 4; ++i) {
         for (let j = 0; j <= n; ++j) {