1、添加分隔符并验证区间合法性的切割问题
1.1 leetcode 93：复原IP地址
第一遍代码
runtime error: signed integer overflow: 255255111 * 10 cannot be represented in type 'int' (solution.cpp)
需要提前判断舍弃让值别那么大，或者改long int
对开头含有0的情况做特殊处理：如"101023"，“0000”
别忘了对全局变量path做回溯
class Solution {
public:
string path;
vector<string> res;
void backTracking(string s, int startindex, int num) {
if(num == 4 && startindex == s.size()) {
res.push_back(path);
return;
}
if(startindex > s.size() - 1 || num >= 4) {
return;
}
for(int i = startindex; i < s.size(); i++) {
int tmp = 0;
//对开头含有0的情况做特殊处理：如"101023"，"0000"
if(s[startindex] == '0' && i != startindex) {
break;
}
for(int j = startindex; j <= i; j++) {//别写成j--，从前往后递加
tmp = tmp*10 + (int)(s[j] - '0');
if(tmp > 255) {
break;//避免tmp太大超过范围
}
}
if(tmp <= 255) {
if(!path.empty()) {
path.push_back('.');
}
for(int y = startindex; y <= i; y++) {
path.push_back(s[y]);
}
backTracking(s, i+1, num+1);
//别忘了对全局变量path做回溯
for(int y = startindex; y <= i; y++) {
path.pop_back();
}
if(!path.empty()) {
path.pop_back();
}
}
else {
break;
}
}
}
vector<string> restoreIpAddresses(string s) {
backTracking(s, 0, 0);
return res;
}
};
string的操作（字符串 / 字符不能混，参数是指针 / 下标 还是 字符串 / 字符 不能随意替换）
1）substr：第一个参数是指针，第二个参数是长度
2）插入操作
insert() 函数:
可以在指定位置插入另一个字符串、字符、或多个字符的副本（第一个参数只能为下标 不能是指针）
string str = "Hello World";
str.insert(6, "C++ "); // 结果: "Hello C++ World"
插入单个字符（第一个参数只能为指针 不能是下标）：
string str = "abc";
str.insert(str.begin() + 1, 'X'); // 结果: "aXbc"
插入多个相同的字符：
string str = "Hello";
str.insert(0, 5, 'A'); // 结果: "AAAAAHello"
2）删除操作
erase() 函数:
可以删除从指定位置开始的特定数量的字符或整个字符串中的某个范围
string str = "Hello World";
str.erase(5, 6); // 删除从位置5开始的6个字符，结果: "Hello"
删除单个字符：
string str = "Hello";
str.erase(str.begin() + 1); // 删除位置1的字符，结果: "Hllo"
删除一个范围的字符：
string str = "Hello World";
str.erase(str.begin() + 6, str.end()); // 删除从位置6到结束的所有字符，结果: "Hello "
插入删除操作时，对字符串操作 参数为下标，对字符操作 参数为指针
3）std::stoi（string to integer）函数来实现 字符串转换为整数
4）push_back / pop_back只能对字符操作，而不能对字符串操作
用对字符串操作 完成题目
class Solution {
private:
vector<string> res;
string path;
void backTracking(const string& s, int num, int startIndex) {
if (num == 4 && startIndex == s.size()) {
res.push_back(path);
return;
}
if (num == 4)
return;
for (int i = startIndex; i < s.size(); i++) {
if (s[startIndex] == '0' && i != startIndex)
return;
string s1 = s.substr(startIndex, i - startIndex + 1);
// 先将字符串转换为整数。可以使用std::stoi（string to integer）函数来实现这一转换
if (stoi(s1) > 255) // string不支持两个string对象相减
return;
if (startIndex != 0) // 条件要加，不然输出会出现["...255.255.11.135","...255.255.111.35"]
path.insert(path.end(), '.'); // 注意第一个参数是指针的话，第二个参数是字符不是字符串
path.insert(path.size(), s1); // 第一个参数是下标的话，第二个参数才能是字符串，但不能是字符
backTracking(s, num + 1, i + 1);
int t = i - startIndex + 1;
while (t--) {
path.pop_back(); // push_back / pop_back只能对字符操作，而不能对字符串操作
}
if (startIndex != 0)
path.pop_back();
}
}
public:
vector<string> restoreIpAddresses(string s) {
backTracking(s, 0, 0);
return res;
}
};
思路
与leetcode 131一样是切割问题，切割问题就可以使用回溯搜索法把所有可能性搜出来
切割问题与组合问题相似，而且同样可以抽象为树型结构，如图：
回溯三部曲
1、递归参数
与leetcode 131类似，startIndex一定是需要的，因为不能重复分割，记录下一层递归分割的起始位置
本题我们还需要一个变量pointNum，记录添加逗点的数量（在第一遍代码中，是直接记录已经分割完成的数字数量）
所以代码如下：
vector<string> result;// 记录结果
// startIndex: 搜索的起始位置，pointNum:添加逗点的数量
void backtracking(string& s, int startIndex, int pointNum) {
2、递归终止条件
终止条件和leetcode 131情况就不同了，本题明确要求只会分成4段，所以不能用切割线切到最后作为终止条件，而是分割的段数作为终止条件
pointNum表示逗点数量，pointNum为3说明字符串分成了4段了（第一遍代码中记录已经分割完成的数字数量同理，数值都一样）
然后验证一下第四段是否合法，如果合法就加入到结果集里（组合分割问题中，终止条件都要分合法的，需要压入结果集再返回的 和 非法的直接返回的 两种）
代码如下：
if (pointNum == 3) { // 逗点数量为3时，分隔结束
// 判断第四段子字符串是否合法，如果合法就放进result中
if (isValid(s, startIndex, s.size() - 1)) {
result.push_back(s);
}
return;
}
3、单层搜索的逻辑
在leetcode 131中已经讲过在循环遍历中如何截取子串
在for (int i = startIndex; i < s.size(); i++)循环中 [startIndex, i] 这个区间就是截取的子串，需要判断这个子串是否合法
如果合法就在字符串后面加上符号.表示已经分割（第一遍代码是在除第一个数字的合法数字后面加上符号）
如果不合法就结束本层循环，如图中剪掉的分支：
然后就是递归和回溯的过程：
递归调用时，下一层递归的startIndex要从i+2开始（因为需要在字符串中加入了分隔符.，跟第一次代码不同，代码随想录代码是直接在目标字符串操作所以+2，第一遍代码还是定义了一个变量记录 所以+1即可），同时记录分割符的数量pointNum 要 +1
回溯的时候，就将刚刚加入的分隔符. 删掉就可以了（因为第一遍代码还是定义了一个变量记录 所以需要把之前的数字也给删了），pointNum也要-1
代码如下：
for (int i = startIndex; i < s.size(); i++) {
if (isValid(s, startIndex, i)) { // 判断 [startIndex,i] 这个区间的子串是否合法
s.insert(s.begin() + i + 1 , '.'); // 在i的后面插入一个逗点
pointNum++;
backtracking(s, i + 2, pointNum); // 插入逗点之后下一个子串的起始位置为i+2
pointNum--; // 回溯，别忘了回溯全
s.erase(s.begin() + i + 1); // 回溯删掉逗点
} else break; // 不合法，直接结束本层循环
}
判断子串是否合法
最后就是在写一个判断段位是否是有效段位了
主要考虑到如下三点：
1、段位以0为开头的数字不合法（但是单独一个0 是合法的）
2、段位里有非正整数字符不合法
3、段位如果大于255了不合法
代码如下：
// 判断字符串s在左闭又闭区间[start, end]所组成的数字是否合法
bool isValid(const string& s, int start, int end) {
if (start > end) {
return false;
}
if (s[start] == '0' && start != end) { // 0开头的数字不合法
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) { // 如果大于255了不合法
return false;
}
}
return true;
}
可以写出如下回溯算法C++代码（直接在原string上加点）：
class Solution {
private:
vector<string> result;// 记录结果
// startIndex: 搜索的起始位置，pointNum:添加逗点的数量
void backtracking(string& s, int startIndex, int pointNum) {
if (pointNum == 3) { // 逗点数量为3时，分隔结束
// 判断第四段子字符串是否合法，如果合法就放进result中
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)) { // 判断 [startIndex,i] 这个区间的子串是否合法
s.insert(s.begin() + i + 1 , '.'); // 在i的后面插入一个逗点
pointNum++;
backtracking(s, i + 2, pointNum); // 插入逗点之后下一个子串的起始位置为i+2
pointNum--; // 回溯
s.erase(s.begin() + i + 1); // 回溯删掉逗点
} else break; // 不合法，直接结束本层循环
}
}
// 判断字符串s在左闭又闭区间[start, end]所组成的数字是否合法
bool isValid(const string& s, int start, int end) {
if (start > end) {
return false;
}
if (s[start] == '0' && start != end) { // 0开头的数字不合法
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) { // 如果大于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;
}
};
时间复杂度: O(34)，IP地址最多包含4个数字，每个数字最多有3种可能的分割方式，则搜索树的最大深度为4，每个节点最多有3个子节点
空间复杂度: O(n）
2、子集问题
2.1 leetcode 78：子集（树枝去重）
第一遍代码
回溯就是组合专业户，全部穷举出来就完事了，只要保证path内没有元素重复即可，那通过设置起始位置作为函数参数解决
class Solution {
public:
vector<vector<int>> res;
vector<int> path;
void backTracking(vector<int>& nums, int startindex) {
if(startindex >= nums.size()) {
return;
}
for(int i = startindex; i < nums.size(); i++) {
path.push_back(nums[i]);
res.push_back(path);
backTracking(nums, i+1); // 在当前path的基础上继续加元素
path.pop_back();
}
}
vector<vector<int>> subsets(vector<int>& nums) {
vector<int> empty;
res.push_back(empty);
backTracking(nums, 0);
return res;
}
};
思路
如果把 子集问题、组合问题、分割问题都抽象为一棵树的话，那么组合问题和分割问题都是收集树的叶子节点，而子集问题是找树的所有节点
其实子集也是一种组合问题，因为它的集合是无序的，子集{1,2} 和 子集{2,1}是一样的（即在树枝上去重）
既然是无序，取过的元素不会重复取，写回溯算法的时候，for就要从startIndex开始，而不是从0开始
什么时候for可以从0开始呢？
求排列问题的时候，就要从0开始，因为集合是有序的，{1, 2} 和{2, 1}是两个集合
以示例中nums = [1,2,3]为例把求子集抽象为树型结构，如下：
遍历这个树的时候，把所有节点都记录下来，就是要求的子集集合
回溯三部曲
1、递归函数参数
全局变量数组path为子集收集元素，二维数组result存放子集组合。（也可以放到递归函数参数里）
递归函数参数在上面讲到了，需要startIndex
代码如下：
vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int>& nums, int startIndex) {
2、递归终止条件
从图中可以看出：
剩余集合为空的时候，就是叶子节点，然后就return了
那么什么时候剩余集合为空呢？
就是startIndex已经大于数组的长度了，就终止了，因为没有元素可取了，代码如下:
if (startIndex >= nums.size()) {
return;
}
其实可以不需要加终止条件，因为startIndex >= nums.size()，本层for循环本来也结束了
3、单层搜索逻辑
求取子集问题，不需要任何剪枝！因为子集就是要遍历整棵树
那么单层递归逻辑代码如下：
for (int i = startIndex; i < nums.size(); i++) {
path.push_back(nums[i]); // 子集收集元素
backtracking(nums, i + 1); // 注意从i+1开始，元素不重复取
path.pop_back(); // 回溯
}
回溯算法C++代码：
class Solution {
private:
vector<vector<int>> result;
vector<int> path;
void backtracking(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]);
backtracking(nums, i + 1);
path.pop_back();
}
}
public:
vector<vector<int>> subsets(vector<int>& nums) {
result.clear();
path.clear();
backtracking(nums, 0);
return result;
}
};
有的同学可能担心不写终止条件会不会无限递归？
并不会，因为每次递归的下一层就是从i+1开始的，函数里面的for循环自然会进不去，也就不继续递归了
2.2 leetcode 78：总结
要清楚子集问题和组合问题、分割问题的的区别，子集是收集树形结构中树的所有节点的结果
而组合问题、分割问题是收集树形结构中叶子节点的结果
2.3 leetcode 90：不能包含重复的子集（树层去重）
第一遍代码
重点是对子集的去重，对于同一树层上的元素如果后一个与前一个相等就continue，同时通过startindex来完成子集中的树枝去重
去重思路 就是之前树枝上 去重的那一套（leetcode 40）
class Solution {
//重点是对子集的去重，对于同一树层上的元素如果后一个与前一个相等就continue
//通过startindex来去重
public:
vector<vector<int>> res;
vector<int> path;
void backTracking(vector<int>& nums, int startindex) {
if(startindex >= nums.size()) {
return;
}
for(int i = startindex; i < nums.size(); i++) {
if(i > startindex) {
if(nums[i] == nums[i-1]) {
continue;
}
}
path.push_back(nums[i]);
res.push_back(path);
backTracking(nums, i+1);
path.pop_back();
}
}
vector<vector<int>> subsetsWithDup(vector<int>& nums) {
sort(nums.begin(), nums.end());
vector<int> tmp;
res.push_back(tmp);
backTracking(nums, 0);
return res;
}
};
思路
这道题目和leetcode 78区别就是集合里有重复元素了，而且求取的子集要去重
与leetcode 40去重是一个套路，这道题就是典型的同一树层上去重，理解“树层去重”和“树枝去重”非常重要
用示例中的[1, 2, 2] 来举例，如图所示：（注意去重需要先对集合排序）
从图中可以看出，同一树层上重复取2 就要过滤掉，同一树枝上就可以重复取2，因为同一树枝上元素的集合才是唯一子集
本题就是其实就是leetcode 78的基础上加上了去重，去重我们在leetcode 40也讲过了
不加used数组一样ac，因为for是从前往后遍历的，遍历到后面前面肯定用过了
代码随想录代码如下：
class Solution {
private:
vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int>& nums, int startIndex, vector<bool>& used) {
result.push_back(path);
for (int i = startIndex; i < nums.size(); i++) {
// used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
// used[i - 1] == false，说明同一树层candidates[i - 1]使用过
// 而我们要对同一树层使用过的元素进行跳过
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) {
result.clear();
path.clear();
vector<bool> used(nums.size(), false);
sort(nums.begin(), nums.end()); // 去重需要排序
backtracking(nums, 0, used);
return result;
}
};
时间复杂度: O(n * 2n)
空间复杂度: O(n)
使用set去重的版本（由于递归，每一层都会创建新的set）
class Solution {
private:
vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int>& nums, int startIndex) {
result.push_back(path);
unordered_set<int> uset;
for (int i = startIndex; i < nums.size(); i++) {
if (uset.find(nums[i]) != uset.end()) {
continue;
}
uset.insert(nums[i]);
path.push_back(nums[i]);
backtracking(nums, i + 1);
path.pop_back();
}
}
public:
vector<vector<int>> subsetsWithDup(vector<int>& nums) {
result.clear();
path.clear();
sort(nums.begin(), nums.end()); // 去重需要排序
backtracking(nums, 0);
return result;
}
};
本题也可以不使用used数组来去重，因为递归的时候下一个startIndex是i+1而不是0
如果要是全排列的话，每次要从0开始遍历，为了跳过已入栈的元素，需要使用used，第一遍代码就是这样
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
