leetcode773

使用两种语言实现，先贴C++的

class Solution {
public:
    vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int newColor) {
        int row = image.size();
        int col = image[].size();

        int oldColor = image[sr][sc];
        if (oldColor == newColor)
        {
            return image;
        }
        queue<pair<int, int>> Q;
        Q.push(make_pair(sr, sc));

        const int N = ;

        int Visited[N][N];

        for (int i = ; i < row; i++)
        {
            for (int j = ; j < col; j++)
            {
                Visited[i][j] = false;
            }
        }

        while (!Q.empty())
        {
            pair<int, int> Node = Q.front();
            Q.pop();
            int x = Node.first;
            int y = Node.second;
            if (Visited[x][y])
            {
                continue;//略过此点
            }
            else
            {
                Visited[x][y] = true;
                image[x][y] = newColor;
            }
            pair<int, int> Up_Node = make_pair(x - , y);
            pair<int, int> Down_Node = make_pair(x + , y);
            pair<int, int> Left_Node = make_pair(x, y - );
            pair<int, int> Right_Node = make_pair(x, y + );

            if (Up_Node.first >=  && !Visited[Up_Node.first][Up_Node.second] && image[Up_Node.first][Up_Node.second] == oldColor)
            {
                Q.push(Up_Node);
            }

            if (Down_Node.first <= row -  && !Visited[Down_Node.first][Down_Node.second] && image[Down_Node.first][Down_Node.second] == oldColor)
            {
                Q.push(Down_Node);
            }

            if (Left_Node.second >=  && !Visited[Left_Node.first][Left_Node.second] && image[Left_Node.first][Left_Node.second] == oldColor)
            {
                Q.push(Left_Node);
            }

            if (Right_Node.second <= col -  && !Visited[Right_Node.first][Right_Node.second] && image[Right_Node.first][Right_Node.second] == oldColor)
            {
                Q.push(Right_Node);
            }
        }

        return image;
    }
};

下面贴出C#的

public class Solution
    {
        public int[,] FloodFill(int[,] image, int sr, int sc, int newColor)
        {
            int row = image.GetLength();
            int col = image.GetLength();

            int oldColor = image[sr, sc];
            if (oldColor == newColor)
            {
                return image;
            }
            Queue<KeyValuePair<int, int>> Q = new Queue<KeyValuePair<int, int>>();
            Q.Enqueue(new KeyValuePair<int, int>(sr, sc));

            bool[,] Visited = new bool[row, col];

            while (Q.Any())
            {
                var Node = Q.Dequeue();
                int x = Node.Key;
                int y = Node.Value;
                if (Visited[x, y])
                {
                    continue;//略过此点
                }
                else
                {
                    Visited[x, y] = true;
                    image[x, y] = newColor;
                }
                var Up_Node = new KeyValuePair<int, int>(x - , y);
                var Down_Node = new KeyValuePair<int, int>(x + , y);
                var Left_Node = new KeyValuePair<int, int>(x, y - );
                var Right_Node = new KeyValuePair<int, int>(x, y + );

                if (Up_Node.Key >=  && !Visited[Up_Node.Key, Up_Node.Value] && image[Up_Node.Key, Up_Node.Value] == oldColor)
                {
                    Q.Enqueue(Up_Node);
                }

                if (Down_Node.Key <= row -  && !Visited[Down_Node.Key, Down_Node.Value] && image[Down_Node.Key, Down_Node.Value] == oldColor)
                {
                    Q.Enqueue(Down_Node);
                }

                if (Left_Node.Value >=  && !Visited[Left_Node.Key, Left_Node.Value] && image[Left_Node.Key, Left_Node.Value] == oldColor)
                {
                    Q.Enqueue(Left_Node);
                }

                if (Right_Node.Value <= col -  && !Visited[Right_Node.Key, Right_Node.Value] && image[Right_Node.Key, Right_Node.Value] == oldColor)
                {
                    Q.Enqueue(Right_Node);
                }
            }

            return image;
        }
    }