回溯算法模板总结+力扣原题解析

回溯算法复杂度分析
回溯本质是遍历所有可能的情况，所以复杂度会比较高，但可以通过剪枝来优化。
子集问题：由于每个元素只有选择或者不选两种，所以遍历到每一种情况，时间复杂度为O(2^n),再加上构造的每一组子集都需要放入数组，需要o(n),所以总共O（n * 2^n）.空间复杂度，递归深度n,系统栈所用空间O(n)；
排列问题：时间复杂度O(N!)，第一层n个分枝，第二层每个分支又有n-1分支。所以nn-1n-1…*1=n!，空间复杂度O(N)
组合问题：组合问题就是一种子集问题（组合一般限制元素个数）

回溯算法通常用来解决的问题
组合问题：在n个数里面按照一定规则找出k个数的集合
排列问题：n个数按照一定规则排列，有几种排列方式
切割问题：一个字符串按一定规则有几种切割方式
子集问题：一个n个数的集合里有多少符合条件的子集

回溯法模板

void backtracking(参数) {
if (终⽌条件) 
{
	存放结果;
	return;
}
for (选择：本层集合中元素（树中节点孩⼦的数量就是集合的⼤⼩） )
 {
	处理节点;
	backtracking(路径，选择列表); // 递归
	回溯，撤销处理结果
}
}

回溯算法的各种技巧和注意点
去重手法：
利用used数组记录元素是否访问过，实现同一树层和同一树枝去重,这里要注意used数组是作为函数参数传递，还是每一个for前重置以实现同一层用一个used，不同层用不同used

以下的题目都是力扣原题

组合问题

组合问题是不能交换元素位置的 也就是（1，2）（2，1）是同一个组合

组合

题目：给定两个整数 n 和 k，返回 1 … n 中所有可能的 k 个数的组合。

牢记回溯的本质是暴力解，枚举所有的情况，多叉树，利用for来遍历每个节点的所有分支。
由于前面同一个树枝上，前面选择过的元素后面不能再选，所以用startindex来控制选择的范围。

这个题也是套常规的回溯模板

但要加一个剪枝 就是如果剩下的元素已经不足还需要的元素就要没必要继续下去了

#include<iostream>
using namespace std;
#include<vector>

class Solution 
{
public:
    vector<vector<int>> res;
    vector<vector<int>> combine(int n, int k) 
    {
        vector<int> temp;
        backstacking(temp,n,k,1);
        return res;
    }
    void backstacking(vector<int>& temp,int n,int k,int StartIndex)
    {
        if (temp.size() == k)
        {
            res.push_back(temp);
            return;
        }

        //剪枝优化  如果剩下的元素已经不足还需要的元素就要没必要继续下去了
        //已经选择的元素个数 temp.size()  
        //还需要  k-temp.size()
        //集合至少要从n-(k-temp.size())+1
        for (int i = StartIndex; i <= n - (k - temp.size()) + 1; i++)
        {
            temp.push_back(i);
            backstacking(temp, n, k, i + 1);
            temp.pop_back();
        }
    }
};c++

组合问题3

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

说明：

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

组合问题在在做单层选择时要使用start_index,避免重复组合

剪枝：元素数量总和剪枝 for循环的范围剪枝

#include<iostream>
using namespace std;
#include<vector>
#include <unordered_set>
class Solution {
public:
    vector<vector<int>> res;
    vector<vector<int>> combinationSum3(int k, int n) 
    {
        //记录所有的路径  
        vector<int> temp;
       // unordered_set<int> hash_set;
    
        dfs( temp, k, n,0,1);
        return res;
    }

    //i 已经用掉了几个数
    //sum 当前的总和
    //temp 存放当前的路径
   
    void dfs(vector<int>& temp,int k,int n,int sum,int start_index)
    {
        if (temp.size() == k && sum == n)
        {
            res.push_back(temp);
            return;
        }
        if (temp.size() > k || sum > n) return;

        for (int j = start_index; j <= 9; j++)
        {            
            temp.push_back(j);
            sum += j;
         //   cout<<j<<" "<<pos<<endl;
            dfs(temp, k, n, sum ,j+1);  
            sum -= j;
            temp.pop_back();
        }


    }
};

