代码随想录回溯算法03

最新推荐文章于 2025-06-02 20:51:47 发布

Naive_7

最新推荐文章于 2025-06-02 20:51:47 发布

阅读量592

点赞数 5

文章标签：算法

本文链接：https://blog.youkuaiyun.com/xiangjiaonigebun/article/details/147029774

版权

93.复原IP地址

本期本来是很有难度的，不过大家做完分割回文串之后，本题就容易很多了

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

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

有效 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 中的任何数字。你可以按任何顺序返回答案。

class Solution {
    List<String>res=new ArrayList<>();
    public List<String> restoreIpAddresses(String s) {
        StringBuilder st=new StringBuilder(s);//将s转化为可以增删的字符串
        back(st,0,0);
        return res;
    }
      public  void back(StringBuilder s,int index,int num)
      {
        if(num==3&&isvalid(s,index,s.length()-1))
        {
            res.add(s.toString());
            return;
        }
        for(int i=index;i<s.length();i++)
        {
            if(isvalid(s,index,i)){//实际上已经是一个剪枝的操作，若此段不符合要求，则后续回溯操作不必进行
         s.insert(i+1,'.');//添加点的步骤
         back(s,i+2,num+1);//back(StringBuilder s,int index,int num)，index更新为i+2,表示从剩余的元素（索引为index+2）中开始选切割
         s.deleteCharAt(i+1);//删去i+1索引的这个点，便于选择另外一个方向
        }
        else
        {
            break;
        }
      }}
//[start,end]为左闭右闭，为每一个分割开的字符，适用于StringBuilder
    public boolean isvalid(StringBuilder s,int start,int end)
    {
        if(start>end)
        {
            return false;
        }
    String seg=s.substring(start,end+1);//左闭右开
    if(seg.length()>3)
    {
        return false;
    }
    int num=Integer.parseInt(seg);
    if(num>255||num<0)
    {
        return false;
    }
    //前导0
    if(seg.charAt(0)=='0'&&seg.length()>1)
    {
        return false;
    }
    return true;

    }
}

注意点：

问题	说明
`"9245587303"`	长度太长，不可能是合法 IP 段（超过 255）
`Integer.parseInt()`	只能处理合法 int 范围（-2,147,483,648 到 2,147,483,647）
`.substring(start, end+1)`	如果不加长度限制，可能会生成很长子串导致异常

在使用Integer.parseInt()之前，为避免长度太长，应该提前筛去length>3的切割字符串

`insert()`	`StringBuilder`	向字符串中插入字符	`sb.insert(1, ".")`
`add()`	`List` 接口实现类	向列表中添加元素	`list.add("192")`

方法名	适用类型	用途
`deleteCharAt(int index)`	`StringBuilder` / `StringBuffer`	删除指定位置的字符
`remove(int index)`	`List`（如 `ArrayList`）	删除集合中指定索引的元素
`remove(Object o)`	`List`, `Set` 等	删除集合中指定值的元素

String的方法大全

`length()`	获取字符串长度	`"abc".length()` → `3`
`charAt(int index)`	获取指定位置的字符	`"hello".charAt(1)` → `'e'`
`substring(int begin)`	从索引开始截取到末尾	`"hello".substring(2)` → `"llo"`
`substring(int begin, int end)`	截取部分字符串 `[begin, end)`	`"hello".substring(1, 4)` → `"ell"`
`indexOf(String str)`	查找子串首次出现的位置	`"apple".indexOf("p")` → `1`
`lastIndexOf(String str)`	查找子串最后出现位置	`"apple".lastIndexOf("p")` → `2`
`contains(String s)`	是否包含子串	`"abc".contains("b")` → `true`
`isEmpty()`	是否为空字符串（长度为 0）	`"".isEmpty()` → `true`
`equals(String s)`	判断是否相等（区分大小写）	`"abc".equals("ABC")` → `false`
`equalsIgnoreCase(String s)`	忽略大小写比较	`"abc".equalsIgnoreCase("ABC")` → `true`
`toLowerCase()` / `toUpperCase()`	转小写 / 转大写	`"Hello".toLowerCase()` → `"hello"`
`trim()`	去除首尾空格	`" hi ".trim()` → `"hi"`

方法	用法	说明
`String.valueOf(任意类型)`	`String.valueOf(123)` → `"123"`	将任意值转为字符串
`Integer.parseInt(String s)`	`"123"` → `123`	将字符串转为整数（注意捕获异常）
`Double.parseDouble(String s)`	`"3.14"` → `3.14`	将字符串转为小数

`startsWith(String prefix)`	`"hello".startsWith("he")` → `true`	是否以指定前缀开始
`endsWith(String suffix)`	`"hello".endsWith("lo")` → `true`	是否以指定后缀结束
`matches(String regex)`	`"123".matches("\\d+")` → `true`	是否符合正则表达式

char[] arr = "hello".toCharArray(); // 字符串 → 字符数组
String s = new String(arr); // 字符数组 → 字符串

解法：

画出回溯的树形结构来分析，

78.子集

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

题目链接/文章讲解：https://programmercarl.com/0078.%E5%AD%90%E9%9B%86.html

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

class Solution {
    List<List<Integer>>res=new ArrayList<>();//注意接口和实现类
    LinkedList<Integer>path=new LinkedList<>();
    public List<List<Integer>> subsets(int[] nums) {
        back(nums,0);
        return res;
    }
    public void back(int []nums,int index)
   {
    res.add(new LinkedList<>(path));
    for(int i=index;i<nums.length;i++)
    {
        
        path.add(nums[i]);
        back(nums,i+1);
        path.removeLast();
    }
   }


}

空集的产生：在第一次调用 back(nums, 0) 时，path 是空的，res.add(new LinkedList<>(path)) 就把空集 [] 加入到结果中。

90.子集II

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

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

class Solution {
    List<List<Integer>> result = new ArrayList<>();// 存放符合条件结果的集合
    LinkedList<Integer> path = new LinkedList<>();// 用来存放符合条件结果
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        Arrays.sort(nums);//去重前应该先排序
        back(nums, 0);
        return result;
    }

    private void back(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]){continue;}//判断i>startIndex避免出现-1
            path.add(nums[i]);
            back(nums, i + 1);
            path.removeLast();
        }
    }
}

先排序，再进行经典去重操作