代码随想录训练营第24天 || 93. 复原 IP 地址 78. 子集

93. 复原 IP 地址：

讲解：代码随想录

思路：

递归：抽象成一个树

代码：

​
class Solution:
    def panduan(self,s,start,end):#判断是否符合条件
        if start>end:
            return False
        if s[start] == '0' and  start !=end:
            return False
        num = 0
        for i in range(start,end+1):
            if not s[i].isdigit():
                return False
            num = num*10 + int(s[i])
            if num >255:
                return False
        return True

    def caozuo(self,s,point_num,current,result,startindex):#递归函数
        if point_num ==3:
            if self.panduan(s,startindex,len(s)-1):
                current+=s[startindex:]
                result.append(current)
            return
        for i in range(startindex,len(s)):
            if self.panduan(s,startindex,i):
                sub = s[startindex:i+1]
                self.caozuo(s,point_num+1,current+sub+'.',result,i+1)
            else:
                break#因为当前区间已经大于255，或者为01时再加数的话，也是不满足的所以直接结束遍历
                
    def restoreIpAddresses(self, s: str) -> List[str]:
        result = []
        current =""
        self.caozuo(s,0,current,result,0)
        return result

​

遇到的问题：

1.对于break的理解：因为当前区间已经大于255，或者为01时再加数的话，也是不满足的所以直接结束遍历

78. 子集：

讲解：代码随想录

思路：

递归：抽象成一个树，子集问题就是收集所有树的结点

代码：

class Solution {
vector<vector<int>> result;
vector<int> path;
private:
    void caozuo(vector<int>& nums,int startindex)
    {
        result.push_back(path);//空集在此处就已经添加了，非常巧妙
        if(startindex >= nums.size())
        {
            return;
        }
        for(int i =startindex;i<nums.size();i++)
        {
            path.push_back(nums[i]);
            caozuo(nums,i+1);
            path.pop_back();
        }
    }
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        result.clear();
        path.clear();
        caozuo(nums,0);
        return result;
    }
};

遇到的问题：

1.对于向result添加的方式：在递归函数的开头，中止条件的前添加结果，可以在一开始添加进去空集

90. 子集 II：

讲解：代码随想录

思路：

递归：是组合|| 和子集两个题的结合体，需要在遍历同一层时，进行去重，需要一个used列表进行层遍历的判断

代码：

class Solution {
    vector<vector<int>> result;
    vector<int> path;

private:
    void caozuo(vector<int>& nums,vector<bool>& used,int startindex)
    {
        result.push_back(path);
        if(startindex >= nums.size())
        {
            return;
        }
        for(int i = startindex; i<nums.size();i++)
        {
            if(i>0 && nums[i] == nums[i-1] && used[i-1] == false)
            {
                continue;
            }
            used[i]=true;
            path.push_back(nums[i]);
            caozuo(nums,used,i+1);
            used[i]=false;
            path.pop_back();
        }
    }
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        vector<bool> used(nums.size(),false);
        result.clear();
        path.clear();
        sort(nums.begin(),nums.end());//去重需要排序，是前提
        caozuo(nums,used,0);
        return result;
    }
};

遇到的问题：

1.对于used列表的理解：当进行向叶子节点的遍历时，不需要去重，当遍历完叶子节点，回到上一层的树时，需要进行去重，因为此时从左到右遍历会出现与之前相同的结果子集