力扣回溯算法专题（三）- 排列 棋盘问题 棋盘问题 46.全排列、47.全排列Ⅱ、332.重新安排行程、51.N皇后、37.解数独 分析 思路 C++实现 总结 回溯法总结

最新推荐文章于 2024-10-05 21:10:28 发布
最新推荐文章于 2024-10-05 21:10:28 发布
阅读量229 收藏
点赞数
分类专栏： C++刷题-LeetCode-牛客 文章标签： c++ leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/uuuuu22/article/details/130608851
版权

文章目录

回溯法模板与伪代码

//返回值一般为void 先写逻辑再确定参数
//一般搜到叶子节点也就找到了满足条件的一条答案，存放该答案并结束本层递归
//for循环横向遍历集合区间，for循环执行次数=一个节点孩子数：处理节点 递归 回溯
void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

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

46.全排列

在这里插入图片描述

三要素及思路

先写逻辑，再确定递归函数参数：

函数参数：
path，一维数组，存放符合条件的一个排列，全局变量
result，二维数组，存放排列子集集合，全局变量
nums，题目给的数组
used，标记数组，标记使用过的元素，一个排列中元素不重复

终止条件：
排列问题是找叶子节点，当收集元素的数组path的大小达到和nums数组一样大的时候，说明找到了一个全排列，也表示遍历到了叶子节点，结束本层递归。

单层搜索：

  1. 和组合、切割、子集问题最大区别是，排列问题for循环不需要startindex，每次递归从0开始，因为排列有序，[1,2]和[2,1]是两个集合。
  2. 但是一个元素在一个排列中只能使用一次，因此需要used数组记录path里都用哪些元素使用过。
  3. 去重，一个排列元素不重复，used数组对应更新标记元素状态
  4. 然后保存节点、递归、回溯，注意递归时的起始位置，从0开始

代码

class Solution {
public:
    vector<int> path;
    vector<vector<int>> result;
    void backtracking(vector<int>& nums, vector<bool>& used)
    {
        //终止条件 遍历到叶子节点 保存节点 结束递归 找到一个排列
        if(path.size()==nums.size())
        {
            result.push_back(path);
            return;
        }
        //单层搜索
        for(int i=0; i<nums.size(); i++)
        {
            //去重 一个排列元素不重复
            if(used[i]==true) continue;
            used[i] = true;
            path.push_back(nums[i]);
            backtracking(nums, used);
            used[i] = false;
            path.pop_back();
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        path.clear();
        result.clear();
        vector<bool> used(nums.size(), false);
        backtracking(nums, used);
        return result;
    }
};

47.全排列Ⅱ

在这里插入图片描述
这道题目和46.全排列的区别在于，给定一个可包含重复数字的序列，要返回所有不重复的全排列，因此需要去重处理。

和组合、子集问题一样，去重前先排序，但是对于递增序列的去重不需要排序

三要素及思路

先写逻辑，再确定递归函数参数：

函数参数：
path，一维数组，存放符合条件的一个排列，全局变量
result，二维数组，存放排列子集集合，全局变量
nums，题目给的数组
used，标记数组，标记使用过的元素，一个排列中元素不重复

终止条件：
排列问题是找叶子节点，当收集元素的数组path的大小达到和nums数组一样大的时候，说明找到了一个全排列，也表示遍历到了叶子节点，结束本层递归。

单层搜索：

  1. 但是一个元素在一个排列中只能使用一次，因此需要used数组记录path里都用哪些元素使用过。
  2. 去重，一个排列元素不重复，used数组对应更新标记元素状态
  3. 然后保存节点、递归、回溯，注意递归时的起始位置，从0开始

去重：

  • 对同一父节点
  • 两种实现方式，used数组和set

在这里插入图片描述

代码

