DAY30 回溯算法 子集问题 Ⅰ

93. 复原 IP 地址 - 力扣（LeetCode）

class Solution {
private:
    vectorresult;
    void backTracking(string& s,int startIndex,int piontNum){
        if(piontNum==3){
            if(isUseful(s,startIndex,s.size()-1)){
                result.push_back(s);
            }
            return;
        }
        for(int i=startIndex;i < s.size();i++){
            if(isUseful(s,startIndex,i)){
                s.insert(s.begin()+i+1,'.');
                piontNum++;
                backTracking(s,i+2,piontNum);
                s.erase(s.begin()+i+1);
                piontNum--;
            }
            else break;
        }
    }
    bool isUseful(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;
    }
public:
    vector restoreIpAddresses(string s) {
        result.clear();
        if(s.size()<4||s.size()>12) return result;
        backTracking(s,0,0);
        return result;
    }
};

 78. 子集 - 力扣（LeetCode）

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

90. 子集 II - 力扣（LeetCode）

class Solution {
private:
    vector>result;
    vectorpath;
    void backTracking(vector& nums,int startIndex,vector& used){
        result.push_back(path);
        if(startIndex>=nums.size()){
            return;
        }
        for(int i=startIndex;i0 && 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();
        }
    }
public:
    vector> subsetsWithDup(vector& nums) {
    result.clear();
    path.clear();
    vectorused(nums.size(),false);
    sort(nums.begin(),nums.end());
    backTracking(nums,0,used);
    return result;  
    }
};

这几道题的思路在前一节都涉及过，需要经常回顾。