93.复原IP地址
![](https://i-blog.csdnimg.cn/blog_migrate/2f70b114fbb79f04b69b40d8b1a5d9e9.png)
class Solution {
//存储结果
List<String> result = new ArrayList<>();
public List<String> restoreIpAddresses(String s) {
//剪枝,去除非法长度
if(s.length() > 12){
return result;
}
restoreIpAddresses1(s, 0, 0);
return result;
}
//startIndex:for循环起始index
//pointNum:标记逗点添加的个数,作为递归出口
public void restoreIpAddresses1(String s, int startIndex, int pointNum){
//递归出口
//已添加3个逗点,分割结束
if(pointNum == 3){
//需要判断最后一段是否合法(区间均为左闭右闭)
if(isValid(s, startIndex, s.length() - 1)){
result.add(s);
}
//无论是否合法,此时均需结束,return
return;
}
//递归回溯部分
//以startIndex为划分界限
for(int i = startIndex; i < s.length(); i++){
//若当前划分区间符合要求则往下处理
if(isValid(s, startIndex, i)){
//加工逗点处理(substring左闭右开)
//在i和i+1中间插入逗点
s = s.substring(0, i + 1) + "." + s.substring(i + 1);
//已添加了一个逗点
pointNum++;
//递归
//需要把已添加逗点的位置空出来,所以是i+2为起始(i+1为逗点)
restoreIpAddresses1(s, i + 2, pointNum);
//回溯
pointNum--;
//空出了i+1的逗点位置,删掉逗点
s = s.substring(0, i + 1) + s.substring(i + 2);
}else{
//若当前划分区间不合要求,则结束当前循环返回上一层
break;
}
}
}
public boolean isValid(String s, int start, int end){
//根据区间左闭右闭判断终止条件
if(start > end){
return false;
}
//不合法情况;0开头数字不合法,0单独的数字合法
if(s.charAt(start) == '0' && start != end){
return false;
}
int num = 0;
for(int i = start; i <= end; i++){
//字符Ascll码比较
if(s.charAt(i) > '9' || s.charAt(i) < '0'){
return false;
}
//计算当前总和是否合法
num = num * 10 + (s.charAt(i) - '0');
if(num > 255){
return false;
}
}
return true;
}
}
78.子集
![](https://i-blog.csdnimg.cn/blog_migrate/e7542c6dd4b8dfa92ee585e295113d1b.png)
class Solution {
//存放最后符合条件结果的集合
List<List<Integer>> result = new ArrayList<>();
//每次符合条件的结果
LinkedList<Integer> path = new LinkedList<>();
//这道题目与之前题目的区别在于:
//这道题是求子集,回溯树上每一个结点都需要取值
//之前的组合问题,回溯树上只取叶子结点的值
public List<List<Integer>> subsets(int[] nums) {
subsets1(nums, 0);
return result;
}
public void subsets1(int[] nums, int startIndex){
//需要先将当前结点放入最后结果集,因为若放在递归出口后面,就会漏掉叶子结点的结果
result.add(new ArrayList<>(path));
//递归出口
if(startIndex >= nums.length){
return;
}
for(int i = startIndex; i < nums.length; i++){
path.add(nums[i]);
//递归部分
//为了防止集合重复,需要startIndex+1
subsets1(nums, i + 1);
//回溯部分
path.removeLast();
}
}
}
90.子集II
![](https://i-blog.csdnimg.cn/blog_migrate/c2d0b211628d9d24c21d4e3177053b53.png)
class Solution {
//存储所有的结果
List<List<Integer>> result = new ArrayList<>();
//存放当前符合条件的结果
LinkedList<Integer> path = new LinkedList<>();
//标记当前元素是否使用过,用来进行树层去重
boolean[] used;
//本题与上一个的区别在于去重,其他则同样需要收集回溯树上的每一个结点
public List<List<Integer>> subsetsWithDup(int[] nums) {
if(nums.length == 0){
return result;
}
Arrays.sort(nums);
used = new boolean[nums.length];
subsetsWithDup1(nums, 0);
return result;
}
public void subsetsWithDup1(int[] nums, int startIndex){
//因为需要添加回溯树上的每个结点,所以需要最先添加
//并且为了不漏下叶子结点上的结果,要放在递归出口的前面
result.add(new ArrayList<>(path));
//递归出口
if(startIndex >= nums.length){
return;
}
//递归回溯部分
for(int i = startIndex; i < nums.length; i++){
//树层去重
if(i > 0 && nums[i] == nums[i - 1] && !used[i - 1]){
continue;
}
path.add(nums[i]);
used[i] = true;
//递归部分,上下级需要防重复
subsetsWithDup1(nums, i + 1);
//回溯部分
path.removeLast();
used[i] = false;
}
}
}