回溯【基础算法精讲 14】_dfs为什么要恢复现场

视频地址 : 

回溯算法套路①子集型回溯【基础算法精讲 14】_哔哩哔哩_bilibili

基本概念

1 . 例子

例如从abc和def(n = 2)中各选出一个组成新的字符串?

 如果n很大 , 这个时候for循环的表达能力有限 ;

2 . 原问题 和 子问题

 3 . 增量构造答案

这个增量构造答案的过程就是回溯的特点 ；

回溯三问

关于恢复现场的理解

在递归到某一“叶子节点”（非最后一个叶子）时，答案需要向上返回，而此时还有其他的子树（与前述节点不在同一子树）未被递归到，又由于path为全局变量。若直接返回，会将本不属于该子树的答案带上去，故需要恢复现场。
恢复现场的方式为：在递归完成后 dfs(i+1); 后，进行与“当前操作”相反的操作，“反当前操作”。 

17 . 电话号码的字母组合

这也就是n(n=8)个字符串中选两个的组合问题 ;

思路 : 

1 . 先创建一个下标 与 对应字符串映射的数组，这里使用hash表进行映射也是可以的 ；

2 . 对于回溯 ， 如果到了叶子节点 ， 那么就直接添加即可 ， 对于每一个path[i],都是存放digits[i]中数字字符对应字符串中的一个字符 ， 遍历该字符串 ， 对每一个字符进行递归操作 ；

3 . 对于不用恢复现场 : 因为每次递归到 i，一定会修改 path【i】，那么递归到终点时，每个 path【i】 都被覆盖成要枚举的字母，所以不需要恢复现场。

代码实现 : 

class Solution {
public:
    const string mp[10] = {
        "",      //0
        "",     //1 
        "abc",  //2
        "def",  //3
        "ghi",  //4
        "jkl",  //5
        "mno",  //6
        "pqrs", //7
        "tuv",  //8
        "wxyz", //9
    };
    vector<char> path ;
    vector<string> ans ;
    int n ; 
 
    string get(){
        string tmp = "" ;
        for(char c : path){
            tmp += c ;
        }
        return tmp ;
    }
 
    void dfs(string digits , int i){
        // 先写递归终止条件
        if(i == n){
            ans.push_back(get()) ;
            return ; // 回溯
        }
        for(char c : mp[digits[i]-'0']){
            path[i] = c ;
            dfs(digits , i + 1) ;
            // 因为每一次path[i]都会被覆盖 ， 那么就不用进行回溯
        }
    }
 
    vector<string> letterCombinations(string digits) {
        n = digits.size() ;
        if(n == 0) return ans ;
        path.resize(n) ;
        dfs(digits , 0) ;
        return ans ;
    }
};

更加优雅的写法 : 

class Solution {
    string MAPPING[10] = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
public:
    vector<string> letterCombinations(string digits) {
        int n = digits.length();
        if (n == 0) return {};
        vector<string> ans;
        string path(n, 0); // 本题 path 长度固定为 n
        function<void(int)> dfs = [&](int i) {
            if (i == n) {
                ans.emplace_back(path);
                return;
            }
            for (char c : MAPPING[digits[i] - '0']) {
                path[i] = c; // 直接覆盖
                dfs(i + 1);
            }
        };
        dfs(0);
        return ans;
    }
};
 

78 . 子集

链接 : 

. - 力扣（LeetCode）

法一(对于每一个数选或不选) : 

class Solution {
public:
    vector<vector<int>> ans  ;
    vector<int> path ;
 
    void dfs(vector<int>& nums , int i){
        if(i==nums.size()){
            ans.push_back(path) ;
            return ;// 回溯
        }
        // 不选
        dfs(nums,i+1) ;// 不选i
        
        // 选
        path.push_back(nums[i]) ;
        dfs(nums,i+1) ;
        path.pop_back() ;
 
    }
 
    vector<vector<int>> subsets(vector<int>& nums) {
        if(nums.size()==0) return ans ;
        ans.clear() ;
        path.clear() ;
        dfs(nums,0) ;
        return ans ;
    }
};

法二(枚举第i个数选谁):

 这样的话  每一个结点都是答案 ;

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

131 . 分割回文串

链接 : 

. - 力扣（LeetCode）

思路 : 

 代码 (枚举子串结束位置): 

class Solution {
public:
    bool pd(string s , int l ,int r){
        while(l <= r){
            if(s[l++] != s[r--])
                return false;
        }
        return true ;
    }
 
    vector<vector<string>> ans  ;
    vector<string> path ;
    int n = 0 ;  
    // 答案视角 ， 判断每一个子串结束的地方
 
    void dfs(string s , int i){
        if(i==n){
            ans.push_back(path) ;
            return ;
        }
        for(int j=i;j<n;j++){ // 枚举子串结束的位置
            if(pd(s,i,j)){
                path.push_back(s.substr(i,j-i+1)) ;
                dfs(s,j+1) ;
                path.pop_back();// 恢复现场
            }
        }
    }
 
 
    vector<vector<string>> partition(string s) {
        n = s.size() ;
        dfs(s,0) ;
        return ans ;
    }
};

代码(每个分割点选不选) : 

class Solution {
public:
    bool pd(string s , int l ,int r){
        while(l <= r){
            if(s[l++] != s[r--])
                return false;
        }
        return true ;
    }
 
    vector<vector<string>> partition(string s) {
        vector<vector<string>> ans  ;
        vector<string> path ;
        // 判断每个逗号选或不选
        int n = s.size() ;
        // start 表示这一段回文串的开始位置
        function<void(int,int)> dfs = [&](int i,int start){
            if(i==n){
                ans.push_back(path) ;
                return  ;
            }
            // 不选i-i+1
            if(i < n - 1){
                dfs(i+ 1, start) ;
            }
            // 选
            if(pd(s,start,i)){
                path.push_back(s.substr(start,i-start+1));
                dfs(i + 1 , i + 1 ) ;
                path.pop_back() ;
            }
        };
        dfs(0 , 0) ;
        return ans ;
    }
};