229、最大加号标志

题目描述：
在一个大小在 (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 。

提示：

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/largest-plus-sign
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

emm，没有想到其他的方法，使用了dfs进行操作
在进入循环之前判断一下

class Solution {
   public int orderOfLargestPlusSign(int N, int[][] mines) {
		int tem[][] = new int[N][N];
//		由于一开始初始化为0，为了便于使用，将0变成1即可
		for (int[] is : mines) {
			int x = is[0];
			int y = is[1];
			tem[x][y] = 1;
		}
//		是否遍历
		int max = 0;
//		使用遍历即可
	for (int i = 0; i < tem.length; i++) {
			for (int j = 0; j < tem[i].length; j++) {
				if(tem[i][j] == 0 &&  max <= i && max <= tem.length - 1 - i && max <= tem[0].length - 1 - j && max <= j){
					max = Math.max(max, get(i, j, tem));
				}
			}
		}
		return max;
	}

	public int get(int x,int y,int tem[][]){
		int temx = x;
		int temy = y;
		while (temx >= 0 && tem[temx][y] == 0) {
			temx--;
		}
		int maxleft = x - temx;
		if(maxleft == 1){
			return 1;
		}
		temx = x;
		while (temx < tem.length && tem[temx][y] == 0) {
			temx++;
		}
		int maxright = temx - x;
		if(maxright == 1){
			return 1;
		}
		
		while (temy >= 0 && tem[x][temy] == 0) {
			temy--;
		}
		int maxup = y - temy;
		if(maxup == 1){
			return 1;
		}
		temy = y;
		while (temy < tem[0].length && tem[x][temy] == 0) {
			temy++;
		}
		int maxdown = temy - y;
		return Math.min(Math.min(maxdown, maxup), Math.min(maxleft, maxright));
	}
}

可以考虑使用dp来进行操作，后续来看吧

class Solution {
    public int orderOfLargestPlusSign(int N, int[][] mines) {
        int[][] dp = new int[N][N];
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                dp[i][j] = 1;
            }
        }
        for (int[] i : mines) {
            dp[i[0]][i[1]] = 0;
        }
        //
        //
        for (int i = 0; i < N; i++) {
            int lt = 0;
            for (int j = 0; j < N; j++) {
                lt = dp[i][j] > 0 ? ++lt : 0;
                dp[i][j] = lt;
            }
            int rt = 0;
            for (int j = N - 1; j >= 0; j--) {
                rt = dp[i][j] > 0 ? ++rt : 0;
                dp[i][j] = Math.min(dp[i][j], rt);
            }
        }
        for (int j = 0; j < N; j++) {
            int up = 0;
            for (int i = 0; i < N; i++) {
                up = dp[i][j] > 0 ? ++up : 0;
                dp[i][j] = Math.min(dp[i][j], up);
            }
            int dn = 0;
            for (int i = N - 1; i >= 0; i--) {
                dn = dp[i][j] > 0 ? ++dn : 0;
                dp[i][j] = Math.min(dp[i][j], dn);
            }
        }
        //
        //
        int res = 0;
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                res = Math.max(res, dp[i][j]);
            }
        }
        return res;
    }
}