第五章：搜索算法

一、深度优先搜索（DFS）

1、岛屿的最大面积

问题：

给你一个大小为 m x n 的二进制矩阵 grid 。

岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在 水平或者竖直的四个方向上 相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。

岛屿的面积是岛上值为 1 的单元格的数目。

计算并返回 grid 中最大的岛屿面积。如果没有岛屿，则返回面积为 0 。

示例 1：

输入：grid = [[0,0,1,0,0,0,0,1,0,0,0,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,1,1,0,1,0,0,0,0,0,0,0,0],[0,1,0,0,1,1,0,0,1,0,1,0,0],[0,1,0,0,1,1,0,0,1,1,1,0,0],[0,0,0,0,0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,0,0,0,0,0,0,1,1,0,0,0,0]]
输出：6
解释：答案不应该是 11 ，因为岛屿只能包含水平或垂直这四个方向上的 1 。
示例 2：

输入：grid = [[0,0,0,0,0,0,0,0]]
输出：0

package LeetCode.test5_sousuosuanfa;

public class ques_695_岛屿的最大面积 {
    public static void main(String[] args) {
        int[][] grid = {{0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0},
                {0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0},
                {0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0},
                {0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0}};
        System.out.println(maxAreaOfIsland(grid));
    }

    public static int maxAreaOfIsland(int[][] grid) {
        if (grid == null || grid.length == 0) {
            return 0;
        }
        int[] X = {0, 0, 1, -1};
        int[] Y = {1, -1, 0, 0};
        int max_area = 0;
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if (grid[i][j] == 1) {
                    System.out.println(DFS_maxAreaOfIsland(i, j, grid, X, Y));
//                    max_area = Math.max(DFS_maxAreaOfIsland(i, j, grid, X, Y), max_area);
                }
            }
        }
        return max_area;
    }

    public static int DFS_maxAreaOfIsland(int x, int y, int[][] grid, int[] X, int[] Y) {
        int area = 1;
        grid[x][y] = 0;
        for (int i = 0; i < 4; i++) {
            int newX = x + X[i];
            int newY = y + Y[i];
            if (newX >= 0 && newY >= 0 && newX < grid.length && newY < grid[0].length && grid[newX][newY] == 1) {
                area += DFS_maxAreaOfIsland(newX, newY, grid, X, Y);
            }
        }
        return area;
    }
}

2、省份数量

问题：

有 n 个城市，其中一些彼此相连，另一些没有相连。如果城市 a 与城市 b 直接相连，且城市 b 与城市 c 直接相连，那么城市 a 与城市 c 间接相连。

省份是一组直接或间接相连的城市，组内不含其他没有相连的城市。

给你一个 n x n 的矩阵 isConnected ，其中 isConnected[i][j] = 1表示第 i 个城市和第 j 个城市直接相连，而 isConnected[i][j] = 0 表示二者不直接相连。

返回矩阵中省份的数量。

示例 1：

输入：isConnected = [[1,1,0],[1,1,0],[0,0,1]]
输出：2
示例 2：

输入：isConnected = [[1,0,0],[0,1,0],[0,0,1]]
输出：3

package LeetCode.test5_sousuosuanfa;

public class ques_547_省份数量 {
    public static void main(String[] args) {
        int[][] isConnected = {{1, 0, 0, 1},
                {0, 1, 1, 0},
                {0, 1, 1, 1},
                {1, 0, 1, 1}};
        System.out.println(findCircleNum(isConnected));
    }

    public static int findCircleNum(int[][] isConnected) {
        //新建一个visited数组表示当前城市是否被访问
        boolean[] visited = new boolean[isConnected.length]; // 默认为false
        int res = 0; //计数
        for (int i = 0; i < isConnected.length; i++) {
            if (!visited[i]) {
                res++;  //找到一个没有访问的城市时则视为找到一个省份，再递归将所有与其相连城市设置为访问状态
                DFS_findCircleNum(isConnected, visited, i);
            }
        }
        return res;
    }

    public static void DFS_findCircleNum(int[][] isConnected, boolean[] visited, int i) {
        visited[i]=true;  //将当前探索城市设置为已访问状态
        for (int j = 0; j < isConnected.length; j++) {
            if (isConnected[i][j]==1&& !visited[j]){
                //当当前城市A与其他城市B相连接且B没有被访问到时继续递归寻找城市
                DFS_findCircleNum(isConnected,visited,j);
            }
        }
    }
}

3、太平洋大西洋水流问题

问题：

给定一个 m x n 的非负整数矩阵来表示一片大陆上各个单元格的高度。“太平洋”处于大陆的左边界和上边界，而“大西洋”处于大陆的右边界和下边界。

规定水流只能按照上、下、左、右四个方向流动，且只能从高到低或者在同等高度上流动。

请找出那些水流既可以流动到“太平洋”，又能流动到“大西洋”的陆地单元的坐标。

示例：

给定下面的 5x5 矩阵:

heights = {{1, 2, 2, 3, 5},

　　　　{3, 2, 3, 4, 4},

　　　　{2, 4, 5, 3, 1},

　　　　{6, 7, 1, 4, 5},

　　　　{5, 1, 1, 2, 4}};

返回:

[[0, 4], [1, 3], [1, 4], [2, 2], [3, 0], [3, 1], [4, 0]] 

package LeetCode.test5_sousuosuanfa;

import java.util.ArrayList;
import java.util.List;

public class ques_417_太平洋大西洋水流问题 {
    public static void main(String[] args) {
        int[][] heights = {{1, 2, 2, 3, 5},
                {3, 2, 3, 4, 4},
                {2, 4, 5, 3, 1},
                {6, 7, 1, 4, 5},
                {5, 1, 1, 2, 4}};
        System.out.println(pacificAtlantic(heights));
    }

    public static List<List<Integer>> pacificAtlantic(int[][] heights) {
        int[] X = {0, 0, 1, -1};
        int[] Y = {1, -1, 0, 0};
        int m = heights.length;
        int n = heights[0].length;
        List<List<Integer>> can_reach = new ArrayList<>();
        boolean[][] can_reach_p = new boolean[m][n];
        boolean[][] can_reach_a = new boolean[m][n];

        for (int i = 0; i < m; i++) {
            DFS_pacificAtlantic(heights, can_reach_a, i, 0, X, Y); // 左边
            DFS_pacificAtlantic(heights, can_reach_p, i, n - 1, X, Y); // 右边
        }
        for (int i = 0; i < n; i++) {
            DFS_pacificAtlantic(heights, can_reach_a, 0, i, X, Y); // 上边
            DFS_pacificAtlantic(heights, can_reach_p, m - 1, i, X, Y); // 下边
        }
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (can_reach_a[i][j] && can_reach_p[i][j]) {
                    List<Integer> can = new ArrayList<>();
                    can.add(i);
                    can.add(j);
                    can_reach.add(can);
                }
            }
        }
        return can_reach;
    }

    public static void DFS_pacificAtlantic(int[][] heights, boolean[][] can_reach, int r, int c, int[] X, int[] Y) {
        if (can_reach[r][c]) {
            return;
        }
        can_reach[r][c] = true;
        for (int i = 0; i < 4; i++) {
            int newX = r + X[i];
            int newY = c + Y[i];
            if (newX >= 0 && newY >= 0 && newX < heights.length && newY < heights[0].length && heights[r][c] <= heights[newX][newY]) {
                DFS_pacificAtlantic(heights, can_reach, newX, newY, X, Y);
            }
        }
    }
}

