题目：

给你一个数组nums,
2: 阳性
1: 阴性
0: 阻断的环境
t->t+1（每个标准单位时间）： 2会将其上下左右四个方向的1变为2
问题：求全局所有1都变为2的最短时间
实现： int findMinTime(int [][]nums)
例子：
1、输入nums=
{
{1,0,1,2},
{1,0,1,1},
{1,1,1,1},
{1,0,1,2},
}
输出： 6
2、nums=
{
{1,0,1,2},
{1,0,1,1},
{1,0,1,1},
{1,0,1,2},
}
输出： -1

思路：

广度优先遍历，利用队列。
初始时先把数组中所有的2放入队列中。
遍历队列， 每遍历一遍队列并且遇到了1，就把1传播成2，把新传播的数对放入队列中。 次数+1.
如果最后仍然存在1，则返回-1， 否则返回传播次数。

java代码：

public int findMinTime(int[][] nums) {
    int minTime = 0;
    int len = nums.length;

    Queue<int[]> queue = new LinkedList<int[]>();
    for (int i = 0; i < len; i++) {
        for (int j = 0; j < len; j++) {
            if (nums[i][j] == 2) {
                queue.offer(new int[] {i, j});
            }
        }
    }

    while (!queue.isEmpty()) {
        int size = queue.size();
        boolean added = false;
        int[][] dict = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
        for (int k = 0; k < size; k++) {
            int[] map2 = queue.poll();
            for (int[] dic : dict) {
                int m = map2[0] + dic[0];
                int n = map2[1] + dic[1];
                if (m < 0 || n < 0 || m >= len || n >= len || nums[m][n] != 1) {
                    continue;
                }

                nums[m][n] = 2;
                queue.offer(new int[] {m, n});
                if (!added) {
                    added = true;
                    minTime++;
                }
            }

        }
    }


    for (int i = 0; i < len; i++) {
        for (int j = 0; j < len; j++) {
            if (nums[i][j] == 1) {
                return -1;
            }
        }
    }

    return minTime;
}