  • used数组去重
class Solution {
public:
    vector<int> path;
    vector<vector<int>> result;
    void backtracking(vector<int>& nums, vector<bool>& used)
    {
        if(path.size()==nums.size())//找到了一组排列
        {
            result.push_back(path);
            return;
        }
        
        //used数组
        for(int i=0; i<nums.size(); i++)
        {
            // used[i - 1] == true，说明同一树枝nums[i - 1]使用过
            // used[i - 1] == false，说明同一树层nums[i - 1]使用过
            // 如果同一树层nums[i - 1]使用过则直接跳过
            if(i>0 && nums[i]==nums[i-1] && used[i-1]==false) continue;
            if(used[i]==false)//同一树层nums[i]使用过
            {
                used[i] = true;
                path.push_back(nums[i]);
                backtracking(nums, used);
                used[i] = false;
                path.pop_back();
            }
        }
    }
    
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        path.clear();
        result.clear();
        vector<bool> used(nums.size(), false);
        sort(nums.begin(), nums.end());
        backtracking(nums, used);//used数组；set去重
        return result;
    }
};
  • set去重
class Solution {
public:
    vector<int> path;
    vector<vector<int>> result;
    void backtracking(vector<int>& nums, vector<bool>& used)
    {
        if(path.size()==nums.size())//找到了一组排列
        {
            result.push_back(path);
            return;
        }
        //set去重
        unordered_set<int> uset;
        for(int i=0; i<nums.size(); i++)
        {
            // used[i - 1] == true，说明同一树枝nums[i - 1]使用过
            // used[i - 1] == false，说明同一树层nums[i - 1]使用过
            // 如果找到nums[i]，说明同一树层使用过，直接跳过
            if(uset.find(nums[i]) != uset.end()) continue;
            if(used[i]==false)//同一树层nums[i]使用过
            {
                uset.insert(nums[i]); // set去重 记录元素
                used[i] = true;
                path.push_back(nums[i]);
                backtracking(nums, used);
                used[i] = false;
                path.pop_back();
            }
        }
    }
    
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        path.clear();
        result.clear();
        vector<bool> used(nums.size(), false);
        sort(nums.begin(), nums.end());
        backtracking(nums, used);//used数组；set去重
        return result;
    }
};

去重补充

  1. 当i > 0 && nums[i] == nums[i - 1]时，有
  • used[i - 1] == true，说明同一树枝nums[i - 1]使用过
  • used[i - 1] == false，说明同一树层nums[i - 1]使用过
  1. 对于这道题，树枝去重和树层去重都可以，但树层去重效率更高。
  • 树层去重，used[i - 1] == false，树层上对前一位去重非常彻底，效率很高
    在这里插入图片描述
  • 树枝去重，used[i - 1] == true，树枝上对前一位去重虽然最后可以得到答案，但是做了很多无用搜索
    在这里插入图片描述

332.重新安排行程

在这里插入图片描述

分析 思路 步骤

这道题实际是图论的深度优先搜索，但深搜中使用了回溯。查找路径时，如果不回溯无法找到目标路径

题目难点：
一个行程中，如果航班处理不好容易变成一个圈，成为死循环，如何避免死循环？
有多种解法，字母序靠前排在前面，如何记录映射关系 ？
使用回溯法（也可以说深搜） 的话，终止条件是什么？
搜索过程中，如何遍历一个机场所对应的所有机场？

理解死循环：

出发机场和到达机场也可能会重复，如果没有对集合元素处理好，就造成死循环

记录映射关系：

1. 怎么建立映射： 一个机场映射多个机场，机场之间要靠字母序排列，可以使用std::unordered_map。如果让多个机场之间再有顺序的话，就用std::map或者std::multimap 或者 std::multiset。

2. 如何定义映射： 因此，一个机场映射多个机场，可以如下建立映射

  • unordered_map<string, multiset> targets，含义是：unordered_map<出发机场, 到达机场的集合> targets
  • unordered_map<string, map<string, int>> targets，含义是：unordered_map<出发机场, map<到达机场, 航班次数>> targets

3. 使用哪种定义方式建立映射： 如果使用unordered_map<string, multiset<string>> targets ，遍历multiset的时候，不能删除元素。一旦删除元素，迭代器就失效了。

4.为什么要增删元素： 出发机场和到达机场是可能会重复的，如果搜索过程没及时删除目的机场，就会死循环。因此搜索时要不断地删multiset里的元素，因此使用unordered_map<string, map<string, int>> targets。

