代码随想录算法训练营第二十四天|93.复原IP地址，78.子集 ， 90.子集II

93. 复原 IP 地址 - 力扣（LeetCode）

有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 '.' 分隔。

• 例如："0.1.2.201" 和 "192.168.1.1" 是 有效 IP 地址，但是 "0.011.255.245"、"192.168.1.312" 和 "192.168@1.1" 是 无效 IP 地址。

给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 '.' 来形成。你 不能 重新排序或删除 s 中的任何数字。你可以按 任何 顺序返回答案。

示例 1：

输入：s = "25525511135"
输出：["255.255.11.135","255.255.111.35"]

思路：这题和切割回文类似，切割字符串就是在组合过程。

解决：首先需要定义一个保存结果的数组vector<string> r，然后确定回溯三部曲；

        第一步：确定参数；

        这里参数首先需要字符串s，其次还需要一个参数start记录每次遍历的起点。

        最后根据终止条件还需要一个参数用来记录'.'个数。

        第二步：确定终止条件；

        如果目前切割的数组不满足0-255，不符合直接回溯；其次如果切割到最后都满足，字符串中“.”的个数应该等于3，并且字符串要合法，然后加入到结果数组中。

        第三步：确定遍历过程。

        首先判断当前切割的字符串是否合法，合法就在后面插入 '.'， '.'个数加一，然后递归遍历后面字符串，最后回溯，个数减一

最后需要一个函数判断字符串是否违法，违法有三种情况：

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

代码：

class Solution {
private:
    vector<string> r;
    bool isValid(const string& s, int start, int end) {
    if (start > end) {
        return false;
    }
    if (s[start] == '0' && start != end) { // 0开头的数字不合法
            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) { // 如果大于255了不合法
            return false;
        }
    }
    return true;
}
    void backtracking(string& s,int start,int pointnum){
        if(pointnum==3){
            if(isValid(s,start,s.size()-1)){
                r.push_back(s);
                return;
            }
            return;
        }
        for(int i=start;i<s.size();i++){
            if(isValid(s,start,i)){
                s.insert(s.begin()+i+1,'.');
                pointnum++;
                backtracking(s,i+2,pointnum);
                pointnum--;
                s.erase(s.begin()+i+1);
            }else{
                break;
            }
        }
    }
public:
    vector<string> restoreIpAddresses(string s) {
        r.clear();
        if (s.size() < 4 || s.size() > 12) return r; // 算是剪枝了
        backtracking(s, 0, 0);
        return r;
    }
};

78. 子集 - 力扣（LeetCode）

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

示例 1：

输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

思路：这题不是得到组合结果，而是在遍历过程中每个树的节点都需要。

解决：首先需要两个数组，一个记录所有结果的二维数组r，一个记录单一结果的一维数组p；

        接着回溯三部曲

        第一步：确定参数；

        参数需要nums数组，一个记录遍历起点的start参数。

        第二步：确定终止条件；

        这里终止条件就是起点已经在数组最后了，没有数可以再进行组合，start==nums.size()。

        第三步：确定遍历过程；

        首先将空元素加入r数组中，再循环。

代码：

class Solution {
private:
    vector<vector<int>> r;
    vector<int> p;
    void backtracking(vector<int>& nums,int start){
        r.push_back(p);
        if(start>=nums.size()){
            return;
        }
        for(int i=start;i<nums.size();i++){
            p.push_back(nums[i]);
            backtracking(nums,i+1);
            p.pop_back();
        }
    }
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        r.clear();
        p.clear();
        backtracking(nums,0);
        return r;
    }
};

90. 子集 II - 力扣（LeetCode）

给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。

示例 1：

输入：nums = [1,2,2]
输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]

思路：这题其实是78. 子集 - 力扣（LeetCode）和40. 组合总和 II - 力扣（LeetCode）的组合，首先每个树节点都算一个组合，其次树层需要去重。

解决：这里直接给出代码，参照70和40题。

代码：

class Solution {
private:
    vector<vector<int>> r;
    vector<int> p;
    void backtracking(vector<int>& nums,int start,vector<bool>& used){
        r.push_back(p);
        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;
            }
            p.push_back(nums[i]);
            used[i]=true;
            backtracking(nums,i+1,used);
            used[i]=false;
            p.pop_back();
        }
    }
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        vector<bool> used(nums.size(),false);
        r.clear();
        p.clear();
        backtracking(nums,0,used);
        return r;
    }
};