day28 打卡93.复原IP地址 78.子集 90.子集II

day28 打卡93.复原IP地址 78.子集 90.子集II

93.复原IP地址

93题目链接

class Solution {
    List<String> result = new ArrayList<>();

    public List<String> restoreIpAddresses(String s) {
        backtracking(s, 0, 0);
        return result;
    }

    private void backtracking(String s, int startIndex, int pointSum) {
        if (pointSum == 3) {
            // 判断最后一个子串是否也符合要求
            if (isValid(s, startIndex, s.length()-1)) {
                result.add(s);
                return;
            }
        }

        for (int i = startIndex; i<s.length() ; i++) {
            if (!isValid(s, startIndex, i)) {
                break;
            }
            s = s.substring(0, i+1) + "." + s.substring(i+1, s.length());
            pointSum++;
            backtracking(s, i+2, pointSum);
            s = s.substring(0, i+1) + s.substring(i+2, s.length());
            pointSum--;
        }
    }

    // 左闭右闭
    private boolean isValid(String s, int start, int end) {
        if (start > end) return false;

        // 数字前面不能多个0，除了一个0
        if (s.charAt(start) == '0' && start != end) return false;

        for (int i = start; i<=end ; i++) {
            if (s.charAt(i) < '0' && s.charAt(i) > '9') {
                return false;
            }
        }
        Long num = Long.parseLong(s.substring(start, end+1));
        return num >= 0 && num <= 255;
    }
}

78.子集

78题目链接

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();

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

    private void backtracking(int[] nums, int startIndex) {
        result.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.removeLast();
        }
    }
}

90.子集II

90题目链接

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    boolean[] used;

    public List<List<Integer>> subsetsWithDup(int[] nums) {
        used = new boolean[nums.length];
        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>0 && nums[i] == nums[i-1] && !used[i-1]) {
                continue;
            }
            used[i] = true;
            path.add(nums[i]);
            backtracking(nums, i+1);
            used[i] = false;
            path.removeLast();
        }
    } 
}

参考资料

代码随想录