93.复原IP地址
题目链接/文章讲解: 代码随想录
解题思路
本题和切割子串还是很相似的,但是细节上有所不同
终止条件:用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.子集
题目链接/文章讲解: 代码随想录
解题思路
这道题其实本质和组合没有区别,唯一的不同就在于我们收集结果的位置,组合是在叶子节点收集,而子集则是在每个节点都要收集
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
题目链接/文章讲解: 代码随想录
解题思路
这题的思路和子集没什么差别,主要是多了一个去重的操作,我们对于去重的操作都是先排序,然后利用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)
收获
继续加油