电话号码得字母组合

前面两个组合都同一集合之间的组合，下面来看不同集合之间的组合
不同集合中的组合就不用startindex了

首先要搞清楚如何建立一个映射，将数字映射到字母组合

注意控制决策层数和树的单层遍历

#include<iostream>
using namespace std;
#include<vector>
#include<string>

class Solution {
public:

    //建立一个映射 将数字映射到字母组合
   
    string convert_map[10]
    {
       "","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"
    };
    vector<string> res;
    string path;
    vector<string> letterCombinations(string digits)
    {
        if (digits.size() == 0) return {};
        backstacking(digits, 0);
        return res;
    }
    //index控制决策树的高度
    void backstacking(string digits,int index)
    {
        if (index == digits.size())
        {
            res.push_back(path);
            return;
        }

        int nums = digits[index] - '0';//将index对应得字母转换为数字


        //单层树  遍历该数字对应得字母
        for (int i = 0; i < convert_map[nums].size(); i++)
        {
            path.push_back(convert_map[nums][i]);
            backstacking(digits, index + 1);
            path.pop_back();
        }


    }


};

组合总和

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的数字可以无限制重复被选取。

说明：

• 所有数字（包括 target）都是正整数。
• 解集不能包含重复的组合。

这个题要注意的点是：

1.不能重复 要用startindex来控制

2.for循环遍历的范围存在一个剪枝的优化点

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    vector<vector<int>> combinationSum(vector<int>& candidates, int target)
    {
        sort(candidates.begin(), candidates.end());
        backstacking(candidates, target, 0,0);
        return res;

    }

    void backstacking(vector<int>& candidates, int target, int sum,int startindex)
    {
        if (sum == target)
        {
            res.push_back(path);
            return;
        }
        if (sum > target)
        {
            return;
        }
//如果sum+接下里循环的第一个数就超过target 就没有必要进入下层遍历
        for (int i = startindex; i < candidates.size()&&sum+candidates[i]<=target; i++)
        {
            path.push_back(candidates[i]);
            sum += candidates[i]; 
            backstacking(candidates, target, sum, i);
            sum -= candidates[i];
            path.pop_back();
        }


    }
};

组合总和2

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

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

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

要注意是同一个树层上去重还是同一个树枝上去重

主要for的循环范围可以优化 只要有排序这里就可以优化

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
class Solution 
{
public:
    //遇到相同元素在树层上剪枝
    vector<vector<int>> res;
    vector<int> path;
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target)
    {
        sort(candidates.begin(), candidates.end());
        vector<bool> used(candidates.size(),false);
        backstacking(candidates, target, 0, 0,used);
        return res;
    }
    void backstacking(vector<int>& candidates, int target,int sum,int startindex,vector<bool>& used)
    {
        if (sum == target)
        {
            res.push_back(path);
            return;
        }
        if (sum > target)
        {
            return;
        }
        //
        for (int i = startindex; i < candidates.size()&&sum+candidates[i]<=target; i++)
        {
            if (i > 0 && candidates[i] == candidates[i - 1]&&used[i-1]==false) continue;
            used[i] = true;
            path.push_back(candidates[i]);
            sum += candidates[i];
            if (sum > target) return;
            backstacking(candidates, target, sum, i + 1, used);
            used[i] = false;
            path.pop_back();
            sum-= candidates[i];
        }
    }
};

切割问题

分割回文串

这个字符串处理挺麻烦的

主要是这句话

string temp = s.substr(startindex,i-startindex+1);

#include<iostream>
using namespace std;
#include<vector>
#include<string>

class Solution
{
public:
    vector<vector<string>> res;
    //每一层选择的节点都必须是回文串
    vector<vector<string>> partition(string s)
    {
        vector<string> path;
        backstacking(s, path, 0);
        return res;
    }
    //在每一个树层遍历所有的可能情况  把不是回文的删除
    //终止条件是切割完