二、回溯法

4、全排列

问题：

给定一个不含重复数字的数组 nums ，返回其所有可能的全排列 。你可以按任意顺序返回答案。

示例 1：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
示例 2：

输入：nums = [0,1]
输出：[[0,1],[1,0]]
示例 3：

输入：nums = [1]
输出：[[1]]

package LeetCode.test5_sousuosuanfa;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
    思路：怎样输出所有的排列方式呢？对于每一个当前位置 i，可以将其于之后的任意位置交换，
    然后继续处理位置 i+1，直到处理到最后一位。为了防止每此遍历时都要新建一个子数组储
    存位置 i 之前已经交换好的数字，可以利用回溯法，只对原数组进行修改，在递归完成后再
    修改回来。
 */
public class ques_46_全排列 {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3};
        System.out.println(permute(nums));
    }

    public static List<List<Integer>> permute(int[] nums) {
        List<Integer> perm = new ArrayList<>();
        for (Integer num: nums) {
            perm.add(num);
        }
        List<List<Integer>> res = new ArrayList<>();
        backtracking(perm, 0, res);
        return res;
    }
    /*
    为什么在往结果集中添加排列结果的时候，需要进行new ArrayList添加??????
    假设这段代码，「正确」res.add(new ArrayList<>(output)); 变为「错误」res.add(output);关键在于res存放的是list引用。
    那么回溯过程中，将数字使用状态重置撤销的时候，会将list的元素移除掉，也会影响到res里面的list情况。
    因为它们是同一个引用。全部为空，是因为回溯结束的同时，会将全部数字重置撤销，这样list里面的元素就会为空了，同样的，也会影响到res的存放情况。
     */
    public static void backtracking(List<Integer> perm, int first, List<List<Integer>> res) {
        if (first == perm.size() - 1) {
            res.add(new ArrayList<>(perm));
            return;
        }
        for (int i = first; i < perm.size(); i++) {
            Collections.swap(perm,i,first);  //修改当前节点状态
            backtracking(perm,first+1,res); //递归子节点
            Collections.swap(perm,i,first); //回改当前节点状态
        }
    }
}

package LeetCode.test5_sousuosuanfa;

import java.util.ArrayList;
import java.util.List;

public class ques_46_全排列 {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3};
//        int[] nums = {1, 1, 2};
        System.out.println(permuteUnique(nums));
    }

    public static List<List<Integer>> permuteUnique(int[] nums) {
        List<Integer> perm = new ArrayList<>(); // 每种排列的容器
        List<List<Integer>> res = new ArrayList<>();  // 所有排列的容器
        boolean[] visited = new boolean[nums.length];
        backtracking(visited, 0, nums, perm, res);
        return res;
    }

    public static void backtracking(boolean[] visited, int index, int[] nums, List<Integer> perm, List<List<Integer>> res) {
        if (index == nums.length) {
            res.add(new ArrayList<>(perm));
            return;
        }
        for (int j = 0; j < nums.length; j++) {
            if (visited[j]) {
                continue;
            }
            perm.add(nums[j]);
            visited[j] = true;
            backtracking(visited, index + 1, nums, perm, res);
            visited[j] = false;
            perm.remove(index);
        }
    }
}

5、组合

问题：

给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按 任何顺序 返回答案。

示例 1：

输入：n = 4, k = 2
输出：
[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]
示例 2：

输入：n = 1, k = 1
输出：[[1]]

package LeetCode.test5_sousuosuanfa;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 思路：类似于排列问题，也可以进行回溯。排列回溯的是交换的位置，而组合回溯的是否把当前的数字加入结果中。
 */
public class ques_77_组合 {
    public static void main(String[] args) {
        int n = 4;
        int k = 2;
        System.out.println(combine(n, k));
    }

    public static List<List<Integer>> combine(int n, int k) {
        List<List<Integer>> res = new ArrayList<>();
        Integer[] perm = new Integer[k];
        int count = 0;
        backtracking(res, n, k, count, 1, perm);
        return res;
    }

    public static void backtracking(List<List<Integer>> res, int n, int k, int count, int pos, Integer[] perm) {
        if (count == k) {
            res.add(new ArrayList<>(Arrays.asList(perm)));
            return;
        }
        for (int i = pos; i <= n; i++) {
            perm[count++] = i;
            backtracking(res, n, k, count, i + 1, perm);
            count--;
        }
    }
}

6、单词搜索

问题：

给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。

单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

示例 1：

输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
输出：true
示例 2：

输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "SEE"
输出：true
示例 3：

输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCB"
输出：false

package LeetCode.test5_sousuosuanfa;

/**
 * 思路：不同于排列组合问题，本题采用的并不是修改输出方式，而是修改访问标记。在对任意
 * 位置进行深度优先搜索时，先标记当前位置为已访问，以避免重复遍历（如防止向右搜索后
 * 又向左返回）；在所有的可能都搜索完成后，再回改当前位置为未访问，防止干扰其它位置搜索
 * 到当前位置。使用回溯法，可以只对一个二维的访问矩阵进行修改，而不用把每次的搜索状
 * 态作为一个新对象传入递归函数中。
 */
public class ques_79_单词搜索 {
    public static void main(String[] args) {
        char[][] board = {{'A', 'B', 'C', 'E'},
                {'S', 'F', 'C', 'S'},
                {'A', 'D', 'E', 'E'}};
        String word = "ABCCED";
        System.out.println(exist(board, word));
    }

    public static boolean exist(char[][] board, String word) {
        int m = board.length;
        int n = board[0].length;
        boolean[][] visited = new boolean[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (backtracking(i, j, board, word, visited, 0)){
                    return true;
                }
            }
        }
        return false;
    }

    public static boolean backtracking(int i, int j, char[][] board, String word, boolean[][] visited, int pos) {
        if (i < 0 || j < 0 || i >= board.length || j >= board[0].length) {
            return false;
        }
        if (visited[i][j] || board[i][j] != word.charAt(pos)) {
            return false;
        }
        if (pos == word.length() - 1) {
            return true;
        }
        visited[i][j] = true;
        boolean res = (backtracking(i + 1, j, board, word, visited,  pos + 1)||
                        backtracking(i - 1, j, board, word, visited,  pos + 1)||
                        backtracking(i, j + 1, board, word, visited,  pos + 1)||
                        backtracking(i, j - 1, board, word, visited,  pos + 1));
        visited[i][j] = false;
        return res;
    }
}

7、N皇后

问题：

n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。

给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。

每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。

示例 1：

输入：n = 4
输出：[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]
解释：如上图所示，4 皇后问题存在两个不同的解法。
示例 2：

输入：n = 1
输出：[["Q"]]

