思路
切割问题 可以看成组合问题
startIndex 是需要的,因为不能重复分割,记录下一层递归分割的起始位置
path 里存储的字符串为4个
/**
* @param {string} s
* @return {string[]}
*/
var restoreIpAddresses = function(s) {
const res = [],path = []
// i 为 startIndex 切割的起始位置
let backtracking = (i)=>{
const len = path.length //path里面 有几个切割好的字符串 为4段 则ok
if(len>4) return
if(len===4&&i===s.length){
res.push(path.join("."))//把字符串数组 变成字符串
return
}
for(let j=i;j<s.length;j++){
const str = s.slice(i,j+1);//为左闭右开的 取不到右边的
if(str.length>3||+str>255)break
if(str.length>1&&str[0]==="0")break
path.push(str);
backtracking(j+1)
path.pop()
}
}
backtracking(0)
return res
};
子集 (思路)
子集问题是找树的所有节点
组合问题和分割问题都是收集树的叶子节点
/**
* @param {number[]} nums
* @return {number[][]}
*/
var subsets = function(nums) {
let result = [],path = []
let backtracking = (nums,startIndex)=>{
result.push([...path])//收集子集,要放在终止添加的上面 否则会漏掉自己
if(startIndex>=nums.length)return
for(let i = startIndex;i<nums.length;i++){
path.push(nums[i])
backtracking(nums,i+1)
path.pop()
}
}
backtracking(nums,0)
return result
};
思路
去重 + 子集
// /**
// * @param {number[]} nums
// * @return {number[][]}
// */
var subsetsWithDup = function(nums) {
// let result = []
let result = []
// let path = []
let path = []
let nums1 = nums.sort((a,b)=>{return a-b})
// let nums1=nums.sort((a,b)=>a-b)
// let nums1 = nums.sort((a,b)=>a-b)
let backtracking = (nums1,startIndex)=>{
// result.push([...path])
result.push([...path])
// if(startIndex>nums.length)return
// if(startIndex>nums1.length-1)return;
for(let i=startIndex;i<nums1.length;i++){
if(i>startIndex&&nums1[i]===nums1[i-1]){
continue
}
path.push(nums1[i])
backtracking(nums1,i+1)//是 i!!!!!! 不是startIndex i+1代表下次递归的起始位置!!!
path.pop()
}
}
backtracking(nums1,0)
return result
};