   //检查一个字符是否是回文串
   //是回文串返回ture 不是返回false
    bool check(string s)
    {
        if (s.size() == 1)
        {
            return true;
        }
        int flag = true;
        //定义两个指针一个指向头一个指向尾
        int head = 0;
        int end = s.size() - 1;

        while (head < end)
        {
            if (s[head] != s[end])
            {
                flag = false;
            }
            head++;
            end--;
        }
        return flag;
    }
    //num 从哪个字母开始截取
    void  backstacking(string s, vector<string> path, int startindex)
    {
        if (startindex == s.size())
        {
            res.push_back(path);
            return;
        }

        //从num开始  i个字符
        for (int i = startindex; i < s.size(); i++)
        {
            //难点在于如何切分
            //同一树层应该是从同一个点开始逐渐增加切割的大小
            //同一树枝应该是startindex要往前进一位，切割大小逻辑不变
            //i-startindex+1保证了切割数量同一树层是逐个增加的
            string temp = s.substr(startindex,i-startindex+1);
            if (!check(temp))    continue;

            path.push_back(temp);
            backstacking(s, path, i + 1);
            path.pop_back();
        }
    }


};

复原ip地址

#include<iostream>
using namespace std;
#include<vector>
#include<string>
#include<cstring>

class Solution 
{
public:
    vector<string> res;
    string path;
    //一个字符串分割成四个整数   最多三位最少一位

    //剪枝条件 整数大于255  有前导0
    
    vector<string> restoreIpAddresses(string s) 
    {
        backstacking(s, 0, 0);
        return res;
    }
    //传入一个字符串  有效返回true 无效返回false
    bool is_vaild(string temp)
    {
        if (temp.size() > 3 || temp.size() == 0) return false;

        int num = stoi(temp);
        if (num > 255)   return false;
        if (temp[0] == '0' && temp.size() != 1) return false;

        return true;


    }
    void backstacking(string s,int startindex,int pointnums)
    {
        //当有三个逗点时 只需要判断剩下字符串是否满足条件
        if (pointnums == 3)
        {
            string temp = s.substr(startindex, s.size() - startindex);
           // cout<<temp<<endl;
            if (is_vaild(temp))
            {
     
                res.push_back(path+temp);
            }
            
            return;
        }
        for (int i = startindex; i < s.size(); i++)
        {
            string temp = s.substr(startindex, i - startindex + 1);
       
            if (!is_vaild(temp))  continue;
      
       
            //有效
            path += temp;
            pointnums++;
            path.push_back('.');
            backstacking(s, i + 1, pointnums);         
            pointnums--;
    
          path.erase(path.size()-(i - startindex + 2), i - startindex + 2);
        //  path.erase(startindex)

          


        }
    }

};

子集问题

子集

这个题实际上是收集所有的叶子节点就可以了，自己琢磨的时候想复杂了

收集所有的叶子节点

class Solution 
{
private:
vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int>& nums, int startIndex)
{
    result.push_back(path); // 收集⼦集，要放在终⽌添加的上⾯，否则会漏掉⾃⼰
    if (startIndex >= nums.size())
    { // 终⽌条件可以不加
    	return;
	}
    for (int i = startIndex; i < nums.size(); i++) 
    {
        path.push_back(nums[i]);
        backtracking(nums, i + 1);
        path.pop_back();
    }
}
public:
vector<vector<int>> subsets(vector<int>& nums)
{
    result.clear();
    path.clear();
    backtracking(nums, 0);
    return result;
}
};

在结尾加了一个最大值，自己h瞎写的，也可以过

