Day28｜回溯算法part04：93.复原IP地址、78. 子集、90. 子集II

最新推荐文章于 2024-07-20 09:51:47 发布

QHG7C0

最新推荐文章于 2024-07-20 09:51:47 发布

阅读量287

点赞数 6

分类专栏：数据结构与算法（二刷）文章标签：算法

本文链接：https://blog.csdn.net/weixin_43303286/article/details/137342781

版权

数据结构与算法（二刷）专栏收录该内容

65 篇文章 0 订阅

订阅专栏

*****复原IP地址

这就是一个切割问题，跟切割子串类似，但是这题使用.切割。

来不及看了，先贴个题解：

class Solution {
        List<String> result = new ArrayList<>();
        public List<String> restoreIpAddresses(String s) {
            StringBuilder sb = new StringBuilder(s);
            backTracking(sb, 0, 0);
            return result;
        }
        private void backTracking(StringBuilder s, int startIndex, int dotCount){
            if(dotCount == 3){
                if(isValid(s, startIndex, s.length() - 1)){
                    result.add(s.toString());
                }
                return;
            }
            for(int i = startIndex; i < s.length(); i++){
                if(isValid(s, startIndex, i)){
                    s.insert(i + 1, '.');
                    backTracking(s, i + 2, dotCount + 1);
                    s.deleteCharAt(i + 1);
                }else{
                    break;
                }
            }
        }
        //[start, end]
        private boolean isValid(StringBuilder s, int start, int end){
            if(start > end)
                return false;
            if(s.charAt(start) == '0' && start != end)
                return false;
            int num = 0;
            for(int i = start; i <= end; i++){
                int digit = s.charAt(i) - '0';
                num = num * 10 + digit;
                if(num > 255)
                    return false;
            }
            return true;
        }
    }

子集（元素互不相同）

class Solution {
    private List<List<Integer>> resList = new ArrayList<>();
    List<Integer> res = new ArrayList<>();

    private void backtracking(int[] nums, int startIndex) {
        if (res.size() <=  nums.length) {
            resList.add(new ArrayList<>(res));
        }

        for (int i = startIndex; i < nums.length; i++) {
            res.add(nums[i]);
            backtracking(nums, i + 1); //递归；
            res.remove(res.size() - 1);

        }
    }
    public List<List<Integer>> subsets(int[] nums) {
        backtracking(nums, 0);
        return resList;
    }
}

根组合那题差不多，用一个startIndex避免重复。

子集II（元素相同但不可重复取）

class Solution {
        private List<List<Integer>> resList = new ArrayList<>();
        List<Integer> res = new ArrayList<>();

        private boolean used[];

        private void backtracking(int[] nums, int startIndex) {
            if (res.size() <= nums.length) {
                resList.add(new ArrayList<>(res));
            }

            for (int i = startIndex; i < nums.length; i++) {
                if(i > 0 && nums[i] == nums[i - 1] && !used[i - 1]){
                    continue;
                }
                used[i] = true;
                res.add(nums[i]);
                backtracking(nums, i + 1); //递归；
                res.remove(res.size() - 1);
                used[i] = false;

            }
        }

        public List<List<Integer>> subsetsWithDup(int[] nums) {
            used = new boolean[nums.length];
            Arrays.sort(nums);
            backtracking(nums,0);
            return resList;
        }
    }