力扣回溯法40\216\90\491\47

已于 2022-02-20 16:53:03 修改
阅读量113 收藏
点赞数
文章标签： 1024程序员节 算法 c++
于 2021-10-24 15:46:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44535077/article/details/120932597
版权

回溯法问题包括：

  1. 组合问题
  2. 子集问题
  3. 子序列问题
  4. 排列问题

回溯法问题解决起来大同小异
40.组合总和II
首先是代码模板和解答树（这一步最好在脑中有大概的想象）
（参考自https://programmercarl.com/）
https://programmercarl.com/%E5%9B%9E%E6%BA%AF%E7%AE%97%E6%B3%95%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html#%E5%85%B6%E4%BB%96%E8%AF%AD%E8%A8%80%E7%89%88%E6%9C%AC

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

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

第二步：实现细节（考虑树形结构中每一层和每一个树枝对元素的操作）
A. 如果题目要求同一元素不能重复遍历，那么我们在回溯函数中需要将每一次开始遍历的位置记录下来，记为start，每一次遍历从上一次遍历的地方+1开始

B. 如果题目中包含重复元素而且不是子序列问题，那么就先对数组进行排序，再通过回溯函数的循环中建立used数组用以记录该层元素的使用情况（由于used在每一层即每一次递归都是独立建立的，因此每层递归之间used没有影响），使用used数组和原数组排序后可以解决重复元素的问题

（为什么一定要先经过排序？那是因为假设数组{2，6，7，6，7}求不重复子集，如果不经过排序，考虑第一层即子集内元素为0，在遍历到第一个6时会生成以6为开头的子集例如{6，7}，在遍历到第一个7时，由于元素7的used记录它还未被使用，那么会导致生成例如{7，6}的子集，这样就会产生重复子集。而如果我们先经过排序{2，6，6，7，7}，那么在遇到第一个6时会生成{6，7}，在遍历到7时后面的元素没有6那就一定不会产生重复）

C. 如果题目要求包含重复元素的子序列问题，那么就不能提前排序（因为排序后就会改变了原有的排序性质）。这时候解决重复元素的方法也是像上面一样，每层递归维护一个自身的used数组用以该层使用的元素情况
（为什么子序列问题不需要经过排序也能解决重复元素的问题呢？因为子序列问题是求不重复的递增或递减子序列，假设求递增子序列，{2，6，7，6，7}，不会出现上面重复出现{6，7}{7，6}的原因是我们为了得到递增序列，我们会添加nums[i] > temp.back()，也就是说新加入的元素必须要大于结果数组中的最后一个元素，换言之就是这样的一个条件相当于提前数组排序的作用，因此不会出现重复的子序列）

D. 如果题目要求包含重复元素的排列问题（暂时碰到的是全排列问题），由于全排列问题需要包含原有数组中所有的元素，因此遍历到哪个元素后都需要遍历它之前和之后的元素，因此需要解决重复遍历同一元素以遍历重复元素的问题，这个时候就必须在递归过程维护一个数组used用以记录访问元素的情况，即将used作为递归函数的参数用以传递。used数组在每个树枝即从初始元素到最后元素整个过程生效，直到下一个元素才重置

组合问题

基础的组合问题，给定一个集合，要求输出符合条件的不重复组合（即结果数组中的元素排列不同依然为同一种结果）。

由于回溯法相当于一颗树的遍历，去重分为三种：
1、自身元素的去重（即同一位置的元素不能重复选取）（startindex）
2、树层上不能重复选择同一数值元素（排序和used，使用上一元素与当前元素对比去重）
3、树枝上不能重复选择同一数值元素（排序和used）

回溯法就相当于树层遍历等同于循环，树枝是递归，控制去重从这两个方面进行入手

不重复元素

对于不重复元素，由于数组中的元素不重复，因此只要不选择之前选择过的元素，组合就不会重复。

使用startindex标定每次开始遍历的元素，这样每次开始的位置均为上一次的下一元素，因此同一位置的元素就不会重复选取，也不会出现重复组合
77

