代码随想录算法训练营DAY30|C++回溯算法Part.6|332.重新安排行程、51.N皇后、31.解数独

最新推荐文章于 2024-07-17 23:24:38 发布

Che3rry

最新推荐文章于 2024-07-17 23:24:38 发布

阅读量639

点赞数 23

分类专栏： # 代码随想录文章标签：算法 c++ 开发语言

本文链接：https://blog.csdn.net/caiziming_001/article/details/138091420

版权

代码随想录专栏收录该内容

71 篇文章 0 订阅

订阅专栏

文章介绍了如何使用回溯算法解决旅行行程规划（避免死循环并按字母序排序）、N皇后问题（二维数组搜索）和数独问题（递归填充）。作者提供了伪代码和C++代码示例，展示了如何通过记录映射关系和检查合法性来解决问题。

摘要由CSDN通过智能技术生成

332.重新安排行程

力扣题目链接

文章讲解：332.重新安排行程

状态：题目要求所有机票都必须用一次且只能用一次

其实，深搜和回溯本来就是相关联的，他们经常被放到一起来讨论。

深度优先搜索是一种遍历或搜索算法，它从一个节点开始，尽可能深地搜索树或图的分支。在每个节点上，DFS会选择一个未被访问过的邻接节点继续搜索，直到到达一个没有未被访问过的邻接节点的节点，然后回溯到上一个节点继续搜索。这个过程会一直进行，直到所有节点都被访问过。

那么现在我们来讨论本题的五个难点，做完题目之后应当回答：

一个行程中，如果航班处理不好容易变成一个圈，成为死循环
有多种解法，字母序靠前排在前面，应该如何记录映射关系呢？
使用回溯法的话，终止条件是什么呢？
搜索的过程中，如何遍历一个机场所对应的所有机场。

思路

首先一个基本的思路应该是什么样的呢？也就是如何绘制树形结构图：

死循环的问题

记录映射关系解决死循环并解决字母序问题

我们在本题中，首先就涉及到映射关系的选型，这里先给出答案：

unordered_map<出发机场, map<到达机场, 航班次数>> targets

一个机场要映射多个机场，机场之间要靠字母序排列。

所以一个机场映射多个机场我们使用unordered_map；

机场之间靠字母序map\multimap\multiset

所以映射关系有

unordered_map<string, multiset<string>> targets;
unordered_map<string, map<string, int>> targets

本题中，为了防止搜索过程没有及时删除目的机场陷入死循环，同时，遍历multiset的时候如果删除元素会导致迭代器失效，为了使思路更加简单我们使用第二个。

再遍历 unordered_map<出发机场, map<到达机场, 航班次数>> targets的过程中，可以使用"航班次数"这个字段的数字做相应的增减，来标记到达机场是否使用过了。

如果“航班次数”大于零，说明目的地还可以飞，如果“航班次数”等于零说明目的地不能飞了，而不用对集合做删除元素或者增加元素的操作。

伪代码实现

初始化结果集和映射关系

for (const vector<string>& vec : tickets) {
  target[vec[0]][vec[1]]++;	//记录映射关系
}
result.push_back("JFK");	//起始机场

递归函数参数：
- 使用unordered_map<string, map<string, int>> targets; 来记录航班的映射关系，定义为全局变量。
- 参数里还需要ticketNum，表示有多少个航班（终止条件会用上）。
- 返回值用bool，因为我们只需要找到一个行程，也就是说找到在树形结构中唯一的一条通向叶子结点的路线就返回！
```
// unordered_map<出发机场, map<到达机场, 航班次数>> targets
unordered_map<string, map<string, int>> targets;
bool backtracking(int ticketNum, vector<string>& result) {
}
```
递归终止条件：输入: [[“MUC”, “LHR”], [“JFK”, “MUC”], [“SFO”, “SJC”], [“LHR”, “SFO”]] ，这是有4个航班，那么只要找出一种行程，行程里的机场个数是5就可以了。

所以终止条件是：我们回溯遍历的过程中，遇到的机场个数，如果达到了（航班数量+1），那么我们就找到了一个行程，把所有航班串在一起了。
```
if (result.size() == ticketNum + 1){
  return true;
}
```
单层搜索的逻辑：

