代码随想录28|93复原IP地址、78子集以及90子集Ⅱ

1 复原IP地址

93复原IP地址

本题类似于昨天的分割回文串，只不过要对字符串进行添加（也属于分割问题）

class Solution {
public:
    vector<string> result;

    void backtracking(string s,int startIndex,int pointNum){
        if(pointNum == 3){
            if(isEffective(s,startIndex,s.size()-1)){
                result.push_back(s);
            }
            return;
        }
        for(int i = startIndex; i < s.size();i++){
            if(isEffective(s,startIndex,i)){
                s.insert(s.begin()+i+1,'.');
                pointNum++;
                backtracking(s,i+2,pointNum);
                pointNum--;
                s.erase(s.begin()+i+1);
            }else continue;
        }
    }

    bool isEffective(string& s,int begin,int end){
        if(begin > end) return false;
        if(s[begin] == '0' && begin!=end) return false;//只有一个零的情况
        int num = 0;
        for(int i = begin; 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<string> restoreIpAddresses(string s) {
        if(s.size()<4 || s.size()>12) return result;
        backtracking(s,0,0);
        return result;
    }
};

2 子集

78子集

子集问题也算组合问题，只不过组合问题和分割问题收集叶子节点，子集问题需要收集所有节点

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();
        }
    }
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        if(nums.size() == 0) return result;
        backtracking(nums,0);
        return result;
    }
};

3 子集问题Ⅱ

90子集问题Ⅱ

存在重复元素，所以去重很关键

（排序）

使用used数组

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

仅使用startIndex

class Solution {
    vector<int> path;
    vector<vector<int>> result;
private:
    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();
       }
        
    }
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        if(nums.size() == 0) return result;
        sort(nums.begin(),nums.end());
        backtracking(nums,0);
        return result;
    }
};