feat: add solutions to lc problem: No.0733

No.0733.Flood Fill

Author: YangFong

solution/0700-0799/0733.Flood Fill/README.md

@@ -226,6 +226,69 @@ func floodFill(image [][]int, sr int, sc int, newColor int) [][]int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function floodFill(
+    image: number[][],
+    sr: number,
+    sc: number,
+    newColor: number,
+): number[][] {
+    const m = image.length;
+    const n = image[0].length;
+    const target = image[sr][sc];
+    const dfs = (i: number, j: number) => {
+        if (
+            i < 0 ||
+            i === m ||
+            j < 0 ||
+            j === n ||
+            image[i][j] !== target ||
+            image[i][j] === newColor
+        ) {
+            return;
+        }
+        image[i][j] = newColor;
+        dfs(i + 1, j);
+        dfs(i - 1, j);
+        dfs(i, j + 1);
+        dfs(i, j - 1);
+    };
+    dfs(sr, sc);
+    return image;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    fn dfs(image: &mut Vec<Vec<i32>>, sr: i32, sc: i32, new_color: i32, target: i32) {
+        if sr < 0 || sr == image.len() as i32 || sc < 0 || sc == image[0].len() as i32 {
+            return;
+        }
+        let sr = sr as usize;
+        let sc = sc as usize;
+        if sr < 0 || image[sr][sc] == new_color || image[sr][sc] != target {
+            return;
+        }
+        image[sr][sc] = new_color;
+        let sr = sr as i32;
+        let sc = sc as i32;
+        Self::dfs(image, sr + 1, sc, new_color, target);
+        Self::dfs(image, sr - 1, sc, new_color, target);
+        Self::dfs(image, sr, sc + 1, new_color, target);
+        Self::dfs(image, sr, sc - 1, new_color, target);
+    }
+    pub fn flood_fill(image: Vec<Vec<i32>>, sr: i32, sc: i32, new_color: i32) -> Vec<Vec<i32>> {
+        let target = image[sr as usize][sc as usize];
+        Self::dfs(&mut image, sr, sc, new_color, target);
+        image
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0700-0799/0733.Flood Fill/README_EN.md

@@ -242,6 +242,69 @@ func floodFill(image [][]int, sr int, sc int, newColor int) [][]int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function floodFill(
+    image: number[][],
+    sr: number,
+    sc: number,
+    newColor: number,
+): number[][] {
+    const m = image.length;
+    const n = image[0].length;
+    const target = image[sr][sc];
+    const dfs = (i: number, j: number) => {
+        if (
+            i < 0 ||
+            i === m ||
+            j < 0 ||
+            j === n ||
+            image[i][j] !== target ||
+            image[i][j] === newColor
+        ) {
+            return;
+        }
+        image[i][j] = newColor;
+        dfs(i + 1, j);
+        dfs(i - 1, j);
+        dfs(i, j + 1);
+        dfs(i, j - 1);
+    };
+    dfs(sr, sc);
+    return image;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    fn dfs(image: &mut Vec<Vec<i32>>, sr: i32, sc: i32, new_color: i32, target: i32) {
+        if sr < 0 || sr == image.len() as i32 || sc < 0 || sc == image[0].len() as i32 {
+            return;
+        }
+        let sr = sr as usize;
+        let sc = sc as usize;
+        if sr < 0 || image[sr][sc] == new_color || image[sr][sc] != target {
+            return;
+        }
+        image[sr][sc] = new_color;
+        let sr = sr as i32;
+        let sc = sc as i32;
+        Self::dfs(image, sr + 1, sc, new_color, target);
+        Self::dfs(image, sr - 1, sc, new_color, target);
+        Self::dfs(image, sr, sc + 1, new_color, target);
+        Self::dfs(image, sr, sc - 1, new_color, target);
+    }
+    pub fn flood_fill(image: Vec<Vec<i32>>, sr: i32, sc: i32, new_color: i32) -> Vec<Vec<i32>> {
+        let target = image[sr as usize][sc as usize];
+        Self::dfs(&mut image, sr, sc, new_color, target);
+        image
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0700-0799/0733.Flood Fill/Solution.rs

@@ -0,0 +1,24 @@
+impl Solution {
+    fn dfs(image: &mut Vec<Vec<i32>>, sr: i32, sc: i32, new_color: i32, target: i32) {
+        if sr < 0 || sr == image.len() as i32 || sc < 0 || sc == image[0].len() as i32 {
+            return;
+        }
+        let sr = sr as usize;
+        let sc = sc as usize;
+        if sr < 0 || image[sr][sc] == new_color || image[sr][sc] != target {
+            return;
+        }
+        image[sr][sc] = new_color;
+        let sr = sr as i32;
+        let sc = sc as i32;
+        Self::dfs(image, sr + 1, sc, new_color, target);
+        Self::dfs(image, sr - 1, sc, new_color, target);
+        Self::dfs(image, sr, sc + 1, new_color, target);
+        Self::dfs(image, sr, sc - 1, new_color, target);
+    }
+    pub fn flood_fill(image: Vec<Vec<i32>>, sr: i32, sc: i32, new_color: i32) -> Vec<Vec<i32>> {
+        let target = image[sr as usize][sc as usize];
+        Self::dfs(&mut image, sr, sc, new_color, target);
+        image
+    }
+}

solution/0700-0799/0733.Flood Fill/Solution.ts

@@ -0,0 +1,30 @@
+function floodFill(
+    image: number[][],
+    sr: number,
+    sc: number,
+    newColor: number,
+): number[][] {
+    const m = image.length;
+    const n = image[0].length;
+    const target = image[sr][sc];
+    // 递归函数
+    const dfs = (i: number, j: number) => {
+        if (
+            i < 0 ||
+            i === m ||
+            j < 0 ||
+            j === n ||
+            image[i][j] !== target ||
+            image[i][j] === newColor
+        ) {
+            return;
+        }
+        image[i][j] = newColor;
+        dfs(i + 1, j);
+        dfs(i - 1, j);
+        dfs(i, j + 1);
+        dfs(i, j - 1);
+    };
+    dfs(sr, sc);
+    return image;
+}