代码随想录算法训练营第二十四天|复原IP地址、子集、子集Ⅱ

复原IP地址 leetcode 93

回溯三部曲，确定返回值和参数，参数为传入的字符串，分割线startIndex，加入逗点的次数。

递归结束条件，当加入逗点次数为3且最后一个字符串有效则存入结果容器且结束当前递归。

单层搜索逻辑，从分割线开始for循环遍历宽度，分割线不动for循环控制i++，从startIndex到i分割，如果有效则在i后面加逗点，之后从i+2（因为加了一个逗点）处开始下一层递归（深度），递归之后回溯。

class Solution {
public:
    bool isValid(const string& s,int start,int end){
        if(start>end) return false;
        if(s[start]=='0'&&start!=end) return false;
        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;
        }
        return true;
    }
    vector<string> res;
    void backtracking(string& s,int startIndex,int count){
        if(count==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)){
                s.insert(s.begin()+i+1,'.');
                count++;
                backtracking(s,i+2,count);
                s.erase(s.begin()+i+1);
                count--;
            }else break;
        }
    }
    vector<string> restoreIpAddresses(string s) {
        res.clear();
        if(s.size()<4||s.size()>12) return res;
        backtracking(s,0,0);
        return res;
    }
};

vec.insert(s.begin,i)在第一个元素后面插入i，vec.erase(s.begin())，删掉第一个元素。

子集 leetcode 78

之前的回溯都是在递归结束时收获结果，这道题需要在树中的每一个节点收获结果。一开始path为空，第一次执行递归函数时就会把空集放进去。

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

子集Ⅱ leetcode 90

上一题树中每个节点收获结果的思想加上组合Ⅱused数组去重的思想可以解决本题。

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    void backtracking(vector<int>& nums,int startIndex,vector<bool>& used){
        res.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]==0) continue;
            path.push_back(nums[i]);
            used[i]=true;
            backtracking(nums,i+1,used);
            path.pop_back();
            used[i]=false;
        }
    }
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        res.clear();
        path.clear();
        vector<bool> used(nums.size(),false);
        sort(nums.begin(),nums.end());
        backtracking(nums,0,used);
        return res;
    }
};