5.如何记录映射： 在遍历 unordered_map<出发机场, map<到达机场, 航班次数>> targets 的过程中，可以使用航班次数这个字段的数字做相应的增减，来标记到达机场是否使用过了。
如果航班次数大于零，说明目的地还可以飞，如果航班次数等于零，说明目的地不能飞了，而不是对集合做实际的删除或增加元素的操作，只是标记

先写逻辑，再确定递归函数参数与返回值：

函数参数：
unordered_map<string, map<string, int>> targets，记录航班的映射关系，全局变量
result，一维数组，记录一条路径，局部变量，相当于之前的path
ticketnum，表示有多少个航班，终止条件控制
targets和result都需要初始化

函数返回值：
之前的回溯函数返回值都是void，这次是bool。因为我找到一个行程，就是在树形结构中唯一的一条通向叶子节点的路线

终止条件： 回溯遍历的时，如果遇到的机场个数=航班数量+1，说明找到了一个行程，把所有航班串在一起了

单层搜索： 要找到一个对数据进行排序的容器，而且还要容易增删元素，迭代器还不能失效，来建立机场直之间的映射，即unordered_map<string, map<string, int>> targets。通过targets的int字段判断这个集合里的机场是否使用过，避免直接去删元素，然后再处理航班

代码

class Solution {
private:
    // unordered_map<出发机场, map<到达机场, 航班次数>> targets
    unordered_map<string, map<string, int>> targets;
    bool backtracking(vector<string>& result, int ticketnum)
    {
        //终止条件 找到一条路径
        if(result.size() == ticketnum+1) return true;
        //单层搜索 用对组类型创建与targets.second同类型容器target  遍历targets.second这个map容器
        //通过target.second这个字段 int类型元素 判断该机场是否飞过 并做对应的记录
        //target.second>0 目的地还可以飞；target.second=0 目的地不能飞
        for(pair<const string, int>& target : targets[result[result.size()-1]])
        {
            if(target.second > 0)//目的地还可以飞
            {
                result.push_back(target.first);//保存目的地
                target.second--;
                //递归函数是bool类型  写法和之前的不一样
                if(backtracking(result, ticketnum)) 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(result, tickets.size());
        return result;
    }
};

好难好难

51. N皇后

在这里插入图片描述

分析 思路 步骤

分析：

搜索皇后的位置可以抽象为一棵树，二维矩阵中，矩阵的高就是这棵树的高度，矩阵的宽就是树形结构中每一个节点的宽度
皇后们的约束条件：不能同行、不能同列、不能同斜线
利用皇后的约束条件回溯搜索这棵树，只要搜索到了树的叶子节点，说明就找到了皇后们的合理位置

先写逻辑，再确定递归函数参数与返回值：

函数参数：
chessboard, 一维数组，保存符合条件的单个子集，局部变量
result，二维数组，记录最终结果，全局变量
n，题目给的数，棋盘的大小
row，记录当前遍历到棋盘的第几层
函数没有返回值

终止条件： 根据前面的分析，当递归到棋盘最底层时，也就是遍历到叶子节点时，就可以收集结果并返回了，即row=n时，结束递归

单层搜索：
递归深度就是row控制棋盘的行，每一层里for循环的col控制棋盘的列，一行一列，确定了放置皇后的位置。
每次都是要从新的一行的起始位置开始搜索，都是从0开始。
并且根据皇后约束条件，还需要验证位置是否合法

步骤： 验证位置合法、放置皇后（保存节点）、递归（从下一行row+1开始）、回溯（赋值覆盖皇后）

验证棋盘是否合法：

  • 按照皇后约束条件去重，分别对同行、同列，同斜线（45度和135度角）检查
  • 对列检查，相当于剪枝
  • 对45度角检查，找角度时默认直角坐标系，45度 找左下角 [row, col] -> [row-1, col-1]
  • 对135度角检查，找角度时默认直角坐标系，135度 找左上角 [row, col] -> [row-1, col+1]
  • 没有对行检查，因为在单层搜索的过程中，每一层递归，只会选for循环（也就是同一行）里的一个元素，所以不用去重了。

代码

class Solution {
private:
    vector<vector<string>> result;
    void backtracking(int n, int row, vector<string>& chessbord)
    {
        //递归终止条件 遍历到叶子节点 深度=宽度 正方形棋盘
        if(row == n)
        {
            result.push_back(chessbord);
            return;
        }
        //单层搜索
        for(int col=0; col<n; col++)
        {
            //验证位置合法性 如果合法就放置皇后
            if(isvalid(row, col, chessbord, n))
            {
                chessbord[row][col] = 'Q';//放置皇后
                backtracking(n, row+1, chessbord);//从下一行开始
                chessbord[row][col] = '.';//回溯 撤销皇后 题目中.表示空位 可以赋值来覆盖皇后
            }
        }
    }

    //验证位置合法性
    bool isvalid(int row, int col, vector<string>& chessbord, int n)
    {
        //检查列 行变 列固定 相当于剪枝
        for(int i=0; i<row; i++)
        {
            if(chessbord[i][col] == 'Q') return false;//说明这一列的某一行有皇后
        }

        //找角度时默认直角坐标系
        //检查斜线-45度 找左下角 [row, col] -> [row-1, col-1]
        for(int i=row-1, j=col-1; i>=0 && j>=0; i--, j--)
        {
            if(chessbord[i][j] == 'Q') return false;//说明这斜线 45度角的某个位置有皇后
        }

        //检查斜线-135度 找左上角 [row, col] -> [row-1, col+1]
        for(int i=row-1, j=col+1; i>=0 && j<n; i--, j++)
        {
            if(chessbord[i][j] == 'Q') return false;//说明这斜线 135度角的某个位置有皇后
        }
        return true;
    }

public:
    vector<vector<string>> solveNQueens(int n) {
        result.clear();
        std::vector<std::string> chessbord(n, std::string(n, '.'));//初始化 正方形棋盘 n*n二维矩阵 .默认填充
        backtracking(n, 0, chessbord);
        return result;
    }
};

37. 解数独

在这里插入图片描述

分析 思路 步骤

分析：
在这里插入图片描述

  1. 数独唯一解，意味着找到从根节点到叶子节点一条唯一路径就返回，因此回溯函数的返回值是bool类型，同332题
  2. N皇后问题是因为每一行每一列只放一个皇后，只需要一层for循环遍历行，递归遍历列，然后一行一列确定皇后的唯一位置。
  3. N皇后是一行只放一个皇后，属于一维递归。解数独问题则是棋盘的每一个位置都要放一个数字，而N皇后是一行只放一个皇后，因此本题属于二维递归，解数独的树形结构要比N皇后更宽更深。

先写逻辑，再确定递归函数参数与返回值：

函数参数： board, 题目给的数独。而且这个是二维递归，遍历整棵树，不需要行、列来记录深度、宽度

函数返回值： bool类型的函数返回值，数独唯一解，相当于找到从根节点到叶子节点一条唯一路径就返回

终止条件：

  • 要遍历整棵树，找到唯一解，即找到可能的叶子节点就返回，因此不需要终止条件。

  • 会不会死循环？ 递归的下一层棋盘一定比上一层的棋盘多一个数，数填满了棋盘自然就终止，说明找到结果了，所以不需要终止条件

单层搜索：
二维递归，需要两个for循环嵌套实现，一个for循环遍历棋盘的行，一个for循环遍历棋盘的列。某个位置，即所在行与列确定之后，递归遍历这个位置放9个数字的可能性

会不会填不满？ 一行一列确定后，如果9个数字都不合法，说明这个棋盘找不到数独问题的唯一解，直接返回假。 这也就是为什么没有终止条件也不会永远填不满棋盘而无限递归下去

步骤：

遍历整棵树，默认返回真，相当于遍历整棵树之后一定找到一条唯一路径，数独有唯一解

  1. 遍历行
  2. 遍历列
  3. 确定位置，如果该位置没有数字，则处理，有数字就跳过
  4. 验证位置合法，验证该位置放9个数字的可能性：如果合法，放置数字、递归（找到一条路径就返回）、回溯（赋值覆盖）
  5. 9个数字都验证完了并且没有合适的数字，说明该位置对9个数字都不合法，意味着这个棋盘找不到数独问题的唯一解数独，就直接返回假
  6. 返回真

验证棋盘是否合法：

  • 按照数独约束条件去重，分别对同行、同列，九宫格检查
  • 对行检查，查看数字是否有重复
  • 对列检查，查看数字是否有重复
  • 对九宫格检查，查看数字是否有重复。注意九宫格的转换和遍历方式

代码

class Solution {
private:
    //回溯函数
    bool backtracking(vector<vector<char>>& board)
    {
        //不需要终止条件 找到唯一路径就返回 默认返回真 一定有唯一解
        
        for(int i=0; i<board.size(); i++)//遍历行
        {
            //遍历列 board[0].size()列数 i、j确定位置
            for(int j=0; j<board[0].size(); j++)
            {
                if(board[i][j] == '.')//该位置是空格，可以填数字 
                {
                    //递归遍历(i, j)位置 对9个数字的可能性
                    for(char k='1'; k<='9'; k++)
                    {
                        if(isvalid(i, j, k, board))//(i, j)位置放k合适 
                        {
                            board[i][j] = k;//放k
                            if(backtracking(board)) return true;//递归 找到路径就返回真
                            board[i][j] = '.';//回溯
                        }
                    }
                    return false;//(i, j)位置对9个数字都不合适 找不到数独唯一解 返回假
                }
            }
        }
        return true;
    }
    //验证位置合法
    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;
        }

        //九宫格 数字重复检查 九宫格每行每列只有3个数字 所以i<startrow+3 j<startcol+3
        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;
    }
public:
    void solveSudoku(vector<vector<char>>& board) {
        backtracking(board);
    }
};

