leetcode surrounded-regions

Given a 2D board containing’X’and’O’, capture all regions surrounded by’X’.
A region is captured by flipping all’O’s into’X’s in that surrounded region .
For example,
X X X X
X O O X
X X O X
X O X X

After running your function, the board should be:
X X X X
X X X X
X X X X
X O X X

class Solution {
public:
    void solve(vector<vector<char> > &board) 
    {
        int x = board.size();
        if (0 == x)
            return;
        int y = board[0].size();
        vector<vector<int> >flag (x, vector<int> (y, -1));  //0是  1不是  -1 未判定 2寻找中
        for(int i=1;i<x-1;i++)
            for (int j=1;j<y-1;j++)
                if (board[i][j] == 'O' && flag[i][j] == -1)
                    judge(board, flag, i, j);

        for(int i=1;i<x;i++)
            for (int j=1;j<y;j++)
                if (flag[i][j] == 0)
                    board[i][j] = 'X';
    }
    void judge(vector<vector<char> > &board, vector<vector<int> > &flag, int i, int j)
    {
        vector<pair<int, int> > allO;
        int res = findallO(board, allO, flag, i, j)?0:1;
        for (int k=0;k<allO.size();k++)
        {
            if(flag[allO[k].first][allO[k].second] != 0 && flag[allO[k].first][allO[k].second] != 1) 
                flag[allO[k].first][allO[k].second] = res;
        }
    }
    bool findallO(vector<vector<char> > &board, vector<pair<int, int> > &allO,  vector<vector<int> > &flag, int i, int j)
    {
        if (i == 0 || j == 0 || i == board.size()-1 || j == board[0].size()-1)
            return false;
        bool res = true;
        allO.push_back(pair<int,int>(i,j));
        flag[i][j] = 2;
        if (board[i-1][j] == 'O' && flag[i-1][j] == -1)
            res = res & findallO(board, allO, flag, i-1, j);
        
        if (board[i+1][j] == 'O' &&  flag[i+1][j]  == -1)
            res = res & findallO(board, allO, flag, i+1, j);
        
        if (board[i][j-1] == 'O' &&  flag[i][j-1]  == -1)
            res = res & findallO(board, allO, flag, i, j-1);
        
        if (board[i][j+1] == 'O' &&  flag[i][j+1]  == -1)
            res = res & findallO(board, allO, flag, i, j+1);
        return res;
    }
};



//网上的思路   从四周的"O"开始  将所有联通的“O”变为“a”  最后剩下的“O”变为“X” “a”变为“O”

class Solution {
public:
    void solve(vector<vector<char> > &board) 
    {
        int x = board.size();
        if (0 == x)
            return;
        int y = board[0].size();
        for(int i=0;i<x;i++)
            for (int j=0;j<y;j++)
                if (board[i][j] == 'O' && (i == 0 || j == 0 || i == x-1 || j == y-1))
                    DFS(board, i, j);

        for (int i = 0; i < board.size(); ++i) 
        {
            for (int j = 0; j < board[i].size(); ++j) 
            {
                if (board[i][j] == 'O') board[i][j] = 'X';
                if (board[i][j] == 'a') board[i][j] = 'O';
            }
        }
    }
    void DFS(vector<vector<char> > &board, int i, int j)
    {
        board[i][j] = 'a';
        if (i>0 && board[i-1][j] == 'O')//>0或1都行
            DFS(board,i-1, j);
        
        if (i<board.size()-1 && board[i+1][j] == 'O')
            DFS(board, i+1, j);
        
        if (j>0 && board[i][j-1] == 'O')//>0或1都行
            DFS(board, i, j-1);
        
        if (j<board[0].size()-1 && board[i][j+1] == 'O' )
            DFS(board, i, j+1);
    }
};

测试

