LeetCode-【动态规划】- 最大加号标志

在一个大小在 (0, 0) 到 (N-1, N-1) 的2D网格 grid 中，除了在 mines 中给出的单元为 0，其他每个单元都是 1。网格中包含 1 的最大的轴对齐加号标志是多少阶？返回加号标志的阶数。如果未找到加号标志，则返回 0。

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

k 阶轴对称加号标志示例:

阶 1:
000
010
000

阶 2:
00000
00100
01110
00100
00000

阶 3:
0000000
0001000
0001000
0111110
0001000
0001000
0000000

示例 1：

输入: N = 5, mines = [[4, 2]]
输出: 2
解释:

11111
11111
11111
11111
11011

在上面的网格中，最大加号标志的阶只能是2。一个标志已在图中标出。

示例 2：

输入: N = 2, mines = []
输出: 1
解释:

11
11

没有 2 阶加号标志，有 1 阶加号标志。

示例 3：

输入: N = 1, mines = [[0, 0]]
输出: 0
解释:

0

没有加号标志，返回 0 。

提示：

1. 整数N 的范围： [1, 500].
2. mines 的最大长度为 5000.
3. mines[i] 是长度为2的由2个 [0, N-1] 中的数组成.
4. (另外,使用 C, C++, 或者 C# 编程将以稍小的时间限制进行​​判断.)

题解：对数组中值为1的点，判断它的四个方向(i+k,j),(i-k,j),(i,j-k),(i,j+k)其中0=<k<n,这样做是从这点开始不断判断它的第一层是否为1，第二层是为1，第三层。。。，如果在某一层遇到某个位置值不为1，直接结束遍历，记录此时最大加号的阶。不断比较数组元素为1的最大加号的阶，最后得到最大值。

class Solution {
    static int res=1;
    public static void dfs(int[][] grid,int n,int i,int j){
        for(int k=1;k<n;k++){
            int a=i+k,b=i-k,c=j+k,d=j-k;
            if(a>=0&&a<n&&b>=0&&b<n&&c>=0&&c<n&&d>=0&&d<n){
                if(grid[i][c]==1&&grid[i][d]==1&&grid[a][j]==1&&grid[b][j]==1){
                    res++;
                }
                else
                    break;
            }
        }
    }
    public int orderOfLargestPlusSign(int N, int[][] mines) {
        int[][] grid=new int[N][N];
        for(int[] g:grid)
            Arrays.fill(g,1);
        for(int[] m:mines)
            grid[m[0]][m[1]]=0;
        int max=0;
        for(int i=0;i<N;i++){
            for(int j=0;j<N;j++){
                if(grid[i][j]==1){
                    res=1;
                    dfs(grid,N,i,j);
                    max=Math.max(max,res);
                }       
            }
        }
        return max;
    }
}

巧妙解法：参考：https://blog.csdn.net/magicbean2/article/details/79627099

class Solution {
    public int orderOfLargestPlusSign(int N, int[][] mines) {
    int[][] grid = new int[N][N];
        
    for (int i = 0; i < N; i++) {
        Arrays.fill(grid[i], N);
    }
        
    for (int[] m : mines) {
        grid[m[0]][m[1]] = 0;
    }
        
    for (int i = 0; i < N; i++) {
        for (int j = 0, k = N - 1, l = 0, r = 0, u = 0, d = 0; j < N; j++, k--) {
            grid[i][j] = Math.min(grid[i][j], l = (grid[i][j] == 0 ? 0 : l + 1));
            grid[i][k] = Math.min(grid[i][k], r = (grid[i][k] == 0 ? 0 : r + 1));
            grid[j][i] = Math.min(grid[j][i], u = (grid[j][i] == 0 ? 0 : u + 1));
            grid[k][i] = Math.min(grid[k][i], d = (grid[k][i] == 0 ? 0 : d + 1));
        }
    }
        
    int res = 0;
        
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            res = Math.max(res, grid[i][j]);
        }
    }
        
    return res;
    }
}