994.腐烂的橘子

在给定的网格中，每个单元格可以有以下三个值之一：

值 0 代表空单元格；
值 1 代表新鲜橘子；
值 2 代表腐烂的橘子。
每分钟，任何与腐烂的橘子（在 4 个正方向上）相邻的新鲜橘子都会腐烂。

返回直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1。

思路

采用广度优先遍历，因为腐烂的橘子只会引起其周围的橘子腐烂。

class Solution {
public:
    int orangesRotting(vector<vector<int>>& grid) {
        int col = grid.size();
        int row = grid[0].size();
        //用来保存每个橘子的腐烂时间
        int dp[100][100];
        //初始化为-1
        memset(dp, -1, sizeof(dp));
        //广度优先遍历队列
        queue<pair<int,int>> que;

        int cnt = 0;
        //找到所有腐烂的橘子
        for(int i = 0; i < col; ++i)
            for(int j = 0; j < row; ++j)
            {
                if(grid[i][j] == 2) 
                {
                    que.push(make_pair(i,j));
					//腐烂的橘子设置其腐烂时间为0
                    dp[i][j] = 0;
                }
                //统计有多少个橘子（因为有没有橘子的格子
                else if(grid[i][j] == 1) cnt++;
            }
		
		//为了方便取得当前橘子的上下左右的坐标，定义两个坐标数组
        int x[4] = {0,1,0,-1};
        int y[4] = {1,0,-1,0};
        //返回值
        int ans = 0;
        while(!que.empty())
        {
            pair<int, int> temp = que.front();
            que.pop();
            for(int i = 0; i < 4; ++i)
            {
                int nx = temp.first + x[i];
                int ny = temp.second + y[i];
				//前四个测试条件是测试是否越界。检测dp是为了跳过当前已经腐烂的橘子，检测
				//grid是跳过当前没有橘子的格子。
                if(nx < 0 || nx >= col || ny < 0 || ny >= row || dp[nx][ny] >= 0 || !grid[nx][ny]) continue;

                que.push(make_pair(nx,ny));
                //更新橘子的腐烂时间
                dp[nx][ny] = dp[temp.first][temp.second] + 1;
                //每腐烂一个，就减去一个橘子
                cnt--;
                //记录所需的最大时间
                if(dp[nx][ny] > ans) ans = dp[nx][ny];
            }
        }
		//若仍有完好的橘子，即cnt！=0，返回-1
        return (cnt > 0) ? -1 : ans;
    }
};

此题和695类似，其采用深度优先遍历

695.岛屿的最大面积

给定一个包含了一些 0 和 1的非空二维数组 grid , 一个 岛屿 是由四个方向 (水平或垂直) 的 1 (代表土地) 构成的组合。你可以假设二维矩阵的四个边缘都被水包围着。

找到给定的二维数组中最大的岛屿面积。(如果没有岛屿，则返回面积为0。)

示例 1:

[[0,0,1,0,0,0,0,1,0,0,0,0,0],
[0,0,0,0,0,0,0,1,1,1,0,0,0],
[0,1,1,0,1,0,0,0,0,0,0,0,0],
[0,1,0,0,1,1,0,0,1,0,1,0,0],
[0,1,0,0,1,1,0,0,1,1,1,0,0],
[0,0,0,0,0,0,0,0,0,0,1,0,0],
[0,0,0,0,0,0,0,1,1,1,0,0,0],
[0,0,0,0,0,0,0,1,1,0,0,0,0]]
对于上面这个给定矩阵应返回 6。注意答案不应该是11，因为岛屿只能包含水平或垂直的四个方向的‘1’。

class Solution {
public:
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        int m = grid.size();
        int n = grid[0].size();
        int res = 0;
        int dp[50][50];
        memset(dp, 0, sizeof(dp));
        stack<pair<int, int>> stac;
        int x[4] = {0, 1, 0, -1};
        int y[4] = {1, 0, -1, 0};

        
        for(int i = 0; i < m; ++i)
        {
            for(int j = 0; j < n; ++j)
            {
                int cur = 0;
                stac.push(make_pair(i,j));
                while(!stac.empty())
                {
                    auto temp = stac.top();
                    stac.pop();

                    if(temp.first < 0 || temp.first >= m || temp.second < 0 || temp.second >= n || grid[temp.first][temp.second] == 0)      continue;
                    cur++;
                    //已经访问到的节点，可以剔除，剪枝
                    grid[temp.first][temp.second] = 0;
                    for(int i = 0; i < 4; ++i)
                    {
                        int nx = temp.first + x[i];
                        int ny = temp.second + y[i];

                        stac.push(make_pair(nx, ny));
                    }
                }
                res = max(res, cur);
            }
        }

        

        return res;
    }
};