还原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
中的任何数字。你可以按 任何 顺序返回答案。
示例 1:
输入:s = "25525511135"
输出:["255.255.11.135","255.255.111.35"]
示例 2:
输入:s = "0000"
输出:["0.0.0.0"]
示例 3:
输入:s = "101023"
输出:["1.0.10.23","1.0.102.3","10.1.0.23","10.10.2.3","101.0.2.3"]
解题思路
通过回溯算法尝试在字符串的不同位置插入点(.
),以形成有效的IP地址。每次插入点后,检查剩余部分是否有效,并在所有可能的位置插入点后,收集所有有效的IP地址。
回溯三部曲:
1. 回溯函数的参数和返回值
-
参数:
string &s
:当前正在处理的字符串。int startIndex
:当前处理的子字符串的起始位置。int pointNum
:已经插入的点的数量。
-
返回值:无返回值(
void
)。结果通过类的成员变量result
存储。
2. 回溯函数的终止条件
- 终止条件:当
pointNum
等于 3 时,表示已经插入了三个点,此时需要检查剩余部分是否有效。如果有效,则将当前字符串加入结果集。
3. 回溯函数的单层逻辑
-
具体回溯过程:
- 从
startIndex
开始遍历字符串,尝试在每个位置后插入点。 - 如果当前部分有效(通过
isValid
函数检查),则在当前位置后插入点,并递归处理下一个部分。 - 递归返回后,进行回溯操作,移除插入的点,继续尝试下一个位置。
- 从
-
剪枝逻辑:
- 如果当前部分无效,则跳出循环,不再继续尝试后续位置。这样可以避免无效的递归调用,提高效率。
代码实现
测试地址:https://leetcode.cn/problems/restore-ip-addresses/description/
class Solution {
private:
vector<string> result;
// 回溯函数,用于生成所有可能的IP地址
void backtracking(string &s, int startIndex, int pointNum) {
// 如果已经插入了3个点,检查剩余部分是否有效
if (pointNum == 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, '.'); // 在当前位置后插入点
pointNum++;
backtracking(s, i + 2, pointNum); // 递归处理下一个部分
pointNum--;
s.erase(s.begin() + i + 1); // 回溯,移除插入的点
}
else
break; // 如果当前部分无效,则跳出循环
}
}
// 检查字符串的某个部分是否是有效的IP地址段
bool isValid(const 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) { // 数字必须在0到255之间
return false;
}
}
return true;
}
public:
vector<string> restoreIpAddresses(string s) {
if (s.size() < 4 || s.size() > 12) // 字符串长度必须在4到12之间
return result;
backtracking(s, 0, 0);
return result;
}
};
子集
题目描述
给你一个整数数组 nums
,数组中的元素 互不相同 。返回该数组所有可能的子集(幂集)。
解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。
示例 1:
输入:nums = [1,2,3]
输出:[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
示例 2:
输入:nums = [0]
输出:[[],[0]]
解题思路
1. 回溯函数的参数和返回值
-
参数:
vector<int> &nums
:输入的数组,用于生成子集。int startIndex
:当前处理的元素起始索引,用于控制遍历的起始位置。
-
返回值:无返回值(
void
),结果直接存储在类的成员变量result
中。
2. 回溯函数的终止条件
- 当
startIndex
大于或等于nums.size()
时,表示已经遍历完所有元素,此时直接返回,结束当前递归分支。
3. 回溯函数的单层逻辑
- 选择当前元素:将
nums[i]
添加到path
中。 - 递归处理下一个元素:调用
backtracking(nums, i + 1)
,从下一个元素开始继续生成子集。 - 回溯:在递归返回后,执行
path.pop_back()
,移除当前元素,以便尝试其他可能的选择。
代码实现
测试地址:https://leetcode.cn/problems/subsets/
class Solution {
private:
vector<vector<int>> result; // 存储所有子集的结果集
vector<int> path; // 当前正在处理的子集路径
void backtracking(vector<int> &nums, int startIndex) {
// 将当前路径(子集)添加到结果集中
result.push_back(path);
// 终止条件:startIndex 超出数组范围
if (startIndex >= nums.size())
return;
// 单层逻辑:遍历从 startIndex 开始的每个元素
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); // 从索引 0 开始回溯
return result;
}
};
子集II
题目描述
给你一个整数数组 nums
,其中可能包含重复元素,请你返回该数组所有可能的 子集(幂集)。
解集 不能 包含重复的子集。返回的解集中,子集可以按 任意顺序 排列。
示例 1:
输入:nums = [1,2,2]
输出:[[],[1],[1,2],[1,2,2],[2],[2,2]]
示例 2:
输入:nums = [0]
输出:[[],[0]]
解题思路
1. 回溯函数的参数和返回值
-
参数:
vector<int> &nums
:输入的数组,用于生成子集。int startIndex
:当前处理的元素起始索引,用于控制遍历的起始位置。vector<bool> &used
:标记数组中每个元素是否已使用的布尔数组。
-
返回值:无返回值(
void
),结果直接存储在类的成员变量result
中。
2. 回溯函数的终止条件
- 回溯函数没有显式的终止条件,因为它是通过循环和递归来遍历所有可能的子集组合。循环会在
i
达到nums.size()
时自然结束。
3. 回溯函数的单层逻辑
- 剪枝逻辑:在循环中,通过检查当前元素是否与前一个元素相同且前一个元素未被使用,来避免生成重复的子集。
- 选择当前元素:将
nums[i]
添加到path
中,并标记used[i]
为true
。 - 递归处理下一个元素:调用
backtracking(nums, i + 1, used)
,从下一个元素开始继续生成子集。 - 回溯:在递归返回后,执行
used[i] = false
和path.pop_back()
,移除当前元素并标记为未使用,以便尝试其他可能的选择。
代码实现
测试地址:https://leetcode.cn/problems/subsets-ii/
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); // 从索引 0 开始回溯
return result;
}
};