#include<iostream>
using namespace std;
#include<vector>

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    vector<vector<int>> subsets(vector<int>& nums)
    {
        nums.push_back(INT_MIN);
        backstacking(nums, 0, nums.size());
        return res;
    }

    //-1
    void backstacking(vector<int>& nums, int startindex, int size)
    {
        if (startindex == size)
        {
          //  cout<<"--"<<endl;
            res.push_back(path);
            return;
        }
        for (int i = startindex; i < size; i++)
        {
            if (nums[i] != INT_MIN)
            {
              //  cout<<nums[i]<<endl;
                path.push_back(nums[i]);
            }
            backstacking(nums, i + 1, size);
            if (nums[i] != INT_MIN)
            {
                path.pop_back();
            }


        }
    }
};

递增子序列

感觉很难得一道

要注意不准排序的情况下 树层上去掉重复元素得方法

#include<iostream>
using namespace std;
#include<vector>



class Solution
{
private:
	vector<vector<int>> result;
	vector<int> path;
	void backtracking(vector<int>& nums, int startIndex)
	{
		if (path.size() > 1) 
		{
			result.push_back(path);
		}
		int used[201] = { 0 }; // 这⾥使⽤数组来进⾏去重操作，题⽬说数值范围[-100, 100]
		for (int i = startIndex; i < nums.size(); i++) 
		{
			if ((!path.empty() && nums[i] < path.back())
				|| used[nums[i] + 100] == 1) 
			{
				continue;
			}
			used[nums[i] + 100] = 1; // 记录这个元素在本层⽤过了，本层后⾯不能再⽤了
			path.push_back(nums[i]);
			backtracking(nums, i + 1);
			path.pop_back();
		}
	}
public:
	vector<vector<int>> findSubsequences(vector<int>& nums)
	{
		result.clear();
		path.clear();
		backtracking(nums, 0);
		return result;
	}
};

排列问题

全排列

题目c++

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

排列问题就不用start_index,要使用used数组记录使用过的元素

#include<iostream>
using namespace std;
#include<vector>

class Solution {
public:
    //排列问题是有顺序的
    //相当于一颗多叉树，每个节点都可以选择没用过的元素
    vector<vector<int>> res;
    vector<vector<int>> permute(vector<int>& nums)
    {
        vector<bool> used(nums.size(), false);
        vector<int> temp;
        BackTracking(nums, temp, used);
        return res;
    }
    void BackTracking(vector<int>& nums, vector<int>& temp,vector<bool>& used)
    {
        //终止条件
        if (temp.size() == nums.size())
        {
            res.push_back(temp);
            return;
        }

        for (int i = 0; i < nums.size(); i++)
        {
            //第i个数已经被用过了
            if (used[i] == true) return;
            used[i] = true;
            temp.push_back(nums[i]);
            BackTracking(nums, temp, used);
            used[i] = false;
            temp.pop_back();
        }


    }

};

全排列2

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

这道题的关键在于去重

画决策树可以知道 如果同一树层两个节点相同，那么他这两个节点对应剩下的树枝都是相同的，所以应该在树层剪枝

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>

class Solution {
public:
    //排列问题是有顺序的
    //相当于一颗多叉树，每个节点都可以选择没用过的元素
    vector<vector<int>> res;
    vector<vector<int>> permuteUnique(vector<int>& nums)
    {
        vector<bool> used(nums.size(), false);
        vector<int> temp;
        sort(nums.begin(), nums.end());
        BackTracking(nums, temp, used);
        return res;
    }
    void BackTracking(vector<int>& nums, vector<int>& temp,vector<bool>& used)
    {
        //终止条件
        if (temp.size() == nums.size())
        {
            res.push_back(temp);
            return;
        }

        for (int i = 0; i < nums.size(); i++)
        {
            //由于排过序了  如果当前这个数跟前一个数一样  就在同一树层把这个分支减掉
            if (i > 0 && nums[i - 1] == nums[i]&& used[i-1]==false ) continue;
             
            //第i个数已经被用过了
            if (used[i] == true) continue;
            used[i] = true;
            temp.push_back(nums[i]);
            BackTracking(nums, temp, used);
            used[i] = false;
            temp.pop_back();
        }


    }

};

回溯算法告一段落 接下来是几道困难题留在以后在研究
重新安排行程
N皇后
解数独