class Solution {
public:
    vector<vector<int> > result;
    vector<int> path;
    void getcombine(int n,int k,int startindex){
        if(path.size() == k){
            result.push_back(path);
            return;
        }
        for(int i = startindex;i <= n - (k - path.size()) + 1;++i){
            path.push_back(i);
            getcombine(n,k,i + 1);
            path.pop_back();
        }
    }
    vector<vector<int>> combine(int n, int k) {
        getcombine(n,k,1);
        return result;
    }
};

216

class Solution {
public:
    vector<vector<int> > result;
    vector<int> path;
    void backtracking(int targetnum,int k,int sum,int startindex){
        if(sum > targetnum){
            return;
        }
        if(path.size() == k){
            if(sum == targetnum)result.push_back(path);
            return;
        }
        for(int i = startindex;i <= 9 - (k - path.size()) + 1;++i){
            sum += i;
            path.push_back(i);
            backtracking(targetnum,k,sum,i + 1);
            sum -= i;
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum3(int k, int n) {
        backtracking(n,k,0,1);
        return result;
    }
};

39

class Solution {
public:
    vector<vector<int> > res;
    vector<int> path;
    void backtracking(vector<int>& candidates,int target,int startindex,int sum){
        if(sum > target){
            return;
        }
        if(sum == target){
            res.push_back(path);
            return;
        }
        for(int i = startindex;i < candidates.size();++i){
            sum += candidates[i];
            path.push_back(candidates[i]);
            backtracking(candidates,target,i,sum);
            sum -= candidates[i];
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        backtracking(candidates,target,0,0);
        return res;
    }
};

131

class Solution {
private:
    vector<vector<string>> result;
    vector<string> path; // 放已经回文的子串
    void backtracking (const string& s, int startIndex) {
        // 如果起始位置已经大于s的大小，说明已经找到了一组分割方案了
        if (startIndex >= s.size()) {
            result.push_back(path);
            return;
        }
        for (int i = startIndex; i < s.size(); i++) {
            if (isPalindrome(s, startIndex, i)) {   // 是回文子串
                // 获取[startIndex,i]在s中的子串
                string str = s.substr(startIndex, i - startIndex + 1);
                path.push_back(str);
            } else {                                // 不是回文，跳过
                continue;
            }
            backtracking(s, i + 1); // 寻找i+1为起始位置的子串
            path.pop_back(); // 回溯过程，弹出本次已经填在的子串
        }
    }
    bool isPalindrome(const string& s, int start, int end) {
        for (int i = start, j = end; i < j; i++, j--) {
            if (s[i] != s[j]) {
                return false;
            }
        }
        return true;
    }
public:
    vector<vector<string>> partition(string s) {
        result.clear();
        path.clear();
        backtracking(s, 0);
        return result;
    }
};

重复元素

对于重复元素的情况，只靠startindex是不够的，因为可能会出现后面元素与前面元素相同的情况导致组合重复，例如1，2，3，2，3只记录startindex的话可能会出现两个2，3

树层需要去重，也就是同一层不能选择重复数值元素，树枝不需要去重，也就是每次递归新加入的元素数值可以重复（例如1，2，2，2，可以出现2，2，但不能出现两次2，2，此时只要控制第二次第一个选取的元素不为2即可）

两种方法去重：
1、使用startindex对同一树枝上上层元素自身的去重，使用排序和used对同一树层同一树枝的去重（后面全排列会用到）：对元素进行排序，排序后相同元素会相邻，设置used数组或unordered_set记录元素使用情况，配合排序，分为：
1a、当前元素等于上一元素且used上一元素为false，说明同一树层使用过相同元素，跳过
1b、当前元素等于上一元素且used上一元素为true，说明同一树枝上前一层用过，没问题
1c、当前元素不等于上一元素，没问题

由于used在树层和树枝上都需要使用，因此used应为全局变量，在树枝返回（即递归返回时需要将对应值复原）

2、使用startindex对同一树枝上上层元素自身的去重，使用排序和startindex对同一树层同一树枝的去重：这里不需要上一步使用used的原因是startindex本身就是指向上一层使用元素的下一个元素，树枝就是从下一元素开始遍历，所以和上一层没关系；同一树层的元素，只要当前遍历的元素的位置大于这一层一开始的位置且当前元素等于上一元素，那么就重复了

40
使用startindex对同一树枝上上层元素自身的去重，使用排序和used对同一树层同一树枝的去重

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& candidates, int target, int sum, int startIndex, vector<bool>& used) {
        if (sum == target) {
            result.push_back(path);
            return;
        }
        for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
            // used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
            // used[i - 1] == false，说明同一树层candidates[i - 1]使用过
            // 要对同一树层使用过的元素进行跳过
            if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) {
                continue;
            }
            sum += candidates[i];
            path.push_back(candidates[i]);
            used[i] = true;
            backtracking(candidates, target, sum, i + 1, used); // 和39.组合总和的区别1，这里是i+1，每个数字在每个组合中只能使用一次
            used[i] = false;
            sum -= candidates[i];
            path.pop_back();
        }
    }

