Flood Fill

class Solution {
public:
    vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int color) {
        int orig = image[sr][sc];
        if (orig == color) return image;
        function<void(int,int)> dfs = [&](int r, int c) {
            if (r < 0 || r >= (int)image.size() || c < 0 || c >= (int)image[0].size() || image[r][c] != orig) return;
            image[r][c] = color;
            dfs(r+1,c); dfs(r-1,c); dfs(r,c+1); dfs(r,c-1);
        };
        dfs(sr, sc);
        return image;
    }
};

func floodFill(image [][]int, sr int, sc int, color int) [][]int {
    orig := image[sr][sc]
    if orig == color {
        return image
    }
    m, n := len(image), len(image[0])
    var dfs func(r, c int)
    dfs = func(r, c int) {
        if r < 0 || r >= m || c < 0 || c >= n || image[r][c] != orig {
            return
        }
        image[r][c] = color
        dfs(r+1, c)
        dfs(r-1, c)
        dfs(r, c+1)
        dfs(r, c-1)
    }
    dfs(sr, sc)
    return image
}

from typing import List

class Solution:
    def floodFill(self, image: List[List[int]], sr: int, sc: int, color: int) -> List[List[int]]:
        orig = image[sr][sc]
        if orig == color:
            return image
        m, n = len(image), len(image[0])

        def dfs(r: int, c: int) -> None:
            if r < 0 or r >= m or c < 0 or c >= n or image[r][c] != orig:
                return
            image[r][c] = color
            dfs(r + 1, c)
            dfs(r - 1, c)
            dfs(r, c + 1)
            dfs(r, c - 1)

        dfs(sr, sc)
        return image

var floodFill = function(image, sr, sc, color) {
    const orig = image[sr][sc];
    if (orig === color) return image;
    const m = image.length, n = image[0].length;
    const dfs = (r, c) => {
        if (r < 0 || r >= m || c < 0 || c >= n || image[r][c] !== orig) return;
        image[r][c] = color;
        dfs(r + 1, c);
        dfs(r - 1, c);
        dfs(r, c + 1);
        dfs(r, c - 1);
    };
    dfs(sr, sc);
    return image;
};

class Solution {
    private int m, n, orig, color;
    private int[][] image;

    public int[][] floodFill(int[][] image, int sr, int sc, int color) {
        this.orig = image[sr][sc];
        if (orig == color) return image;
        this.image = image;
        this.color = color;
        this.m = image.length;
        this.n = image[0].length;
        dfs(sr, sc);
        return image;
    }

    private void dfs(int r, int c) {
        if (r < 0 || r >= m || c < 0 || c >= n || image[r][c] != orig) return;
        image[r][c] = color;
        dfs(r + 1, c);
        dfs(r - 1, c);
        dfs(r, c + 1);
        dfs(r, c - 1);
    }
}

function floodFill(image: number[][], sr: number, sc: number, color: number): number[][] {
    const orig = image[sr][sc];
    if (orig === color) return image;
    const m = image.length, n = image[0].length;
    const dfs = (r: number, c: number): void => {
        if (r < 0 || r >= m || c < 0 || c >= n || image[r][c] !== orig) return;
        image[r][c] = color;
        dfs(r + 1, c);
        dfs(r - 1, c);
        dfs(r, c + 1);
        dfs(r, c - 1);
    };
    dfs(sr, sc);
    return image;
}