回溯算法（例题详细解析）

    public static void main(String[] args) {
        int n;
        Scanner scanner=new Scanner(System.in);
        n=scanner.nextInt();
        //为什么数组要多创建一个空间 因为0下标的用不上 从1开始计数并且使用
        //此处也是看需求而定
        int [] boxs=new int[n+1];  //盒子
        int [] books=new int[n+1]; //准备一数组标记值
        Dfs(1,n,boxs,books); //深度优先遍历
    }
    private static void Dfs(int index, int n, int[] boxs, int[] books) {
        //判定盒子是否是装满的 为啥index == n+1 因为 Dfs要多执行一次 所以index会在原有个数上多一
        if(index==n+1){
            //以下是为了打印 能到底层的路径
            for(int i=1;i<=n;i++){
                System.out.print(boxs[i]+" ");
            }
            System.out.println();
            return ;
        }
        for(int i=1;i<=n;i++){
            if(books[i]==0){  //第 i 号牌仍在手上 说明还没有被用，就是还没有被标记
                //  把当前还没有进行标记的值 赋值给盒子
                boxs[index]=i;
                books[i]=1;    //这个值 已经给了一个盒子，这个值就不能再用了，需要标记一下
                //处理下一个盒子  下面参数 index+1 就表示下一个盒子
                Dfs(index+1,n,boxs,books);
                //无论什么情况回溯 都需要 将本值的标记取消，因为该值能回退，说明已经用过了
                books[i]=0;
            }
        }
    }

1.2、员工的重要性

使用方法：深度优先搜索

题目源于力扣：力扣

题目描述：给定一个保存员工信息的数据结构，它包含了员工 唯一的 id ，重要度 和 直系下属的 id 。

比如，员工 1 是员工 2 的领导，员工 2 是员工 3 的领导。他们相应的重要度为 15 , 10 , 5 。那么员工1的数据结构是[1,15,[2]],员工2的数据结构是[2,10,[3]],员工3的数据结构是[3,5,[]]。(图解)

