764.最大加号标志(DP)

764. 最大加号标志

在一个 n x n 的矩阵 grid 中，除了在数组 mines 中给出的元素为 0，其他每个元素都为 1。mines[i] = [xi, yi]表示 grid[xi][yi] == 0

返回  grid 中包含 1 的最大的 轴对齐 加号标志的阶数 。如果未找到加号标志，则返回 0 。

一个 k 阶由 1 组成的 “轴对称”加号标志 具有中心网格 grid[r][c] == 1 ，以及4个从中心向上、向下、向左、向右延伸，长度为 k-1，由 1 组成的臂。注意，只有加号标志的所有网格要求为 1 ，别的网格可能为 0 也可能为 1 。

示例 1：

输入: n = 5, mines = [[4, 2]]
输出: 2
解释: 在上面的网格中，最大加号标志的阶只能是2。一个标志已在图中标出。

示例 2：

输入: n = 1, mines = [[0, 0]]
输出: 0
解释: 没有加号标志，返回 0 。

思路：动态规划+预处理

首先我们可以思考一下，如果这题简化到只需要求grid中最长的一条横线应该怎么做？

我们可以用 dp[i][j] 表示每个点(i, j)左边最长的连续1的格子数，然后 dp 矩阵中的最大值就是结果。

同理，这道题就是将一个方向转化为了上下左右四个方向。所以我们只需要事先计算好 up, down,left, right 这四个矩阵用于表示点 (i, j) 上面最长的连续1的格子数，下面最长的连续1的格子数......

那么，点 (i, j) 能组成的最大的加号阶数就是这四个方向上的最小值：min(up[i][j], down[i][j], left[i][j], right[i][j])，grid的最大加号阶数就是所有点的最大的加号阶数的最大值。

class Solution {
public:
    int orderOfLargestPlusSign(int n, vector<vector<int>>& mines) {
        vector<vector<int>> grid(n,vector<int>(n,1));
        for(int i=0;i<mines.size();i++)//初始化grid数组
        {
            int x=mines[i][0];
            int y=mines[i][1];
            grid[x][y]=0;
        }
        vector<vector<int>> up(n,vector<int>(n,0));
        vector<vector<int>> down(n,vector<int>(n,0));
        vector<vector<int>> left(n,vector<int>(n,0));
        vector<vector<int>> right(n,vector<int>(n,0));
        for(int i=0;i<n;i++)//点(i,j)左边最长的连续1的格子数
        {
            int cnt=0;
            for(int j=0;j<n;j++)
            {
                cnt=grid[i][j]==0?0:cnt+1;
                left[i][j]=cnt;
            }
        }
        for(int i=0;i<n;i++)//点(i,j)右边最长的连续1的格子数
        {
            int cnt=0;
            for(int j=n-1;j>=0;j--)
            {
                cnt=grid[i][j]==0?0:cnt+1;
                right[i][j]=cnt;
            }
        }
        for(int j=0;j<n;j++)//点(i,j)上边最长的连续1的格子数
        {
            int cnt=0;
            for(int i=0;i<n;i++)
            {
                cnt=grid[i][j]==0?0:cnt+1;
                up[i][j]=cnt;
            }
        }
        for(int j=0;j<n;j++)//点(i,j)下边最长的连续1的格子数
        {
            int cnt=0;
            for(int i=n-1;i>=0;i--)
            {
                cnt=grid[i][j]==0?0:cnt+1;
                down[i][j]=cnt;
            }
        }
        int res=0;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                //点(i,j)能组成的最大的加号阶数是四个方向上的最小值
                int cnt=min({up[i][j],down[i][j],left[i][j],right[i][j]});//在min函数中放一个数组，得出数组的最小值
                //int cnt=min(up[i][j],min(down[i][j],min(left[i][j],right[i][j])));
                res=max(res,cnt);
            }
        }
        return res;
    }
};

上面使用了四个二维数组up，down，left，right来记录四个方向上最长的连续1的格子数。

其实，可以直接在grid数组上原地修改，用grid数组记录点 (i, j) 在四个方向上最长的连续1的格子数中的最小值， 即该点的最大的加号阶数，结果就是grid数组中的最大值。

class Solution {
public:
    int orderOfLargestPlusSign(int n, vector<vector<int>>& mines) {
        vector<vector<int>> grid(n,vector<int>(n,INT_MAX));
        for(int i=0;i<mines.size();i++)
        {
            int x=mines[i][0];
            int y=mines[i][1];
            grid[x][y]=0;
        }
        for(int i=0;i<n;i++)
        {
            int up=0,down=0,left=0,right=0;
            for(int j=0,k=n-1;j<n;j++,k--)
            {
                left=grid[i][j]==0?0:left+1;
                grid[i][j]=min(grid[i][j],left);

                right=grid[i][k]==0?0:right+1;
                grid[i][k]=min(grid[i][k],right);

                up=grid[j][i]==0?0:up+1;
                grid[j][i]=min(grid[j][i],up);

                down=grid[k][i]==0?0:down+1;
                grid[k][i]=min(grid[k][i],down);
            }
        }
        int res=0;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                res=max(res,grid[i][j]);
            }
        }
        return res;
    }
};

上面的遍历+比较是如何运作的呢？

i=0，第一次外循环，由图可见，只有第一个点(0,0)是上下左右四个方向的最长的连续1的格子数中的最小值，因为它被比较了四次，而其他的点，只被比较了两次。

 i=1，第二次外循环，向外扩了一圈，有四个结点存的是最终结果。

 i=2，第三次外循环，又向外扩了一圈，有九个结点存的是最终结果。

 i=3，全部都是最终结果，dp结束

 dp数组内的数据逐步更新，最终达成目标。