package LeetCode.test5_sousuosuanfa;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ques_51_N皇后 {
    public static void main(String[] args) {
        int n = 4;
        System.out.println(solveNQueens(n));
    }

    public static List<List<String>> solveNQueens(int n) {
        List<List<String>> ans = new ArrayList<>();
        char[][] board = new char[n][n];
        for (int i = 0; i < n; i++) {
            Arrays.fill(board[i], '.');
        }
        //列数组长度为n
        boolean[] column = new boolean[n];
        //假设n=4：[0,1,2,3,4,5,6] 在同一45度线上的元素，row+col刚好都相等,数组长度为2*n-1  数组下标：row+col
        boolean[] diag_45 = new boolean[2 * n - 1];
        //假设n=4：[-3,-2,-1,0,1,2,3] 在同一45度线上的元素，row-col刚好都相等,数组长度为2*n-1  数组下标：n-1-(row-col)
        boolean[] diag_135 = new boolean[2 * n - 1];
        backtracking(ans, board, column, diag_45, diag_135, 0, n);
        return ans;
    }

    public static void backtracking(List<List<String>> ans, char[][] board, boolean[] column,
                                    boolean[] diag_45, boolean[] diag_135, int row, int n) {
        if (row == n) {
            List<String> list = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                list.add(String.valueOf(board[i]));
            }
            ans.add(list);
        }
        for (int col = 0; col < n; col++) {
            if (column[col] || diag_45[row + col] || diag_135[n - 1 - (row - col)]) {
                continue;
            }
            board[row][col] = 'Q'; // 修改当前节点状态
            column[col] = diag_45[row + col] = diag_135[n - 1 - (row - col)] = true;
            backtracking(ans, board, column, diag_45, diag_135, row + 1, n); // 递归子节点
            board[row][col] = '.'; // 回改当前节点状态
            column[col] = diag_45[row + col] = diag_135[n - 1 - (row - col)] = false;
        }
    }
}

三、广度优先搜索（BFS）

8、最短的桥

问题：

在给定的二维二进制数组 A 中，存在两座岛。（岛是由四面相连的 1 形成的一个最大组。）

现在，我们可以将 0 变为 1，以使两座岛连接起来，变成一座岛。

返回必须翻转的 0 的最小数目。（可以保证答案至少是 1 。）

示例 1：

输入：A = [[0,1],[1,0]]
输出：1
示例 2：

输入：A = [[0,1,0],[0,0,0],[0,0,1]]
输出：2
示例 3：

输入：A = [[1,1,1,1,1],[1,0,0,0,1],[1,0,1,0,1],[1,0,0,0,1],[1,1,1,1,1]]
输出：1

package LeetCode.test5_sousuosuanfa;

import java.util.*;

/**
 * 最短！！！
 */
public class ques_934_最短的桥 {
    public static void main(String[] args) {
        int[][] grid = {{0, 1, 0},
                        {0, 0, 0},
                        {0, 0, 1}};
//        int[][] grid = {{1, 1, 1, 1, 1},
//                {1, 0, 0, 0, 1},
//                {1, 0, 1, 0, 1},
//                {1, 0, 0, 0, 1},
//                {1, 1, 1, 1, 1}};
        System.out.println(shortestBridge(grid));
    }

    public static int shortestBridge(int[][] grid) {
        int[] X = {0, 0, 1, -1};
        int[] Y = {1, -1, 0, 0};

        // (1) dfs搜索第一个岛屿，并把1全部赋值为2
        boolean flag = false;  //保证只搜索第一个岛屿
        for (int i = 0; i < grid.length; i++) {
            if (flag) break;  //内层循环结束，外层循环也必须结束
            for (int j = 0; j < grid[0].length; j++) {
                if (grid[i][j] == 1) {
                    dfs(grid, i, j, X, Y);
                    flag = true;
                    break;
                }
            }
        }
        // (2) bfs:首先将所有的2的节点放入队列，搜索第二个岛屿，并把过程中经过的0赋值为2
        Queue<int[]> points = new LinkedList<>();
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if (grid[i][j] == 2) {
                    points.offer(new int[]{i, j});
                }
            }
        }
        int count = 0;
        while (!points.isEmpty()) {
            int size = points.size();
            for (int j = 0; j < size; j++) {
                int[] top = points.poll();
                for (int i = 0; i < 4; i++) {
                    assert top != null;
                    int newX = top[0] + X[i];
                    int newY = top[1] + Y[i];
                    if (newX < 0 || newX >= grid.length || newY < 0 || newY >= grid[0].length) {
                        continue;
                    }
                    if (grid[newX][newY] == 2) {
                        continue;
                    }
                    if (grid[newX][newY] == 1) {
                        return count;
                    }
                    grid[newX][newY] = 2;
                    points.offer(new int[]{newX, newY});
                }
            }
            count++;
        }
        return count;
    }

    public static void dfs(int[][] grid, int i, int j, int[] X, int[] Y) {
        if (grid[i][j] == 1) {
            grid[i][j] = 2;
        }
        for (int k = 0; k < 4; k++) {
            int newX = i + X[k];
            int newY = j + Y[k];
            if (newX < 0 || newX >= grid.length || newY < 0 || newY >= grid[0].length) {
                continue;
            }
            if (grid[newX][newY] == 0 || grid[newX][newY] == 2) {
                continue;
            }
            dfs(grid, newX, newY, X, Y);
        }
    }
}

9、单词接龙II

问题：（https://blog.csdn.net/zzzzz_zzz___rss/article/details/121286731）

按字典 wordList 完成从单词 beginWord 到单词 endWord 转化，一个表示此过程的 转换序列 是形式上像 beginWord -> s1 -> s2 -> ... -> sk 这样的单词序列，并满足：

每对相邻的单词之间仅有单个字母不同。
转换过程中的每个单词 si（1 <= i <= k）必须是字典 wordList 中的单词。注意，beginWord 不必是字典 wordList 中的单词。
sk == endWord
给你两个单词 beginWord 和 endWord ，以及一个字典 wordList 。请你找出并返回所有从 beginWord 到 endWord 的 最短转换序列 ，如果不存在这样的转换序列，返回一个空列表。

每个序列都应该以单词列表 [beginWord, s1, s2, ..., sk] 的形式返回。

示例 1：

输入：beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log","cog"]
输出：[["hit","hot","dot","dog","cog"],["hit","hot","lot","log","cog"]]
解释：存在 2 种最短的转换序列：
"hit" -> "hot" -> "dot" -> "dog" -> "cog"
"hit" -> "hot" -> "lot" -> "log" -> "cog"
示例 2：

输入：beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log"]
输出：[]
解释：endWord "cog" 不在字典 wordList 中，所以不存在符合要求的转换序列。

思路：

 （1）使用双向BFS的方法，每次从队列长度小的一端开始搜索。

（2）在对某一层BFS开始之前，先将队列中的全部元素进行标记。

 （3）然后开始BFS，如果遍历到的节点未被标记，那么将该节点放入队列中，如果该节点存在于另一个队列中，说明已经找到最短的路径了。

（4）此时将该层节点遍历结束后，方可进行回溯记录路径。

（5）此外，需要在遍历节点的时候，通过判断这次遍历是从后向前还是从前向后，以确定构建的图的起始节点和结束节点。

package LeetCode.test5_sousuosuanfa;

import java.util.*;

/**
 * 最短！！！
 */
public class ques_126_单词接龙II {
    public static void main(String[] args) {
        String beginWord = "hit";
        String endWord = "cog";
        String[] word = {"hot", "dot", "dog", "lot", "log", "cog"};
        List<String> wordList = new ArrayList<>(Arrays.asList(word));
        System.out.println((findLadders(beginWord, endWord, wordList)));
    }