for (pair<const string, int>& target: targets[result[result.size() - 1]]){
  if (target.second > 0){ //记录到达飞机是否飞过
    result.push_back(target.first);
    target.second--;
    if (backtracking(ticketNum, result)) return true;
    result.pop_back();
    target.second++;
  }
}

CPP代码

class Solution {
private:
// unordered_map<出发机场, map<到达机场, 航班次数>> targets
unordered_map<string, map<string, int>> targets;
bool backtracking(int ticketNum, vector<string>& result) {
    if (result.size() == ticketNum + 1) {
        return true;
    }
    for (pair<const string, int>& target : targets[result[result.size() - 1]]) {
        if (target.second > 0 ) { // 记录到达机场是否飞过了
            result.push_back(target.first);
            target.second--;
            if (backtracking(ticketNum, result)) return true;
            result.pop_back();
            target.second++;
        }
    }
    return false;
}
public:
    vector<string> findItinerary(vector<vector<string>>& tickets) {
        targets.clear();
        vector<string> result;
        for (const vector<string>& vec : tickets) {
            targets[vec[0]][vec[1]]++; // 记录映射关系
        }
        result.push_back("JFK"); // 起始机场
        backtracking(tickets.size(), result);
        return result;
    }
};

51.N皇后

力扣题目链接

文章讲解：51.N皇后

视频讲解：这就是传说中的N皇后？回溯算法安排！| LeetCode：51.N皇后

状态：题目要求每行和没列都不允许有两个皇后，然后两个四十五度角也不能出现两个皇后。

本题首先第一个难点就是：

一个棋盘，我们要搜索的是一个二维数组，这应该怎么弄？
树形结构咋画？

看完全部解答后，再回答这两个问题。

思路

以3X3为例：

从图中，可以看出，二维矩阵中矩阵的高就是这棵树的高度，矩阵的宽就是树形结构中每一个节点的宽度。

所以到这里就可以确定，只要搜索到了树的叶子节点，说明就找到了皇后们的合理位置了。

伪代码实现

递归函数参数：用全局变量result来记录最终结果，参数n是棋盘的大小，然后用row来记录当前遍历到棋盘的第几层了。

vector<vector<string>> result;
void backtracking(int n, int row, vector<string>& chessboard) {

递归终止条件：前文说过只要搜索到了树的叶子节点，说明就找到了皇后们的合理位置了。

if (row == n) {
  result.push_back(chessboard);
  return ;
}

单层搜索逻辑

递归深度就是row控制棋盘的行，每一层里for循环的col控制棋盘的列，一行一列，确定了放置皇后的位置。
每次都是要从新的一行的起始位置开始搜，所以都是从0开始。

for (int col = 0; col < n; col++){
  if (Valid(row, col, chessboard, n)){//验证合法
    chessboard[row][col] = 'Q'; //放置皇后
    backtracking(n, row + 1, chessboard);
    chessboard[row][col] = '.'; //回溯，撤销皇后
  }
}

验证棋盘是否合法：不能同行；不能同列；不能同斜线（45度和135度）
- 在单层搜索的过程中，每一层递归，只会选for循环（也就是同一行）里的一个元素，所以行不用检查

bool isValid(int row, int col, vector<string>& chessboard, int n) {
    // 检查列
    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; i--, j++) {
        if (chessboard[i][j] == 'Q') {
            return false;
        }
    }
    return true;
}

CPP代码

class Solution {
private:
  vector<vector<string>> result;
  // n 为输入的棋盘大小
  // row 是当前递归到棋盘的第几行了
  void backtracking(int n, int row, vector<string>& chessboard) {
      if (row == n) {
          result.push_back(chessboard);
          return;
      }
      for (int col = 0; col < n; col++) {
          if (isValid(row, col, chessboard, n)) { // 验证合法就可以放
              chessboard[row][col] = 'Q'; // 放置皇后
              backtracking(n, row + 1, chessboard);
              chessboard[row][col] = '.'; // 回溯，撤销皇后
          }
      }
  }
  bool isValid(int row, int col, vector<string>& chessboard, int n) {
      // 检查列
      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; i--, j++) {
          if (chessboard[i][j] == 'Q') {
              return false;
          }
      }
      return true;
  }
public:
    vector<vector<string>> solveNQueens(int n) {
        result.clear();
        std::vector<std::string> chessboard(n, std::string(n, '.'));
        backtracking(n, 0, chessboard);
        return result;
    }
};