public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        vector<bool> used(candidates.size(), false);
        path.clear();
        result.clear();
        // 首先把给candidates排序，让其相同的元素都挨在一起。
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0, 0, used);
        return result;
    }
};

使用startindex对同一树枝上上层元素自身的去重，使用排序和startindex对同一树层同一树枝的去重

class Solution {
public:
    vector<vector<int> > res;
    vector<int> path;
    void backtracking(vector<int>& candidates,int target,int sum,int startindex){
        if(sum == target){
            res.push_back(path);
            return;
        }
        for(int i = startindex;i < candidates.size()&&sum + candidates[i] <= target;++i){
            if(i > startindex&&candidates[i - 1] == candidates[i]){
                continue;
            }
            sum += candidates[i];
            path.push_back(candidates[i]);
            backtracking(candidates,target,sum,i + 1);
            sum -= candidates[i];
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(),candidates.end());
        backtracking(candidates,target,0,0);
        return res;
    }
};

子集问题

子集问题其实就约等于组合问题，只是组合问题需要的是叶子节点（也就是最终结果），子集问题需要的是所有节点，所以只需要在组合问题上，把每一步的结果加入到res中即可

不重复元素

78

class Solution {
public:
    vector<vector<int> > res;
    vector<int> path;
    void backtracking(vector<int> &nums,int startindex){
        res.push_back(path);
        for(int i = startindex;i < nums.size();++i){
            path.push_back(nums[i]);
            backtracking(nums,i + 1);
            path.pop_back();
        }
    } 
    vector<vector<int>> subsets(vector<int>& nums) {
        backtracking(nums,0);
        return res;
    }
};

重复元素

90

class Solution {
public:
    vector<vector<int> > res;
    vector<int> path;
    void backtracking(vector<int>& nums,int startindex,vector<bool>& used){
        res.push_back(path);
        for(int i = startindex;i < nums.size();++i){
            if(i > 0&&nums[i - 1] == nums[i]&&used[i - 1] == false){
                continue;
            }
            path.push_back(nums[i]);
            used[i] = true;
            backtracking(nums,i + 1,used);
            path.pop_back();
            used[i] = false; 
        }
    }
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        vector<bool> used(nums.size(),false);
        sort(nums.begin(),nums.end());
        backtracking(nums,0,used);
        return res;
    }
};

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startIndex) {
        result.push_back(path);
        for (int i = startIndex; i < nums.size(); i++) {
            // 而我们要对同一树层使用过的元素进行跳过
            if (i > startIndex && nums[i] == nums[i - 1] ) { // 注意这里使用i > startIndex
                continue;
            }
            path.push_back(nums[i]);
            backtracking(nums, i + 1);
            path.pop_back();
        }
    }

public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        result.clear();
        path.clear();
        sort(nums.begin(), nums.end()); // 去重需要排序
        backtracking(nums, 0);
        return result;
    }
};

递增子序列

递增子序列问题和组合问题中的重复元素类似，只是子序列问题，不能通过排序进行去重，但是本来排序的原因只是因为我们需要借助上一位置的元素和当前元素比较进行去重，现在求递增子序列自然要引入递增条件，因此起到排序的效果。

每次加入元素需要将他与path最后一个元素进行大小比较

也不能使用startindex和排序进行去重了，因为不能排序导致原数组中的同一数值元素并不相邻，必须要用used。used也不用在树枝中传递，因为树枝中不会重复选择同一数值元素，因为递增。但如果不是严格递增的话，那也没问题

491