    public static List<List<String>> findLadders(String beginWord, String endWord, List<String> wordList) {
        wordList.add(beginWord);
        // 构建一个标记集合，开始每个word都在集合中。后边每次将元素放到队列中，便将该元素从集合中删除.
        Set<String> wordListSet = new HashSet<>(wordList);
        if (!wordList.contains(endWord)) {
            return new ArrayList<>();
        }
        // 标记是不是已经找到了最短的路径，并用res来记录这些路径
        boolean found = false;
        List<List<String>> res = new ArrayList<>();
        // 构建map, 用来记录单词之间的关系
        Map<String, Set<String>> map = new HashMap<>();
        // 使用双向的BFS来检索最短的变换路径
        Queue<String> queueBegin = new LinkedList<>();
        Queue<String> queueEnd = new LinkedList<>();
        queueBegin.add(beginWord);
        queueEnd.add(endWord);
        // 每次只对比较短的BFS进行搜索，使用reverse标记两个方向的队列是不是交换过。
        boolean reverse = false;
        while (!queueBegin.isEmpty() && !queueEnd.isEmpty()) {
            if (queueBegin.size() > queueEnd.size()) {
                Queue<String> queue = queueBegin;
                queueBegin = queueEnd;
                queueEnd = queue;
                // 标记是不是转换过，如果转换过的话，需要在构建图的时候将两个节点逆转
                reverse = !reverse;
            }
            // 将上一层访问过的节点从集合中删除
            wordListSet.removeAll(queueBegin);
            // 根据queueEnd创建一个集合，用来判断遍历到的单词是不是出现在另一端遍历的队列中
            Set<String> queueEndToSet = new HashSet<>(queueEnd);
            int count = queueBegin.size();
            while (count-- > 0) {
                String top = queueBegin.poll();
                assert top != null;
                char[] tops = top.toCharArray();
                for (int i = 0; i < tops.length; i++) {
                    char c = tops[i];
                    for (char j = 'a'; j <= 'z'; j++) {
                        tops[i] = j;
                        String newStr = new String(tops);
                        // 如果当前元素存在于另一个队列中，说明找到了最短的路径
                        // 只需要将当前的两个队列遍历一遍，找到全部的结果集，而不需要再次向下遍历。
                        if (queueEndToSet.contains(newStr)) {
                            found = true;
                        }
                        // 如果未被访问过，那么将该元素放到queueBegin中。
                        if (wordListSet.contains(newStr)) {
                            queueBegin.add(newStr);
                        }
                        // 通过判断是不是reverse过，来构建节点关系图（保证其正向）
                        if (wordListSet.contains(newStr) || queueEndToSet.contains(newStr)) {
                            Set<String> subList;
                            if (reverse) {
                                subList = map.get(newStr);
                                if (subList == null) {
                                    subList = new HashSet<>();
                                }
                                subList.add(top);
                                // {dot=[dog], lot=[log], hit=[hot], hot=[lot, dot], dog=[cog], log=[cog]}
                                map.put(newStr, subList);
                            } else {
                                subList = map.get(top);
                                if (subList == null) {
                                    subList = new HashSet<>();
                                }
                                subList.add(newStr);
                                // {hit=[hot], hot=[lot, dot]}
                                map.put(top, subList);
                            }
                        }
                    }
                    tops[i] = c;
                }
            }
            // 将其放到最后进行遍历，原因在于：
            // 在构建图的时候，需要考虑到，此时两个遍历方向的队列已经到了中间层。如果得到结果就直接返回的话，肯定会导致缺少路径。
            // 因此在while(count--)之后再回溯记录路径，便会找到全部的路径
            if (found){
                List<String> path = new ArrayList<>();
                path.add(beginWord);
                dfs(map, path, res, beginWord, endWord);
                return res;
            }
        }
        return res;
    }

    // 回溯法记录路径
    public static void dfs(Map<String, Set<String>> map, List<String> path, List<List<String>> res, String beginWord, String endWord) {
        if (beginWord.equals(endWord)){
            res.add(new ArrayList<>(path));
            return;
        }
        if (map.get(beginWord)!=null){
            for (String str:map.get(beginWord)) {
                path.add(str);
                dfs(map, path, res, str, endWord);
                path.remove(str);
            }
        }
    }
}

10、单词接龙

问题：（https://blog.csdn.net/zzzzz_zzz___rss/article/details/121256294）

字典 wordList 中从单词 beginWord 和 endWord 的 转换序列 是一个按下述规格形成的序列：

序列中第一个单词是 beginWord 。
序列中最后一个单词是 endWord 。
每次转换只能改变一个字母。
转换过程中的中间单词必须是字典 wordList 中的单词。
给你两个单词 beginWord 和 endWord 和一个字典 wordList ，找到从 beginWord 到 endWord 的 最短转换序列 中的 单词数目 。如果不存在这样的转换序列，返回 0。

示例 1：

输入：beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log","cog"]
输出：5
解释：一个最短转换序列是 "hit" -> "hot" -> "dot" -> "dog" -> "cog", 返回它的长度 5。
示例 2：

输入：beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log"]
输出：0
解释：endWord "cog" 不在字典中，所以无法进行转换。

方法1：单向BFS

package LeetCode.test5_sousuosuanfa;

import java.util.*;

/**
 * 最短！！！
 * 方法1：单向BFS
 */
public class ques_127_单词接龙 {
    public static void main(String[] args) {
        String beginWord = "hit";
        String endWord = "cog";
        String[] word = {"hot","dot","dog","lot","log","cog"};
        List<String> wordList = new ArrayList<>(Arrays.asList(word));
        System.out.println((findLadders(beginWord, endWord, wordList)));
    }

    public static int  findLadders(String beginWord, String endWord, List<String> wordList) {
        // bfs的深度
        int level = 0;
        wordList.add(beginWord);
        if (!wordList.contains(endWord)) {
            return 0;
        }
        // 构建map, 用来记录单词之间的关系
        Map<String, Set<String>> wordMap = new HashMap<>();
        for (String s: wordList) {
            Set<String> set = new HashSet<>();
            for (String ss : wordList) {
                if (checkDiff(ss, s)) {  //检查ss和s是不是只有一个字符不相同
                    set.add(ss);
                }
            }
            wordMap.put(s, set);
        }
        // 标记单词是不是已经使用过
        Set<String> map = new HashSet<>();
        Set<String> tmpMap = new HashSet<>();

        // 定义一个Queue来实现bfs
        Queue<String> queue = new ArrayDeque<>();
        queue.add(beginWord);
        while (!queue.isEmpty()) {
            int count = queue.size();
            level++;
            // 将上一层bfs使用过的单词，在该层统一进行标记
            map.addAll(tmpMap);
            tmpMap.clear();
            while (count-- > 0) {
                // 拿出queue中的元素，并在list中查找与其仅有一个字符不同的单词
                String key = queue.remove();
                // 将key临时记录，并在当前循环结束之后放入map中记录，之后不再访问之
                tmpMap.add(key);
                // 在Map中获取与当前单词key直接相连的单词
                Set<String> list = wordMap.get(key);
                for (String s : list) {
                    // 找到list中未曾访问过的某个元素
                    if (!map.contains(s)) {
                        queue.add(s);
                        if (s.equals(endWord)) {
                            return level + 1;
                        }
                    }
                }
            }
        }
        return 0;
    }

    public static boolean checkDiff(String key, String str) {
        if (key == null || str == null) {
            return false;
        }
        int keyLen = key.length();
        int strLen = str.length();
        if (keyLen != strLen) {
            return false;
        }
        int count = 0;
        for (int i = 0; i < keyLen; i++) {
            if (key.charAt(i) != str.charAt(i)) {
                count++;
                if (count > 1) {
                    return false;
                }
            }
        }
        return count == 1;
    }
}

方法2：双向BFS

package LeetCode.test5_sousuosuanfa;

import java.util.*;

/**
 * 最短！！！
 * 方法2：双向BFS
 */
