代码随想录算法训练营第三十天 | 力扣 332.重新安排行程, 51. N皇后, 37. 解数独

332.重新安排行程

题目

332. 重新安排行程

给你一份航线列表 tickets ，其中 tickets[i] = [fromi, toi] 表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。

所有这些机票都属于一个从 JFK（肯尼迪国际机场）出发的先生，所以该行程必须从 JFK 开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。

例如，行程 ["JFK", "LGA"] 与 ["JFK", "LGB"] 相比就更小，排序更靠前。
假定所有机票至少存在一种合理的行程。且所有的机票 必须都用一次 且 只能用一次。

解析

本题很难，详解见代码随想录

深搜一般都使用了回溯法的思路

Java代码实现

List<String> result = new ArrayList<>();

Deque<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()];
    backTrack(tickets, used);
    return result;
}

private boolean backTrack(List<List<String>> tickets, boolean[] used) {
    if (path.size() == tickets.size() + 1) {
        result = 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, used)) {
                return true;
            }
            used[i] = false;
            path.removeLast();
        }
    }
    return false;
}

51. N皇后

题目

51. N 皇后

按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。

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

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

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

解析

约束条件：

1. 不能同行
2. 不能同列
3. 不能同斜线

用约束条件，来回溯搜索这棵树，只要搜索到了树的叶子节点，说明就找到了皇后们的合理位置了。

Java代码实现

List<List<String>> result = new ArrayList<>();

public List<List<String>> solveNQueens(int n) {

    char[][] chessboard = new char[n][n];

    for (char[] chars : chessboard) {
        Arrays.fill(chars, '.');
    }
    backTrack(n, 0, chessboard);
    return result;
}

private void backTrack(int n, int row, char[][] chessboard) {

    if (n == row) {
        result.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] = '.';
        }
    }

}

private List<String> array2List(char[][] chessboard) {
    List<String> list = new ArrayList<>();
    for (char[] chars : chessboard) {
        list.add(String.copyValueOf(chars));
    }
    return list;
}

private boolean isValid(int row, int col, int n, char[][] chessboard) {
    for (int i = 0; i < row; i++) {
        if (chessboard[i][col] == 'Q') {
            return false;
        }
    }

    for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
        if (chessboard[i][j] == 'Q') {
            return false;
        }
    }

    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. 解数独

题目

37. 解数独

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

数独的解法需 遵循如下规则：

数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）
数独部分空格内已填入了数字，空白格用 '.' 表示。

解析

题目

解数独是要遍历整个树形结构寻找可能的叶子节点就立刻返回。

在树形图中可以看出我们需要的是一个二维的递归（也就是两个for循环嵌套着递归）

一个for循环遍历棋盘的行，一个for循环遍历棋盘的列，一行一列确定下来之后，递归遍历这个位置放9个数字的可能性！

如果一行一列确定下来了，尝试了9个数都不行，说明这个棋盘找不到解决数独问题的解！

那么会直接返回false， 这也就是为什么没有终止条件也不会永远填不满棋盘而无限递归下去！

Java代码实现

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

private boolean sudoku(char[][] board) {
    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++) {
                if (isValidSudoku(i, j, k, board)) {
                    board[i][j] = k;
                    if (sudoku(board)) {
                        return true;
                    }
                    board[i][j] = '.';
                }
            }
            return false;
        }
    }
    return true;
}

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 i = 0; i < 9; i++) {
        if (board[i][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;
}