代码随想录算法训练营第二十八天|回溯算法part 4

93. 复原IP地址

有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 '.' 分隔。

例如："0.1.2.201" 和 "192.168.1.1" 是 有效 IP 地址，但是 "0.011.255.245"、"192.168.1.312" 和 "192.168@1.1" 是 无效 IP 地址。
给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 '.' 来形成。你 不能 重新排序或删除 s 中的任何数字。你可以按 任何 顺序返回答案。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/restore-ip-addresses
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

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

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

	// number表示stringbuilder中ip段的数量
	public void restoreIpAddressesHandler(String s, int start, int number) {
		// 如果start等于s的长度并且ip段的数量是4，则加入结果集，并返回
		if (start == s.length() && number == 4) {
			result.add(stringBuilder.toString());
			return;
		}
		// 如果start等于s的长度但是ip段的数量不为4，或者ip段的数量为4但是start小于s的长度，则直接返回
		if (start == s.length() || number == 4) {
			return;
		}
		// 剪枝：ip段的长度最大是3，并且ip段处于[0,255]
		for (int i = start; i < s.length() && i - start < 3 && Integer.parseInt(s.substring(start, i + 1)) >= 0
				&& Integer.parseInt(s.substring(start, i + 1)) <= 255; i++) {
			// 如果ip段的长度大于1，并且第一位为0的话，continue
			if (i > start && s.charAt(start) - '0' == 0) {
				continue;
			}
			stringBuilder.append(s.substring(start, i + 1));
			// 当stringBuilder里的网段数量小于3时，才会加点；如果等于3，说明已经有3段了，最后一段不需要再加点
			if (number < 3) {
				stringBuilder.append(".");
			}
			number++;
			restoreIpAddressesHandler(s, i + 1, number);
			number--;
			// 删除当前stringBuilder最后一个网段，注意考虑点的数量的问题
            // 这个number表示当前下标前加的逗号的数量
            // 所以前后下标还需要后移
			stringBuilder.delete(start + number, i + number + 2);
		}
	}
}

 与分割回文字符串一样

78. 子集

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

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

class Solution {
    List<List<Integer>> res;
    LinkedList<Integer> temp;
    public List<List<Integer>> subsets(int[] nums) {
        res = new ArrayList<>();
        temp = new LinkedList<>();
        backtracking(nums,0);
        return res;
    }
    private void backtracking(int[] nums, int startIndex){
        res.add(new ArrayList<>(temp));
        if(startIndex>=nums.length){
            return;
        }
        for(int i= startIndex;i<nums.length;i++){
            temp.add(nums[i]);
            // 元素不重复取 所以从i+1开始
            backtracking(nums,i+1);
            temp.removeLast();
        }
    }
}

90. 子集||

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

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

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/subsets-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
    List<List<Integer>> res;
    LinkedList<Integer> temp;
    boolean[] used;
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        res = new ArrayList<>();
        temp = new LinkedList<>();
        used = new boolean[nums.length];
        Arrays.fill(used,false);
        Arrays.sort(nums);
        backtracking(nums,0);
        return res;
    }

    private void backtracking(int[] nums, int startIndex){
        res.add(new ArrayList<>(temp));
        if(startIndex>=nums.length){
            return;
        }
        for(int i=startIndex;i<nums.length;i++){
            // used[i-1]==false表明是本层的关系
            // 可以想象同一位数字
            if(i>0&&nums[i]==nums[i-1]&&used[i-1]==false){
                continue;
            }else{
                used[i] = true;
                temp.add(nums[i]);
                backtracking(nums,i+1);
                temp.removeLast();
                used[i] = false;
            }
        }
    }
}

本题为40 组合总和|| + 78 子集的思路