回溯算法OJ刷题(2)

被围绕的区域

题目描述

给你一个 m x n 的矩阵 board ，由若干字符 'X' 和 'O' ，找到所有被 'X' 围绕的区域，并将这些区域里所有的 'O' 用 'X' 填充。被围绕的区间不会存在于边界上，换句话说，任何边界上的 ‘O’ 都不会被填充为 ‘X’。 任何不在边界上，或不与边界上的 ‘O’ 相连的 ‘O’ 最终都会被填充为 ‘X’。

解题思路

抓住重点：从每一个边缘的’O’开始，只要’O’和边缘的’O’联通，则它就没有被包围。

先建一个与board一样大的全’X’数组。

我们要从board边界的’O’开始找（搜寻第一行、第一列、最后一行、最后一列），对于边上的每一个’O’进行DFS扩散搜索，遇到’O’就把ret对应位置的’X’改为’O’。

class Solution {
public:
    void DFS(const vector<vector<char>>& board, vector<vector<char>>& ret, vector<vector<bool>>& flag, const int& row, const int& col, int curX, int curY)
    {
        //首先判断坐标是否越界
        if(!(curX >= 0 && curX < row))
            return;
        if(!(curY >= 0 && curY < col))
            return;
        //如果这个格子是'O'
        if(board[curX][curY] == 'O' && !flag[curX][curY])
        {
            //修改ret + 标记
            ret[curX][curY] = 'O';
            flag[curX][curY] = true;
            //遍历四周的格子
            DFS(board, ret, flag, row, col, curX - 1, curY);
            DFS(board, ret, flag, row, col, curX, curY - 1);
            DFS(board, ret, flag, row, col, curX + 1, curY);
            DFS(board, ret, flag, row, col, curX, curY + 1);
        }
    }
    void solve(vector<vector<char>>& board) {
        int row = board.size();
        int col = board[0].size();
        vector<vector<char>> ret(row, vector<char>(col, 'X'));
        vector<vector<bool>> flag(row, vector<bool>(col, false));
        //第1行 最后一行
        for(int i = 0; i < col; ++i)
        {
            DFS(board, ret, flag, row, col, 0, i);
            DFS(board, ret, flag, row, col, row - 1, i);
        }
        
        //第1列 最后一列
        for(int i = 0; i < row; ++i)
        {
            DFS(board, ret, flag, row, col, i, 0);
            DFS(board, ret, flag, row, col, i, col - 1);
        }
        board = ret;
    }
};

岛屿数量

题目描述

给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。此外，你可以假设该网格的四条边均被水包围。

解题思路

优化：直接把已经访问过的陆地’1’改成水’0’，可以节省一个标记数组。

思路：与图像渲染类似，连在一起的陆地都算做一个岛屿。最后看深度优先算法执行了多少次，就有几个岛屿。

class Solution {
public:
    int change[4][2] = {{-1, 0},{1,0},{0,-1},{0,1}};
    void DFS(vector<vector<char>>& grid, const int& row, const int& col, int curX, int curY)
    {
        //将当前的陆地改成水
        grid[curX][curY] = '0';
        for(int i = 0; i < 4; ++i)
        {
            //尝试4个方向
            int newX = curX + change[i][0];
            int newY = curY + change[i][1];
            //判断新位置是否越界
            if(newX >= row || newX < 0 || newY >= col || newY < 0) continue;
            //坐标符合要求，且为陆地
            if(grid[newX][newY] == '1')
            {
                DFS(grid, row, col, newX, newY);
            }
        }
    }
    int numIslands(vector<vector<char>>& grid) {
        int row = grid.size();
        int col = grid[0].size();
        int ret = 0;
        for(int i = 0; i < row; ++i)
        {
            for(int j = 0; j < col; ++j)
            {
                //由于直接将访问过的陆地改为水，所以计算岛屿数量只用这个条件就行
                if(grid[i][j] == '1')
                {
                     ++ret;//岛屿数量
                     DFS(grid, row, col, i, j);
                }
            }
        }
        return ret;
    }
};

岛屿的最大面积

题目描述

给你一个大小为 m x n 的二进制矩阵 grid 。岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在 水平或者竖直的四个方向上 相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。岛屿的面积是岛上值为 1 的单元格的数目。计算并返回 grid 中最大的岛屿面积。如果没有岛屿，则返回面积为 0 。

解题思路

与岛屿数量这道题思路类似，没有使用标记数组。只不过这里的累计岛屿面积需要在DFS函数内部进行计数。

class Solution {
public:
    int change[4][2] = {{1,0},{-1,0},{0,1},{0,-1}};
    void DFS(vector<vector<int>>& grid, const int& row, const int& col, int X, int Y, int* area)
    {
        grid[X][Y] = 0;
        for(int i = 0; i < 4; ++i)
        {
            int curX = X + change[i][0];
            int curY = Y + change[i][1];
            //判断新坐标是否越界
            if(curX >= row || curX < 0 || curY >= col || curY < 0) continue;
            //判断是否是陆地
            if(grid[curX][curY] == 1)
            {
                (*area)++;
                DFS(grid, row, col, curX, curY, area);
            }
        }
    }
    int maxAreaOfIsland(vector<vector<int>>& grid) {        
        int max_area = 0;
        int row = grid.size();
        int col = grid[0].size();
        for(int i = 0; i < row; ++i)
        {
            for(int j = 0; j < col; ++j)
            {
                if(grid[i][j] == 1)
                {
                    //保存以该点为起点的岛屿面积
                    int area = 1;
                    DFS(grid, row, col, i, j, &area);
                    //更新岛屿最大面积
                    max_area = area > max_area ? area : max_area;
                }
            }
        }
        return max_area;
    }
};