代码随想录打卡Day 28 | 回溯算法part04

心得：

第一题，判断字串是否符合IP地址规范，可以用start从左开始，for循环num = num*10 + （s[i] - '0'）来计算。同样用startIndex来分割字符串，用startIndex和i来作为字串的start和end。

本题明确要求只会分成4段，所以不能用切割线切到最后作为终止条件，而是分割的段数作为终止条件。pointNum表示逗点数量，pointNum为3说明字符串分成了4段了。

第二题子集问题和前面的组合以及分割问题的区别在于，子集问题在每一个节点都要去收集答案，而组合和风格问题只在叶子节点搜集答案。

第三题和组合-2类似。可以用一个布尔数组来判断是否在同一个树层，也可以用用startIndex。因为i>startIndex 时说明是在同一个数层。for决定树层，递归体现在树枝往下探。

---

---

第一题、复原IP地址 LeetCode93 https://leetcode.cn/problems/restore-ip-addresses/

回溯三部曲

• 递归参数

在131.分割回文串 (opens new window)中我们就提到切割问题类似组合问题。

startIndex一定是需要的，因为不能重复分割，记录下一层递归分割的起始位置。

本题我们还需要一个变量pointNum，记录添加逗点的数量。

所以代码如下：

vector<string> result;// 记录结果
// startIndex: 搜索的起始位置，pointNum:添加逗点的数量
void backtracking(string& s, int startIndex, int pointNum) {

• 递归终止条件

终止条件和131.分割回文串 (opens new window)情况就不同了，本题明确要求只会分成4段，所以不能用切割线切到最后作为终止条件，而是分割的段数作为终止条件。

pointNum表示逗点数量，pointNum为3说明字符串分成了4段了。

然后验证一下第四段是否合法，如果合法就加入到结果集里

代码如下：

if (pointNum == 3) { // 逗点数量为3时，分隔结束
    // 判断第四段子字符串是否合法，如果合法就放进result中
    if (isValid(s, startIndex, s.size() - 1)) {
        result.push_back(s);
    }
    return;
}

• 单层搜索的逻辑

在131.分割回文串 (opens new window)中已经讲过在循环遍历中如何截取子串。

在for (int i = startIndex; i < s.size(); i++)循环中 [startIndex, i] 这个区间就是截取的子串，需要判断这个子串是否合法。

如果合法就在字符串后面加上符号.表示已经分割。

如果不合法就结束本层循环，如图中剪掉的分支：

然后就是递归和回溯的过程：

递归调用时，下一层递归的startIndex要从i+2开始（因为需要在字符串中加入了分隔符.），同时记录分割符的数量pointNum 要 +1。

回溯的时候，就将刚刚加入的分隔符. 删掉就可以了，pointNum也要-1。

整体代码如下：

class Solution {
public:
    vector<string> res;
     
    bool isValid(const string& s, int start, int end){
        if(start > end){
            return false;
        } 
        if(s[start] == '0' && start != end){
            return false;
        }
        int sum = 0;
        for(int i = start; i <= end; i++){
            if(s[i] > '9' || s[i] < '0'){
                return false;
            }
            sum = sum * 10 + (s[i] - '0');
            if(sum > 255){
                return false;
            }
        }
        return true;
    }

    void backtracking(string& s, int startIndex, int pointSum){
        if(pointSum == 3){
            if(isValid(s, startIndex, s.size() - 1)){// 判断第四个子串是否合法
                res.push_back(s);
            }
            return;
        }
        for(int i = startIndex; i < s.size(); i++){
            if(isValid(s, startIndex, i)){// 判断 [startIndex,i] 这个区间的子串是否合法
                s.insert(s.begin() + i + 1, '.');//加入逗点
                pointSum += 1;
                backtracking(s, i + 2, pointSum);
                pointSum -= 1;
                s.erase(s.begin() + i + 1);//去除逗点

            }
            else break;
        }
    }

    vector<string> restoreIpAddresses(string s) {
        res.clear();
        backtracking(s, 0, 0);
        return res;
    }
};

---

---

第二题、子集 LeetCode78  https://leetcode.cn/problems/subsets/

子集问题需要在每一个节点都搜集答案，而之前的组合和分割问题都是在叶子节点搜集答案。

因此这一题的放入结果集的操作不需要放在if判断之下。每一次递归直接放就可以。、

class Solution {
public:
    
    vector<vector<int>> res;
    vector<int> path;

    void backtracking(vector<int>& nums, int startIndex){       
        res.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();
        }
        return;
    }
    
    vector<vector<int>> subsets(vector<int>& nums) {
        res.clear();
        path.clear();
        backtracking(nums, 0);
        return res;
    }
};

 

---

---

第三题、子集-2 https://leetcode.cn/problems/subsets-ii/

这一题就和组合-2 LeetCode40类似，要用nums[i] = nums[i - 1]和used数组来判断是否需要continue。因为是通过一个树枝可以重复，但同一个树层不能重复。

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] == nums[i - 1] && used[i - 1] == false){
                continue;
            }
            path.push_back(nums[i]);
            used[i] = true;
            backtracking(nums, i + 1, used);
            used[i] = false;
            path.pop_back();
        }
        return;
    }

    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        vector<bool> used(nums.size(), false);
        res.clear();
        path.clear();
        sort(nums.begin(), nums.end());
        backtracking(nums, 0, used);
        return res;
    }
};

 当然也可以不用used来判断，直接用startIndex。因为i>startIndex 时说明是在同一个数层。for决定树层，递归体现在树枝往下探。

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++){
            if(i > startIndex && nums[i] == nums[i - 1]){
                continue;
            }
            path.push_back(nums[i]);
            //used[i] = true;
            backtracking(nums, i + 1);
            //used[i] = false;
            path.pop_back();
        }
        return;
    }

    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        //vector<bool> used(nums.size(), false);
        res.clear();
        path.clear();
        sort(nums.begin(), nums.end());
        backtracking(nums, 0);
        return res;
    }
};