总结

1. 排列问题

排列问题：N个数按一定规则全排列，有几种排列方式——46.全排列、47.全排列Ⅱ、332.重新安排行程

  • 排列强调顺序的，组合不强调元素顺序，即组合无序，排列有序。例如，{1, 2} 和{2, 1}在排列问题中是两个集合，在组合问题中是一个集合。

  • 与组合、分割问题一样，排列问题找叶子节点，但子集问题找所有节点

  • 和组合、切割、子集问题最大区别在于，排列for循环不需要startindex，每次递归从0开始，因为排列有序，[1,2]和[2,1]是两个集合

  • 排列去重，排列的for循环每次从0开始遍历，需要使用标记数组used记录哪些元素使用过，因为一个排列中元素不重复，只能使用一次

  • 两种去重实现方式，标记数组used和set，注意使用set去重时的错误写法，使用set去重的版本相对于used数组的版本效率都要低很多

  • 去重前，先排序

  • 46.全排列：标记数组used实现元素去重

  • 47.全排列Ⅱ：

    • 和46.全排列的区别在于，47给的是一个可包含重复数字的序列，要返回所有不重复的全排列
    • 标记数组used或者set实现元素去重，注意使用set去重时的错误写法
    • 树枝去重和树层去重都可以，但是树层去重效率更高

