①、复原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
中的任何数字。你可以按 任何 顺序返回答案。
事例:
输入:s = "25525511135" 输出:["255.255.11.135","255.255.111.35"]
思路:
原题给的参数需要进行切割,判断然后拼凑成一个合法的ip地址。采用回溯算法,在递归切割的时候依次判断切割完的子字符串是否符合规则,若不符合,直接结束,若符合,则添加到结果集中,由于ip地址只包含4个整数,故递归只需要递归到第三层。
回溯三部曲:
结束条件:递归层数即加点"."个数为3,代表字符串已切割成四段,无须切割
参数及返回值:参数 int[] nums int startIndex int pointSum startIndex代表切割字符串的起始位置以及递归字符串的索引 pointSum代表添加点的个数
单层逻辑:判断截出来的子字符串是否符合题意
代码:
public List<String> restoreIpAddresses(String s) {
backtracking(s,0,0);
return res;
}
private List<String> res = new ArrayList<>();
private StringBuilder sb = new StringBuilder();
public void backtracking(String s,int startIndex,int pointSum){
if(pointSum == 3){
if(isDigits(s,startIndex,s.length() - 1)){
res.add(s);
}
return;
}
//单层逻辑
for(int i = startIndex;i < s.length();i++){
if(isDigits(s,startIndex,i)){
s = s.substring(0,i + 1) + "." + s.substring(i + 1,s.length());
pointSum++;
//递归
backtracking(s,i + 2,pointSum);
//回溯
pointSum--;
s = s.substring(0,i + 1) + s.substring(i + 2,s.length());
}else {
break;
}
}
}
public boolean isDigits(String s,int left,int right){
if (left > right) {
return false;
}
if (s.charAt(left) == '0' && left != right) { // 0开头的数字不合法
return false;
}
int num = 0;
for (int i = left; i <= right; i++) {
if (s.charAt(i) > '9' || s.charAt(i) < '0') { // 遇到⾮数字字符不合法
return false;
}
num = num * 10 + (s.charAt(i) - '0');
if (num > 255) { // 如果⼤于255了不合法
return false;
}
}
return true;
}
②、子集
给你一个整数数组
nums
,数组中的元素 互不相同 。返回该数组所有可能的子集(幂集)。解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。
事例:
输入:nums = [1,2,3] 输出:[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
思路:
跟组合做法一致,只是多了第一个空集,即每个tmp都应该加入到res集合中,第一次空集也要加入。使用回溯思想,与之前不同的事,改变res的添加条件,在for循环遍历、tmp集合添加数之前添加tmp。
代码:
public List<List<Integer>> subsets(int[] nums) {
backtracking(nums,0);
return res;
}
private List<List<Integer>> res = new ArrayList<>();
private LinkedList<Integer> tmp = new LinkedList<>();
public void backtracking(int[] nums,int startIndex){
if(startIndex > nums.length){
return;
}
res.add(new ArrayList<>(tmp));
for(int i = startIndex;i < nums.length;i++){
tmp.add(nums[i]);
//递归
backtracking(nums,i + 1);
//回溯
tmp.removeLast();
}
}
③、子集Ⅱ
给你一个整数数组
nums
,其中可能包含重复元素,请你返回该数组所有可能的子集(幂集)。解集 不能 包含重复的子集。返回的解集中,子集可以按 任意顺序 排列。
事例:
输入:nums = [1,2,2] 输出:[[],[1],[1,2],[1,2,2],[2],[2,2]]
思路:
跟上一题一样的添加操作,只是在单层逻辑for循环中添加了去重操作。与组合总和2那题类似,将数组排序(方便去重),借助int数组used记录当前子集是否使用过某下标的值,若当前下标的值与前一个相等,且tmp集合中无前一个的值,说明前一个数已经递归完,当前数开头构成的所有子集都重复,应直接跳过。
代码:
public List<List<Integer>> subsetsWithDup(int[] nums) {
int[] used = new int[nums.length];
Arrays.sort(nums);
backtracking(nums,0,used);
return res;
}
private List<List<Integer>> res = new ArrayList<>();
private LinkedList<Integer> tmp = new LinkedList<>();
public void backtracking(int[] nums,int startIndex,int[] used){
if(startIndex > nums.length){
return;
}
res.add(new ArrayList<>(tmp));
for(int i = startIndex;i < nums.length;i++){
//去重
if(i > 0 && nums[i] == nums[i - 1] && used[i - 1] == 0){
continue;
}
tmp.add(nums[i]);
used[i] = 1;
//递归
backtracking(nums,i + 1,used);
//回溯
tmp.removeLast();
used[i] = 0;
}
}