93.复原IP地址 

• 思路：
  • 与分割回文串相似，复原ip地址是将给定字符串分割成点分十进制的四段，切割问题就可以使用回溯搜索法把所有可能性搜出来。
  • 回溯三部曲：
    • 递归参数：除了传入的需要分割的字符串，仍然需要startIndex保证不会重复分割，还需要一个变量pointNum来记录已添加的逗点数量。
    • 终止条件：当分割出四段，也就是逗点数量记录为3时，说明分割结束。再验证最后一段的合法性，若合法就可以加入结果集中。前三段的合法性在添加逗点之前判断，因为最后一段之后没有逗点了，所以要单独判断。
    • 单层逻辑：在for循环中，判断截取的左闭右闭区间子串 [startIndex, i] 合法后，在后面一位加上‘ . ’表示已经分割，记录分隔符的变量pointNum加一，再从‘ . ’的下一位开始继续递归，回溯时将‘ . ’再删除，pointNum减一。如果不合法，结束本层循环。
  • 判断子串是否合法：
    • 以0开头，但不只有0一个字符的子串不合法
    • 含有非0-9字符的子串不合法
    • 大于255的不合法
    • 
  • 剪枝：输入长度不合法的字符串时(主函数中)，子串不合法时剪枝(isValid)。
  • 时间复杂度: O(3^4)，IP地址最多包含4个数字，每个数字最多有3种可能的分割方式，则搜索树的最大深度为4，每个节点最多有3个子节点。
  • 空间复杂度: O(n)

class Solution {
private:
    vector<string> res;
    //startIndex记录起始位置(切割线)，pointNum记录已添加的逗点数量
    void backtracking(string& s, int startIndex, int pointNum) {
        if(pointNum == 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)) {//判断[startIndex, i]这一段的合法性，合法才继续向下执行递归逻辑，否则直接结束本层循环
                s.insert(s.begin() + i + 1, '.');//在这一字段后面添加逗点
                pointNum++;//逗点计数加一
                backtracking(s, i + 2, pointNum);//递归，从逗点后一位作为新的起始位置，所以是i+2
                pointNum--;//回溯
                s.erase(s.begin() + i + 1);//回溯
            } else break;
        }
    }

    //判断左闭右闭区间[start, end]字符串的合法性
    bool isValid(const string& s, int start, int end) {
        if(start > end) return false;
        //以0开头，但不只有0一个字符的区间不合法
        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;//大于255则不合法
        }
        return true;
    }

public:
    vector<string> restoreIpAddresses(string s) {
        res.clear();
        if(s.size() < 4 || s.size() > 12) return res;//传入字符串的长度不合法
        backtracking(s, 0, 0);
        return res;
    }
};

class Solution {
private:
    vector<int> path;
    vector<vector<int>> res;
    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();
        }
    }

public:
    vector<vector<int>> subsets(vector<int>& nums) {
        path.clear();
        res.clear();
        backtracking(nums, 0);
        return res;
    }
};

class Solution {
private:
    vector<int> path;
    vector<vector<int>> res;
    void backtracking(vector<int>& nums, int startIndex) {
        res.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) {
        path.clear();
        res.clear();
        sort(nums.begin(), nums.end());//排序方便去重
        backtracking(nums, 0);
        return res;
    }
};