代码随想录刷LeetCode | day28刷题回顾

最新推荐文章于 2024-07-06 07:39:36 发布

风吹衣ou

最新推荐文章于 2024-07-06 07:39:36 发布

阅读量81

点赞数

文章标签： leetcode 算法 java

本文链接：https://blog.csdn.net/weixin_40142386/article/details/128305989

版权

前沿：撰写博客的目的是为了再刷时回顾和进一步完善，其次才是以教为学，所以如果有些博客写的较简陋，是为了保持进度不得已而为之，还请大家多多见谅。

预：看到题目后的思路和实现的代码。

见：参考答案展示。

感思：对比答案后的思考，与之前做过的题目是否有关联。

行：

（1）对于没做出来的题目，阅读答案后重新做一遍；

（2）下次做题可以尝试改善的方向；

（3）有助于理解的相关的题目

优先级：做题进度＞学习&总结＞默写回顾＞做题数量

题目回顾

1.复原 IP 地址

题目链接：93. 复原 IP 地址

思路：本质上跟分割是一回事

分割规则：

只能依次分割；
每次分割长度[1,3]；
1. (i+1)-startindex < 4 → i < 3+startindex
共四个整数，即分割3次→IP地址长度[4,12]
1. 终止条件：index = 4 && path.size = s.len
分割区间值[0,255];
不能出现‘012’这种不正常值；
分割完一个IP地址时(遍历完)，所有字符都要用上。

以下代码存在问题，只作为记录。

class Solution {
    List<String> result = new ArrayList<>();
    StringBuilder path = new StringBuilder();
    public List<String> restoreIpAddresses(String s) {
        if(s.length() < 4 || s.length() > 12){
            return result;
        }
        backtracking(s,0,0);
        return result;
    }
    void backtracking(String s,int startindex,int index){
        if(path.length() == s.length() && index == 4){
                result.add(path.toString());
                return;
        }
        if(path.length() == s.length() || index == 4){
            return;
        }
        for(int i = startindex;i < s.length() && i < 3+startindex;i++){
            String temp = s.substring(startindex,i+1);
            // 不能出现‘012’这种不正常值；
            if(temp.charAt(0) == '0' && temp.length() != 1){
                continue;
            }else if(Integer.parseInt(temp) < 0 || Integer.parseInt(temp) > 255){
                continue;
            }
            path.append(temp);
            index++;
            if(index < 4){
                path.append(".");
            }
            backtracking(s,i+1,index);
            index--;
            System.out.println(path);
            path.delete(startindex+index,i+1+index+1);
        }
    }
}

2.子集II

题目链接：90.子集II

思路：求子集→回溯过程存储

求解子集相对于将回溯的每个过程无终止条件的存储，但该题与普通子集区别在于其可能出现重复，但又要求获取结果不能重复。

通过图可知，只要保证树层不重复选值，则可保证子集组合不重复。

与40.组合总和II相同:

求树层不同→排序+startindex+当同层循环（i > startindex）时，判断i与上i-1是否相同。

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        Arrays.sort(nums);
        backtracking(nums,0);
        return result;
    }
    void backtracking(int[] nums,int startindex){
        result.add(new ArrayList(path));
        for(int i = startindex;i < nums.length;i++){
            {
                continue;if(i > startindex && nums[i-1] == nums[i])
            }
            path.add(nums[i]);
            backtracking(nums,i+1);
            path.removeLast();
        }
    }
}

3. 子集

题目链接：78.子集

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。

解集不能包含重复的子集。你可以按 任意顺序 返回解集。
输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> subsets(int[] nums) {
        // result.add(new ArrayList(path));
        backtracking(nums,0);
        return result;
    }
    void backtracking(int[] nums,int startindex){
        result.add(new ArrayList(path));
        for(int i = startindex;i < nums.length;i++){
            path.add(nums[i]);
            backtracking(nums,i+1);
            path.removeLast();
        }

    }
}