这道题和选取回文子串的题目类似，就是一个子集划分的问题，但是子集划分是有终止条件的，也就是这个划分并不是把所有的划分可能都塞进结果集了。当划分到达最后一个位置的时候，划分结束，不包含最后一个划分位置的子集划分方案不要，超出四个子集的划分方案不要。

仔细看的话，这个递归是有两个出口的，一个是正常执行结束到函数体末尾（也就是：不包含最后一个划分位置的子集划分方案不要），一个是终止条件，当我们需要所有的划分可能时候，直接拿掉终止条件就行

class Solution {
public:
    vector<string> res;
    vector<string> resVec;
    void resInit() {}
    bool isValid(string& chooseList, int start, int i) {
        string s(chooseList.begin() + start, chooseList.begin() + i + 1);
        if (s.size() > 1 && s[0] == '0') {
            return false;
        }
        int str_to_int = atoi(s.c_str());
        if (str_to_int > 255 || str_to_int < 0) {
            return false;
        }
        return true;
    }
    void traceback(vector<string> resVec, string& chooseList, int start) {
        if (start >= chooseList.size()) {
            if (resVec.size() == 4) {
                string resStr = "";
                for (auto i : resVec) {
                    resStr += i;
                    resStr += ".";
                }
                resStr.pop_back();
                res.push_back(resStr);
            }

            return;
        }

        for (int i = start; i < chooseList.size(); i++) {
            if (!isValid(chooseList, start, i)) {
                continue;
            }

            resVec.push_back(
                string(chooseList.begin() + start, chooseList.begin() + i + 1));
            traceback(resVec, chooseList, i + 1);
            resVec.pop_back();
        }
    }
    vector<string> restoreIpAddresses(string s) {
        traceback(resVec, s, 0);
        return res;
    }
};

无重元素，不可复取

class Solution {
public:
    vector<vector<int>> res;
    vector<int> resVec;
    void resInt();
    bool isValid(){
        return true;
    }
    void traceback(vector<int> resVec,vector<int>& nums,int start){

         for(int i = start;i< nums.size();i++){
             if(!isValid()){
               continue;
             }

             resVec.push_back(nums[i]);
             traceback(resVec,nums,i+1);
             resVec.pop_back();
         }

            res.push_back(resVec);
         
    }
    vector<vector<int>> subsets(vector<int>& nums) {
          traceback(resVec,nums,0);

          return res;
    }
};

可重元素，不可复取

class Solution {
public:
    vector<vector<int>> res;
    vector<int> resVec;
    vector<bool> visit;
    void resInit(vector<int>& nums){
        vector<bool> visitTem(nums.size(),false);
        visit = visitTem;
        sort(nums.begin(),nums.end());
    }
    bool isValid(vector<int>& nums,vector<bool> &visit,int i){
        if(i - 1 >= 0 && !visit[i-1] && nums[i-1] == nums[i]){
            return false;
        }
        return true;
    }
    void traceback(vector<int> resVec,vector<bool> visit,vector<int>& nums,int start){
        for(int i = start;i< nums.size();i++){
           if(!isValid(nums,visit,i)){
              continue;
           }
           resVec.push_back(nums[i]);
           visit[i] = true;
           traceback(resVec,visit,nums,i+1);
           resVec.pop_back();
           visit[i] = false;
        }
        res.push_back(resVec);
    }
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        resInit(nums);
        traceback(resVec,visit,nums,0);
        return res;
    }
};