public class ques_127_单词接龙_2 {
    public static void main(String[] args) {
        String beginWord = "hit";
        String endWord = "cog";
        String[] word = {"hot", "dot", "dog", "lot", "log", "cog"};
        List<String> wordList = new ArrayList<>(Arrays.asList(word));
        System.out.println((findLadders(beginWord, endWord, wordList)));
    }

    public static int findLadders(String beginWord, String endWord, List<String> wordList) {
        // 两个bfs的深度
        int level = 0;
        wordList.add(beginWord);
        // 构建一个标记集合，开始每个word都在集合中。后边每次将元素放到队列中，便将该元素从集合中删除.
        Set<String> wordListSet = new HashSet<>(wordList);
        if (!wordList.contains(endWord)) {
            return 0;
        }

        // 标记单词是不是已经使用过 - 从begin处向后
        Set<String> usedBegin = new HashSet<>();
        // 标记单词是不是已经使用过 - 从end处向前
        Set<String> usedEnd = new HashSet<>();

        // 定义一个Queue来实现bfs
        Queue<String> queueBegin = new ArrayDeque<>();
        Queue<String> queueEnd = new ArrayDeque<>();
        queueEnd.add(endWord);
        queueBegin.add(beginWord);

        usedBegin.add(beginWord);
        usedEnd.add(endWord);

        while (!queueBegin.isEmpty() && !queueEnd.isEmpty()) {
            level++;
            if (queueBegin.size() > queueEnd.size()) {
                // 交换
                Queue<String> queue = queueBegin;
                queueBegin = queueEnd;
                queueEnd = queue;
                // 交换
                Set<String> set = usedBegin;
                usedBegin = usedEnd;
                usedEnd = set;
            }
            int count = queueBegin.size();
            while (count-- > 0) {
                String top = queueBegin.poll();
                assert top != null;
                char[] tops = top.toCharArray();
                for (int i = 0; i < tops.length; i++) {
                    char c = tops[i];
                    for (char j = 'a'; j <= 'z'; j++) {
                        tops[i] = j;
                        String newStr = new String(tops);
                        if (usedBegin.contains(newStr)) {
                            continue;
                        }
                        if (usedEnd.contains(newStr)) {
                            return level + 1;
                        }
                        if (wordListSet.contains(newStr)) {
                            queueBegin.add(newStr);
                            usedBegin.add(newStr);
                        }
                    }
                    tops[i] = c;
                }
            }
        }
        return 0;
    }
}

package LeetCode.test5_sousuosuanfa;

import java.util.*;

/**
 * 最短！！！
 * 方法2：双向BFS
 */
public class ques_127_单词接龙_3 {
    public static void main(String[] args) {
        String beginWord = "hit";
        String endWord = "cog";
        String[] word = {"hot", "dot", "dog", "lot", "log", "cog"};
        List<String> wordList = new ArrayList<>(Arrays.asList(word));
        System.out.println((findLadders(beginWord, endWord, wordList)));
    }

    public static int findLadders(String beginWord, String endWord, List<String> wordList) {
        wordList.add(beginWord);
        // 构建一个标记集合，开始每个word都在集合中。后边每次将元素放到队列中，便将该元素从集合中删除.
        Set<String> wordListSet = new HashSet<>(wordList);
        if (!wordList.contains(endWord)) {
            return 0;
        }
        // 两个bfs的深度
        int level = 0;
        // 构建map, 用来记录单词之间的关系
        Map<String, Set<String>> map = new HashMap<>();
        // 使用双向的BFS来检索最短的变换路径
        Queue<String> queueBegin = new LinkedList<>();
        Queue<String> queueEnd = new LinkedList<>();
        queueBegin.add(beginWord);
        queueEnd.add(endWord);
        // 每次只对比较短的BFS进行搜索，使用reverse标记两个方向的队列是不是交换过。
        boolean reverse = false;
        while (!queueBegin.isEmpty() && !queueEnd.isEmpty()) {
            level++;
            if (queueBegin.size() > queueEnd.size()) {
                Queue<String> queue = queueBegin;
                queueBegin = queueEnd;
                queueEnd = queue;
                // 标记是不是转换过，如果转换过的话，需要在构建图的时候将两个节点逆转
                reverse = !reverse;
            }
            // 将上一层访问过的节点从集合中删除
            wordListSet.removeAll(queueBegin);
            // 根据queueEnd创建一个集合，用来判断遍历到的单词是不是出现在另一端遍历的队列中
            Set<String> queueEndToSet = new HashSet<>(queueEnd);
            int count = queueBegin.size();
            while (count-- > 0) {
                String top = queueBegin.poll();
                assert top != null;
                char[] tops = top.toCharArray();
                for (int i = 0; i < tops.length; i++) {
                    char c = tops[i];
                    for (char j = 'a'; j <= 'z'; j++) {
                        tops[i] = j;
                        String newStr = new String(tops);
                        // 如果当前元素存在于另一个队列中，说明找到了最短的路径
                        if (queueEndToSet.contains(newStr)) {
                            return level + 1;
                        }
                        // 如果未被访问过，那么将该元素放到queueBegin中。
                        if (wordListSet.contains(newStr)) {
                            queueBegin.add(newStr);
                        }
                        // 通过判断是不是reverse过，来构建节点关系图（保证其正向）
                        if (wordListSet.contains(newStr) || queueEndToSet.contains(newStr)) {
                            Set<String> subList;
                            if (reverse) {
                                subList = map.get(newStr);
                                if (subList == null) {
                                    subList = new HashSet<>();
                                }
                                subList.add(top);
                                // {dot=[dog], lot=[log], hit=[hot], hot=[lot, dot], dog=[cog], log=[cog]}
                                map.put(newStr, subList);
                            } else {
                                subList = map.get(top);
                                if (subList == null) {
                                    subList = new HashSet<>();
                                }
                                subList.add(newStr);
                                // {hit=[hot], hot=[lot, dot]}
                                map.put(top, subList);
                            }
                        }
                    }
                    tops[i] = c;
                }
            }
        }
        return 0;
    }
}

练习（6道）

1、被围绕的区域

问题：

 给你一个 m x n 的矩阵 board ，由若干字符 'X' 和 'O' ，找到所有被 'X' 围绕的区域，并将这些区域里所有的 'O' 用 'X' 填充。

示例 1：

输入：board = [["X","X","X","X"],["X","O","O","X"],["X","X","O","X"],["X","O","X","X"]]
输出：[["X","X","X","X"],["X","X","X","X"],["X","X","X","X"],["X","O","X","X"]]
解释：被围绕的区间不会存在于边界上，换句话说，任何边界上的 'O' 都不会被填充为 'X'。 任何不在边界上，或不与边界上的 'O' 相连的 'O' 最终都会被填充为 'X'。如果两个元素在水平或垂直方向相邻，则称它们是“相连”的。
示例 2：

输入：board = [["X"]]
输出：[["X"]]

package LeetCode.test5_sousuosuanfa;

import java.util.Arrays;

public class ques_130_被围绕的区域 {
    public static void main(String[] args) {
        char[][] board = {{'X', 'X', 'X', 'X'},
                {'X', 'O', 'O', 'X'},
                {'X', 'X', 'O', 'X'},
                {'X', 'O', 'X', 'X'}};
//        char[][] board = {{'O', 'O', 'O'},
//                {'O', 'O', 'O'},
//                {'O', 'O', 'O'}};
        solve(board);
        System.out.println(Arrays.deepToString(board));
    }