class Solution {
public:
    vector<vector<int> > res;
    vector<int> path;
    void backtracking(vector<int>& nums,int startindex){
        if(path.size() > 1){
            res.push_back(path);
        }
        int used[201] = {0};
        for(int i = startindex;i < nums.size();++i){
            if((!path.empty()&&nums[i] < path.back())||used[nums[i] + 100] != 0){
                continue;
            }
            used[nums[i] + 100] = 1;
            path.push_back(nums[i]);
            backtracking(nums,i + 1);
            path.pop_back();
        }
    }
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        backtracking(nums,0);
        return res;
    }
};
注意

这里的递增子序列和前面的组合总和40，我尝试使用该方法，不排序不传递，每次递归建立一个used数组记录当前层的元素使用情况，测试用例没问题，但是提交的时候会出现超时问题，但组合总和不会，怀疑是candidate数组元素太大会造成超时情况，毕竟回溯法是穷举性质，40中用到15大小的candidate，递增子序列使用的是100。（详细原因没去分析）

全排列

全排列问题特殊点在于不需要startindex，因为当前遍历会遍历上一个元素之前的店（全排列和元素排序有关，例如2，3和3，2就是两种结果）

所以使用used数组记录树枝上使用过的元素情况

不重复元素

46

class Solution {
public:
    vector<vector<int> > res;
    vector<int> path;
    void backtracking(vector<int>& nums,vector<int>& used){
        if(path.size() == nums.size()){
            res.push_back(path);
            return;
        }
        for(int i = 0;i < nums.size();++i){
            if(used[i] == 1){
                continue;
            }
            used[i] = 1;
            path.push_back(nums[i]);
            backtracking(nums,used);
            used[i] = 0;
            path.pop_back();
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        vector<int> used(nums.size(),0);
        backtracking(nums,used);
        return res;
    }
};

重复元素

对于重复元素，此时需要同时考虑同一树层和同一树枝上的去重问题

所以还是使用排序去重的方法，比较上一元素和当前元素

47

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    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 (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
                continue;
            }
            if (used[i] == false) {
                used[i] = true;
                path.push_back(nums[i]);
                backtracking(nums, used);
                path.pop_back();
                used[i] = false;
            }
        }
    }
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        result.clear();
        path.clear();
        sort(nums.begin(), nums.end()); // 排序
        vector<bool> used(nums.size(), false);
        backtracking(nums, used);
        return result;
    }
};

分割线----------------------------------------------

6. 组合总和 II
给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用一次。

注意：解集不能包含重复的组合。 

 

示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]
示例 2:

输入: candidates = [2,5,2,1,2], target = 5,
输出:
[
[1,2,2],
[5]
]
 

提示:

1 <= candidates.length <= 100
1 <= candidates[i] <= 50
1 <= target <= 30

class Solution {
public:
    vector<vector<int> > res;
    vector<int> temp;
    void getcombinationSum2(vector<int>& candidates,int target,int ans,int start){
        if(ans == target){
            res.push_back(temp);
            return;
        }
        if(ans > target){
            return;
        }
        vector<int> flag(51,0);
        for(int i = start;i < candidates.size();++i){
            if(flag[candidates[i]] == 1){
                continue;
            }
            temp.push_back(candidates[i]);
            ans += candidates[i];
            flag[candidates[i]] = 1;
            getcombinationSum2(candidates,target,ans,i + 1);
            temp.pop_back();
            ans -= candidates[i];
        }
        return;
    }
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(),candidates.end());
        getcombinationSum2(candidates,target,0,0);
        return res;
    }
};


class Solution {
public:
    vector<vector<int> > res;
    vector<int> path;
    void backtracking(vector<int>& candidates,int target,int sum,int startindex){
        if(sum == target){
            res.push_back(path);
            return;
        }
        for(int i = startindex;i < candidates.size()&&sum + candidates[i] <= target;++i){
        //注意这里判断语句中i > startindex要写在首位，放在
        //后面的话会出现当i = 0时，判断语句先判断i - 1导致
        //下标溢出，如果非要这样写的话就要加上i ！= 0的
        //判断语句。如果按现在这样写的话，判断语句就不会先执行i - 1
            if(i > startindex&&candidates[i - 1] == candidates[i]){
                continue;
            }
            sum += candidates[i];
            path.push_back(candidates[i]);
            backtracking(candidates,target,sum,i + 1);
            sum -= candidates[i];
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(),candidates.end());
        backtracking(candidates,target,0,0);
        return res;
    }
};

