【代码随想录Day28回溯算法】93.复原IP地址、78.子集、90.子集Ⅱ

最新推荐文章于 2024-11-12 21:59:57 发布

joyboy0405

最新推荐文章于 2024-11-12 21:59:57 发布

阅读量26

点赞数

文章标签：算法 leetcode java

本文链接：https://blog.csdn.net/weixin_38550348/article/details/131242258

版权

文章介绍了使用回溯法解决两个编程问题：一是复原IP地址，通过检查字符串是否符合0-255的条件来构建所有可能的IP地址；二是子集问题，包括无重复元素的子集和有重复元素的子集，通过递归回溯遍历所有可能的组合。

摘要由CSDN通过智能技术生成

Day28

93.复原IP地址

class Solution {
    List<String> res = new ArrayList<>();
    List<String> path = new ArrayList<>();
    public List<String> restoreIpAddresses(String s) {
        backTracking(s, 0, 0);
        return res;
    }
    public void backTracking (String s, int startIndex, int turn) {
        int sum = 0;
        StringBuilder sb = new StringBuilder();
        for (String ss : path) {
            sum += ss.length();
            sb.append(ss);
            sb.append(".");
        }
        if (sb.length() > 1) {
            sb.deleteCharAt(sb.length() -1);
        }
        if (path.size() == 4 && sum == s.length() && turn == 4) {
            res.add(sb.toString());
            return;
        }
        for (int i = startIndex; i < s.length() && i < startIndex + 3; i++) {
            String tmp = s.substring(startIndex, i + 1);
            if (check(tmp)) {
                path.add(tmp);
                backTracking(s, i + 1, turn + 1);
                path.remove(path.size() - 1);
            }
        }
    }
    public boolean check (String s) {
        if (s.charAt(0) == '0' && s.length() > 1) return false;
        if (Integer.parseInt(s) > 255) return false;
        return true;
    }
}

78.子集

如果把子集问题、组合问题、分割问题都抽象为一棵树的话，那么组合问题和分割问题都是收集树的叶子节点，而子集问题是找树的所有节点。

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    public List<List<Integer>> subsets(int[] nums) {
        backTracking(nums, 0);
        return res;
    }

    public void backTracking(int[] nums, int startIndex) {
        res.add(new ArrayList<>(path));
        if (startIndex >= nums.length) return;
      
        for (int i = startIndex; i < nums.length; i++) {
            path.add(nums[i]);
            backTracking(nums, i + 1);
            path.remove(path.size() - 1);
        }
    }
}

90.子集Ⅱ

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        Arrays.sort(nums);
        backTracking(nums, 0);
        return res;
    }

    public void backTracking(int[] nums, int startIndex) {
        res.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;
            }
            path.add(nums[i]);
            backTracking(nums, i + 1);
            path.remove(path.size() - 1);
        }
    }
}