    public static void solve(char[][] board) {
        int m = board.length;
        int n = board[0].length;
        for (int i = 0; i < m; i++) {
            dfs(board, i, 0);
            dfs(board, i, n - 1);
        }
        for (int i = 0; i < n; i++) {
            dfs(board, 0, i);
            dfs(board, m - 1, i);
        }
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (board[i][j] == 'C') {
                    board[i][j] = 'O';
                } else if (board[i][j] == 'O') {
                    board[i][j] = 'X';
                }
            }
        }
    }

    public static void dfs(char[][] board, int i, int j) {
        if (i < 0 || i >= board.length || j < 0 || j >= board[0].length || board[i][j] != 'O') {
            return;
        }
        board[i][j] = 'C';
        dfs(board, i, j + 1);
        dfs(board, i, j - 1);
        dfs(board, i + 1, j);
        dfs(board, i - 1, j);
    }
}

2、二叉树的所有路径

问题：

给你一个二叉树的根节点 root ，按 任意顺序 ，返回所有从根节点到叶子节点的路径。叶子节点是指没有子节点的节点。

示例 1：

输入：root = [1,2,3,null,5]
输出：["1->2->5","1->3"]
示例 2：

输入：root = [1]
输出：["1"]

package LeetCode.test5_sousuosuanfa;

import java.util.ArrayList;
import java.util.List;

public class ques_257_二叉树的所有路径 {
    public static void main(String[] args) {
//        String[] root = {"1", "2", "3", null, "5"};
        String[] root = {"1"};
        int index = 0;
        TreeNode bt = createBTree(root, index);
        System.out.println(binaryTreePaths(bt));
    }

    public static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode() {
        }

        TreeNode(int val) {
            this.val = val;
        }

        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }


    public static List<String> binaryTreePaths(TreeNode root) {
        List<String> paths = new ArrayList<>();
        String s = "";
        getPath(root, s, paths);
        return paths;
    }

    public static void getPath(TreeNode root, String s, List<String> paths) {
        if (root != null) {
            StringBuilder sb = new StringBuilder(s);
            sb.append(root.val);
            if (root.left == null && root.right == null) {
                paths.add(sb.toString());
            } else {
                sb.append("->");
                getPath(root.left, sb.toString(), paths);
                getPath(root.right, sb.toString(), paths);
            }
        }
    }

    public static TreeNode createBTree(String[] root, int index) {
        TreeNode rootNode;
        if (index >= root.length || root[index] == null) {
            return null;
        }
        rootNode = new TreeNode(Integer.parseInt(root[index]));
        rootNode.left = createBTree(root, 2 * index + 1);
        rootNode.right = createBTree(root, 2 * index + 2);
        return rootNode;
    }
}

3、全排列II

问题：

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

示例 1：

输入：nums = [1,1,2]
输出：
[[1,1,2],
[1,2,1],
[2,1,1]]
示例 2：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

package LeetCode.test5_sousuosuanfa;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ques_47_全排列II {
    public static void main(String[] args) {
        int[] nums = {1, 1, 2};
        System.out.println(permuteUnique(nums));
    }

    public static List<List<Integer>> permuteUnique(int[] nums) {
        List<Integer> perm = new ArrayList<>(); // 每种排列的容器
        List<List<Integer>> res = new ArrayList<>();  // 所有排列的容器
        boolean[] visited = new boolean[nums.length];
        Arrays.sort(nums);
        backtracking(visited, 0, nums, perm, res);
        return res;
    }

    public static void backtracking(boolean[] visited, int index, int[] nums, List<Integer> perm, List<List<Integer>> res) {
        if (index == nums.length) {
            res.add(new ArrayList<>(perm));
            return;
        }
        for (int j = 0; j < nums.length; j++) {
            // 重复问题：保证在填第index个数的时候重复数字只会被填入一次即可。
            // 选择对原数组排序，保证相同的数字都相邻，然后每次填入的数一定是这个数所在重复数集合中(从左往右第一个未被填过的数字)
            // eg({1, 1, 2}): index=0时，填第一个1，visited[0]=true
            //                回退回来(如何避免index=0时填入第二个1) 此时visited[0]=false
            //                保证nums[1] == nums[0]且visited[0]=false即可
            if (visited[j] || (j > 0 && nums[j] == nums[j - 1] && !visited[j - 1])) {
                continue;
            }
            perm.add(nums[j]);
            visited[j] = true;
            backtracking(visited, index + 1, nums, perm, res);
            visited[j] = false;
            perm.remove(index);
        }
    }
}

补：不包含重复数字

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> res = new ArrayList<>();
        boolean[] flag = new boolean[nums.length]; 
        helper(nums,0,flag, result,res); 
        return result;
    }

    public void helper(int[] nums,int index,boolean[] flag,List<List<Integer>> result,List<Integer> res){
        if(index == nums.length){
            result.add(new ArrayList<>(res));
            return;
        }
        for(int i=0;i<nums.length;i++){
            if(!flag[i]){
                res.add(nums[i]);
                flag[i]=true;
                helper(nums,index+1,flag,result,res);
                flag[i]=false;
                res.remove(index);
            }
        }
    }
}

4、组合总和II

问题：

给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用一次。

注意：解集不能包含重复的组合。 

示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]
示例 2:

输入: candidates = [2,5,2,1,2], target = 5,
输出:
[
[1,2,2],
[5]
]

package LeetCode.test5_sousuosuanfa;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ques_40_组合总和II {
    public static void main(String[] args) {
        int[] candidates = {10, 1, 2, 7, 6, 1, 5};
        int target = 8;
        System.out.println(combinationSum2(candidates, target));
    }

    public static List<List<Integer>> combinationSum2(int[] candidates, int target) {
        Arrays.sort(candidates);
        List<List<Integer>> res = new ArrayList<>();
        List<Integer> perm = new ArrayList<>();
        backtrack(candidates, 0, target, perm, res);
        return res;
    }

    public static void backtrack(int[] candidates, int begin, int target, List<Integer> perm, List<List<Integer>> res) {
        int sum = perm.stream().reduce(0, Integer::sum);
        if (sum == target) {
            res.add(new ArrayList<>(perm));
            return;
        }
        for (int i = begin; i < candidates.length; i++) {
            if (i > begin && candidates[i] == candidates[i - 1]) {  // 避免重复
                continue;
            }
            if (sum < target) {
                perm.add(candidates[i]);
                backtrack(candidates, i + 1, target, perm, res);
                perm.remove(perm.size() - 1);
            }else {
                break;
            }
        }
    }
}

5、解数独

问题：

编写一个程序，通过填充空格来解决数独问题。

数独的解法需 遵循如下规则：

数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）
数独部分空格内已填入了数字，空白格用 '.' 表示。

示例：

输入：board = [["5","3",".",".","7",".",".",".","."],["6",".",".","1","9","5",".",".","."],[".","9","8",".",".",".",".","6","."],["8",".",".",".","6",".",".",".","3"],["4",".",".","8",".","3",".",".","1"],["7",".",".",".","2",".",".",".","6"],[".","6",".",".",".",".","2","8","."],[".",".",".","4","1","9",".",".","5"],[".",".",".",".","8",".",".","7","9"]]
输出：[["5","3","4","6","7","8","9","1","2"],["6","7","2","1","9","5","3","4","8"],["1","9","8","3","4","2","5","6","7"],["8","5","9","7","6","1","4","2","3"],["4","2","6","8","5","3","7","9","1"],["7","1","3","9","2","4","8","5","6"],["9","6","1","5","3","7","2","8","4"],["2","8","7","4","1","9","6","3","5"],["3","4","5","2","8","6","1","7","9"]]
解释：输入的数独如上图所示，唯一有效的解决方案如下所示：

 