216. 组合总和 III
找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。

说明：

所有数字都是正整数。
解集不能包含重复的组合。 
示例 1:

输入: k = 3, n = 7
输出: [[1,2,4]]
示例 2:

输入: k = 3, n = 9
输出: [[1,2,6], [1,3,5], [2,3,4]]

class Solution {
public:
    vector<vector<int> > res;
    vector<int> temp;
    void getcombinationsum(int k,int n,int start,int ans){
        if(ans > n){
            return;
        }
        if(temp.size() == k){
            if(ans == n){
                res.push_back(temp);
            }
            return;
        }
        else{
            for(int i = start;i <= 9;++i){
                temp.push_back(i);
                ans += i;
                getcombinationsum(k,n,i + 1,ans);
                ans -= i;
                temp.pop_back();
            }
            return;
        }
    }
    vector<vector<int>> combinationSum3(int k, int n) {
        getcombinationsum(k,n,1,0);
        return res;
    }
};

90. 子集 II
给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。

 

示例 1：

输入：nums = [1,2,2]
输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]
示例 2：

输入：nums = [0]
输出：[[],[0]]
 

提示：

1 <= nums.length <= 10
-10 <= nums[i] <= 10

class Solution {
public:
    vector<vector<int> > res;
    vector<int> tmp;
    void getsubsetsWithDup(vector<int>& nums,int start){
        if(!tmp.empty()){
            res.push_back(tmp);
        }
        vector<int> used(21,0);
        for(int i = start;i < nums.size();++i){
            if(used[nums[i] + 10] == 1){
                continue;
            }
            tmp.push_back(nums[i]);
            used[nums[i] + 10] = 1;
            getsubsetsWithDup(nums,i + 1);
            tmp.pop_back();
        }
        return;
    }
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        vector<int> emptyV = {};
        res.push_back(emptyV);
        vector<bool> used(nums.size(),false);
        sort(nums.begin(),nums.end());
        getsubsetsWithDup(nums,0);
        return res;
    }
};

491. 递增子序列
给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。

数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。

 

示例 1：

输入：nums = [4,6,7,7]
输出：[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]
示例 2：

输入：nums = [4,4,3,2,1]
输出：[[4,4]]
 

提示：

1 <= nums.length <= 15
-100 <= nums[i] <= 100

class Solution {
public:
    vector<vector<int> > res;
    vector<int> temp;
    void getSubsequences(vector<int>& nums,int start){
        if(temp.size() > 1){
            res.push_back(temp);
        }
        int used[201] = {0};
        for(int i = start;i < nums.size();++i){
            if((!temp.empty()&&nums[i] < temp.back())||used[nums[i] + 100] != 0){
                continue;
            }
            temp.push_back(nums[i]);
            used[nums[i] + 100] = 1;
            getSubsequences(nums,i + 1);
            temp.pop_back();
        }
        return;
    }
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        res.clear();
        temp.clear();
        getSubsequences(nums,0);
        return res;
    }
};

47. 全排列 II
给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

 

示例 1：

输入：nums = [1,1,2]
输出：
[[1,1,2],
 [1,2,1],
 [2,1,1]]
示例 2：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
 

提示：

1 <= nums.length <= 8
-10 <= nums[i] <= 10

class Solution {
public:
    vector<vector<int> > res;
    vector<int> temp;
    void getpermuteUnique(vector<int>& nums,vector<int>& used){
        if(temp.size() == nums.size()){
            res.push_back(temp);
            return;
        }
        for(int i = 0;i < nums.size();++i){
            if(i > 0&&nums[i] == nums[i - 1]&&used[i - 1] == 0){
                continue;
            }
            if(used[i] == 1){
                continue;
            }
            temp.push_back(nums[i]);
            used[i] = 1;
            getpermuteUnique(nums,used);
            temp.pop_back();
            used[i] = 0;
        }
        return;
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        res.clear();
        temp.clear();
        vector<int> used(nums.size() + 1,0);
        sort(nums.begin(),nums.end());
        getpermuteUnique(nums,used);
        return res;
    }
};