31.解数独

力扣题目链接

文章讲解：31.解数独

视频讲解：回溯算法二维递归？解数独不过如此！| LeetCode：37. 解数独

状态：仅做记录

数独是一个典型的递归、回溯游戏

这里与N皇后不同的就是，棋盘的每一个位置都要放一个数字（而N皇后是一行只放一个皇后），并检查数字是否合法，解数独的树形结构要比N皇后更宽更深。

树形结构如图

2020111720451790-20230310131816104

伪代码实现

递归函数以及参数：

因为解数独找到一个符合的条件（就在树的叶子节点上）立刻就返回，相当于找从根节点到叶子节点一条唯一路径，所以需要使用bool返回值

bool backtracking(vector<vector<char>>& board)

递归终止条件:本题不需要终止条件，解数独是要遍历整个树形结构寻找可能的叶子节点就立刻返回。

本题中的终止条件全部放到单层递归的逻辑里面，因为递归的下一层的棋盘一定比上一层的棋盘多一个数，等数填满了棋盘自然就终止（填满当然好了，说明找到结果了），所以不需要终止条件！

在一个棋盘中如果出现了永远填不满的情况，我们也会在单层递归里面去return false

单层递归逻辑

我们需要一个二维递归，一个遍历行，一个遍历列。如果一行一列确定下来了，在某个格子常识了9个数都不行，就说明该数独问题无解，可以直接return false

bool backtracking(vector<vector<char>>& board) {
    for (int i = 0; i < board.size(); i++) {        // 遍历行
        for (int j = 0; j < board[0].size(); j++) { // 遍历列
            if (board[i][j] != '.') continue;
            for (char k = '1'; k <= '9'; k++) {     // (i, j) 这个位置放k是否合适
                if (isValid(i, j, k, board)) {
                    board[i][j] = k;                // 放置k
                    if (backtracking(board)) return true; // 如果找到合适一组立刻返回
                    board[i][j] = '.';              // 回溯，撤销k
                }
            }
            return false;                           // 9个数都试完了，都不行，那么就返回false
        }
    }
    return true; // 遍历完没有返回false，说明找到了合适棋盘位置了
}

判断合法性：同行是否重复，同列是否重复，9宫格里是否重复

bool isValid(int row, int col, char val, vector<vector<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;
        }
    }
    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;
}

CPP代码

class Solution {
private:
bool backtracking(vector<vector<char>>& board) {
    for (int i = 0; i < board.size(); i++) {        // 遍历行
        for (int j = 0; j < board[0].size(); j++) { // 遍历列
            if (board[i][j] == '.') {
                for (char k = '1'; k <= '9'; k++) {     // (i, j) 这个位置放k是否合适
                    if (isValid(i, j, k, board)) {
                        board[i][j] = k;                // 放置k
                        if (backtracking(board)) return true; // 如果找到合适一组立刻返回
                        board[i][j] = '.';              // 回溯，撤销k
                    }
                }
                return false;  // 9个数都试完了，都不行，那么就返回false
            }
        }
    }
    return true; // 遍历完没有返回false，说明找到了合适棋盘位置了
}
bool isValid(int row, int col, char val, vector<vector<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;
        }
    }
    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;
}
public:
    void solveSudoku(vector<vector<char>>& board) {
        backtracking(board);
    }
};

Che3rry

关注

23
点赞
踩
22

收藏

觉得还不错? 一键收藏
0
评论
代码随想录算法训练营DAY30|C++回溯算法Part.6|332.重新安排行程、51.N皇后、31.解数独

递归终止条件：输入: [[“MUC”, “LHR”], [“JFK”, “MUC”], [“SFO”, “SJC”], [“LHR”, “SFO”]] ，这是有4个航班，那么只要找出一种行程，行程里的机场个数是5就可以了。本题中的终止条件全部放到单层递归的逻辑里面，因为递归的下一层的棋盘一定比上一层的棋盘多一个数，等数填满了棋盘自然就终止（填满当然好了，说明找到结果了），所以不需要终止条件！因为解数独找到一个符合的条件（就在树的叶子节点上）立刻就返回，相当于找从根节点到叶子节点一条唯一路径，所以需要使用。
复制链接

扫一扫