LeetCode 130.被围绕的区域 深度优先搜索DFS+广度优先搜索BFS

深度优先搜索 时间复杂度O(m×n) 空间复杂度O(n×m)

//搜索x,y上下左右的方向
void dfs(char** board, int x, int y,int n, int m)
{
    if(x<0||x>=n||y<0||y>=m||board[x][y]!='O')
        return;
    board[x][y]='T';
    dfs(board,x+1,y,n,m);
    dfs(board,x-1,y,n,m);
    dfs(board,x,y+1,n,m);
    dfs(board,x,y-1,n,m);
}

void solve(char** board, int boardSize, int* boardColSize)
{
    int i,j,n,m;
    n=boardSize;
    if(n==0)
        return;
    m=*boardColSize;
    //找到边缘为O的点，深度搜索它附近的点
    for(i=0;i<boardSize;i++)
    {
        dfs(board,i,0,n,m);
        dfs(board,i,m-1,n,m);
    }
    for(i=0;i<*boardColSize;i++)
    {
        dfs(board,0,i,n,m);
        dfs(board,n-1,i,n,m);
    }

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

深度优先搜索 时间复杂度O(n×m) 空间复杂度O(n×m)

//确定好搜索的方向
const int dx[4] = {1, -1, 0, 0};
const int dy[4] = {0, 0, 1, -1};

void solve(char** board, int boardSize, int* boardColSize)
{
    int n = boardSize;
    if (n == 0)
    {
        return;
    }
    int m = boardColSize[0];
	//创建队列
    int** que = (int**)malloc(sizeof(int*) * n * m);
    //因为队列中要存点的位置x，y所以要开辟空间
    for (int i = 0; i < n * m; i++)
    {
        que[i] = (int*)malloc(sizeof(int) * 2);
    }
    int l = 0, r = 0;
    //遍历边缘找到为O的点，入队
    for (int i = 0; i < n; i++)
    {
        if (board[i][0] == 'O')
        {
            board[i][0] = 'A';
            que[r][0] = i, que[r++][1] = 0;
        }
        if (board[i][m - 1] == 'O')
        {
            board[i][m - 1] = 'A';
            que[r][0] = i, que[r++][1] = m - 1;
        }
    }
    for (int i = 1; i < m - 1; i++)
    {
        if (board[0][i] == 'O')
        {
            board[0][i] = 'A';
            que[r][0] = 0, que[r++][1] = i;
        }
        if (board[n - 1][i] == 'O') {
            board[n - 1][i] = 'A';
            que[r][0] = n - 1, que[r++][1] = i;
        }
    }
    //出队，每出队一组数据，搜索其附近的点，若为O，则该点入队
    while (l < r) {
        int x = que[l][0], y = que[l][1];
        l++;
        for (int i = 0; i < 4; i++)
        {
            int mx = x + dx[i], my = y + dy[i];
            if (mx < 0 || my < 0 || mx >= n || my >= m || board[mx][my] != 'O')
            {
                continue;
            }
            board[mx][my] = 'A';
            que[r][0] = mx, que[r++][1] = my;
        }
    }
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++)
        {
            if (board[i][j] == 'A')
            {
                board[i][j] = 'O';
            } else if (board[i][j] == 'O')
            {
                board[i][j] = 'X';
            }
        }
    }
    //释放空间
    for (int i = 0; i < n * m; i++)
    {
        free(que[i]);
    }
    free(que);
}