Day30--数据结构与算法（Java) 回溯算法：重新安排行程 ，N皇后 ，37. 解数独

目录

一、332.重新安排行程

回溯法模板

 回溯代码

二、第51题. N皇后

三、37. 解数独

---

一、332.重新安排行程

力扣题目链接

本题以输入：[["JFK", "KUL"], ["JFK", "NRT"], ["NRT", "JFK"]为例，抽象为树形结构如下：

回溯法模板

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

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

 回溯代码

class Solution {
    private LinkedList<String>result;
    private LinkedList<String>path=new LinkedList<>();
    public List<String> findItinerary(List<List<String>> tickets) {
    Collections.sort(tickets,(a,b)->a.get(1).compareTo(b.get(1)));
    path.add("JFK");
    boolean [] used=new boolean[tickets.size()];
    backTracking((ArrayList)tickets,used);
    return result;
    }
    private boolean backTracking(ArrayList<List<String>> tickets,boolean []used)
    {
    if(path.size()==tickets.size()+1)
    {
        result=new LinkedList<>(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(backTracking(tickets,used))
        {
            return true;
        }
        used[i]=false;
        path.removeLast();
        }
         }
         return false;
    }
}

二、第51题. N皇后

力扣题目链接

用一个 3 * 3 的棋盘，将搜索过程抽象为一棵树，如图：

 

 

 

class Solution {
    List<List<String>> result=new ArrayList<>();
    public List<List<String>>  solveNQueens(int n) {
    char[][]chessboard=new char[n][n];
    for(char[] c:chessboard)
    {
        Arrays.fill(c,'.');
    }
    backTrack(n,0,chessboard);
    return result;
    }
    public void backTrack(int n,int row,char[][] chessboard)
    {
      if(row==n)
      {
          result.add(Array2List(chessboard));
          return;
      }
      for(int col=0;col<n;++col)
      {
       if(isVaild(row,col,n,chessboard)){
           chessboard[row][col]='Q';
           backTrack(n,row+1,chessboard);
           chessboard[row][col]='.';
       }
      }
    }
    public List Array2List(char[][] chessboard){
        List<String> list=new ArrayList<>();
         for(char []c:chessboard)
       {
       list.add(String.copyValueOf(c));
       }
       return list;
    }
    public boolean isVaild(int row,int col,int n,char[][] chessboard)
    {
        //检查列
       for(int i=0;i<row;++i)
       {
           if(chessboard[i][col]=='Q')
           return false;
       }
       //检查45度对角线
       for(int i=row-1,j=col-1;i>=0&&j>=0;i--,j--)
       {
           if(chessboard[i][j]=='Q')
           {
               return false;
           }
       }
       //检查135度对角线
       for(int i=row-1,j=col+1;i>=0&&j<=n-1;i--,j++)
       {
           
           if(chessboard[i][j]=='Q')
           {
               return false;
           }
       }
       return true;
    }
}

三、37. 解数独

力扣题目链接

一个数独的解法需遵循如下规则： 数字 1-9 在每一行只能出现一次。 数字 1-9 在每一列只能出现一次。 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。 空白格用 '.' 表示。

一个数独。

答案被标成红色。

如图所示：

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

    private boolean solveSudokuHelper(char[][] board){
        //「一个for循环遍历棋盘的行，一个for循环遍历棋盘的列，
        // 一行一列确定下来之后，递归遍历这个位置放9个数字的可能性！」
        for (int i = 0; i < 9; i++){ // 遍历行
            for (int j = 0; j < 9; j++){ // 遍历列
                if (board[i][j] != '.'){ // 跳过原始数字
                    continue;
                }
                for (char k = '1'; k <= '9'; k++){ // (i, j) 这个位置放k是否合适
                    if (isValidSudoku(i, j, k, board)){
                        board[i][j] = k;
                        if (solveSudokuHelper(board)){ // 如果找到合适一组立刻返回
                            return true;
                        }
                        board[i][j] = '.';
                    }
                }
                // 9个数都试完了，都不行，那么就返回false
                return false;
                // 因为如果一行一列确定下来了，这里尝试了9个数都不行，说明这个棋盘找不到解决数独问题的解！
                // 那么会直接返回， 「这也就是为什么没有终止条件也不会永远填不满棋盘而无限递归下去！」
            }
        }
        // 遍历完没有返回false，说明找到了合适棋盘位置了
        return true;
    }

    /**
     * 判断棋盘是否合法有如下三个维度:
     *     同行是否重复
     *     同列是否重复
     *     9宫格里是否重复
     */
    private boolean isValidSudoku(int row, int col, char val, char[][] board){
        // 同行是否重复
        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;
            }
        }
        // 9宫格里是否重复
        int startRow = (row / 3) * 3;
        int startCol = (col / 3) * 3;
        for (int i = startRow; i < startRow + 3; i++){
            for (int j = startCol; j < startCol + 3; j++){
                if (board[i][j] == val){
                    return false;
                }
            }
        }
        return true;
    }
}