【C++编程能力提升】

一、93 复原IP地址

题目链接：93 复原IP地址

核心：与切割问题类似，区别在于本题要求IP为四段，即终止条件是切割的段数，具体而言当目前已有3个逗点时进入终止条件的return，而是否要记录该有效IP，则需判断最后一个子串是否有效。
（1）在for循环的回溯遍历搜索过程中，每遍历一个子串[start,i]，都需要判断该子串是否有效，只有在有效的情况下才能成为有效IP的一部分，否则直接退出本层循环；
（2）在子串有效的情况下，需要在子串后插入一个逗点，以及统计逗点数量（++）；相应地，在回溯时，也需要移除这个插入的逗点，以及统计逗点数量（–）；
（3）由于在子串有效时插入了一个逗点，且已分割的元素是不能再被分割的，因此调用回溯函数时，起始位置参数应为i+2；
（4）判断子串有效的情况，需要列出所有无效的情况，比如：起止范围无效、数字前导为0、字串内存在某个元素不是数字、以及十进制数字大于255。

    vector<string> res;
    void backtracking(string& s,int start,int pointNum)
    {//start:搜索的起始位置，pointNum:添加逗点的数量
        if(pointNum==3)
        {//已有3个逗点，再判断最后一个子串是否有效（符合要求）
            if(isValid(s,start,s.size()-1))
                res.push_back(s);   //最后一个子串有效则该s有效
            return; //不论最后一个子串是否有效都需要return
        }
        for(int i=start;i<s.size();++i)
        {//回溯遍历的搜索过程，需判断子串[start,i]是否有效
            if(isValid(s,start,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,i]无效，该IP无效，退出本层循环
        }
    }
    bool isValid(string& s,int left,int right)
    {//判断s子串[left,right]是否有效
        if(left>right)
            return false;   //限制子串的范围
        if(s[left]=='0' && left!=right)
            return false;   //子串存在前导0，比如：010
        int num=0;    //计算该字串组成的数字
        for(int i=left;i<=right;++i)
        {
            if(s[i] >'9' || s[i]<'0')
                return false;   //子串内任意元素不是0-9的整数
            num=num*10+(s[i]-'0');  //得到十进制数
            if(num>255)
                return false;
        }
        return true;
    }
    vector<string> restoreIpAddresses(string s) {
        if(s.size()<4 || s.size()>12)
            return res;         //剪枝优化
        backtracking(s,0,0);    //调用回溯函数
        return res;
    }

二、78 子集

题目链接：78 子集

核心：理解子集与组合、分割的区别在于子集需要统计树的所有节点，而组合、分割只需统计树的叶子节点，即每个树枝的节点。
（1）统计/收集树的所有节点，需要在终止条件（函数最开始）就要记录当前path到res；
（2）终止条件与分割类似，当起始位置start大于等于数组大小时，说明已经遍历了数组的所有元素，可结束搜索；
（3）在for循环的回溯遍历搜索过程中，每遍历一个节点都需要记录到path，并且下一次递归时不能重复选择同一个元素，即起始位置是i+1.

    vector<vector<int>> res;
    vector<int> path;
    //start:同一个集合里选取数都需要使用start
    void backtracking(vector<int>& nums,int start)
    {//子集需要记录树的所有节点，不仅仅是叶子节点
        res.push_back(path);    //收集每一个节点，必须在起始，否则会漏了节点
        if(start>=nums.size())
            return;     //终止条件，可忽略，因为for循环已限制了start的范围
        for(int i=start;i<nums.size();++i)
        {
            path.push_back(nums[i]);
            backtracking(nums,i+1);     //集合是无序的，不能选取重复元素
            path.pop_back();
        }
    }
    vector<vector<int>> subsets(vector<int>& nums) {
        backtracking(nums,0);       //start从0开始
        return res;
    }

三、90 子集II

题目链接：90 子集II

核心：与78 子集的区别在于去重，且是树层去重，不是树枝去重。
结合78 子集和树层去重的思想，值得注意的是只要涉及到去重，都需要先排序。
参考40 组合III使用used数组实现去重的方法，主函数需要对该数组初始化为false，每递归处理一个节点令其为true，每回溯处理一个节点令其为false，那么利用i>0 && nums[i]==nums[i-1] && used[i-1]==false就能完成去重。

    vector<vector<int>> res;
    vector<int> path;   
    void backtracking(vector<int>& nums,int start,vector<bool>& used)
    {//在子集基础上增加了去重
        res.push_back(path);
        //if(start>=nums.size())
         //   return;
        for(int i=start;i<nums.size();++i)
        {
            if(i>0 && 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();
        }
    }
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        vector<bool> used(nums.size(),false);
        sort(nums.begin(),nums.end());      //去重需要排序，否则无法实现去重
        backtracking(nums,0,used);
        return res;
    }