还有螺柱说的求孤岛的,我刚开始用了DFS,没加DP,过了80,提示的错误也是数组越界,然后我猜可能是栈溢出,在本地输入了一个1000X1000全是1的数组,结果溢出了,然而时间所剩无几,没有将DFS改为循环,完了写了循环的方式,可以解决1000X1000全是1的情况,但是不知道能不能真的AC,也有人说是第二个的此时用例还是初始化有问题,那可能是吧,下边是我循环的代码
import java.util.ArrayDeque;
import java.util.Scanner;

/*
4
1 0 0 0
0 0 0 0
0 0 0 1
0 0 0 0
*/

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String line = in.nextLine();
        int N = Integer.parseInt(line);
        String[] split = null;
        boolean stand[][] = new boolean[N][N];
        boolean flag[][] = new boolean[N][N];
        for (int i = 0; i < N; i++) {
            line = in.nextLine();
            split = line.split(" ");
            for (int j = 0; j < N; j++) {
                if (split[j].equals("1"))
                    stand[i][j] = true;
            }
        }

        System.out.println(findTeam(N, stand));
    }

    public static int findTeam(int N, boolean stand[][]) {
        boolean flag[][] = new boolean[N][N];
        ArrayDeque<Integer[]> deque = new ArrayDeque<>();
        int ret = 0;
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                if (stand[i][j] && !flag[i][j]) {
                    deque.offer(new Integer[] { i, j });
                    flag[i][j] = true;
                    while (!deque.isEmpty()) {
                        Integer[] site = deque.poll();
                        int m = site[0];
                        int n = site[1];
                        if (m > 0 && stand[m - 1][n] && !flag[m - 1][n]) {
                            deque.offer(new Integer[] { m - 1, n });
                            flag[m - 1][n] = true;
                        }
                        if (n > 0 && stand[m][n - 1] && !flag[m][n - 1]) {
                            deque.offer(new Integer[] { m, n - 1 });
                            flag[m][n - 1] = true;
                        }
                        if (n < N - 1 && stand[m][n + 1] && !flag[m][n + 1]) {
                            deque.offer(new Integer[] { m, n + 1 });
                            flag[m][n + 1] = true;
                        }
                        if (m < N - 1 && stand[m + 1][n] && !flag[m + 1][n]) {
                            deque.offer(new Integer[] { m + 1, n });
                            flag[m + 1][n] = true;
                        }
                    }
                    ret++;
                }
            }
        }
        return ret;
    }
}