目录
- 93. 复原 IP 地址
- 题目描述
- 题解
- 78. 子集
- 题目描述
- 题解
- 90. 子集 II
- 题目描述
- 题解
93. 复原 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"]
提示:
1 <= s.length <= 20
s
仅由数字组成
题解
回溯算法解决,整体思路和 131. 分割回文串 差不多,可参见其 对应题解 。
需要注意的主要是一些细节方面的问题,比如:
- 分割成功的标志为:
- 恰好分为4段
- 每段都是[0, 255]之间的整数,且不能有先导0
- 每次添加一段时,还要添加
.
- 回溯时,要删除上次添加的整个子串和
.
代码实现如下,思路及细节处理见注释:
class Solution
{
private:
string ip;
vector<string> res;
int partCount = 0; // 有效ip地址应由4个部分组成
bool isLegalIpPart(const string &s) {
if (s.size() > 1 && s[0] == '0') // 不能含有前导0
return false;
if (s.size() > 3) // 不能超过3位(最大255)
return false;
return stoi(s) >= 0 && stoi(s) <= 255;
}
public:
void backTracking(const string &s, int cutPos) {
// 递归出口:分割位置到达字符串末尾,或分割出大于4个部分(纵向遍历)
if (partCount > 4)
return;
if (cutPos >= s.size()) {
if (partCount == 4)
res.push_back(ip.substr(1, ip.size() - 1)); // 注意ip开头的'.'要去除
return;
}
// 横向遍历
for (int i = cutPos; i < s.size(); ++i) {
// 处理
string sub = s.substr(cutPos, i - cutPos + 1);
if (!isLegalIpPart(sub))
continue;
ip += "." + sub;
partCount++;
// 递归
backTracking(s, i + 1);
// 回溯
while (!ip.empty() && ip.back() != '.')
ip.pop_back(); // 删除上次添加的子串
if (!ip.empty())
ip.pop_back(); // 删除结尾的 '.'
partCount--;
}
}
vector<string> restoreIpAddresses(string s)
{
backTracking(s, 0);
return res;
}
};
78. 子集
点此跳转题目链接
题目描述
给你一个整数数组 nums
,数组中的元素 互不相同 。返回该数组所有可能的子集(即返回其幂集)。
解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。
示例 1:
输入:nums = [1,2,3]
输出:[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
示例 2:
输入:nums = [0]
输出:[[],[0]]
提示:
1 <= nums.length <= 10
-10 <= nums[i] <= 10
nums
中的所有元素 互不相同
题解
用回溯算法解决,和基本的 组合问题 框架差不多,还是 处理、递归、回溯 的三部曲框架,要注意的是 ⚠️ :
由于需要获得 所有 子集,不用像一般组合问题那样,在递归出口才将组合加入结果集,而是每次递归过程中都将当前组合加入结果集。
代码(C++)
class Solution
{
private:
vector<int> path;
vector<vector<int>> res;
public:
void backTracking(const vector<int> &nums, int start)
{
// 要求所有子集,故每次都要将path加入结果集
res.push_back(path);
// 递归出口(纵向遍历)
if (start >= nums.size())
return;
// 横向遍历
for (int i = start; i < nums.size(); ++i)
{
path.push_back(nums[i]); // 处理
backTracking(nums, i + 1); // 递归
path.pop_back(); // 回溯
}
}
vector<vector<int>> subsets(vector<int> &nums)
{
backTracking(nums, 0);
return res;
}
};
90. 子集 II
点此跳转题目链接
题目描述
给你一个整数数组 nums
,其中可能包含重复元素,请你返回该数组所有可能的子集(即返回其幂集)。
解集 不能 包含重复的子集。返回的解集中,子集可以按 任意顺序 排列。
示例 1:
输入:nums = [1,2,2]
输出:[[],[1],[1,2],[1,2,2],[2],[2,2]]
示例 2:
输入:nums = [0]
输出:[[],[0]]
提示:
1 <= nums.length <= 10
-10 <= nums[i] <= 10
题解
这题在 78. 子集 的基础上多了一个条件: nums
中 可能包含重复元素 ,这就要求我们对子集结果进行去重。去重需要在搜索过程中解决,具体思路和 40. 组合总和 II 如出一辙,都是采用 used
数组解决,可以移步我之前的笔记 40-题解(github) 或 40-题解(CSDN) 查看。
代码(C++)
class Solution
{
private:
vector<int> path;
vector<vector<int>> res;
vector<int> used;
public:
void backTracking(const vector<int> &nums, int start) {
// 求全部子集:每次都要将path加入结果集res
res.push_back(path);
// 递归出口(纵向遍历)
if (start >= nums.size())
return;
// 横向遍历
for (int i = start; i < nums.size(); ++i) {
// 去重
if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1])
continue;
// 处理
path.push_back(nums[i]);
used[i] = 1;
// 递归
backTracking(nums, i + 1);
// 回溯
path.pop_back();
used[i] = 0;
}
}
vector<vector<int>> subsetsWithDup(vector<int> &nums)
{
used.resize(nums.size());
sort(nums.begin(), nums.end()); // 先排序,便于去重
backTracking(nums, 0);
return res;
}
};