代码随想录 day30

重新安排行程

给定一个机票的字符串二维数组 [from, to]，子数组中的两个成员分别表示飞机出发和降落的机场地点，对该行程进行重新规划排序。所有这些机票都属于一个从 JFK（肯尼迪国际机场）出发的先生，所以该行程必须从 JFK 开始。

提示：

• 如果存在多种有效的行程，请你按字符自然排序返回最小的行程组合。例如，行程 [“JFK”, “LGA”] 与 [“JFK”, “LGB”] 相比就更小，排序更靠前
• 所有的机场都用三个大写字母表示（机场代码）。
• 假定所有机票至少存在一种合理的行程。
• 所有的机票必须都用一次 且 只能用一次。

示例 1：

• 输入：[[“MUC”, “LHR”], [“JFK”, “MUC”], [“SFO”, “SJC”], [“LHR”, “SFO”]]
• 输出：[“JFK”, “MUC”, “LHR”, “SFO”, “SJC”]

示例 2：

• 输入：[[“JFK”,“SFO”],[“JFK”,“ATL”],[“SFO”,“ATL”],[“ATL”,“JFK”],[“ATL”,“SFO”]]
• 输出：[“JFK”,“ATL”,“JFK”,“SFO”,“ATL”,“SFO”]
• 解释：另一种有效的行程是 [“JFK”,“SFO”,“ATL”,“JFK”,“ATL”,“SFO”]。但是它自然排序更大更靠后

332. 重新安排行程 - 力扣（LeetCode）

1. 一个行程中，如果航班处理不好容易变成一个圈，成为死循环

用一个boolean[] used 来记录

2. 有多种解法，字母序靠前排在前面

Collections.sort(tickets, (a, b) -> a.get(1).compareTo(b.get(1)));

先对其进行排序

3. 使用回溯法（也可以说深搜） 的话，那么终止条件是什么呢

有一条合乎逻辑 的路线

函数返回值用的是bool

因为只需要找到一个行程，就是在树形结构中唯一的一条通向叶子节点的路线

4. 搜索的过程中，如何遍历一个机场所对应的所有机场

回溯

private static LinkedList<String> res;
private static LinkedList<String> path = new LinkedList<>();

public static 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 res;
}

public static boolean backTracking(ArrayList<List<String>> tickets, boolean[] used) {
    if (path.size()== tickets.size()+1){
        res=new LinkedList<>(path);
        return true;
    }
    for (int i = 0; i < tickets.size(); i++) {
        //没有使用过 且 这个数组的开头对应path路径的结尾
        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;
}

N皇后

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

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

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

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

https://leetcode.cn/problems/n-queens/

按照如下标准去重：

1. 不能同行
2. 不能同列
3. 不能同斜线 （45度和135度角）

看起来很难，但是代码真的有点简单

1. 定义一个二维数组填充 “ . ”，方便进行验证棋盘是否合法 isValid（）
2. 用回溯，一次在每一行的每一列，填充皇后，然后检验合法性，不行就下一个

static List<List<String>> res = new ArrayList<>();

public static List<List<String>> solveNQueens(int n) {
    char[][] chessboard = new char[n][n];
    for (char[] c : chessboard) {
        Arrays.fill(c, '.');
    }
    backTrack(n, 0, chessboard);
    return res;
}

/**
 *
 * @param n 列号
 * @param row 行号
 * @param chessboard
 */
public static void backTrack(int n, int row, char[][] chessboard) {
    if (row == n) {
        res.add(Array2List(chessboard));
        return;
    }

    for (int col = 0;col < n; ++col) {
        if (isValid (row, col, n, chessboard)) {
            chessboard[row][col] = 'Q';
            backTrack(n, row+1, chessboard);
            chessboard[row][col] = '.';
        }
    }

}

//这里只是将一个二维数组转成了一个list
public static List Array2List(char[][] chessboard) {
    List<String> list = new ArrayList<>();

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


public static boolean isValid(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;
}

解数独

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

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

一脸懵…

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;
}