代码随想录算法训练营第三十天 _ 回溯_332.重新安排行程、51. N皇后 、37. 解数独。

学习目标:

60天训练营打卡计划!

学习内容:

332.重新安排行程

  • 这这这,着实是上强度了。。。
  • 对HashMap的API不熟悉,然后遇到了双层map,很自闭。
  • 难点一:如何把List tickets和回溯的树形结构画上联系?
    设计了HashMap> map的数据结构,其中第一个String存的是出发地;Map是一个树形映射,按照升序构造,Map中的String存的是目的地,Integer存的是到目的地的次数。在主程序构造出这样的结构。
  • 难点二:
    递归的结束条件:res.size() == size + 1,由题干可知。
    主要是数据结构太复杂,导致操作很复杂,实现也很臃肿,但确实让我大开眼界。
class Solution {
    // 不知道为什么要设置为队列
    // 应该是为了方便String last = res.getLast();取出下一次的起始站。
    // 设置为List也可以,但是代价差不多。
    private Deque<String> res;
    private HashMap<String, Map<String, Integer>> map;

    private boolean backtracking(int size){
        if(res.size() == size + 1){
            return true;
        }
        String last = res.getLast();
        if(map.containsKey(last)){
            for(Map.Entry<String, Integer> target:map.get(last).entrySet()){
                int count = target.getValue();
                if(count > 0){
                    res.add(target.getKey());
                    target.setValue(count - 1);
                    if(backtracking(size))  return true;
                    res.removeLast();
                    target.setValue(count);
                }
            }
        }
        return false;
    }

    public List<String> findItinerary(List<List<String>> tickets) {
        map = new HashMap<String, Map<String, Integer>>();
        res = new LinkedList<>();
        // temp中存储的是目的地和次数。
        Map<String, Integer> temp = null;
        for(List<String> t :tickets){
            // t.get(0)是String ,而且是出发地
            if(map.containsKey(t.get(0))){
                // 取出对应的目的地,和要去目的地的次数。
                temp = map.get(t.get(0));
                // t.get(1)是目的地
                // 仅仅放到了temp中,并没有返回给map
                // 为了获取与当前机票目的地相关联的机票数量。
                // 如果目的地已经在 temp 中有对应的数量记录,那么就会返回记录
                // 如果没有记录(即目的地是第一次出现),则默认返回值为 0。
                temp.put(t.get(1), temp.getOrDefault(t.get(1), 0) + 1);
            }
            else{
                // map为空时,靠该分支构建升序树
                temp = new TreeMap<>(); 
                temp.put(t.get(1), 1);
            }
            map.put(t.get(0),temp);
        }
        res.add("JFK");
        backtracking(tickets.size());
        return new ArrayList<>(res);
    }
}

51. N皇后

  • 为了使用 List cheeseBoard = new ArrayList<>();,更符合题目最后的返回值,所以用了StringBuilder类,使实现的时间和空间都比较差。
  • 难点一:isValid()函数的实现
    因为皇后是逐行放入的,每行有且仅有一个,故只需要判断该列,该45度线和135度线是否已经有皇后?若无则满足题意。
  • 难点二:List中对String的修改操作
    使用StringBuilder类先把位置处的元素删除,再使用insert方法插入需要的元素。deleteCharAt(rank); insert(rank, c);
    但是确实有长进了,看到String不再是束手无策,脑子里会出现StringBuilder 类,虽然用的还不是很熟练。
  • 难点三:回溯的实现
    最小的回溯条件很像切割IP的判断
    先假设某个放了皇后,如果可以放才会真的放置一个皇后,并进入回溯过程。
