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，分割线startIndex，逗点记录pointsum
2、终止条件
前提如果逗点数量为3个，后续第四个子串合法。因为如果前面三个不合法已经在单层搜索里排除了
3、单层搜索的逻辑
在for (int i=startIndex;i<s.length();i++)循环中 [startIndex, i] 这个区间就是截取的子串，需要判断这个子串是否合法。
如果合法就在字符串后面加上符号“.”再加上后面的字符串表示已经分割。
如果不合法就结束本层循环
递归调用时，下一层递归的startIndex要从i+2开始（因为需要在字符串中加入了分隔符.），同时记录分割符的数量pointnum 要 +1。
回溯的时候，就将刚刚加入的分隔符. 删掉，pointnum也要-1。
class Solution {
List<String> result=new ArrayList<>();
public List<String> restoreIpAddresses(String s) {
backtracking(s,0,0);
return result;
}
public void backtracking(String s,int startIndex,int pointsum){
if (pointsum==3){//pointsum代表逗点和树的深度
if (isValid(s,startIndex,s.length()-1)){//左闭右闭。判断第四个字符串是不是合法
result.add(s);
}
}
for (int i=startIndex;i<s.length();i++){
if (isValid(s,startIndex,i)){//如果合法
s=s.substring(0,i+1)+"."+s.substring(i+1);//substring是左闭右开
pointsum++;
backtracking(s,i+2,pointsum);//算上逗点的位置（i+1），新子串的start为i+2
pointsum--;
s=s.substring(0,i+1)+s.substring(i+2);//删除逗点，忽略i+1的位置
}
else break;//因为已经不是合法子串了，所以终止本树层向后面搜索
}
}
public boolean isValid(String s,int start,int end){//左闭右闭
if (start>end){
return false;
}
if (s.charAt(start)=='0'&&start!=end){//0合法意味着子串里只有0，左闭右闭start==end只有一个数
return false;
}
int num=0;
for (int i=start;i<=end;i++){
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.子集
给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。
解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。
示例 1：
输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
示例 2：
输入：nums = [0]
输出：[[],[0]]
问题分析：
1、递归函数的参数和返回值
数组、记录同一数组下标位startIndex
2、终止条件
当startIndex>=nums.length终止，代表已经没有元素可取
3、单层搜索逻辑
每个节点都是子集，不需要剪枝
class Solution {
List<List<Integer>> result=new ArrayList<>();
List<Integer> path=new ArrayList<>();
public List<List<Integer>> subsets(int[] nums) {
backtracking(nums,0);
return result;
}
public void backtracking(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]);
backtracking(nums,i+1);
path.remove(path.size()-1);
}
}
}90.子集II
给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。
解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。
示例 1：
输入：nums = [1,2,2]
输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]
示例 2：
输入：nums = [0]
输出：[[],[0]]
问题分析：
1、递归函数的参数和返回值
数组、记录同一数组下标位startIndex
2、终止条件
当startIndex>=nums.length终止，代表已经没有元素可取
3、单层搜索逻辑
需要去重
class Solution {
List<List<Integer>> result=new ArrayList<>();
List<Integer> path=new ArrayList<>();
public List<List<Integer>> subsetsWithDup(int[] nums) {
Arrays.sort(nums);
backtracking(nums,0);
return result;
}
public void backtracking(int[] nums,int startIndex){
result.add(new ArrayList<>(path));
if (startIndex>= nums.length){
return;
}
for (int i=startIndex;i< nums.length;i++){
if (i>startIndex&&nums[i]==nums[i-1]){//i>startIndex对于本层来说第一个元素已遍历完
continue;
}
path.add(nums[i]);
backtracking(nums,i+1);
path.remove(path.size()-1);
}
}
}注意：
排序问题和去重问题
一开始去重写成了 if (i>0&&nums[i]==nums[i-1])结果报错，问了大佬们
如果i>startIndex对于本层来说，已经不是第一个元素了
