題意：給一個二維的矩陣，包含 ‘X’ 和 ‘O’, 找到所有被 ‘X’ 圍繞的區域，並用 ‘X’ 填充滿。

樣例
給出的二維矩陣：
X X X X
X O O X
X X O X
X O X X

把被 ‘X’ 圍繞的區域填充之後變為：
X X X X
X X X X
X X X X
X O X X

解題思路 1 ：
用bfs確定連通區域。 對二維矩陣邊緣的’O’進行bfs把其相鄰的’O’連線為一個區域 ， 並對這些區域做標記，例如記為‘’,最後遍歷整個二維矩陣，把連通域‘‘重新記為’O’ ,其他視為’X’ 。

class Solution
{
    public
 
:
    void surroundedRegions(vector<vector<char> > &board)
    {
        int m = board.size() ;
        int n = board[0].size() ;

        for(int i = 0 ; i < m ; i ++)
        {
            bfs(board , i , 0 ) ;
            bfs(board , i , n - 1 ) ;
        }

        for(int j = 0 ; j < n ; j ++)
        {
            bfs(board , 0
 
 , j ) ;
            bfs(board , m - 1 , j ) ;
        }

        for(int i = 0 ; i < m ; i ++)
        {
            for (int j = 0 ; j < n ; j ++)
            {
                if(board[i][j] == '*')
                    board[i][j] = 'O' ;
                else board[i][j] = 'X' ;
            }
        }
    }

    private
 
:
    int dx[4] = {0 , 0 , 1 , -1 } ;
    int dy[4] = {1 , -1 , 0 , 0 } ;

    bool isInBoard(int m , int n , int x , int y)
    {
        if(x >= 0 && x < m && y >= 0 && y < n )
            return  true ;
        return  false ;
    }

    void bfs(vector<vector<char> > &board , int x , int y) // 注意對board進行傳引用，不然形參board的修改無法傳到實參中
    {
        int m = board.size() ;
        int n = board[0].size() ;
        int nx , ny ;
        if(isInBoard(m , n , x, y) && board[x][y] == 'O' )
        {

            board[x][y] = '*' ;
            for(int k = 0 ; k < 4 ; k ++)
            {
                nx = x + dx[k] ;
                ny = y + dy[k] ;
                bfs(board , nx , ny ) ;
            }
        }
    }

};

解題思路2 ：
用並查集確定連通區域。 把與二維矩陣邊緣的’O’相鄰的’O’合併為一個集合。需要設定一個集合，然後把所有的元素都扔進去。

#include <iostream>
#include "algorithm"

using namespace std ;

class UnionFind
{

    public :
    UnionFind (int N)
    {
        this->count = N ;
        this->id = new int [N+1] ;
       // this->size = new int[N+1] ;

        for (int i = 0 ; i <= this->count ; i++)
        {
            id[i] = i ;
          //  size[i] = 1 ;
        }
    }

    int Find(int p)
    {
        while( p != id[p])
        {
            id[p] = id[id[p]] ;
            p = id[p] ;
        }

        return  p ;
    }

    void Union(int p , int q)
    {
        int fp = this->Find(p) ;
        int fq = this->Find(q) ;
        if(fp == fq)
            return ;
        else
            id[fp] = fq ;

        count -- ;
    }

    bool Connected (int p , int q)
    {
        int fp = this->Find(p) ;
        int fq = this->Find(q) ;
        if (fp == fq )
            return  true ;
        else
            return  false ;
    }

    int Count ()
    {
        return this->count ;
    }
    private:
    int *id ,  count ;
};

class Solution
{
    public:
    vector <vector<char> > Board ;
   Solution (int m)
    {
        vector<char> d ;
        char c ;
        for(int i = 0 ; i < m ; i ++)
        {
            Board.push_back(d) ;
            for (int j = 0 ; j < m ; j ++)
            {
                cin >> c ;
                Board[i].push_back(c)  ;
            }
        }

    }

    bool isEdge (int n , int m , int x , int y)
    {
        if(x == 0 || x == n -1 || y == 0 || y == m -1 )
            return  true ;
        else return false ;
    }

    bool isInBoard(int n , int m , int x , int y)
    {
        if(x >= 0 && x < n && y >= 0 && y < m)
            return true ;
        else return false ;
    }

    void surroundedRegions(vector<vector<char> > &board)
    {
        int n = board.size() ;
        int m = board[0].size() ;
        //cout << "m : " << m << "n : " << n << endl ;
        if(board.empty()|| n == 0 || m == 0 )
            return ;
        UnionFind uf(n*m) ;
        for(int i = 0 ; i < n ; i ++)
        {
            for(int j = 0 ; j < m ; j ++)
            {
                if(board[i][j] == 'O')
                {
                    if(isEdge(n , m , i , j))
                        uf.Union(m*i+j , m * n) ; //把邊緣的'O'放入m*n所在的集合，最後和邊緣'O'相連通的'O'都在集合m*n中。
                    else
                    {
                        for(int k = 0 ; k < 4 ; k ++)
                        {
                            int nx = i + dx[k] ;
                            int ny = j + dy[k] ;
                            if(isInBoard(n , m , nx , ny) && board[nx][ny] == 'O')
                            {
                                uf.Union(m*i + j , m*nx + ny) ;
                            }
                        }
                    }
                }
            }
        }

        for(int i = 0 ; i <  n ; i ++)
        {
            for(int j = 0 ; j < m ; j ++)
            {
                if(!uf.Connected(m*i + j , m *n))
                {
                    board[i][j] = 'X' ;
                }
            }
        }
    }

    void Output()
    {
        int m = this->Board.size() ;
        //cout << "m : " << m << endl ;
        for(int i = 0 ; i < m ; i ++)
        {
            for (int j = 0 ; j < m ; j ++)
            {
                cout << Board[i][j] ;
            }
            cout << endl ;
        }

    }

    private:
    int dx[4] = {0 , 0 , 1 , -1} ;
    int dy[4] = {1 , -1 , 0 , 0} ;

};

int main()
{
   /* vector<vector<char> > board = {
            {'X' , 'X' , 'X' , 'X'} ,
            {'X' , 'O' , 'O' , 'X'} ,
            {'X' , 'X' , 'O' , 'X'} ,
            {'X' , 'O' , 'X' , 'X'}
    };
    Solution s ;
    s.surroundedRegions(board) ;
    int m = board.size() ;
    int n = board[0].size() ;
    for(int i = 0 ; i < m ; i ++)
    {
        for(int j = 0 ; j < n ; j ++)
        {
            cout << board[i][j] ;
        }
        cout << endl ;
    }*/

    Solution s(4) ;
    s.surroundedRegions(s.Board) ;
    s.Output() ;

    return 0;
}