题目最终求解：所有员工重要度一共是多少(也就是所有员工重要度加起来）

代码解析（附加注释）：

class Employee {
    public int id;  //员工号
    public int importance;  //该员工的重要度
    public List<Integer> subordinates; //存放下级员工id
};
public class GetImportanceTest {
    public int getImportance(List<Employee> employees,int id){
        // 每次都是向下级递归 如果当前级别已经没有下级了也就是空 此处结束 回退
        if(employees.isEmpty()){
            return 0;
        }
        //以下的 Map 存放的是 的是员工的 id  和  员工的整个信息
        Map<Integer,Employee> info=new HashMap<>();
        //存入所有的员工的信息
        for(Employee e:employees){
            //key存放员工 id  同时value对应员工的所有信息
            info.put(e.id, e);
        }
        //使用DFS 实现回溯 加 每个员工的重要度
        return DFS(info,id);
    }

    private int DFS(Map<Integer, Employee> info, int id) {
        //首先获得下级的id 准备向下递归
        Employee cur=info.get(id);
        //获取当前员工的 重要度
        int curSum=cur.importance; 
        // 将下级进行深度优先搜索  如果没有下级就  “回溯”
        for(int curd:cur.subordinates){
            curSum+=DFS(info,curd);
        }
        return curSum;
    }
}

1.3、图像渲染

使用方法：深度优先搜索

题目源于力扣：力扣

题目描述：我们照相的话知道像素，如果使用ps这样的工具把图片拉大了，能看见一小块一小块的图案带有颜色，对题的理解基本如上，如果能够实现相同点数的位置用同一种颜色，就是图像渲染

如何完成上色，从初识像素开始，把和初始坐标开始，颜色值相同的点的颜色全部改为新的颜色，并且只要某个点颜色被更改，则继续以此点周围渲染

代码解析（附加注释）：

    //图像渲染
    //对应参数分别是  当前颜色值使用二维数组表示  当前颜色点的位置 行：srow 列：scol
    //newColor 是新颜色位置
    //四个方位 顺时针建立
    int[][] nextPosition={{0,1},{1,0},{0,-1},{-1,0}};   //从左向右分别代表上右下左
    public int[][] floodFill(int[][] image,int srow,int scol,int newColor){
        //要知道原来的颜色是什么值
        int oldColor =image[srow][scol];
        //当前渲染的 行 和 列 有多大
        int row=image.length;   //行
        int col=image[0].length;  //列
        //建立标记
        int[][] book=new int[row][col];
        //深度遍历同时 回溯
        DFS(image,row,col,book,srow,scol,oldColor,newColor);
        return image;
    }
    private void DFS(int[][] image, int row, int col, int[][] book, int srow, int scol, int oldColor, int newColor) {
        // 修改当前位置的颜色 并且做已标记 ，标记表示已经修改过了
        image[srow][scol]=newColor;
        book[srow][scol]=1;
        for(int k=0;k<4;k++){
            //k 在这里是以4为限制 表示给四个方位逐一加一次
            //处理行 新的行坐标
            int newSrow=srow+nextPosition[k][0];
            //处理列 新的列坐标
            int newScol=scol+nextPosition[k][1];
            //防止向四周进行越界
            if(newSrow>=row||newSrow>0||newScol<0||newScol>=col){
                continue;
            }
            //满足两个条件就可以改色了
            // 第一个就是该颜色是要改的颜色
            // 第二个就是该颜色没有被改过 也就就是没有被标记过
            if(image[newSrow][newScol]==oldColor&&book[newSrow][newScol]!=1){
                //只有进入递归才能 在下一次进行改色
                DFS(image,row,col,book,newSrow,newScol,oldColor,newColor);
            }
        }
    }

1.4、被围绕的区域

使用方法：深度优先搜索

题目源于力扣：力扣

本题的意思被包围的区间不会存在于边界上，所以边界上的o以及与o联通的都不算做包围，只要把边界上的o以及yu之联通的o进行特殊处理，剩下的o替成x即可。故问题转化为，如何寻找和边界联通的o，我们需要考虑如下情况。

代码解释（附加注释）：

    //四个方位 移动
    int[][] nextPosition={{0,1},{1,0},{0,-1},{-1,0}};
    public void dfs(char[][] board,int row,int col,int i,int j){
        //当前位置设为 ‘*’   说了将边界上的o 改为特殊值 进行保存
        board[i][j]='*';
        for(int k=0;k<4;k++){
            //向四个方向扩散
            int ni=i+nextPosition[k][0];
            int nj=j+nextPosition[k][1];
            //判断边界
            if(ni<0||ni>=row||nj<0||nj>=col){
                continue;
            }
            //是 ‘o’ 说明和边界联通 继续搜索是否有联通的
            //只要不等于 *   且不等于 X   一共只有三种标志
            if(board[ni][nj]!='*'&&board[ni][nj]!='X'){
                dfs(board,row,col,ni,nj);
            }
        }
    }
    public void solve(char[][] board){
        if(board.length==0){
            return ;
        }
        //寻找边上的每一个0 ，如果每一
        //表示所有的0都被包围
        int row =board.length;
        int col =board[0].length;
        //寻找第一行和最后一行
        for(int j=0;j<col;j++){
            //首先就是找第一行 的 o 进行处理 
            if(board[0][j]=='O'){
                //将o改值 用来保存边界的o
                dfs(board,row,col,0,j);
            }
            //然后就是最后一行 的 o 进行处理 
            if(board[row-1][j]=='O'){
                //将o改值 用来保存边界的o
                dfs(board,row,col,row-1,j);
            }
        }
        //寻找第一列和最后一列
        for(int i=0;i<row;i++){
            //首先就是找第一列 的 o 进行处理
            if(board[i][0]=='O'){
                //将o改值 用来保存边界的o
                dfs(board,row,col,i,0);
            }
            //然后就是最后一列 的 o 进行处理
            if(board[0][col-1]=='O'){
                //将o改值 用来保存边界的o
                dfs(board,row,col,i,col-1);
            }
        }
        //以上是处理好边界的 o 进行保存的操作 
        for(int i=0;i<row;i++){
            for(int j=0;j<col;j++){
                //从头到尾进行判断是否是 * 因为此时的边界相关的o 已经做了改值处理 进行保存
                if(board[i][j]=='*'){
                    //将原来改为 ‘*’ 的位置 改回来O 因为都边界相关
                    board[i][j]='O';
                }else if(board[i][j]=='O'){ //将中间部分并且是与边界无连接的O进行转变为 X
                    board[i][j]='X';
                }
            }
        }
    }

1.5、电话号码的字母组合

使用方法：深度优先搜索

题目源于力扣：力扣

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

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

代码解析（附加注释）：

    //对应不同编号的 2 - 9 电话的英文字母
    String[] mapString={"","","abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
    private void backTrace(String digits, List<String> ret, StringBuilder curStr, int curDepth) {
        //边界 找到一种组合 ，放入数组中，结束此路径 向上回溯
        if(curDepth==digits.length()){
            if(curStr.length()!=0){
                ret.add(curStr.toString());
            }
            return ;
        }
        //找到当前字符在String映射表中的位置  等到对应的下标
        int curMapIndex=digits.charAt(curDepth)-'0';
        //对应字符串
        String curMap=mapString[curMapIndex];
        //遍历每一种可能的组合
        for(int i=0;i<curMap.length();i++){
            //第一个参数 是输入的数字字符串
            //第二个参数 存储所有结果集合
            //第三个参数 是可变的字符串
            //第四个参数 curDepth输入数字字符串的当前下标
            backTrace(digits,ret,curStr.append(curMap.charAt(i)),curDepth+1);
            //回溯的同时 要取消当前可变字符串进行处理 减少一个位置
            curStr.deleteCharAt(curStr.length()-1);
        }
    }
    public List<String>  letterCombination(String digits){
        //用来存储不同情况的子串
        List<String> ret=new ArrayList<>();
        //处理可变的字符串
        StringBuilder curStr=new StringBuilder("");
        //回溯位置
        backTrace(digits,ret,curStr,0);
        return ret;
    }

1.6、组合总和

使用方法：深度优先搜索

题目源于力扣：力扣

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

此题相加的元素可以重复，所以去下一个元素的位置可以从当前位置开始，DFS+回溯为了保证组合不重复（顺序不同，元素相同，也算重复），不再从当前位置向前看

1.从第一个元素开始相加

2.让局部和继续累加候选的剩余值

3.局部和等于目标值，保存组合，向上回退，寻找其它组合

代码解析（附加注释）：

    public List<List<Integer>> combinationSum(int[] candidates,int target){
        //存放能够组合起来等于 target的组合
        List<Integer> solution=new ArrayList<>();
        //存放不同情况的集合
        List<List<Integer>> solutions=new ArrayList<>();
        //如果这个数组没有值的话  就找不到目标
        if(candidates.length==0){
            return solutions;
        }
        int curSum=0; //计算相加值 与 target对比
        dfs(candidates,solutions,solution,curSum,0,target);
        return solutions;
    }
    private void dfs(int[] candidates, List<List<Integer>> solutions, List<Integer> solution, int curSum, int prevPosition, int target) {
        //边界，如果大于等于目标，则结束
        if(curSum>=target){
            //等于目标 ，找到一个组合
            if(curSum==target){
                List<Integer> news=new ArrayList<>();
                //如果值对应位置
                for(int e: solution){
                    //需要进行拷贝
                    news.add(e);
                }
                //拷贝完成后 ，放入结果集中
                solutions.add(news);
            }
            return ;
        }
        //可以从上一个位置开始 ，因为元素可以重复
        for(int i=prevPosition;i< candidates.length;i++){
            //单个值已经大于目标 ，直接跳过
            if(candidates[i]>target){
                continue;
            }
            //将当前 直接假如
            solution.add(candidates[i]);
            //继续进行可以执行重复数字
            dfs(candidates,solutions,solution,curSum+candidates[i],i,target);
            //回溯 向上回退 删除当前位置
            solution.remove(solution.size()-1);
        }
    }

1.7、活字印刷

使用方法：深度优先搜索

题目源于力扣：力扣

有一套活字字模 tiles，其中每个字模上都刻有一个字母 tiles[i]。返回你可以印出的非空字母序列的数目。

此题组合的长度不唯一，最小组合长度为1，最大组合长度为tiles的长度

按照题意tiles中每一个位置的字符在组合中只能出现一次，所以可以用一个标记辅助

当去组合新的组合时，可以与tiles中的每一个位置组合，但是如果当前位置已经在当前组合中出现过，则跳过虽然此题中每一个位置字符在组合中只能出现一次，但是tiles中可能有相同的字符，所以需要考虑重复的组合

DFS + 回溯

1.当前组合不为空，则插入set中

2.继续给当前组合拼接新的组合，尝试拼接tiles每一个位置的字符

3.如果当前位置已在组合中出现过，返回到2，否则标记当前位置，继续拼接更长的组合的

4.回溯，尝试组合其它位置，返回2

当所有位置都已经使用过时，当前递归就结束了，继续向上层DFS回退（图解）

代码解析（附加注释）：

    public int numTilepossibilities(String tiles){
        if(tiles.length()==0){
            return 0;
        }
        //set 天生去重
        Set<String> totalString =new HashSet<>();
        //标记全部初始化为未使用
        List<Integer> usedIndex=new ArrayList<>();
        //针对 活字模板   将模板的值进行标记 为 0
        for(int i=0;i<tiles.length();i++){
            usedIndex.add(0);
        }
        // 可变字符串 存储当前的字符串
        StringBuilder curStr=new StringBuilder("");
        //将所有字符串进行遍历
        dfs(tiles,curStr,usedIndex,totalString);
        return  totalString.size();
    }
    private void dfs(String tiles, StringBuilder curStr, List<Integer> usedIndex, Set<String> totalString) {
        //是以不同个数模板进行 
        if(curStr.length()!=0){
            totalString.add(curStr.toString());
        }
        //标记保证所有位都用完之后 就结束了
        for(int i=0;i<tiles.length();i++){
            //当前位置的字符已用过，直接跳过
            if(usedIndex.get(i)==1){
                continue;
            }
            //如果种类情况没有，那就设置为1
            usedIndex.set(i,1);
            //此处添加 字符，逐一枚举
            dfs(tiles,curStr.append(tiles.charAt(i)),usedIndex,totalString);
            //回溯 ，尝试其他字符
            usedIndex.set(i,0);
            //同时去除掉字符串的位置
            curStr.deleteCharAt(curStr.length()-1);
        }
    }

1.8、N皇后

使用方法：深度优先搜索

题目源于力扣：力扣

题目描述：N皇后问题：把N个皇后放值N*N的二维矩阵中，保证他们相互不能攻击：既不在同一行，同一列，同一个斜线上（三种可能情况）

思想：DFS + 回溯

从第一行开始放置皇后，每确定一个位置，判断是否会冲突：是否在同一列，同一行，或者同一斜线，当前行位置确定之后，继续确定下一行的位置回退，尝试当前行的其他位置

代码解析（附加注释）：

class pair{
    public  int x;          //横坐标
    public  int y;          //纵坐标
    public pair(int x ,int y){//传参
        this.x=x;
        this.y=y;
    }
}
public class SolveNQueensTest {
    public List<List<String>> solveNQueens(int n){
        //按坐标位置存放所有解决方案   存放结果集
        List<List<pair>> solutions=new ArrayList<>();
        //存放一种解决方案中的所有皇后的位置   存放结果
        List<pair> solution=new ArrayList<>();

        nQueensBackTrack(solutions,solution,0,n);
        //把坐标位置转成String
        return transResult(solutions,n);
    }
    private List<List<String>> transResult(List<List<pair>> solutions, int n) {
        List<String> tmp=new ArrayList<>();
        //把每一种解决方案都转换为String 形式 ，最终结果
        List<List<String>> ret=new ArrayList<>();
        for(List<pair> solution : solutions){
            //n*n char : 每行有n个元素 把皇后的位置修改为 Q 
            List<StringBuilder> solutionString=new ArrayList<>();
            //针对每一行
            for(int i=0;i<n;i++){
                StringBuilder sb=new StringBuilder();
                //针对当前行的每个位置 
                for(int j=0;j<n;j++){
                    sb.append('.');
                }
                //每行的结果集进行存放
                solutionString.add(sb);
            }
            //以所有行都已经赋值了 .  但是皇后还没有附上
            for(pair i:solution){
                solutionString.get(i.x).setCharAt(i.y,'Q');
            }
            //直接拷贝
            List<String> curRet=new ArrayList<>();
            //将所有的 集合中的每行都存放起来
            for(StringBuilder sb : solutionString){
                curRet.add(sb.toString());
            }
            //最终存储到结果集
            ret.add(curRet);
        }
        return ret;
    }
    private boolean nQueensBackTrack(List<List<pair>> solutions, List<pair> solution, int curRow, int n) {
        //如果可以话 说明当前情况已经符合条件了将符合条件进行拷贝存储
        if(curRow==n){
            List<pair> newS=new ArrayList<>();
            //进行拷贝
            for(pair p:solution){
                newS.add(p);
            }
            //放入结果集中
            solutions.add(newS);
        }
        //尝试当前行的每一个位置是否可以放置一个皇后
        for(int col=0;col<n;col++){
            //判断是否在 米 字 方向上 如果不在就向下进行
            if(isValid(solution,curRow,col)){
                //如果可以， 在保存当前位置 ，继续确定下一行皇后的位置
                //直接调用构造函数 ，内部构造 pair 或者调用make_pair
                solution.add(new pair(curRow,col));
                nQueensBackTrack(solutions,solution,curRow+1,n);
                //回溯 删除当前位置，尝试当前行的其他位置
                solution.remove(solution.size()-1);
            }
        }
    }
    //solution : 一个解决方案 ，从第一行开始到当前行的上一行每一行已经放置皇后的点
    private boolean isValid(List<pair> solution, int row, int col) { //判断当前行尝试的皇后位置是否和前面几行的皇后位置有冲突
        // i.second == col  第i个皇后与当前这个点在同一列
        // i.first+i.second =row + col 第i个皇后与当前点在反斜杠 横坐标 + 纵坐标值相同
        // i.first+i.second =row - col 第i个皇后与当前点在正斜杠 横坐标 - 纵坐标值相同
        for(pair i: solution){
            if(i.y==col||i.x+i.y==row+col||i.x-i.y==row-col){
                return false;
            }
        }
        return true;
    }
}

2、广度优先搜索

2.1、迷宫问题

使用方法：广度优先搜索

题目源于力扣：力扣

迷宫问题：假设有一个迷宫，里面有障碍物，迷宫用二维矩阵表示，标记为0的地方表示可以通过，标记为1的地方表示障碍物，不能通过。现在给一个迷宫出口，让你判断是否可以从入口进来之后，走出迷宫，每次可以向任意方向走。（图解）

代码解析（附加注释）：

class  node{
    public int x;    //节点 横坐标
    public int y;    //节点 纵坐标
    public node(int x,int y){
        this.x=x;
        this.y=y;
    }
}
public class MazeTest {
    public static void main(String[] args) {
        int sx,sy,ex,ey;
        int m,n;
        System.out.println("请输入迷宫的大小：行、列");
        Scanner scanner=new Scanner(System.in);
        m= scanner.nextInt();
        n= scanner.nextInt();
        //创建一个数组
        int[][] graph=new int[m][n];
        System.out.println("请输入迷宫的元素");
        //给迷宫所有位置附加值
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                graph[i][j]=scanner.nextInt();
            }
        }
        //入口 和 出口 
        while(true){
            System.out.println("请输入迷宫入口和出口");
            // 入口的下标
            sx=scanner.nextInt();
            sy=scanner.nextInt();
            // 出口的下标
            ex=scanner.nextInt();
            ey=scanner.nextInt();
            
            System.out.println("是否可以走出迷宫");
            //进行广度优先搜索 
            BFS(graph,sx,sy,ex,ey);
            System.out.println();
        }
    }
    private static boolean BFS(int[][] graph, int startx, int starty, int destx, int desty) {
        //迷宫的大小
        int m=graph.length;
        int n=graph[0].length;
        //存储迷宫中的位置
        Queue<node> q=new LinkedList<>();
        //标记迷宫中的位置是否被走过
        int[][] book=new int[m][n];
        //将当前第一个节点 放入 队列中
        q.offer(new node(startx,starty));
        //标记已经走过
        book[startx][starty]=1;
        //四个行走的方向 左右下上
        int[][] next={{-1,0},{1,0},{0,-1},{0,1}};
        //标记是否可以出去
        boolean flag=false;  //此处用来判定 是否找到最终位置
        while(!q.isEmpty()){
            //当前位置带出所有新的位置，可以向上下左右走
            for(int i=0;i<4;i++){
                //计算新的位置
                int nx=q.peek().x+next[i][0];
                int ny=q.peek().y+next[i][1];
                //新的位置越界，继续下一个
                if(nx>=m||nx<0||ny>=n||ny<0){
                    continue;
                }
                //如果新的位置无障碍并且之前也没有走过，保存新的位置
                if(graph[nx][ny]==0&&book[nx][ny]==0){
                    q.offer(new node(nx,ny));
                    //标记已被走过
                    book[nx][ny]=1;
                }
                //如果新的位置为目标位置，则结果查找
                if(nx==destx&&ny==desty){
                    flag=true;
                    break;
                }
            }
            //判定为了结束外界循环
            if(flag){
                break;
            }
            //否则，用新的位置继续向后走
            q.poll();
        }
        return flag;
    }
}