2. 棋盘问题

  • 一维递归-N皇后，二维递归-解数独

  • 位置合法性验证

  • 51.N皇后：

    • 二维矩阵的高就是树的高度，矩阵宽就是树中每一个节点的宽度
    • 一维递归，只需要一层for循环遍历行，递归遍历列，因为每一行每一列只放一个皇后
    • 有递归终止条件，遍历到叶子节点，即达到树的深度时，说明找到了皇后们的合理位置
    • 没有递归函数返回值
    • 利用皇后的约束条件（不能同行、不能同列、不能同斜线45度和135度）去重，只需要对列和斜线去重，对列去重相当于剪枝

  • 37.解数独：

    • 二维递归，两个for循环嵌套，一个for循环遍历棋盘的行，一个for循环遍历棋盘的列，确定唯一位置，因为每行每列，即每个位置都需要遍历
    • 没有递归终止条件，需要遍历整棵树
    • 有递归函数返回值，数独有唯一解，找到符合条件的路径就返回
    • 利用数独约束条件（同行同列及九宫格不能有重复数字）去重，注意九宫格的去重方式
    • 会不会出现死循环？棋盘会不会填不满而无限递归？

3. 深度优先搜索中的回溯

332.重新安排行程

  • 题目难点：
    • 如何避免行程中出现死循环？
    • 有多种解法，字母序靠前排在前面，如何记录映射关系 ？
    • 使用回溯法（也可以说深搜） 的话，终止条件是什么？
    • 搜索过程中，如何遍历一个机场所对应的所有机场？
  • 使用哪种容器建立一个机场对多个机场的映射关系？
  • 机场之间映射建立的过程
  • 建立映射时，为什么使用 unordered_map<string, map<string, int>> targets，而不是 unordered_map<string, multiset> targets，两者含义是什么？如何使用？

