feat: add solutions to lc/lcci problems

* lcci No.08.10.Color Fill
* lc No.0733.Flood Fill

Author: yanglbme

lcci/08.10.Color Fill/README.md

@@ -33,7 +33,13 @@ sr = 1, sc = 1, newColor = 2
 
 <!-- 这里可写通用的实现逻辑 -->
 
-DFS。
+**方法一：Flood fill 算法**
+
+Flood fill 算法是从一个区域中提取若干个连通的点与其他相邻区域区分开（或分别染成不同颜色）的经典算法。因为其思路类似洪水从一个区域扩散到所有能到达的区域而得名。
+
+最简单的实现方法是采用 DFS 的递归方法，也可以采用 BFS 的迭代来实现。
+
+时间复杂度 $O(m \times n)$，空间复杂度 $O(m \times n)$。其中 $m$ 和 $n$ 分别为图像的行数和列数。
 
 <!-- tabs:start -->
 
@@ -46,21 +52,43 @@ class Solution:
     def floodFill(
         self, image: List[List[int]], sr: int, sc: int, newColor: int
     ) -> List[List[int]]:
-        def dfs(i, j, oc, nc):
+        def dfs(i, j):
             if (
-                i < 0
-                or i >= len(image)
-                or j < 0
-                or j >= len(image[0])
+                not 0 <= i < m
+                or not 0 <= j < n
                 or image[i][j] != oc
-                or image[i][j] == nc
+                or image[i][j] == newColor
             ):
                 return
