代码随想录算法训练营第二十八天| 93. 复原 IP 地址、78. 子集、90. 子集 II

[LeetCode] 93. 复原 IP 地址

[LeetCode] 93. 复原 IP 地址 文章解释

[LeetCode] 93. 复原 IP 地址 视频解释

[LeetCode] 93. 复原 IP 地址 文章解释

自己看到题目的第一想法

    和切割回文串是一样的解法, 但是要注意切割的规则, 以及层数一定是4, 并且第四层不需要继续递归处理, 而是直接判断第三层之后所有的字符串.

    同时假设切割出 0xx 这样的字符串, 不能转换成数字 xx, 要判断为非法字符.

看完代码随想录之后的想法 

    思路几乎是一致的. 实现上有些不同, 我使用了 Java 中的 StringBuilder 来拼接字符, 随想录使用的是添加 ‘.’ 来处理字符拼接.

class Solution {
    private List<String> result = new ArrayList<>();
    private StringBuilder ipAddressBuilder = new StringBuilder();
    private int ipAddressNumberCount = 0;
    public List<String> restoreIpAddresses(String s) {
        if (s == null) {
            return result;
        }
        backTracking(s, 0);
        return result;
    }
    private void backTracking(String s, int startIndex) {
        if (startIndex == s.length() && ipAddressNumberCount == 4) {
            result.add(ipAddressBuilder.toString());
            return;
        }
        for (int i = startIndex; i < s.length(); i++) {
            if (ipAddressNumberCount == 3) {
                if (s.length() - startIndex > 3) {// 0 开头的不行, 大于三位数的不行
                    return;
                }
                i = s.length() - 1;
            }
            String ipAddressNumber = getValidNumber(s, startIndex, i);
            if (ipAddressNumber == null) {
                return;
            }
            ipAddressBuilder.append(ipAddressNumber);
            ipAddressNumberCount++;
            if (ipAddressNumberCount != 4) {
                ipAddressBuilder.append('.');
            }
            backTracking(s, i + 1);
            if (ipAddressNumberCount != 4) {
                ipAddressBuilder.deleteCharAt(ipAddressBuilder.length() - 1);
            }
            ipAddressBuilder.delete(ipAddressBuilder.length() - ipAddressNumber.length(), ipAddressBuilder.length());
            ipAddressNumberCount--;
        }
    }
    private String getValidNumber(String s, int startIndex, int endIndex) {
        int number = 0;
        if (startIndex > endIndex) {
            return null;
        }
        if (s.charAt(startIndex) == '0' && startIndex != endIndex) {
            return null;
        }
        for (int i = startIndex; i <= endIndex; i++) {
            number = number * 10 + (s.charAt(i) - '0');
        }
        if(number <= 255) {
            return String.valueOf(number);
        }
        return null;
    }
}

自己实现过程中遇到哪些困难

    晚上重新捋一遍的时候, 发现结束条件依旧写的不好, debug 了好一会儿才明白哪里出了问题. 同时减枝的操作效果不是很明显.

[LeetCode] 78. 子集

[LeetCode] 78. 子集 文章解释

[LeetCode] 78. 子集 视频解释

题目:

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

子集

（幂集）。

解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

示例 1：

输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

示例 2：

输入：nums = [0]
输出：[[],[0]]

提示：

• 1 <= nums.length <= 10
• -10 <= nums[i] <= 10
• nums 中的所有元素 互不相同

[LeetCode] 78. 子集

自己看到题目的第一想法 

    和切割回文子串的思路有点像, 但是回文字符串子集在原字符串中是连续的, 这里的子集是不需要连续的.

    根据子集的元素个数来划分, n 个字符串组成的子集长度是从 0 ~ n. 同时对于长度为 m 的子集, 是由长度为 m - 1 的子集再添加元素组成.

    因此可以通过递归的方式, 从只有一个元素的子集, 添加新的元素组成更大的子集, 一直到处理到最后一个元素为止.

看完代码随想录之后的想法 

    思路几乎是一致的.

class Solution {
    private List<List<Integer>> result = new ArrayList<>();
    private List<Integer> path = new ArrayList<>();
    public List<List<Integer>> subsets(int[] nums) {
        backTracking(nums, 0);
        return result;
    }
    private 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.remove(path.size() - 1);
        }
    }
}

自己实现过程中遇到哪些困难

    无

[LeetCode] 90. 子集 II

[LeetCode] 90. 子集 II 文章解释

[LeetCode] 90. 子集 II 视频解释

问题:

给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的

子集

（幂集）。

解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。

示例 1：

输入：nums = [1,2,2]
输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]

示例 2：

输入：nums = [0]
输出：[[],[0]]

提示：

• 1 <= nums.length <= 10
• -10 <= nums[i] <= 10

[LeetCode] 90. 子集 II

自己看到题目的第一想法 

    与求子集问题一致, 但是需要去重. 去重的关键在于, 如果前一个元素与自己相同,  表示自己与后面元素的组合都已经处理过了, 因此需要忽略自己.

看完代码随想录之后的想法 

    完全一致. AC.

class Solution {
    private List<List<Integer>> result = new ArrayList<>();
    private List<Integer> path = new ArrayList<>();
    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 ArrayList<>(path));
        for (int i = startIndex; i < nums.length; i++) {
            if (i > startIndex && nums[i - 1] == nums[i]) {
                continue;
            }
            path.add(nums[i]);
            backTracking(nums, i + 1);
            path.remove(path.size() - 1);
        }
    }
}

自己实现过程中遇到哪些困难

    无