代码随想Day28 | 93.复原IP地址、78.子集、90.子集II

93.复原IP地址  

这道题首先要解决的一个问题是，判断某个字符串是合格的ip地址：

主要考虑到如下三点：

• 以0为开头的数字不合法
• 里有非正整数字符不合法
• 如果大于255了不合法

接下来，递归三部走：

参数：除了控制下一次开始的索引，还需要增加一个表示添加句点的个数pointnum，用来控制结束条件；

递归结束条件：如果pointnum等于3，说明已经分为4段了，对第四段的有效性验证，有效则加入结果集合；

单层处理逻辑，首先把判断当前子区间的ip有效性，无效则直接打断(剪枝)；有效则把当前结束后的位置加上句点，同时句点个数+1，然后进入下一层，注意进入下一层的索引是i+2，因为增加了一个句点，最后再进行回溯即可。

详细代码如下：

class Solution {
public:
    bool isValid(string s, int l, int r)
    {
        //左闭右闭
        if(l>r) return false;
        //开头为0
        if(s[l]=='0'&&l!=r) return false;
        int num=0;
        for(int i=l;i<=r;i++)
        {
            if(s[i]>'9'||s[i]<'0') return false; //非法字符
            num=num*10+s[i]-'0';
        }
        if(num>255) return false; //大于255
        return true;
    }
    vector<string> res;
    void backtracking(string& s, int index, int pointnum)
    {
        //end
        if(pointnum==3) //分为四段
        {
            if(isValid(s,index,s.size()-1)) res.push_back(s);
            return;
        }
        //backtracking
        for(int i=index;i<s.size();i++)
        {
            if(isValid(s,index,i))
            {
                pointnum++;
                s.insert(s.begin()+i+1,'.');
                backtracking(s,i+2,pointnum);
                pointnum--;
                s.erase(s.begin()+i+1);
            }
            else break; //不符合条件，剪枝
        }
    }
    vector<string> restoreIpAddresses(string s) {
        if(s.size()<4||s.size()>12) return res;
        backtracking(s,0,0);
        return res;
    }
};

78.子集  

子集问题，就是收集树形结构中，每一个节点的结果。 整体代码其实和回溯模板都是差不多的，只要掌握回溯模板基本就可写出来，注意这道题收集结果要写在结束条件前面，详细代码如下：

class Solution {
public:
    vector<int> path;
    vector<vector<int>> res;
    void backtrack(vector<int> nums, int index)
    {
        res.push_back(path);
        if(index==nums.size()) return;
        for(int i=index;i<nums.size();i++)
        {
            path.push_back(nums[i]);
            backtrack(nums,i+1); //后一位递归
            path.pop_back();
        }
    }
    vector<vector<int>> subsets(vector<int>& nums) {
        backtrack(nums,0);
        return res;
    }
};

90.子集II 

之前做了 40.组合总和II 和 78.子集 ，本题就是这两道题目的结合，本题涉及的知识，之前都讲过，没有新内容。 

这道题主要多一个去重的逻辑，注意两点：

1. 需要先排序，不然去重比较困难；

2. 在遇到相邻两个数相同时，需要注意只是continue，略过此次循环，而不是break跳出循环；

详细代码如下：

class Solution {
public:
    vector<int> path;
    vector<vector<int>> res;
    void backtrack(vector<int> nums, int index)
    {
        res.push_back(path);
        if(index>=nums.size()) return;
        //回溯
        for(int i=index;i<nums.size();i++)
        {
            if(i>index&&nums[i]==nums[i-1]) continue;
            path.push_back(nums[i]);
            backtrack(nums,i+1);
            path.pop_back();
        }
    }
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        sort(nums.begin(),nums.end()); //先排序再去重
        backtrack(nums,0);
        return res;
    }
};