-            image[i][j] = nc
-            for x, y in [[0, 1], [0, -1], [1, 0], [-1, 0]]:
-                dfs(i + x, j + y, oc, nc)
+            image[i][j] = newColor
+            for a, b in pairwise(dirs):
+                dfs(i + a, j + b)
+
+        dirs = (-1, 0, 1, 0, -1)
+        m, n = len(image), len(image[0])
+        oc = image[sr][sc]
+        dfs(sr, sc)
+        return image
+```
 
-        dfs(sr, sc, image[sr][sc], newColor)
+```python
+class Solution:
+    def floodFill(
+        self, image: List[List[int]], sr: int, sc: int, newColor: int
+    ) -> List[List[int]]:
+        if image[sr][sc] == newColor:
+            return image
+        q = deque([(sr, sc)])
+        oc = image[sr][sc]
+        image[sr][sc] = newColor
+        dirs = (-1, 0, 1, 0, -1)
+        while q:
+            i, j = q.popleft()
+            for a, b in pairwise(dirs):
+                x, y = i + a, j + b
+                if 0 <= x < len(image) and 0 <= y < len(image[0]) and image[x][y] == oc:
+                    q.append((x, y))
+                    image[x][y] = newColor
         return image
 ```
 
@@ -70,22 +98,55 @@ class Solution:
 
 ```java
 class Solution {
-    private int[][] dirs = new int[][] {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+    private int[] dirs = {-1, 0, 1, 0, -1};
+    private int[][] image;
+    private int nc;
+    private int oc;
 
     public int[][] floodFill(int[][] image, int sr, int sc, int newColor) {
-        dfs(image, sr, sc, image[sr][sc], newColor);
+        nc = newColor;
+        oc = image[sr][sc];
+        this.image = image;
+        dfs(sr, sc);
         return image;
     }
 
-    private void dfs(int[][] image, int i, int j, int oc, int nc) {
-        if (i < 0 || i >= image.length || j < 0 || j >= image[0].length || image[i][j] != oc
-            || image[i][j] == nc) {
+    private void dfs(int i, int j) {
+        if (i < 0 || i >= image.length || j < 0 || j >= image[0].length || image[i][j] != oc || image[i][j] == nc) {
             return;
         }
         image[i][j] = nc;
-        for (int[] dir : dirs) {
-            dfs(image, i + dir[0], j + dir[1], oc, nc);
+        for (int k = 0; k < 4; ++k) {
+            dfs(i + dirs[k], j + dirs[k + 1]);
+        }
+    }
+}
+```
+
+```java
+class Solution {
+    public int[][] floodFill(int[][] image, int sr, int sc, int newColor) {
+        if (image[sr][sc] == newColor) {
+            return image;
+        }
+        Deque<int[]> q = new ArrayDeque<>();
+        q.offer(new int[] {sr, sc});
+        int oc = image[sr][sc];
+        image[sr][sc] = newColor;
+        int[] dirs = {-1, 0, 1, 0, -1};
+        while (!q.isEmpty()) {
+            int[] p = q.poll();
+            int i = p[0], j = p[1];
+            for (int k = 0; k < 4; ++k) {
+                int x = i + dirs[k], y = j + dirs[k + 1];
+                if (x >= 0 && x < image.length && y >= 0 && y < image[0].length
+                    && image[x][y] == oc) {
+                    q.offer(new int[] {x, y});
+                    image[x][y] = newColor;
+                }
+            }
         }
+        return image;
     }
 }
 ```
@@ -95,17 +156,48 @@ class Solution {
 ```cpp
 class Solution {
 public:
-    vector<vector<int>> dirs = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
-
     vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int newColor) {
-        dfs(image, sr, sc, image[sr][sc], newColor);
+        int m = image.size(), n = image[0].size();
+        int oc = image[sr][sc];
+        int dirs[5] = {-1, 0, 1, 0, -1};
+        function<void(int, int)> dfs = [&](int i, int j) {
+            if (i < 0 || i >= m || j < 0 || j >= n || image[i][j] != oc || image[i][j] == newColor) {
+                return;
+            }
+            image[i][j] = newColor;
+            for (int k = 0; k < 4; ++k) {
+                dfs(i + dirs[k], j + dirs[k + 1]);
+            }
+        };
+        dfs(sr, sc);
         return image;
     }
+};
+```
 
-    void dfs(vector<vector<int>>& image, int i, int j, int oc, int nc) {
-        if (i < 0 || i >= image.size() || j < 0 || j >= image[0].size() || image[i][j] != oc || image[i][j] == nc) return;
-        image[i][j] = nc;
-        for (auto& dir : dirs) dfs(image, i + dir[0], j + dir[1], oc, nc);
+```cpp
+class Solution {
+public:
+    vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int newColor) {
+        if (image[sr][sc] == newColor) return image;
+        int oc = image[sr][sc];
+        image[sr][sc] = newColor;
+        queue<pair<int, int>> q;
+        q.push({sr, sc});
+        int dirs[5] = {-1, 0, 1, 0, -1};
+        while (!q.empty()) {
+            auto [a, b] = q.front();
+            q.pop();
+            for (int k = 0; k < 4; ++k) {
+                int x = a + dirs[k];
+                int y = b + dirs[k + 1];
+                if (x >= 0 && x < image.size() && y >= 0 && y < image[0].size() && image[x][y] == oc) {
+                    q.push({x, y});
+                    image[x][y] = newColor;
+                }
+            }
+        }
+        return image;
     }
 };
 ```
@@ -114,19 +206,45 @@ public:
 
 ```go
 func floodFill(image [][]int, sr int, sc int, newColor int) [][]int {
-	dfs(image, sr, sc, image[sr][sc], newColor)
+	oc := image[sr][sc]
+	m, n := len(image), len(image[0])
+	dirs := []int{-1, 0, 1, 0, -1}
+	var dfs func(i, j int)
+	dfs = func(i, j int) {
+		if i < 0 || i >= m || j < 0 || j >= n || image[i][j] != oc || image[i][j] == newColor {
+			return
+		}
+		image[i][j] = newColor
+		for k := 0; k < 4; k++ {
+			dfs(i+dirs[k], j+dirs[k+1])
+		}
+	}
+	dfs(sr, sc)
 	return image
 }
+```
 
-func dfs(image [][]int, i, j, oc, nc int) {
-	if i < 0 || i >= len(image) || j < 0 || j >= len(image[0]) || image[i][j] != oc || image[i][j] == nc {
-		return
+```go
+func floodFill(image [][]int, sr int, sc int, newColor int) [][]int {
+	if image[sr][sc] == newColor {
+		return image
 	}
-	image[i][j] = nc
-	dirs := [4][2]int{{0, -1}, {0, 1}, {1, 0}, {-1, 0}}
-	for _, dir := range dirs {
-		dfs(image, i+dir[0], j+dir[1], oc, nc)
+	oc := image[sr][sc]
+	q := [][]int{[]int{sr, sc}}
+	image[sr][sc] = newColor
+	dirs := []int{-1, 0, 1, 0, -1}
+	for len(q) > 0 {
+		p := q[0]
+		q = q[1:]
+		for k := 0; k < 4; k++ {
+			x, y := p[0]+dirs[k], p[1]+dirs[k+1]
+			if x >= 0 && x < len(image) && y >= 0 && y < len(image[0]) && image[x][y] == oc {
+				q = append(q, []int{x, y})
+				image[x][y] = newColor
+			}
+		}
 	}
+	return image
 }
 ```