package LeetCode.test5_sousuosuanfa;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * 十分经典的数独题，可以利用回溯法求解。事实上对于数独类型的题，
 * 有很多进阶的搜索方法和剪枝策略可以提高速度，如启发式搜索。
 */
public class ques_37_解数独 {
    private boolean valid = false;
    // row[2][3]=True表示数字4在第2行已经出现过，当遍历到第2行的空白格时，就不能填入数字4。
    private boolean[][] row = new boolean[9][9];  // 行
    private boolean[][] col = new boolean[9][9];
    private boolean[][][] block = new boolean[3][3][9];
    // 存储空格所在位置
    private List<int[]> spaces = new ArrayList<>();

    public void solveSudoku(char[][] board) {

        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                if (board[i][j] == '.') {
                    spaces.add(new int[]{i, j});
                } else {
                    int index = board[i][j] - '0' - 1;
                    row[i][index] = col[j][index] = block[i / 3][j / 3][index] = true;
                }
            }
        }
        backtracking(board, 0);
    }

    public void backtracking(char[][] board, int pos) {
        if (pos == spaces.size()) {
            valid = true;
            return;
        }
        int[] res = spaces.get(pos);
        int i = res[0];
        int j = res[1];
        for (int index = 0; index < 9 && !valid; index++) {
            if (!row[i][index] && !col[j][index] && !block[i / 3][j / 3][index]) {
                row[i][index] = col[j][index] = block[i / 3][j / 3][index] = true;
                board[i][j] = (char) (index + '0' + 1);
                backtracking(board, pos + 1);
                row[i][index] = col[j][index] = block[i / 3][j / 3][index] = false;
            }
        }
    }

    public static void main(String[] args) {
        char[][] board = {{'5', '3', '.', '.', '7', '.', '.', '.', '.'},
                {'6', '.', '.', '1', '9', '5', '.', '.', '.'},
                {'.', '9', '8', '.', '.', '.', '.', '6', '.'},
                {'8', '.', '.', '.', '6', '.', '.', '.', '3'},
                {'4', '.', '.', '8', '.', '3', '.', '.', '1'},
                {'7', '.', '.', '.', '2', '.', '.', '.', '6'},
                {'.', '6', '.', '.', '.', '.', '2', '8', '.'},
                {'.', '.', '.', '4', '1', '9', '.', '.', '5'},
                {'.', '.', '.', '.', '8', '.', '.', '7', '9'}};
        ques_37_解数独 s = new ques_37_解数独();
        s.solveSudoku(board);
        System.out.println(Arrays.deepToString(board));
    }
}

6、最小高度树

问题：

树是一个无向图，其中任何两个顶点只通过一条路径连接。 换句话说，一个任何没有简单环路的连通图都是一棵树。

给你一棵包含 n 个节点的树，标记为 0 到 n - 1 。给定数字 n 和一个有 n - 1 条无向边的 edges 列表（每一个边都是一对标签），其中 edges[i] = [ai, bi] 表示树中节点 ai 和 bi 之间存在一条无向边。

可选择树中任何一个节点作为根。当选择节点 x 作为根节点时，设结果树的高度为 h 。在所有可能的树中，具有最小高度的树（即，min(h)）被称为 最小高度树 。

请你找到所有的 最小高度树 并按 任意顺序 返回它们的根节点标签列表。

树的 高度 是指根节点和叶子节点之间最长向下路径上边的数量。

示例 1：

输入：n = 4, edges = [[1,0],[1,2],[1,3]]
输出：[1]
解释：如图所示，当根是标签为 1 的节点时，树的高度是 1 ，这是唯一的最小高度树。
示例 2：

输入：n = 6, edges = [[3,0],[3,1],[3,2],[3,4],[5,4]]
输出：[3,4]
示例 3：

输入：n = 1, edges = []
输出：[0]
示例 4：

输入：n = 2, edges = [[0,1]]
输出：[0,1]

package LeetCode.test5_sousuosuanfa;

import java.util.*;

/**
 * 思路：从边缘开始，先找到所有出度为1的节点，然后把所有出度为1的节点进队列，然后不断地bfs，
 * 最后找到的就是两边同时向中间靠近的节点，那么这个中间节点就相当于把整个距离二分了，
 * 那么它当然就是到两边距离最小的点啦，也就是到其他叶子节点最近的节点了。
 * 出现的问题：超出内存限制
 */
public class ques_310_最小高度树 {
    public static void main(String[] args) {
        int[][] edges = {{3, 0}, {3, 1}, {3, 2}, {3, 4}, {5, 4}};
        int n = 6;
        System.out.println(findMinHeightTrees(n, edges));
    }

    public static List<Integer> findMinHeightTrees(int n, int[][] edges) {
        List<Integer> res = new ArrayList<>();
        // 如果只有一个节点，那么他就是最小高度树
        if (n == 1) {
            res.add(0);
            return res;
        }
        boolean[][] graph = new boolean[n][n];
        int[] degree = new int[n];
        for (int[] edge : edges) {
            graph[edge[0]][edge[1]] = true;
            graph[edge[1]][edge[0]] = true;
            degree[edge[0]]++;
            degree[edge[1]]++;
        }
        Queue<Integer> queue = new LinkedList<>();
        for (int i = 0; i < n; i++) {  // 把所有出度为1的节点，也就是叶子节点入队
            if (degree[i] == 1) {
                queue.offer(i);
            }
        }
        while (!queue.isEmpty()) {
            // 每层循环都要new一个新的结果集合,这样最后保存的就是最终的最小高度树了
            res = new ArrayList<>();
            int size = queue.size();
            for (int i = 0; i < size; i++) {  // eg:假设最后只剩1或者2个节点
                int top = queue.poll();
                res.add(top);
                //经典bfs，把当前节点的相邻接点都拿出来
                List<Integer> neighbors = new ArrayList<>();
                for (int j = 0; j < graph.length; j++) {
                    if (graph[j][top]) {
                        neighbors.add(j);
                    }
                }
                //把它们的出度都减1(当前节点已经不存在了)，而它的相邻节点们就有可能变成叶子节点
                for (Integer neighbor : neighbors) {
                    degree[neighbor]--;
                    if (degree[neighbor] == 1) {
                        queue.offer(neighbor);
                    }
                }
            }
        }
        return res;
    }
}

package LeetCode.test5_sousuosuanfa;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

/**
 * 思路：从边缘开始，先找到所有出度为1的节点，然后把所有出度为1的节点进队列，然后不断地bfs，
 * 最后找到的就是两边同时向中间靠近的节点，那么这个中间节点就相当于把整个距离二分了，
 * 那么它当然就是到两边距离最小的点啦，也就是到其他叶子节点最近的节点了。
 * 出现的问题：超出内存限制
 */
public class ques_310_最小高度树_2 {
    public static void main(String[] args) {
        int[][] edges = {{3, 0}, {3, 1}, {3, 2}, {3, 4}, {5, 4}};
        int n = 6;
        System.out.println(findMinHeightTrees(n, edges));
    }