2.2、腐烂的橘子

使用方法：广度优先搜索

题目源于力扣：力扣

本题可以先找到所有的腐烂橘子，入队，用第一批带出新一批腐烂的橘子，每一批橘子都会在一分钟之内腐烂，每一次腐烂都是一个广度优先搜索，step表示时间，也就是每一次广度优先搜索针对题意都会花费1分钟 step++

最后广度优先遍历结束后，再去遍历原来的给定m*n数组，还有没有新鲜橘子（判定有没有数组值是1）

注：此处就不在进行图像演示了，打开力扣题后图解已经很清晰了。

代码解析（附加注释）：

    public int orangesRotting(int[][] grid){
        //Entry存放位置
        Queue<pair> q=new LinkedList<>();
        int row=grid.length;
        int col=grid[0].length;
        //已经腐烂的位置入队
        for(int i=0;i<row;i++){
            for(int j=0;j<col;j++){
                //为了一会的广度优先遍历 需要先收集起数组中的腐烂橘子
                if(grid[i][j]==2){
                    //已入队列
                    q.offer(new pair(i,j));
                }
            }
        }
        //可以蔓延的方向 向四个方向进行扩张
        int[][] nextp={{0,1},{1,0},{0,-1},{-1,0}};
        int step=0;
        while(!q.isEmpty()){
            int n=q.size();
            int flag=0;
            //用当前这一批已经腐烂的橘子带出下一批要腐烂的橘子
            //故要遍历队列中的所有位置   先处理四个位置
            while(n--!=0){
                //用来接收当前位置坐标
                pair curpos=q.peek();
                q.poll();
                //当前位置向四个方向蔓延
                for(int i=0;i<4;i++){
                    //向四个方向进行扩展
                    int nx= curpos.x+nextp[i][0];
                    int ny= curpos.y+nextp[i][1];
                    //如果位置越界或者是空格 ，或者已经是腐烂橘子的位置，则跳过
                    if(nx>=row||nx<0||ny>=col|ny<0||grid[nx][ny]!=1){
                        continue;
                    }
                    //标记有新的被腐烂的橘子
                    flag=1;
                    //如果前面的判定跳过了  说明当前橘子可以被腐烂
                    grid[nx][ny]=2;
                    //已经成为腐烂的橘子就放入队列
                    q.offer(new pair(nx,ny));
                }
            }
            //如果有新的腐烂
            if(flag==1){
                step++;
            }
        }
        //判断 是否 还有无法腐烂的
        for(int i=0;i<row;i++){
            for(int j=0;j<col;j++){
                if(grid[i][j]==1){
                    return -1;
                }
            }
        }
        return step;
    }

