代码随想录算法训练营第30天| 回溯法完结撒花，332.重新安排行程，51. N 皇后，37. 解数独

332.重新安排行程

链接: 参考讲解

• 遇到的困难
  1 不是很清楚如何给将落地按字典序从小到大排序
  2 不知道如何避免死循环，后面发现用树枝去重就可以避免
  3 刚开始看到挺懵的

看图理解会更加深刻

class Solution {
    List<String> res = new ArrayList<>();
    LinkedList<String> path = new LinkedList<>();
    boolean[] used; // 用来记录访问过的树枝节点，防止死循环
    public List<String> findItinerary(List<List<String>> tickets) {
            // 按字典序从小到大排列降落地
            tickets.sort((a1, a2) -> a1.get(1).compareTo(a2.get(1)));
            // 加入初始起点
            path.add("JFK");
            used = new boolean[tickets.size()];
            backtrack(tickets);
            return res;
    }

    public boolean backtrack(List<List<String>> tickets){
        if(path.size() == tickets.size() + 1){
              res = new ArrayList<>(path);
              return true; 
        }

        for(int i = 0; i < tickets.size(); i++){
            // 如果树枝节点不重复而且当前起飞地和之前的降落地相同
            if(!used[i] && tickets.get(i).get(0).equals(path.getLast())){
                    path.add(tickets.get(i).get(1)); // 加入降落地
                    used[i] = true;
                    if(backtrack(tickets)) return true; // 找到符合的路径就返回
                    used[i] = false;
                    path.removeLast();
            }    
        }
        
        return false; // 所有机票遍历一边都没有合适结果就返回fa
    }
}

51. N 皇后

链接: 参考讲解

• 遇到的困难
  1 不清楚如何判断是否有皇后在45°角或者135°角的位置上
  2 不清楚如何将字符二维数组转化为string类型并保存到 List中

• 解题关键
  判断位置合法性只需要检查正在判断的棋子上方的位置就可以。

• 收获
  学会了一种很新的填充二维数组的方式 如下

  char[][] checkerboard;
  for(char[] c: checkerboard){
              Arrays.fill(c,'.');
          }
  

  学会了一种很新的字符二维数组转化为String的方式 如下

   List<String> list = new ArrayList<>();
          for(char[] c: checkerboard){
              list.add(String.copyValueOf(c));
          }
  

  二维数组表示斜上方45°角位置 如下

   int[row - 1][col - 1] // row 表示行， col 表示列
  

  二维数组表示斜上方135°角位置 如下

   int[row - 1][col + 1] // row 表示行， col 表示列
  

class Solution {
    List<List<String>> res = new ArrayList<>();
    char[][] checkerboard;
    public List<List<String>> solveNQueens(int n) {
        checkerboard = new char[n][n];

        for(char[] c: checkerboard){
            Arrays.fill(c,'.');
        }
        backtrack(checkerboard,n,0);
        return res;
    }

    public List<String> Array2List(char[][] checkerboard){
           List<String> list = new ArrayList<>();

            for(char[] c: checkerboard){
                list.add(String.copyValueOf(c));
            }
            return list;
    }

    public void backtrack(char[][] checkerboard, int n, int row){
        // 到叶子节点了
        if(row == n){
            res.add(Array2List(checkerboard));
            return;
        }

        for(int j = 0; j<n; j++){
            // 检查合法性
            if(isValid(checkerboard,j,row,n)){
                checkerboard[row][j] = 'Q';
                backtrack(checkerboard,n,row+1);
                checkerboard[row][j] = '.';
            }else continue;
        }
    } 

    public boolean isValid(char[][] checkerboard, int col, int row, int n){
         // 检查列的合法性
         for (int i = 0 ; i < row; i++){
             if(checkerboard[i][col] == 'Q') return false;
         }

         // 检查45°角合法性
         for(int i = row - 1, j = col - 1; i >=0 && j >=0; i--, j--){
              if(checkerboard[i][j] == 'Q') return false;
         }
        
         // 检查135°角合法性
         for(int i = row - 1, j = col + 1; i >= 0 && j <= n-1; i--, j++){
              if(checkerboard[i][j] == 'Q') return false;
         }

         return true;
    }  


}

37. 解数独

链接: 参考讲解

• 遇到的困难
  1 二维递归理解需要时间，但通过复现代码理解了。
  2 不知道怎么所给的字符在9方格内是否重复，不知道怎么表达在第几个9方格的第几行第几列。不清楚col,row 与3 之间的关系怎么处理。（所以只能照抄 ：）
• 收获
  理解了二维递归的概念。 看图理解会更加深刻

class Solution {
    public void solveSudoku(char[][] board) {
           backtrack(board);
    }

    public boolean backtrack(char[][] board){
            for(int i = 0; i<9; i++){
                for(int j = 0; j <9; j++){
                    if(board[i][j] == '.'){
                        for(char k = '1'; k <= '9'; k++){
                            if(isValid(board,i,j,k)){
                                board[i][j] = k; 
                                if(backtrack(board)) return true; // 如果找到一组就立即返回 
                                //（有一条树枝一直通到底）
                                board[i][j] = '.'; // 回溯
                            }
                        }
                        return false; // 9个字符都尝试完还是不行就返回false
                    }
                }
            }
            return true; // 遍历完没有返回false，说明找到了合适棋盘位置了
    }

    public boolean isValid(char[][] board, int row, int col, char val){
         // 检查行合法性
         for(int i = 0; i < 9; i++){
             if(board[row][i] == val) return false;
         }
         // 检查列合法性
         for(int j = 0; j < 9; j++){
             if(board[j][col] == val) return false;
         }
		// 以下代码全部照搬carl哥的示例代码
        int startRow = (row / 3) * 3;
        int startCol = (col / 3) * 3;
        for (int i = startRow; i < startRow + 3; i++) { // 判断9方格里是否重复
            for (int j = startCol; j < startCol + 3; j++) {
                if (board[i][j] == val ) {
                    return false;
                }
            }
        }
        return true;
    }
}

回溯总结

• 牢记神仙模板

  void backtracking(参数) {
      if (终止条件) {
          存放结果;
          return;
      }
  
      for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
          处理节点;
          backtracking(路径，选择列表); // 递归
          回溯，撤销处理结果
      }
  }
  

• 区分好树层去重和树枝去重的概念并学会运用

  链接: 参考讲解
  
  

• 知道递归啥时候有返回值啥时候没有返回值

  链接: 参考讲解