广度优先搜索一层一层地进行遍历，每层遍历都以上一层遍历的结果作为起点，遍历一个距离能访问到的所有节点。需要注意的是，遍历过的节点不能再次被遍历。
每一层遍历的节点都与根节点距离相同。设 di 表示第 i 个节点与根节点的距离，推导出一个结论：对于先遍历的节点 i 与后遍历的节点 j，有 di <= dj。利用这个结论，可以求解最短路径等 最优解 问题：第一次遍历到目的节点，其所经过的路径为最短路径。应该注意的是，使用 BFS 只能求解无权图的最短路径，无权图是指从一个节点到另一个节点的代价都记为 1。
在程序实现 BFS 时需要考虑以下问题：
队列：用来存储每一轮遍历得到的节点；
标记：对于遍历过的节点，应该将它标记，防止重复遍历。
1.计算在网格中从原点到特定点的最短路径长度
/*
* 计算在网格中从原点到特定点的最短路径长度
* 在一个 N × N 的方形网格中，每个单元格有两种状态：空（0）或者阻塞（1）。
* */
public int shortestPathBinaryMatrix(int[][] grid) {
int direction[][] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}, {1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
int n = grid.length;
Queue<Pair<Integer, Integer>> queue = new LinkedList<>();
if (grid[0][0] == 0) {
if (n == 1) return 1;
queue.add(new Pair<>(0, 0));
}
int path = 0;
while (!queue.isEmpty()) {
int size = queue.size();
path++;
while (size-- != 0) {//把每层的节点遍历完
Pair<Integer, Integer> curElem = queue.poll();
int x = curElem.getKey();
int y = curElem.getValue();
for (int i = 0; i < 8; i++) {
int curx = direction[i][0] + x, cury = direction[i][1] + y;
if (curx < 0 || curx >= n || cury < 0 || cury >= n || grid[curx][cury] == 1) continue;
if (curx == n - 1 && cury == n - 1) return path + 1;
queue.add(new Pair<>(curx, cury));
grid[curx][cury] = 1;//标记一下已走过
}
}
}
return -1;
}
2. 组成整数的最小平方数数量
/*
* 题目：完全平方数
* 描述：给定正整数 n，找到若干个完全平方数（比如 1, 4, 9, 16, ...）使得它们的和等于 n。
* 你需要让组成和的完全平方数的个数最少。
* 分析：
* 可以将每个整数看成图中的一个节点，如果两个整数之差为一个平方数，那么这两个整数所在的节点就有一条边。
* 要求解最小的平方数数量，就是求解从节点 n 到节点 0 的最短路径。
* 本题也可以用动态规划求解
* */
public int numSquares(int n) {
if (n == 0) return 0;
List<Integer> squares = squareWithinN(n);
Queue<Integer> queue = new LinkedList<>();
queue.add(n);
int book[] = new int[n];
int path = 0;
while (!queue.isEmpty()) {
int size = queue.size();
path++;
while (size-- != 0) {
int cur = queue.poll();
for (Integer square : squares) {
int newNode = cur - square;
if (newNode < 0) break;
if (newNode == 0) return path;
if (book[newNode] == 1) continue;
queue.add(newNode);
book[newNode] = 1;
}
}
}
return -1;
}
//求n以内的平方数
public List<Integer> squareWithinN(int n) {
List<Integer> squares = new LinkedList<>();
for (int a = 1; a <= Math.sqrt(n); a++) {
squares.add(a * a);
}
return squares;
}
3. 最短单词路径
/*
* 题目：给定两个单词（beginWord 和 endWord）和一个字典，找到从 beginWord 到 endWord 的最短转换序列的长度。
* 转换需遵循如下规则：
* 每次转换只能改变一个字母
* 转换过程中的中间单词必须是字典中的单词。
* 说明:
* 如果不存在这样的转换序列，返回 0。所有单词具有相同的长度。所有单词只由小写字母组成。字典中不存在重复的单词。你可以假设 beginWord 和 endWord 是非空的，且二者不相同。
*
* */
public int ladderLength(String beginWord, String endWord, List<String> wordList) {
int n = wordList.size();
/*判断endWord是否在字典中，并找到所在位置*/
int endWordIndex = -1;
for (int i = 0; i < n; i++) {
String word = wordList.get(i);
if (word.equals(endWord)) {
endWordIndex = i;
break;
}
}
if (endWordIndex == -1) return 0;
/*建立一个连通图，graph[i]中存储着第i个词可转化为字典中其它哪些词*/
wordList.add(beginWord);
n = wordList.size();
List<Integer> gragh[] = new List[n];
for (int i = 0; i < n; i++) {
List<Integer> curlist = new LinkedList<>();
String curWord = wordList.get(i);
for (int j = 0; j < i; j++) {
String otherWord = wordList.get(j);
if (isConnect(curWord, otherWord)) {
curlist.add(j);
gragh[j].add(i);
}
}
gragh[i] = curlist;
}
/*广度优先搜索*/
return findLadderLength(gragh, wordList, endWordIndex);
}
public int findLadderLength(List<Integer>[] gragh, List<String> wordList, int endWordIndex) {
Queue<Integer> queue = new LinkedList<>();
int n = gragh.length;
boolean book[] = new boolean[n];
queue.add(n - 1);
int path = 1;
while (!queue.isEmpty()) {
int size = queue.size();
path++;
while (size-- != 0) {
int index = queue.poll();
List<Integer> linkit = gragh[index];
for (int curlinkIndex : linkit) {
if (curlinkIndex == endWordIndex) return path;
if (book[curlinkIndex]) continue;
queue.add(curlinkIndex);
book[curlinkIndex] = true;
}
}
}
return 0;
}
/*判断s1和s2是否可以互相转化*/
public boolean isConnect(String s1, String s2) {
int differ = 0;
for (int i = 0; i < s1.length(); i++) {
if (s1.charAt(i) != s2.charAt(i)) {
differ++;
}
}
return differ == 1;
}
