【代码随想录刷题笔记】DAY28 第七章 回溯算法

93.复原IP地址 

题目链接/文章讲解：代码随想录

视频讲解：回溯算法如何分割字符串并判断是合法IP？| LeetCode：93.复原IP地址_哔哩哔哩_bilibili

//分割问题--》回溯三部曲
//注意这里的终止条件，二个if
//StringBuilder path加入ip段后再加入点，需要判断已有点的数量
//删除path最后加入的ip段和点：path.delete(startIndex + number, path.length())
class Solution {
    //新建List保存result
    List<String> result = new ArrayList<>();
    //新建StringBuilder保存每次得到的路径path
    StringBuilder path = new StringBuilder();

    public List<String> restoreIpAddresses(String s) {
        if (s.length() > 12) return result; // 算是剪枝了
        backtracking(s, 0, 0);
        return result; 
    }
    
    //定义回溯方法
    //number表示path中ip段的数量
    private void backtracking(String s, int startIndex, int number) {
        //注意！！！有二个终止条件
        if(number == 4 && s.length() == startIndex) {
            result.add(path.toString());
            return;
        }
        //注意！！！如果ip段数量>4,则直接返回
        if ( number > 4) {
			return;
		}
        //for循环，单层搜索过程
        for(int i = startIndex; i < s.length(); i++){
            //如果是valid的字段，则加入path
            if(isValid(s, startIndex, i) ) {
                path.append(s.substring(startIndex, i + 1));
            //当stringBuilder里的网段数量小于3时，才会加点
  			if (number < 3) {
				path.append(".");
			}
                number++;
                //递归
                backtracking(s, i + 1, number);
                //回溯
                number--;
                //回溯。删除当前stringBuilder最后一个ip段（左闭右开），注意考虑点的数量的问题
                path.delete(startIndex + number, path.length());
            }
            
        }
    }
    
    //定义方法判断字符串s在左闭⼜闭区间[start, end]所组成的数字是否合法
    private Boolean isValid(String s, int start, int end) {
        if (start > end) {
            return false;
        }
        if (s.charAt(start) == '0' && start != end) { // 0开头的数字不合法
            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) { // 如果⼤于255了不合法
                return false;
            }
        }
        return true;
    }
}

78.子集 

子集问题，就是收集树形结构中，每一个节点的结果。 整体代码其实和 回溯模板都是差不多的。 

题目链接/文章讲解：代码随想录

视频讲解：回溯算法解决子集问题，树上节点都是目标集和！ | LeetCode：78.子集_哔哩哔哩_bilibili

//组合问题和分割问题都是收集树的叶子节点，而子集问题是找树的所有节点！
//所以搜集path到result不需要放在终止条件里面，而是回溯方法最开始
//无序，取过的元素不会重复取，for就要从startIndex开始，而不是从0开始！
class Solution {
    //新建List保存result
    List<List<Integer>> result = new ArrayList<>();
    //新建List保存每次得到的路径path
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> subsets(int[] nums) {
        backtracking(nums, 0);
        return result; 
    }
    
    //定义回溯方法
    private void backtracking(int[] nums, int startIndex) {
        //收集子集，要放在终止条件的上面，否则会漏掉自己
        result.add(new LinkedList<>(path));
        //终止条件， 这里可以不加，因为for循环已有限制
        if(startIndex >= nums.length) {
            return;
        }
        //for循环，单层搜索过程
        for(int i = startIndex; i < nums.length; i++) {
            //将遍历到的nums的第i个元素记录到path
            //！！！注意不是直接add(i)
            path.add(nums[i]);
            //递归
            backtracking(nums, i + 1);
            //回溯
            path.removeLast();
        }
    }
}

90.子集II 

题目链接/文章讲解：代码随想录

视频讲解：回溯算法解决子集问题，如何去重？| LeetCode：90.子集II_哔哩哔哩_bilibili

//子集问题是找树的所有节点
//回溯三部曲
//去重（树层 vs 树枝）
//排序，有利于剪枝和去重

class Solution {
    //新建List保存result
    List<List<Integer>> result = new ArrayList<>();
    //新建List保存每次得到的路径path
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        //排序, 为了去重
        Arrays.sort(nums);
        backtracking(nums, 0);
        return result;
    }
    
    //定义回溯方法
    private void backtracking(int[] nums, int startIndex) {
        result.add(new LinkedList<>(path));
        //终止条件
        if(startIndex >= nums.length) {
            return;
        }
        //for循环，单层搜索过程
        for(int i = startIndex; i < nums.length; i++) {
            //去重
            //!!!注意这里需要i > startIndex，不是0
            if(i > startIndex && nums[i] == nums[i - 1]) {
                continue;
            }
            //记录到path
            path.add(nums[i]);
            //递归
            backtracking(nums, i + 1);
            //回溯
            path.removeLast();
        }
    }
}