还有螺柱说的求孤岛的，我刚开始用了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;
    }
}

NC274	二叉树的深度	2018-09-07	答案正确	13ms	9232K	Java	题解
NC274	二叉树的深度	2018-09-07	答案正确	21ms	9264K	Java	题解
NC76	用两个栈实现队列	2018-08-16	答案正确	12ms	9272K	Java	题解
NC265	从尾到头打印链表	2018-08-16	答案正确	23ms	9404K	Java	题解
NC29	二维数组中的查找	2018-08-16	答案正确	135ms	17348K	Java	题解