DAY29|| 93.复原ip地址 |78.子集 |90.子集Ⅱ

 93.复原ip地址

题目：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"]

本题和切割回文串那里代码大致相同，不同在于，本题直接在字符串上操作改动，终止判断条件那里还需要再比较一次合法，前三段直接在单层搜索里就判断了。还要注意判断是否合法的三种不合法情况。 其余和回溯模板差不多。

树形结构 

代码

剪枝操作咔擦掉小于长于小于4和大于12的字符串就行了。 

class Solution {
    private:
    vector<string>result;
    void backtraking( string& s,int startindex,int pointNum)
    {
        if(pointNum==3)//三个逗号刚好分割成四段
        {
            if(isValid(s,startindex,s.size()-1))//检验第四段是否合法
            result.push_back(s);
            return;
        }

        for(int i=startindex;i<s.size();i++)
        {
            if(isValid(s,startindex,i))
            {
                //合法就直接在字符串中间加逗号来切割字符串
                s.insert(s.begin()+i+1,'.');
                pointNum++;
                backtraking(s,i+2,pointNum);//注意起始下标是+2
                //回溯
                s.erase(s.begin()+i+1);
                pointNum--;
            }
            else break;//不合法直接结束
        }
    }
    bool isValid( string& s,int start,int end)
    {
        if(start>end)return false;
        //段位以0为开头的数字不合法
        if(s[start]=='0'&&start!=end)return false;
       int num=0;
        for(int i=start;i<=end;i++)
        {
             //段位里有非正整数字符不合法
             if(s[i]<'0'||s[i]>'9')return false;
              //段位如果大于255了不合法,把字符转化成数字比较（ascll码）
            num=num*10+(s[i]-'0');
            if(num>255)return false;
        }
        return true;
    }
public:
    vector<string> restoreIpAddresses(string s) {
        result.clear();
        if(s.size()<4||s.size()>12)return result;
        backtraking(s,0,0);
        return result;
    }
};

 78.子集

题目：78. 子集 - 力扣（LeetCode）

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

子集

（幂集）。

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

示例 1：

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

示例 2：

输入：nums = [0]
输出：[[],[0]]

 

 和回溯模板差不多，就是这里是要求所有的组合（子集），如果把 子集问题、组合问题、分割问题都抽象为一棵树的话，那么组合问题和分割问题都是收集树的叶子节点，而子集问题是找树的所有节点！

代码

class Solution {
    private:
    vector<vector<int>>result;
    vector<int>path;
    void backtraking(vector<int>&nums,int startindex)
    {
        result.push_back(path);//没有终止条件，因为for循环结束了也不会超过数组长度

        for(int i=startindex;i<nums.size();i++)
        {
            path.push_back(nums[i]);//所有结果都收集
            backtraking(nums,i+1);
            path.pop_back();
        }
    }
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        backtraking(nums,0);
        return result;

    }
};

90.子集 

题目：90. 子集 II - 力扣（LeetCode）

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

子集

（幂集）。

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

示例 1：

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

示例 2：

输入：nums = [0]
输出：[[],[0]]

本题和上题区别点有：1.数组有重复元素 2.子集顺序不定

是不是意味着，本题和组合总和Ⅱ结合，去掉树层避免重复组合，但是树枝上有重复元素可以，顺序没关系。

那得搬出used来用了。

 

代码 

class Solution {
    vector<vector<int>>result;
    vector<int>path;
    void backtraking(vector<int>&nums,int stratindex,vector<bool>& used)
    {
        result.push_back(path);//不需要终止条件
        
        for(int i=stratindex;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;
            backtraking(nums,i+1,used);
            path.pop_back();
            used[i]=false;
        }
    }
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        result.clear();
        path.clear();
        vector<bool>used(nums.size(),false);
        sort(nums.begin(),nums.end());//!!!注意不能忘记！去重需要排序
        backtraking(nums,0,used);
        return result;

    }
};

去重也可以这么写

if (i > startIndex && nums[i] == nums[i - 1] ) { // 注意这里使用i > startIndex
                continue;
            }

使用set也可以。。