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

93.复原IP地址

题目链接/文章讲解： 代码随想录

视频讲解：回溯算法如何分割字符串并判断是合法IP？| LeetCode：93.复原IP地址_哔哩哔哩_bilibili

解题思路

本题和切割子串还是很相似的，但是细节上有所不同

终止条件：用pointSum来终止，也就是逗点的数量，如果等于3了，说明已经切割完成了，此时去判断一下最后一个区间即可，细节在代码中已经标注

class Solution {
private:
vector<string> result;
    bool isValid(const 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]>'9' || s[i]<'0')
            return false;
          num = num*10+(s[i] -'0');
          if(num>255)
             return false;    //如果超过了255，那么就不合法
      }
      return true;
 }

    void backtracking(string& s,int startIndex, int pointSum)    //startIndex用来切割字符串，而pointSum是逗点数量，用来控制深度，需要修改s的值，因此引用传递
    {
         if(pointSum ==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 , '.');
                  pointSum++;
                  backtracking(s,i+2,pointSum);    //i+1的位置是逗点
                  pointSum--;
                  s.erase(s.begin()+i+1);
              }
              else break;    //不合法就不需要再继续去判断了
         }
    }

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

78.子集

题目链接/文章讲解： 代码随想录

视频讲解：回溯算法解决子集问题，树上节点都是目标集和！ | LeetCode：78.子集_哔哩哔哩_bilibili

解题思路

 这道题其实本质和组合没有区别，唯一的不同就在于我们收集结果的位置，组合是在叶子节点收集，而子集则是在每个节点都要收集

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

void backtracking(vector<int>& nums, int startIndex)
{
    result.push_back(path);    //从一开始就收集结果，每次递归都收集
    //这题终止条件可以不写，因为和for循环的终止条件是一样的
    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) {
            backtracking(nums,0);
            return result;
    }
};

• 时间复杂度: O(n * 2^n)
• 空间复杂度: O(n)

90.子集II

题目链接/文章讲解： 代码随想录

视频讲解：回溯算法解决子集问题，如何去重？| LeetCode：90.子集II_哔哩哔哩_bilibili

解题思路

这题的思路和子集没什么差别，主要是多了一个去重的操作，我们对于去重的操作都是先排序，然后利用used数组来判断是树枝去重还是树层去重，记得used数组要初始化

class Solution {
private:
vector<int> path;
vector<vector<int>> result;
void backtracking(vector<int>& nums , int startIndex , vector<bool>& used)
{
     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;    //上一个没有使用，那就说明在树层上，且和之前的元素相等，那么就说明重复了
          path.push_back(nums[i]);
          used[i] = true;
          backtracking(nums,i+1,used);    //从当前元素的下一个元素开始取
          used[i]= false;
          path.pop_back();
     }
}

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;
    }
};

• 时间复杂度: O(n * 2^n)
• 空间复杂度: O(n) 

收获

继续加油