回溯算法

1.定义

回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。许多复杂的，规模较大的问题都可以使用回溯法，有“通用解题方法”的美称。

ps:回溯法是一种暴力求解的方法，类似于多层for循环。如果没有剪枝操作的话，时间复杂度与for循环相同为O（n的x次方）

---

2.算法核心

1、路径：也就是已经做出的选择。

2、选择列表：也就是你当前可以做的选择。

3、结束条件：也就是到达决策树底层，无法再做选择的条件。

回溯算法可以理解为在一棵决策树上不断做决策，不断返回的一个过程。
例如全排列问题：
要排列的数组为[1,2,3]，则会有下图的决策树。

引用labuladong的图例
每一次的选择的过程就是在决策树上从根节点到最底部节点的遍历。

而回溯的过程就是从最底层的节点，逐渐往上返回的过程。
总体：每层决策树做选择直到最下方叶节点，然后通过回溯过程，逐层返回，一直到遍历所有节点为止。

---

3.算法模板

引用LeetCode 46. 全排列，一道最初级的回溯问题。

解题代码：

class Solution {
public:
    vector<vector<int>>result;//记录答案
    vector<vector<int>> permute(vector<int>& nums) {
    //主函数
        vector<int>trace;//记录每次回溯的过程
        backtrace(nums,trace);
        return result;
    }
    void backtrace(vector<int>nums,vector<int>trace){
        if(trace.size()==nums.size()){
        //遍历到了决策树的最底层节点 添加答案
            result.push_back(trace);
            return;
        }
        for(int i=0;i<nums.size();i++){
/for循环就是每次做的选择
/例如[1,2,3] 每一次都要从1，2,3中选出一个数字加入记录过程的数组
            if(find(trace.begin(),trace.end(),nums[i])!=trace.end()){
            //遍历的数字在上一层就已经被选入（有重复）
                continue;
            }
            //做选择
            trace.push_back(nums[i]);
            //进入下一层决策树
            backtrace(nums,trace);
            //回溯，取消选择
            trace.pop_back();
        }
    }
};

解题模板要领：

1. 通过函数递归来实现进入下一层决策。例如[1,2,3]的全排列，需要决策3次，递归的终止条件为决策进入最后一层。
2. 拥有记录每次决策过程的数组。
3. 核心代码：

 			 //做选择
            trace.push_back(nums[i]);
            //进入下一层决策树
            backtrace(nums,trace);
            //回溯，取消选择
            trace.pop_back();

---

4.例题

引用LeetCode 17题

回溯算法实际上是一个不断做出选择的过程，并且每一次选择都会被记录，最终选择出所有答案(所以与暴力近似)。

这道题案例中给定的“23”字符串，可以根据字符串的长度分层，分成0、1（字符串下标）两层，每一层都可以做出自己的选择，如第0层为“2”，可以选择‘a’,‘b’,‘c’ 3个字符，第1层为‘3’，可以选择‘d’,‘e’,‘f’ 三个字符，然后通过递归进入下一层。

解题代码：

class Solution {
public: 
    vector<char>s2={'a','b','c'}; 
    vector<char>s3={'d','e','f'};
    vector<char>s4={'g','h','i'};
    vector<char>s5={'j','k','l'};
    vector<char>s6={'m','n','o'};
    vector<char>s7={'p','q','r','s'};
    vector<char>s8={'t','u','v'};
    vector<char>s9={'w','x','y','z'};

    vector<string>result;//记录最终结果
    vector<string> letterCombinations(string digits) {
       string trace;//记录每次选择的过程
       if(digits.size()==0) return result;
        backtrace(trace,digits,0);
        return result;
    }
    
    void backtrace(string trace,string digits,int n){
    //n就是第n层（字符串下标）
        if(trace.size()==digits.size()){
            result.push_back(trace);
            return;
        }
        //下面的每一个for循环都是在第n层做出所对应的数字的选择
        if(digits[n]=='2'){
            for(int i=0;i<3;i++){
                trace.push_back(s2[i]);
                backtrace(trace,digits,n+1);
                trace.pop_back();
            }
        }
          if(digits[n]=='3'){
            for(int i=0;i<3;i++){
                trace.push_back(s3[i]);
                backtrace(trace,digits,n+1);
                trace.pop_back();
            }
        }
         if(digits[n]=='4'){
            for(int i=0;i<3;i++){
                trace.push_back(s4[i]);
                backtrace(trace,digits,n+1);
                trace.pop_back();
            }
        }
         if(digits[n]=='5'){
            for(int i=0;i<3;i++){
                trace.push_back(s5[i]);
                backtrace(trace,digits,n+1);
                trace.pop_back();
            }
        }
         if(digits[n]=='6'){
            for(int i=0;i<3;i++){
                trace.push_back(s6[i]);
                backtrace(trace,digits,n+1);
                trace.pop_back();
            }
        }
         if(digits[n]=='7'){
            for(int i=0;i<4;i++){
                trace.push_back(s7[i]);
                backtrace(trace,digits,n+1);
                trace.pop_back();
            }
        }
         if(digits[n]=='8'){
            for(int i=0;i<3;i++){
                trace.push_back(s8[i]);
                backtrace(trace,digits,n+1);
                trace.pop_back();
            }
        }
         if(digits[n]=='9'){
            for(int i=0;i<4;i++){
                trace.push_back(s9[i]);
                backtrace(trace,digits,n+1);
                trace.pop_back();
            }
        }
    }
};

---

思考：

在做这道题的时候，还没有接触过回溯算法，当初的思路是能否通过实例中的字符串"23"写一个for循环：如果遇到2,运行一个for循环，再遇到3，再在上一个for循环内部生成下一个for循环,最终在最后一个for循环中求得答案。这大概就是回溯算法的本质吧，一个多层for循环的实质。

for(2){
	//2中字符
	for(3){
	//3中字符
		result=?
	}
}