leetcode（力扣）93. 复原 IP 地址||78. 子集||90. 子集 II

最新推荐文章于 2024-11-12 10:59:16 发布

大鹏good

最新推荐文章于 2024-11-12 10:59:16 发布

阅读量99

点赞数

文章标签： leetcode 算法职场和发展

本文链接：https://blog.csdn.net/dapeng908972264/article/details/127389363

版权

93. 复原 IP 地址

class Solution {
private:
       vector<string> result;
       bool isValid(string s,int start,int end){
           if(start>end) return false;
           if(s[start]=='0'&&start!=end) 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) return false;

           }

           return true;
       }

       void backtracking(string s,int pointNum,int index){
           if(pointNum==3){
               if(isValid(s,index,s.size()-1)){
                   result.push_back(s);
                   return;
               }
           }
           for(int i=index;i<s.size();i++){
               if(isValid(s,index,i)){
                   s.insert(s.begin()+i+1,'.');
                   pointNum++;
                   backtracking(s,pointNum,i+2);
                   pointNum--;
                   s.erase(s.begin()+i+1);
               }
               else{break;}
               
           }
       }

public:
    vector<string> restoreIpAddresses(string s) {
     if(s.size()<4) return result;
     backtracking(s,0,0);
     return result;
    }
};

78. 子集

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

90. 子集 II

class Solution {
private:
        vector<vector<int>> result;
        vector<int> path;
        void backtracking(vector<int>& nums,int index,vector<bool>& used){
            result.push_back(path);
            if(index>nums.size()) return;
            for(int i=index;i<nums.size();i++){
                if(i>0&&nums[i-1]==nums[i]&&used[i-1]==false) {continue;}
                path.push_back(nums[i]);
                used[i]=true;
                backtracking(nums,i+1,used);
                path.pop_back();
                used[i]=false;
            }
        }
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
       vector<bool> used(nums.size(),false);
       sort(nums.begin(),nums.end());
       backtracking(nums,0,used);
       return result;
    }
};