    public static List<Integer> findMinHeightTrees(int n, int[][] edges) {
        List<Integer> res = new ArrayList<>();
        // 如果只有一个节点，那么他就是最小高度树
        if (n == 1) {
            res.add(0);
            return res;
        }
        // 建立图关系，在每个节点的list中存储相连节点
        List<List<Integer>> map = new ArrayList<>();  // 索引为当前节点，索引所在list中的元素与索引为相邻节点
        for (int i = 0; i < n; i++) {
            map.add(new ArrayList<>());
        }
        // 建立各个节点的出度表
        int[] degree = new int[n];

        for (int[] edge : edges) {
            map.get(edge[0]).add(edge[1]);
            map.get(edge[1]).add(edge[0]);
            degree[edge[0]]++;
            degree[edge[1]]++;
        }
        Queue<Integer> queue = new LinkedList<>();
        for (int i = 0; i < n; i++) {  // 把所有出度为1的节点，也就是叶子节点入队
            if (degree[i] == 1) {
                queue.offer(i);
            }
        }
        while (!queue.isEmpty()) {
            // 每层循环都要new一个新的结果集合,这样最后保存的就是最终的最小高度树了
            res = new ArrayList<>();
            int size = queue.size();
            for (int i = 0; i < size; i++) {  // eg:假设最后只剩1或者2个节点
                int top = queue.poll();
                res.add(top);
                //经典bfs，把当前节点的相邻接点都拿出来
                List<Integer> neighbors = map.get(top);
                //把它们的出度都减1(当前节点已经不存在了)，而它的相邻节点们就有可能变成叶子节点
                for (Integer neighbor : neighbors) {
                    degree[neighbor]--;
                    if (degree[neighbor] == 1) {
                        queue.offer(neighbor);
                    }
                }
            }
        }
        return res;
    }
}

7、迷宫找礼物

问题：给定一个二维数组，0代表能走，1代表不能走，8代表宝藏的位置，入口是二维数组的边界位置的任一个不为0的位置，求从人口到宝藏位置的最短路径，并输出路径

package Interview;

import java.util.*;

class Node {
    int x;
    int y;
    Node pre;

    public Node(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

// 问题：起点为maze四周为0的点(多个)，终点为8，列出所有起点到终点的最短路径中最短的路径。
public class test1 {
    int[] X = {0, 0, 1, -1};
    int[] Y = {1, -1, 0, 0};
    boolean[][] vis;
    ArrayList<Node> arrayList;

    public ArrayList<Node> winMazeGift(int[][] maze) {
        ArrayList<ArrayList<Node>> result = new ArrayList<>();
        for (int i = 0; i < maze.length; i++) {
            if (maze[i][0] == 0 || maze[i][0] == 8) {
                result.add(mut(i, 0, maze));
            }
            if (maze[i][maze[0].length - 1] == 0 || maze[i][maze[0].length - 1] == 8) {
                result.add(mut(i, maze[0].length - 1, maze));
            }
        }

        for (int i = 1; i < maze[0].length - 1; i++) {
            if (maze[0][i] == 0 || maze[0][i] == 8) {
                result.add(mut(0, i, maze));
            }
            if (maze[maze.length - 1][i] == 0 || maze[maze.length - 1][i] == 8) {
                result.add(mut(maze.length - 1, i, maze));
            }
        }

        int min = Integer.MAX_VALUE;
        for (ArrayList<Node> nodes : result) {
            min = Math.min(min, nodes.size());
        }

        int index = -1;
        for (int i = 0; i < result.size(); i++) {
            if (result.get(i).size() == min) {
                index = i;
            }
        }
        // 测试
        for (int j = 0; j < min; j++) {
            Node pop = result.get(index).get(j);
            System.out.println("(" + pop.x + "," + pop.y + ")");
        }

        return index == -1 ? new ArrayList<>() : result.get(index);
    }

    public ArrayList<Node> mut(int x, int y, int[][] maze) {
        ArrayList<Node> res = new ArrayList<>();
        helper(x, y, maze);
        Stack<Node> stack = new Stack<>();
        print(arrayList.get(arrayList.size() - 1), stack);
        while (!stack.isEmpty()) {
            Node pop = stack.pop();
            res.add(pop);
//            System.out.println("(" + pop.x + "," + pop.y + ")");
        }
        return res;
    }


    public void helper(int x, int y, int[][] maze) {
        vis = new boolean[maze.length][maze[0].length];
        Queue<Node> queue = new LinkedList<>();
        // 用来保存每一个出队列的节点
        arrayList = new ArrayList<>();
        queue.offer(new Node(x, y));
        vis[x][y] = true;
        while (!queue.isEmpty()) {
            Node top = queue.poll();
            arrayList.add(top);
            if (maze[top.x][top.y] == 8) {
                return;
            }
            for (int i = 0; i < 4; i++) {
                int newX = top.x + X[i];
                int newY = top.y + Y[i];
                if (judge(newX, newY, maze)) {
                    vis[newX][newY] = true;
                    Node node = new Node(newX, newY);
                    queue.offer(node);
                    node.pre = top;
                }
            }
        }
    }

    public boolean judge(int newX, int newY, int[][] maze) {
        if (newX < 0 || newY < 0 || newX >= maze.length || newY >= maze[0].length) {
            return false;
        }
        if (maze[newX][newY] == 1 || vis[newX][newY]) {
            return false;
        }
        return true;
    }

    public void print(Node node, Stack<Node> stack) {
        stack.push(node);
        if (node.pre != null) {
            print(node.pre, stack);
        }
    }

}

class Test_test1 {
    public static void main(String[] args) {
        test1 t = new test1();

        int[][] maze = {{0, 1, 1, 1},
                {0, 0, 0, 1},
                {1, 0, 8, 1},
                {1, 0, 1, 1}};

//        int[][] maze = {{0, 1, 1, 1},
//                {8, 0, 0, 1},
//                {1, 0, 0, 1},
//                {1, 0, 1, 1}};

//        int[][] maze = {{0, 0, 1, 1, 1, 1, 1, 1, 1, 1},
//                {1, 0, 0, 1, 0, 0, 0, 1, 0, 1},
//                {1, 0, 0, 1, 0, 0, 0, 1, 0, 1},
//                {1, 0, 0, 0, 0, 1, 1, 0, 0, 1},
//                {1, 0, 1, 1, 1, 0, 0, 0, 0, 1},
//                {1, 0, 0, 0, 1, 0, 0, 0, 0, 1},
//                {1, 0, 1, 0, 0, 0, 1, 0, 0, 1},
//                {1, 0, 1, 1, 1, 0, 1, 1, 0, 1},
//                {1, 1, 0, 0, 0, 0, 0, 0, 8, 1},
//                {1, 1, 1, 1, 1, 1, 1, 1, 1, 1}};

        System.out.println(t.winMazeGift(maze));
    }
}

8、电话号码的自由组合

问题：给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按任意顺序返回。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

 

示例 1：

输入：digits = "23"
输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]
示例 2：

输入：digits = ""
输出：[]
示例 3：

输入：digits = "2"
输出：["a","b","c"]

class Solution {
    public List<String> letterCombinations(String digits) {
        List<String> result = new ArrayList<>();
        if(digits == null || digits.isEmpty()){
            return result;
        }
        char[][] temp = {{'a','b','c'},{'d','e','f'},{'g','h','i'},{'j','k','l'},{'m','n','o'},{'p','q','r','s'},{'t','u','v'},{'w','x','y','z'}};
        Queue<String> queue = new LinkedList<>();
        queue.add("");
        while(queue.peek().length()!=digits.length()){
            String top = queue.poll();
            char[] temps = temp[digits.charAt(top.length()) - '2'];
            for(int i=0;i<temps.length;i++){
                queue.offer(top+temps[i]);
            }
        }
        while(!queue.isEmpty()){
            result.add(queue.poll());
        }
        return result;
    }
}