回溯法总结

  1. 回溯法本质，一种搜索算法，本质是穷举，故效率不高
  2. 如何理解回溯法的搜索过程？
  3. 所有回溯问题都可以抽象为树形结构，对应的问题有组合、切割、子集、排列、棋盘，组合无序，排列有序
  4. 回溯函数的三要素，参数及返回值、终止条件、单次搜索过程
  • 参数： 先写逻辑再确定参数；回溯函数参数分析，什么时候用startIndex，什么时候不用？什么时候用目标值sum、val，什么时候不用？
  • 返回值： 先写逻辑再确定返回值及其类型，一般不需要，如果找到唯一路径就有返回值及其类型
  • **终止条件：**如果是找叶子节点，一般需要终止条件；如果遍历整棵树就不需要
  • 单次搜索过程： for循环中体现剪枝操作
  1. 剪枝操作
  2. 去重操作
  • 如何去重
  • 如何理解树枝去重与树层去重
  • 去重有几种方法？位置合法性验证，标记数组used与set实现方式
  • 位置合法性验证，
  1. 一维递归与二维递归，如何理解二维递归？
  2. 回文判定
虚假自律就会真自律！
关注
专栏目录
回溯算法——棋盘问题（力扣37： 解数独）
qq_40472852的博客
11-25 627
前言 回溯算法这个系列我们之前已经总结过， 现在复习一下 回溯算法是一种暴力的搜索算法， 坦白来讲就是穷举 一般来说这些问题遇上了首先应当考虑回溯： 组合问题：给定有n个整数的集合， 从中选出所有包含k个 数的组合 排列问题：给定有n个整数的集合， 求n个数的所有的排列方式 子集问题：给定有n个整数的集合， 求其所有子集 切割问题：按一定规则对字符串进行切割， 求所有切割方式 棋盘问题：N皇后， 数独等等， 求所有解 回溯算法的本质是树形问题， 所有的回溯算法都可以通过...
回溯算法的五类问题：组合、排列、子集、分割、棋盘
m0_56602092的博客
04-06 563
与组合不同的是，排列需要考虑顺序，在剪枝时不能进行顺序性剪枝，只能剪去已使用的元素。用一个boolean数组记录哪些元素已使用。 ### 1. 全排列 **题目简述**：给定一个不含重复数字的数组nums ，返回其所有可能的全排列 **思路**：回溯算法。在路径选择列表剪枝时，组合问题可进行顺序性剪枝，而排列问题只能剪去path已使用过的数据 * 用一个布尔数组标记每个数是否使用过，回溯时删除路径并将对应元素使用标记重置为false * 回溯递归函数参数：（结果集，已选择路径，数组nums和已
[LeetCode] 348、判定井字棋胜负
aift的专栏
12-18 951
题目描述 请在 n × n 的棋盘上，实现一个判定井字棋（Tic-Tac-Toe）胜负的神器，判断每一次玩家落子后，是否有胜出的玩家。 在这个井字棋游戏中，会有 2 名玩家，他们将轮流在棋盘上放置自己的棋子。 在实现这个判定器的过程中，你可以假设以下这些规则一定成立： 每一步棋都是在棋盘内的，并且只能被放置在一个空的格子里； 一旦游戏中有一名玩家胜出的话，游戏将不能再继续； 一个玩家如果在同一行...
力扣(LeetCode)1812. 判断国际象棋棋盘中一个格子的颜色(C++)
墨染
12-08 311
【墨染】根据奇偶性找规律。
训练营第二十七天 | 491.递增子序列46.全排列47.全排列 II332.重新安排行程51. N皇后
weixin_44824156的博客
06-05 1816
则同一树枝重复，是被允许的。拿题目中的示例为例，输入: [["MUC", "LHR"], ["JFK", "MUC"], ["SFO", "SJC"], ["LHR", "SFO"]] ，这是有4个航班，那么只要找出一种行程，行程里的机场个数是5就可以了。所以终止条件是：回溯遍历的过程中，遇到的机场个数，如果达到了（航班数量+1），那么我们就找到了一个行程，把所有航班串在一起了。）来记录当前层中已经使用过的元素，以确保每个元素在每一层递归中只使用一次，但在不同的递归路径中可以使用相同的元素。
代码随想录算法训练营第25天 | 力扣491.非递减子序列、力扣46.全排列、力扣.全排列II、力扣332.重新安排行程、力扣51.N皇后、力扣37.解数独
m0_68237332的博客
08-24 694
所以加上为了避免死循环这个要求，终点站可以采用一个map数组，map是自动有序的，map中存放的是终点站，以及起点到终点的次数，这样当为0的时候也就是说走完了，不会再进入，从而避免了死循环。当然，如果说不存在解，也不会有无限递归的情况，因为如果1~9放在某个位置都不合适，会直接返回false，跳出一层递归，回溯，进行下面的操作。思路：这道题相较于上面的题目就是多了重复的数字，其实跟之前的组合去重思路一样的，先排序，再使用used数组判断同层元素是否重复，重复就跳过，不重复就入循环。
代码随想录算法训练营第二十六天 | 491.递增子序列、46.全排列、47.全排列 II、332.重新安排行程、51.N皇后、37.解数独、回溯算法总结
weixin_43581681的博客
07-16 289
代码随想录 (programmercarl.com)——回溯算法总结。
力扣回溯算法专题（一）- 回溯算法理论基础、组合问题 77.组合、216.组合总和Ⅲ、17.电话号码的字母组合、39.组合总和、40.组合总和Ⅱ 思路及C++实现 组合问题总结
UUUUU22的博客
05-10 196
力扣回溯算法专题（一）- 回溯算法理论基础、组合问题 77.组合、216.组合总和Ⅲ、17.电话号码的字母组合、39.组合总和、40.组合总和Ⅱ 思路及C++实现 组合问题总结
代码随想录算法训练营第三十天 | 332.重新安排行程 51. N皇后 37. 解数独
qq_43511039的博客
07-14 174
回溯算法能解决如下问题：组合问题：N个数里面按一定规则找出k个数的集合排列问题：N个数按一定规则全排列，有几种排列方式切割问题：一个字符串按一定规则有几种切割方式子集问题：一个N个数的集合里有多少符合条件的子集棋盘问题：N皇后，解数独等等。
Python算法题源代码-LeetCode(力扣)-全排列
02-26
力扣热题Python源代码 题目46. 全排列 给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。 示例 1： 输入：nums = [1,2,3] 输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1...
剑指Offer – 面试题38. 字符串的排列（全排列，排序，回溯+剪枝）
12-23
输入一个字符串，打印出该字符串中字符的所有排列。 你可以以任意顺序返回这个字符串数组，但里面不能有重复元素。 示例: 输入：s = "abc" 输出：["abc","acb","bac","bca","cab","cba"] 限制： 1 <= s 的长度 &...
回溯算法——排列问题（力扣46：全排列）
qq_40472852的博客
11-29 460
前言 回溯算法这个系列我们之前已经总结过， 现在复习一下 回溯算法是一种暴力的搜索算法， 坦白来讲就是穷举 一般来说这些问题遇上了首先应当考虑回溯：组合问题， 排列问题， 子集问题， 切割问题， 棋盘问题（通常都是求所有可能） 回溯算法的本质是树形问题， 所有的回溯算法都可以通过树形结构来分析 回溯的关键部分用到递归， 因此和递归一样， 考虑问题时只管当下 回溯解题步骤（事实上还是递归的解题步骤） 确立backTracking函数的参数和功能 确立终止条件 确定当前需要处理的所有可能值
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 858
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
[c语言]一句话讲清循环中break和continue的作用与区别
2303_77060768的博客
09-29 147
1.两者的作用break和contuinue都只能在循环中使用，都用来停止循环。​​​​​​​2.两者的区别break在循环中只要遇到break，就直接永久终止当前循环，开始执行当前循环之外的代码。在循环中只要遇到continue，就结束本次循环，继续进行下一次循环。
C++：图的最短路径问题
han2205277149的博客
10-04 712
最短路径问题是图的一个比较典型的应用问题。例如，给定某公路网的n个城市以及这些城市之间相通公路的距离，能否找到城市A到城市B之间一条距离最近的通路呢？如果将城市用顶点表示城市间的公路用边表示，公路的长度作为边的权值，这个问题就归结为在网图中求顶点A和顶点B的最短路径。
第 21 章 一条记录的多幅面孔——事务的隔离级别与 MVCC
weixin_45740473的博客
10-02 903
并发的事务在运行过程中会出现一些可能的引发一致性问题SQL 标准中有4种隔离级别版本链ReadView。
【C++】stack和queue的使用及注意事项
wangnaisheng的专栏
09-28 660
【C++】stack和queue的使用及注意事项
C - Separated Lunch
最新发布
m0_74304371的博客
10-05 191
C - Separated Lunch(KEYENCE Programming Contest 2024 (AtCoder Beginner Contest 374))
力扣 回溯算法 java
10-18
力扣是一个在线编程平台，提供了大量的算法题目，可以帮助程序员提高算法能力。回溯算法是一种搜索算法，它通过不断地尝试所有可能的解来求解问题。在回溯算法中，我们首先定义一个解空间，然后从解空间中搜索所有可能的解，直到找到符合要求的解为止。回溯算法通常用于求解组合问题、排列问题、子集问题等。 在 Java 中实现回溯算法，通常需要定义一个递归函数来搜索解空间。在递归函数中，我们首先判断当前状态是否符合要求，如果符合要求，则将当前状态加入到解集中；否则，我们继续搜索下一个状态。在搜索下一个状态时，我们需要对当前状态进行一些修改，然后递归调用自身来搜索下一个状态。当搜索完所有可能的状态后，我们需要回溯到上一个状态，继续搜索其他可能的状态。 以下是回溯算法的一般步骤： 1. 定义解空间：确定问题的解空间，并定义一个数据结构来表示解空间中的每个状态。 2. 确定约束条件：确定哪些状态是合法的，并定义一个函数来判断当前状态是否符合要求。 3. 确定搜索策略：确定搜索解空间的顺序，并定义一个函数来生成下一个状态。 4. 搜索解空间：使用递归函数搜索解空间，如果当前状态符合要求，则将其加入到解集中；否则，继续搜索下一个状态。 5. 回溯：当搜索完所有可能的状态后，回溯到上一个状态，继续搜索其他可能的状态。 以下是一个力扣题目的回溯算法 Java 实现示例： ``` class Solution { List<List<Integer>> res = new ArrayList<>(); List<Integer> path = new ArrayList<>(); public List<List<Integer>> subsets(int[] nums) { dfs(nums, 0); return res; } private void dfs(int[] nums, int start) { res.add(new ArrayList<>(path)); for (int i = start; i < nums.length; i++) { path.add(nums[i]); dfs(nums, i + 1); path.remove(path.size() - 1); } } } ``` 该算法用于求解给定数组的所有子集。在递归函数中，我们首先将当前状态加入到解集中，然后从当前位置开始搜索下一个状态。在搜索下一个状态时，我们将当前元素加入到路径中，并递归调用自身来搜索下一个状态。当搜索完所有可能的状态后，我们需要回溯到上一个状态，继续搜索其他可能的状态。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值