class Solution {
    List<List<String>> res = new ArrayList<>();
    List<String> cheeseBoard = new ArrayList<>();
    // row--行,rank--列   
    // 因为是逐行填充的,所以只需要比较该行上面的字符。
    private boolean isValid(int row, int rank, List<String> cheeseBoard){
        for(int j = 0; j < row; j++){
            if(cheeseBoard.get(j).charAt(rank) == 'Q')   return false;
        }
        // 检查45度是否有皇后
        for(int i = row-1, j = rank-1; i >= 0 && j >= 0; i--,j--){
            if(cheeseBoard.get(i).charAt(j) == 'Q')   return false;
        }
        // 检查135度是否有皇后 -- 行减小,列增大。
        for(int i = row-1, j = rank+1; j < cheeseBoard.size() && i >= 0; j++,i--){
            if(cheeseBoard.get(i).charAt(j) == 'Q')   return false;
        }
        return true;
    }
    // 1.回溯的返回值和传入的参数
    private void backtracking(List<String> cheeseBoard, int n, int row){
        // 2.回溯的结束条件
        if(row >= n){
            res.add(new ArrayList<>(cheeseBoard));
            return;
        }

        // 3.最小回溯条件
        // 把 i 作为列的值
        for(int i = 0; i < n; i++){
            if(isValid(row, i, cheeseBoard)){
                // 这一块的操作究极复杂,感觉是我写复杂了。。。
                cheeseBoard.set(row, createStr(i, cheeseBoard.get(row), 'Q'));
                backtracking(cheeseBoard, n, row+1);
                cheeseBoard.set(row, createStr(i, cheeseBoard.get(row), '.'));
            }
        }
        return;
    }
    // 修改字符串
    private String createStr(int rank, String s, char c){
        StringBuilder sb = new StringBuilder(s);
        sb.deleteCharAt(rank);
        sb.insert(rank, c);
        return sb.toString();
    }

    public List<List<String>> solveNQueens(int n) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < n; i++) {
            sb.append('.'); // 在 StringBuilder 中添加空格字符
        }
        for (int i = 0; i < n; i++) {
            cheeseBoard.add(sb.toString());
        }
        backtracking(cheeseBoard, n, 0);
        return res;
    }
}

37. 解数独

  • 和普通的回溯是不一样的,因为他没有明确的结束条件,所以第一次看一定会很懵。
  • 和Q女皇相似,本题也需要对最后的结果有一个合理性地判断函数:
  1. 同行不重复
  2. 同列不重复
  3. 9宫格不重复 — 固定的9 * 9大小的棋盘,可以被分为9个3 *3的小棋盘,所以首先要判断当前的节点落在哪个小棋盘?小棋盘的行列都乘3就是当前小棋盘的初始的位置。
  • 考虑回溯的策略:
    玩法就是对空格填入1-9的数字,所以先对大棋盘进行巡查,找到为空的位置,再使用isValid()判断当前值是否合理?合理则真正放入元素,并进行递归。
class Solution {
    // 判断棋盘是否合法有3个维度:
    // 1.同行不重复
    // 2.同列不重复
    // 3.9宫格不重复
    private boolean isValid(int row, int col, char val, char[][] board){
        for(int i = 0; i < 9; i++)
            if(board[i][col] == val)   return false;

        for(int i = 0; i < 9; i++)
            if(board[row][i] == val)   return false;

        int r_start = (row / 3) * 3;
        int c_start = (col / 3) * 3;
        for(int i = r_start; i < r_start + 3; i++)
            for(int j = c_start; j < c_start + 3; j++)
                if(board[i][j] == val)   return false;

        return true;
        
    }

    // 返回值是boolean是 :因为题目保证只有一种有效的解法
    private boolean backtracking(char[][] board){
        for(int i = 0; i < 9; i++){
            for(int j = 0; j < 9; j++){
                if(board[i][j] == '.'){
                    // 数字 1-9,忘记取等号导致只有数字1-8,故无法填充
                    for(int k = 1; k <= 9; k++){
                        if(isValid(i, j, (char)(k + '0'), board)){
                            board[i][j] = (char)(k + '0');
                            // 相当于在这里使用return 存储了合理的结果
                            if(backtracking(board))  return true;
                            board[i][j] = '.';
                        }
                    }
                    return false;
                }
            }
        }
        // 返回true的条件是遍历完整个棋盘且此时没有为空的位置。
        return true;
    }

    public void solveSudoku(char[][] board) {
        backtracking(board);
    }
}

学习时间:

  • 上午两小时,下午两个半小时,整理文档半小时。

你可能感兴趣的:(刷题训练心得,算法,windows,java)