#include"head.h"
class Solution1 {
public:
    void solve(vector<vector<char> > &board) 
    {
        int x = board.size();
        if (0 == x)
            return;
        int y = board[0].size();
        vector<vector<int> >flag (x, vector<int> (y, -1));  //0是  1不是  -1 未判定 2寻找中
        for(int i=1;i<x-1;i++)
            for (int j=1;j<y-1;j++)
                if (board[i][j] == 'O' && flag[i][j] == -1)
                    judge(board, flag, i, j);

        for(int i=1;i<x;i++)
            for (int j=1;j<y;j++)
                if (flag[i][j] == 0)
                    board[i][j] = 'X';
    }
    void judge(vector<vector<char> > &board, vector<vector<int> > &flag, int i, int j)
    {
        vector<pair<int, int> > allO;
        int res = findallO(board, allO, flag, i, j)?0:1;
        for (int k=0;k<allO.size();k++)
        {
            if(flag[allO[k].first][allO[k].second] != 0 && flag[allO[k].first][allO[k].second] != 1) 
                flag[allO[k].first][allO[k].second] = res;
        }
    }
    bool findallO(vector<vector<char> > &board, vector<pair<int, int> > &allO,  vector<vector<int> > &flag, int i, int j)
    {
        if (i == 0 || j == 0 || i == board.size()-1 || j == board[0].size()-1)
            return false;
        bool res = true;
        allO.push_back(pair<int,int>(i,j));
        flag[i][j] = 2;
        if (board[i-1][j] == 'O' && flag[i-1][j] == -1)
            res = res & findallO(board, allO, flag, i-1, j);
        
        if (board[i+1][j] == 'O' &&  flag[i+1][j]  == -1)
            res = res & findallO(board, allO, flag, i+1, j);
        
        if (board[i][j-1] == 'O' &&  flag[i][j-1]  == -1)
            res = res & findallO(board, allO, flag, i, j-1);
        
        if (board[i][j+1] == 'O' &&  flag[i][j+1]  == -1)
            res = res & findallO(board, allO, flag, i, j+1);
        return res;
    }
};

class Solution {
public:
    void solve(vector<vector<char> > &board) 
    {
        int x = board.size();
        if (0 == x)
            return;
        int y = board[0].size();
        for(int i=0;i<x;i++)
            for (int j=0;j<y;j++)
                if (board[i][j] == 'O' && (i == 0 || j == 0 || i == x-1 || j == y-1))
                    DFS(board, i, j);

        for (int i = 0; i < board.size(); ++i) 
        {
            for (int j = 0; j < board[i].size(); ++j) 
            {
                if (board[i][j] == 'O') board[i][j] = 'X';
                if (board[i][j] == 'a') board[i][j] = 'O';
            }
        }
    }
    void DFS(vector<vector<char> > &board, int i, int j)
    {
        board[i][j] = 'a';
        if (i>0 && board[i-1][j] == 'O')
            DFS(board,i-1, j);
        
        if (i<board.size()-1 && board[i+1][j] == 'O')
            DFS(board, i+1, j);
        
        if (j>0 && board[i][j-1] == 'O')
            DFS(board, i, j-1);
        
        if (j<board[0].size()-1 && board[i][j+1] == 'O' )
            DFS(board, i, j+1);
    }
};
/*
OOOOXX,
OOOOOO,
OXOXOO,
OXOOXO,
OXOXOO,
OXOOOO
[OOOOXX,OOOOOO,OXOXOO,OXOOXO,OXOXOO,OXOOOO]
[OOOOXX,OOOOOO,OXOXOO,OXOOXO,OXOXOO,OXOOOO]

[OOOOXX,OOOOOO,OXOXOO,OXOXXO,OXOXOO,OXOOOO]*/
int main()
{
    Solution s;
    vector<vector<char> > board;
    char A[] = {'O', 'O', 'O', 'O', 'X', 'X'};
    vector<char> tmp1(A, A+6);
    board.push_back(tmp1);
    
    char B[] = {'O', 'O', 'O', 'O','O', 'O'};
    vector<char> tmp2(B, B+6);
    board.push_back(tmp2);
    
    char C[] = {'O', 'X', 'O', 'X','O', 'O'};
    vector<char> tmp3(C, C+6);
    board.push_back(tmp3);
    
    char D[] = {'O', 'X', 'O', 'O','X', 'O'};
    vector<char> tmp4(D, D+6);
    board.push_back(tmp4);
    
    char E[] = {'O', 'X', 'O', 'X','O', 'O'};
    vector<char> tmp5(E, E+6);
    board.push_back(tmp5);
    
    char F[] = {'O', 'X', 'O', 'O','O', 'O'};
    vector<char> tmp6(F, F+6);
    board.push_back(tmp6);
    
    print2Dvectorint(board);
    cout<<endl;
    s.solve(board);
    print2Dvectorint(board);
    
    
}