2.3、单词接龙

使用方法：广度优先搜索

题目源于力扣：力扣

（1）通过广度优先搜索，首先将beginWord带出转换一个字母之后所有可能的结果

（2）每一步都要把队列中上一步添加的所有单词转换一遍，最短的转化肯定在这些单词中，所有这些单词的转换只能算一次转换，其实每次队列每次也只针对一个单词，单词的每个字符都会被26个字母换一遍直到对应词典找到了

（3）把转换成功的新词入队，进行下一步的转换

（4）最后整个转换的长度和广度优先搜索次数一致

代码解析（附加注释）：

    public int ladderLength(String beginword , String endWord, List<String> wordList){
        //hash表的查询效率最高
        Set<String> wordDict=new HashSet<>();
        for(String wd: wordList){
            wordDict.add(wd);
        }
        //标记单词是否已经访问过， 访问过的不再访问
        Set<String> visited=new HashSet<>();
        visited.add(beginword);
        //初始化队列
        Queue<String> q=new LinkedList<>();
        //将首个单词 放入队列进行广度优先
        q.offer(beginword);
        int res=1;
        while(!q.isEmpty()){
            int nextSize=q.size();
            //每一步都要把队列中上一步添加的所有单词转换一遍
            //最短的转换肯定在这些单词当中，所有这些词的转换只能算一次转换
            //因为都是上一步转换出来的
            while(nextSize--!=0){
                //顶部位置
                String curword=q.peek();
                q.poll();
                //尝试转换当前单词的每一个位置
                for(int i=0;i<curword.length();i++){
                    StringBuilder newWord=new StringBuilder(curword);
                    //每一个位置用26字母分别替换
                    for(char ch='a';ch<='z';ch++){
                        //替换第 i 位置的单词
                        newWord.setCharAt(i,ch);
                        //如果列表中没有此单词或者已经访问过，（它的转换已经遍历过，无需再次遍历）
                        String changeWord=newWord.toString();
                        //修改过后的单词是否包含
                        if(!wordDict.contains(changeWord)||visited.contains(changeWord)){
                            continue;
                        }
                        //转换成功，则再上一步转换的基础上+1 处理最后的情况
                        if(changeWord.equals(endWord)){
                            return res+1;
                        }
                        //到了这个位置 就说明 修改过后的单词是被包含在词典中
                        //还没有转换成功，则新的单词入队
                        visited.add(changeWord);
                        //存入队列
                        q.offer(changeWord);
                    }
                }
            }
            //处理下一个已经处理好的单词
            res++;
        }
        //转换不成功 返回 0
        return 0;
    }