未完待续

南拳北腿周星星
关注
回溯-力扣-java
a716121的专栏
05-24 181
class Solution { public boolean exist(char[][] board, String word) { char []words=word.toCharArray(); for(int i=0;i<board.length;i++){ for(int j=0;j<board[0].length;j++){ if(dfs(board,words,i,j,0)...
【回溯算法】-力扣总结
嗑盐工作室
12-31 377
回溯算法的基本思想是：从一条路往前走，能进则进，不能进则退回来，换一条路再试。 回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法。适用于求解组合数较大...
算法学习——LeetCode力扣回溯篇1（77. 组合、216. 组合总和 III、17. 电话号码的字母组合、39. 组合总和）
拉依达不拉跨的博客
02-14 2001
算法学习——LeetCode力扣回溯篇1（77. 组合、216. 组合总和 III、17. 电话号码的字母组合、39. 组合总和）
力扣刷题笔记 回溯算法及其相关题目（含ACM模式）
sangedianhao的博客
03-02 416
代码随想录》学习笔记，原链接：https://programmercarl.com/
力扣-回溯法
weixin_63551790的博客
07-12 919
对于回溯法，首先找到边界条件以及结束的条件。一般为设置的i等于行数。边界条件一般为不要越界。一般还需要设置标记函数。然后一行一行进行访问或者一个位置一个位置的访问，访问过的标记函数置为true。接着继续下一个或者下一行（一般是递归）。然后结束后还原上面的标记函数以及board（一般会设置一个作为答案）。符合的就push_back到ans数组中去。
回溯法——力扣题型全解【更新中】
weixin_43757333的博客
03-09 540
以前回溯时，我们只需要一个sum即可，比如上面那题分为两个等和子集，实际上只需要考虑一个即可。但是本题有k个，所以我们可以设置k个桶，然后每次dfs时使用一个球，将其放到1~k个桶里面。此外这里还有三个剪枝的方法，具体可以看上面那篇文章讲的很详细。
20210810力扣回溯法部分整理（java）
EenKine的博客
08-10 326
前言 之前做过的题，现在回看的时候又不会做了，所以我又重新看了看回溯法，又看了一下代码随想录的视频讲解。 将他的视频笔记写在这里。 # 回溯算法 回溯 <---->递归 1.递归的下面就是回溯的过程 2.回溯法是一个 纯暴力的 搜索 3.回溯法解决的问题： 3.1组合 如：1234 两两组合 3.2切割问题 如：一个字符串有多少个切割方式 ，或者切割出来是回文 3.3子集 ： 1 2 3 4 的子集 3.4排列问题（顺序） 3.5棋盘问题：n皇后 解数独 4
力扣专题. 回溯法
爱学习i的博客
10-06 597
1. 回溯法与深度遍历的联系以及不同点： 回溯法采用试错的思想，它尝试分步的去解决一个问题。当它发现分步的答案不能得到有效的解决时就会退回上一步甚至上几步。回溯法通常用递归的方法来解决。 深度遍历是树的一种遍历方法，它强调的是一头扎到底然后再往回走的途中去遍历其它结点，这个过程会一直持续到初始的根结点。 2.回溯法与动态规划的区别和共同点： 共同点： 一个问题都能够分为很多步骤来解决； 每一个步骤包含了很多种选择； 不同点： 动态规划强调的是问题的最优解，它只需要知道最终的结果； 回溯可以搜索到问
力扣回溯算法题目法总结
秀秀的奇妙旅行
03-24 563
void backtracking(){//一般回溯法的递归函数没有返回值 //参数要根据具体情况进行确定 if(终止条件) { 收集结果 //子集问题每一个节点都要去收集结果，组合排列等叶子节点是收集结果 return } for(集合的元素集，类似子节点的个数) { 处理结点 递归函数； 回溯操作 （撤销处理结点12， 2撤销 ，13 撤销3， 14） } } ...
力扣题型总汇——回溯算法
qq_51329170的博客
03-21 987
回溯算法总结： 题目： Day59:77组合
回溯算法——棋盘问题（力扣37： 解数独）
qq_40472852的博客
11-25 662
前言 回溯算法这个系列我们之前已经总结过， 现在复习一下 回溯算法是一种暴力的搜索算法， 坦白来讲就是穷举 一般来说这些问题遇上了首先应当考虑回溯： 组合问题：给定有n个整数的集合， 从中选出所有包含k个 数的组合 排列问题：给定有n个整数的集合， 求n个数的所有的排列方式 子集问题：给定有n个整数的集合， 求其所有子集 切割问题：按一定规则对字符串进行切割， 求所有切割方式 棋盘问题：N皇后， 数独等等， 求所有解 回溯算法的本质是树形问题， 所有的回溯算法都可以通过...
回溯算法模板总结+力扣原题解析
agentky的博客
07-20 828
回溯算法复杂度分析 回溯本质是遍历所有可能的情况，所以复杂度会比较高，但可以通过剪枝来优化。 子集问题：由于每个元素只有选择或者不选两种，所以遍历到每一种情况，时间复杂度为O(2^n),再加上构造的每一组子集都需要放入数组，需要o(n),所以总共O（n * 2^n）.空间复杂度，递归深度n,系统栈所用空间O(n)； 排列问题：时间复杂度O(N!)，第一层n个分枝，第二层每个分支又有n-1分支。所以nn-1n-1…*1=n!，空间复杂度O(N) 组合问题：组合问题就是一种子集问题（组合一般限制元素个数） 回溯
js回溯法解n皇后（力扣51）
mus-z的博客
08-14 462
n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。 上图为 8 皇后问题的一种解法。 给定一个整数 n，返回所有不同的 n 皇后问题的解决方案。 每一种解法包含一个明确的 n 皇后问题的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。 示例: 输入: 4 输出: [ [".Q..", // 解法 1 "...Q", "Q...", "..Q."], ["..Q.", // 解法 2 "Q...", "...Q",
力扣刷题----组合总和(39、40) 回溯+递归算法
qq_38235017的博客
10-15 463
一、组合总和(可重复选取) 给定一个无重复元素的数组candidates和一个目标数target，找出candidates中所有可以使数字和为target的组合。 candidates中的数字可以无限制重复被选取。 说明：所有数字（包括target）都是正整数。解集不能包含重复的组合。 示例1： 输入：candidates = [2,3,6,7], target = 7, 所求解集为： [[7],[2,2,3]] 示例2： 输入：candidates = [2,3,5...
力扣刷题笔记 回溯篇
weixin_45067603的博客
08-11 478
总结先放在前面： 解答栈与队列时的一些小技巧与注意点： 题目实战 1.NO.77. 组合 2.NO.77. 组合 3.NO.77. 组合 4.NO.77. 组合 5.NO.77. 组合 6.NO.77. 组合 7.NO.77. 组合 8.NO.77. 组合 9.NO.77. 组合 10.NO.77. 组合
数对的最大曼哈顿距离[ABC178E] Dist Max
2301_80882026的博客
10-30 499
/曼哈顿距离化简绝对值之后最终可以化简为两种取最大的即可PII p[N];cin >> n;i <= n;
代码随想录训练营Day12 | 110.平衡二叉树 - 257二叉树的所有路径 - 404.左叶子之和 - 222.完全二叉树的节点个数
Zuoriqiufeng的博客
10-30 403
【代码】代码随想录训练营Day12 | 110.平衡二叉树 - 257二叉树的所有路径 - 404.左叶子之和 - 222.完全二叉树的节点个数。
xtu oj 连接字符串
Go offline for a while
10-30 964
最后总结一下：这题思路比较直观，找公共的元素，代码细节比较多，一个是要求输出字典序小的，第二是前面字符串要枚举完最后一个元素才算满足条件，第三是两个字符串可能完全没有公共部分，需要特判。
二分查找算法—C++
最新发布
2401_82677021的博客
11-03 320
关于求中点位置的操作什么时候需要加1，什么时候不需要。只需看下面的left和right ，如果出现-1，mid就需要加1。否则，不需要加1.
力扣 回溯算法 java
10-18
以下是一个力扣题目的回溯算法 Java 实现示例： ``` class Solution { List<List<Integer>> res = new ArrayList(); List<Integer> path = new ArrayList(); public List<List<Integer>> subsets(int[] nums) {...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值