day28 回溯 复原IP地址 子集 子集Ⅱ

题目1：93 复原IP地址

题目链接：复原IP地址

对题目的理解

返回只包含数字的字符串s中，所有有效的IP地址，不能改变字符串中数字的顺序

有效IP地址由4个整数构成（范围在0-255之间），并且四个整数之间使用"."来分割

自己认为本题的难点：切割的时候要保证，是切割得出4个整数，是先计算每个整数中至少包含多少位数？还是边切割便计算呢？

不用想的这么复杂，使用回溯法将字符串切割4次就停止，找到满足要求的字符字串就可以了

切割问题就可以使用回溯搜索法把所有可能性搜出来，抽象为树形结构

回溯法

回溯三部曲

i）递归参数

startIndex保证不能重复分割，记录下一层递归分割的起始位置，还需要一个变量pointNum，记录添加逗点的数量。

ii）递归终止条件

本题明确要求只会分成4段，所以不能用切割线切到最后作为终止条件，而是分割的段数作为终止条件。pointNum为3说明字符串分成了4段了，然后验证一下第四段是否合法，如果合法就加入到结果集里

iii）单层搜索的逻辑

在for (int i = startIndex; i < s.size(); i++)循环中 [startIndex, i] 这个区间就是截取的子串，需要判断这个子串是否合法，如果合法就在字符串后面加上符号.表示已经分割；如果不合法就结束本层循环。

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

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

判断子串是否合法

最后就是在写一个判断段位是否是有效段位了。

主要考虑到如下三点：

• 段位以0为开头的数字不合法
• 段位里有非正整数字符不合法
• 段位如果大于255了不合法

伪代码

代码

class Solution {
public:
    //判断子串是否合法
    bool isvalid(string& s, int start, int end){
        //start end是字符串中字符的索引,左闭右闭
        if(start>end) return false;
        if(s[start]=='0' && start!=end) return false;//首个字母是0
        int num = 0;
        for(int i=start;i<=end;i++){
            if(s[i]>'9' || s[i]<'0') return false;//出现了非法字符
            num = num*10 + (s[i]-'0');//计算字符串代表的数字
            if(num>255) return false;//数字大于255
        }
        return true;
    }
   
    vector<string> result;
    void backtracking(string& s,int startindex,int pointsum){
        //终止条件
        if(pointsum==3){
            //判断最后一段字符串是否有效,左闭右闭区间
            if(isvalid(s, startindex, s.size()-1))
            result.push_back(s);
            return;
        }
        //单层遍历逻辑
        for(int i=startindex;i<s.size();i++){
            //判断字符串段是否有效，有效就在字符串段后面加‘.’
            if(isvalid(s,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;//如果不合法，就不用再向下循环了，直接跳出for循环
        }
    }
    vector<string> restoreIpAddresses(string s) {
        result.clear();
        if(s.size()<4 || s.size()>12) return result;//剪枝，因为一定不满足条件
        backtracking(s, 0, 0);
        return result;

    }
};

• 时间复杂度: O(3^4)，IP地址最多包含4个数字，每个数字最多有3种可能的分割方式，则搜索树的最大深度为4，每个节点最多有3个子节点。
• 空间复杂度: O(n)

题目2：78子集

题目链接：子集

对题目的理解

整数数组中的元素互不相同，返回所有可能的子集

其实子集也是一种组合问题，因为它的集合是无序的，子集{1,2} 和 子集{2,1}是一样的。

无序意味着取过的元素不会重复取，写回溯算法时，for要从startindex开始，而不是从0开始！

下图说明了遍历的过程，遍历这个树的时候，把所有节点都记录下来，就是要求的子集集合。

回溯法

回溯三部曲

i）递归函数参数

全局变量数组path为子集收集单个结果，二维数组result存放所有子集组合。

递归函数参数需要startIndex

ii）递归终止条件

剩余集合为空的时候，就是叶子节点，就是startIndex已经大于数组的长度就终止，因为没有元素可取了，

其实可以不需要加终止条件，因为startIndex >= nums.size()，本层for循环本来也结束了

iii）单层搜索逻辑

求取子集问题，不需要任何剪枝！因为子集就是要遍历整棵树。

伪代码

代码

class Solution {
public:
    vector<int> path;
    vector<vector<int>> result;
    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();
        }
    }
    vector<vector<int>> subsets(vector<int>& nums) {
        path.clear();
        result.clear();
        backtracking(nums, 0);
        return result;

    }
};

• 时间复杂度: O(n * 2^n)
• 空间复杂度: O(n)

如果把 子集问题、组合问题、分割问题都抽象为一棵树的话，那么组合问题和分割问题都是收集树的叶子节点，而子集问题是找树的所有节点！

题目3：90 子集Ⅱ

题目链接：子集Ⅱ

对题目的理解

整数数组中存在重复元素，返回数组中所有可能的子集。子集不能重复，数组至少包含一个元素，注意去重

！！！一定要记得对数组进行排序，本题就是子集和组合总和Ⅱ（去重）的结合

具体遍历方式演示

伪代码

代码

class Solution {
public:
    vector<int> path;
    vector<vector<int>> result;
    void backtracking(vector<int>& nums, int startindex, vector<bool> used){
        result.push_back(path);
        //终止条件
        if(startindex>=nums.size()) return;
        //单层循环逻辑
        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();//回溯
        }
    }
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        path.clear();
        result.clear();
        vector<bool> used(nums.size(), false);
        //对数组进行排序
        sort(nums.begin(), nums.end());
        backtracking(nums, 0, used);
        return result;

    }
};

• 时间复杂度: O(n * 2^n)
• 空间复杂度: O(n)

使用startindex去重

class Solution {
public:
    vector<int> path;
    vector<vector<int>> result;
    void backtracking(vector<int>& nums, int startindex){
        result.push_back(path);
        //终止条件
        if(startindex>=nums.size()) return;
        //单层循环逻辑
        for(int i=startindex;i<nums.size();i++){
            if(i>startindex && nums[i]==nums[i-1]) continue;
            path.push_back(nums[i]);
            backtracking(nums,i+1);//递归
            path.pop_back();//回溯
        }
    }
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        path.clear();
        result.clear();
        //对数组进行排序
        sort(nums.begin(), nums.end());
        backtracking(nums, 0);
        return result;

    }
};