2.4、打开转盘锁

使用方法：广度优先搜索

题目源于力扣：力扣

题目描述：

（1）锁的初始数字为 '0000' ，一个代表四个拨轮的数字的字符串。

（2）列表 deadends 包含了一组死亡数字，一旦拨轮的数字和列表里的任何一个元素相同，这个锁将会被永久锁定，无法再被旋转。

（3）字符串 target 代表可以解锁的数字，你需要给出解锁需要的最小旋转次数，如果无论如何不能解锁，返回 -1 。

代码解析（附加注释）：

    public int openLock(String[] deadends,String target){
        Set<String> deadendsSet=new HashSet<>();
        //将死亡数字进行存储，去重 后面进行判断拨动的转轮数字是不是被包含在这些死亡数字中
        for(String str :deadends){
            deadendsSet.add(str);
        }
        //如果“0000” 在死亡数字中，则永远开不了 直接结束
        if(deadendsSet.contains("0000")){
            return -1;
        }
        //初始化队列
        Queue<String> que=new LinkedList<>();
        //添加当前初识值
        que.offer("0000");
        //创建一个标记位，已经播过的数字不在进行重复出现
        Set<String> book=new HashSet<>();
        book.add("0000");
        //需要拨动几次
        int step=0;
        while(!que.isEmpty()){
            int n= que.size();
            //从上一步转换之后的字符串都需要进行验证和转换
            //并且只算做一次转换， 类似于层序遍历，转换的步数和层相同
            //同一层的袁术都是经过一步转换得到的
            for(int i=0;i<n;i++){
                String curStr=que.peek();
                //抛出是为了让后面的值一直都是第一个，也是最后一个
                que.poll();
                if(curStr.equals(target)){
                    return step;
                }
                //四位密码锁，每个位置每次都可以转一次
                for(int j=0;j<4;j++){
                    //为啥是两个 其实两个都是同一个滑轮 表示向上转动和向下转动两种情况
                    char newc1=curStr.charAt(j);
                    char newc2=curStr.charAt(j);
                    //当前位置向上
                    if(newc1=='9'){
                        newc1='0';
                    }else{
                        newc1++;
                    }
                    //当前位置向下
                    if(newc2=='0'){
                        newc2='9';
                    }else{
                        newc2++;
                    }
                    //要改变字符串 就需要用到 StringBuild 类型
                    StringBuilder newStr1=new StringBuilder(curStr);
                    StringBuilder newStr2=new StringBuilder(curStr);
                    //借助StringBuild 的方法进行改变 字符串的值
                    newStr1.setCharAt(j,newc1);
                    newStr2.setCharAt(j,newc2);
                    //此处是进行判断 修改后的花轮值 是否 是死亡数字  或者是 被标记过的
                    //被标记过的也就是已滑过的数字 
                    //除以上两种情况 其他情况皆可以存入队列进行下次修改 并且 进行标记 
                    if(!deadendsSet.contains(newStr1.toString())&&!book.contains(newStr1.toString())){
                        que.offer(newStr1.toString());
                        book.add(newStr1.toString());
                    }
                    if(!deadendsSet.contains(newStr2.toString())&&!book.contains(newStr2.toString())){
                        que.offer(newStr2.toString());
                        book.add(newStr2.toString());
                    }
                }
            }
            step++;
        }
        return -1;
    }