day 28|● 93.复原IP地址 ● 78.子集 ● 90.子集II

最新推荐文章于 2024-07-19 19:11:19 发布

brilliantii

最新推荐文章于 2024-07-19 19:11:19 发布

阅读量58

点赞数

文章标签：算法

本文链接：https://blog.csdn.net/qq_44132116/article/details/128770520

版权

93. 复原 IP 地址

有效 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 中的任何数字。你可以按任何顺序返回答案。

解：

class Solution {
private:
    vector<string> result;
    void Backtracking(string s,int startindex,int index)
    {
        if(index == 3)
        {
            if(isVaild(s,startindex,s.size()-1))
            {
                result.push_back(s);
            }
            return;
        }

        for(int i=startindex;i<s.size();i++)
        {
            if(isVaild(s,startindex,i)) 
            {
                s.insert(s.begin()+i+1,'.');
                index+=1;
                Backtracking(s,i+2,index);
                s.erase(s.begin()+i+1);    
                index-=1;
            }
            else
            {
                break;
            }
        }
    return;
    }
    bool isVaild(const string& s,int start, int end)
    {
        if(start>end) return false;
        if(s[start]=='0' &&start != end) return false;
        if((end-start+1)>3) return false;
        if((end-start+1)==3)
        {
            int number=(s[start]-'0')*100+(s[start+1]-'0')*10+(s[end]-'0');
            if(number>255) return false;
        }
        return true;
    }
public:
    vector<string> restoreIpAddresses(string s) {
    result.clear();
    if(s.size()<4 || s.size()>12) return result;
    Backtracking(s,0,0);
    return result;
    }
};

78. 子集

给你一个整数数组 nums ，数组中的元素互不相同。返回该数组所有可能的子集（幂集）。
解集不能包含重复的子集。你可以按任意顺序返回解集。

解：

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void Backtracking(vector<int>& nums,int startindex)
    {
        if(startindex > nums.size()) return;
        result.push_back(path);

        for(int i=startindex;i<nums.size();i++)
        {
            path.push_back(nums[i]);
            Backtracking(nums,i+1);
            path.pop_back();
        }
    }
public:
    vector<vector<int>> subsets(vector<int>& nums) {
    result.clear();
    path.clear();
    Backtracking(nums,0);
    return result;
    }
};

90. 子集 II

给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。
解集不能包含重复的子集。返回的解集中，子集可以按任意顺序排列。

解：

//用一个used
class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void Backtracking(vector<int>&nums,vector<int>& used,int startindex)
    {
        if(startindex>nums.size()) return;
        result.push_back(path);

        for(int i=startindex;i<nums.size();i++)
        {
            if(i>0 && nums[i]==nums[i-1] && used[i-1]==false)     
                continue;
            else
            {
                path.push_back(nums[i]);
                used[i]=true;
                Backtracking(nums,used,i+1);
                used[i]=false;
                path.pop_back();
            }
        }
    }
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        vector<int> used(nums.size(),false);
        Backtracking(nums,used,0);
        return result;
    }
};