广度优先遍历（BFS）的解题思路

通常用于求解无向图的最短路径问题
1 用队列保存与当前节点直接相连的节点
2 用数组记录每个节点是否遍历过，防止重复遍历

LeetCode中应用题目：
279 组成整数的最小平方数数量
127 最短单词路径

基本应用场景：计算在网格中从起点到终点的最短路径长度
[[1,1,0,1],
[1,0,1,0],
[1,1,1,1],
[1,0,1,1]]
1 表示可以经过某个位置，求解从 (0, 0) 位置到 (tr, tc) 位置的最短路径长度。

public int minPathLength(int[][] grids, int tr, int tc) {
    final int[][] direction = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
    final int m = grids.length, n = grids[0].length;
    Queue> queue = new LinkedList<>();
    queue.add(new Pair<>(0, 0));
    int pathLength = 0;
    while (!queue.isEmpty()) {
        int size = queue.size();
        pathLength++;
        while (size-- > 0) {
            Pair cur = queue.poll();
            int cr = cur.getKey(), cc = cur.getValue();
            grids[cr][cc] = 0; // 标记
            for (int[] d : direction) {
                int nr = cr + d[0], nc = cc + d[1];
                if (nr < 0 || nr >= m || nc < 0 || nc >= n || grids[nr][nc] == 0) {
                    continue;
                }
                if (nr == tr && nc == tc) {
                    return pathLength;
                }
                queue.add(new Pair<>(nr, nc));
            }
        }
    }
    return -1;
}

变种题思想：同样是求解最短步数，主要是如何构建图
例如LeetCode 279 组成整数的最小平方数数量
输入n = 12, 返回3 （12 = 4 + 4 + 4）;
输入n = 13, 返回2 （13 = 4 + 9）。
可以理解为0到n的最短距离，如果两个数之间相差一个平方数，就认为这两个数之间有一条边，从而转换为BFS的基本应用场景

public int numSquares(int n) {
    List squares = generateSquares(n);
    Queue queue = new LinkedList<>();
    boolean[] marked = new boolean[n + 1];
    queue.add(n);
    marked[n] = true;
    int level = 0;
    while (!queue.isEmpty()) {
        int size = queue.size();
        level++;
        while (size-- > 0) {
            int cur = queue.poll();
            for (int s : squares) {
                int next = cur - s;
                if (next < 0) {
                    break;
                }
                if (next == 0) {
                    return level;
                }
                if (marked[next]) {
                    continue;
                }
                marked[next] = true;
                queue.add(next);
            }
        }
    }
    return n;
}

ivate List generateSquares(int n) {
    List squares = new ArrayList<>();
    int square = 1;
    int diff = 3;
    while (square <= n) {
        squares.add(square);
        square += diff;
        diff += 2;
    }
    return squares;
}