【刷题day28】回溯算法 | 93.复原IP地址、 78.子集 、90.子集II

93.复原IP地址

题目链接/文章讲解

class Solution {
	private List<String> ans = new ArrayList<String>();
	private Deque<String> path = new LinkedList<String>(); // 保存用 . 分开的四个有效整数
    public List<String> restoreIpAddresses(String s) {
    	if(s.length() > 12 || s.length() < 4) return ans; 
    	backTracking(s, 0);
    	return ans; 
    }
    private void backTracking(String s, int startIndex) {
    	if(path.size() == 3) { // 如果已经加了三个整数，最后一个数便只有字符串所有剩下元素所组成的数字，对其进行额外判断
    		if(!isValid(s, startIndex, s.length()-1)) return;
            path.addLast(s.substring(startIndex)); // 将最后的数字加入path
    		ans.add(String.join(".", path)); // 用 . 进行连接
            path.removeLast(); // ！！！ 注意此处要删除在该层递归中加入的元素，保证上一级递归函数回溯的准确
    	}
    	for(int i = startIndex; i < s.length(); i++) {
    		if(!isValid(s, startIndex, i)) return;
    		path.addLast(s.substring(startIndex, i + 1));
    		backTracking(s, i + 1);
    		path.removeLast();
    	}
    }
    private boolean isValid(String s, int begin, int end) {
    	if(begin > end) return false;
    	// 判断是否大于255
    	if(Integer.parseInt(s.substring(begin, end + 1)) > 255) return false;
    	// 判断是否以 0 开始
    	if(begin < end && s.charAt(begin) == '0') return false;
    	return true;
    }
}

78.子集

题目链接/文章讲解

class Solution {
	private List<List<Integer>> ans = new ArrayList<List<Integer>>();
	private Deque<Integer> path = new LinkedList<Integer>();
    public List<List<Integer>> subsets(int[] nums) {
    	backTracking(nums, 0);
    	return ans;
    }
    private void backTracking(int[] nums, int startIndex) {
        ans.add(new ArrayList<Integer>(path)); // 注意不可以与下一个语句互换，会遗漏解
    	if(startIndex >= nums.length) return;
    	for(int i = startIndex; i < nums.length; i++) {
    		path.addLast(nums[i]);
    		backTracking(nums, i + 1);
    		path.removeLast();
    	}
    }
}

90.子集II

题目链接/文章讲解

注意去重的三种方式：（前两种方式去重前一定记得先对集合进行排序）

1. used 标记数组（见类似题解：组合Ⅱ）
2. startIndex 索引
3. set 去重

注意： 前两种去重方式的前提是集合有序，故要先对集合排序。但是有的情况下，我们并不能对所给定的集合自行排序，前两种方法也就失效了，比如下一章的题目：491.递增子序列

但是需要注意，在使用set去重时，本题中同样需要排序。因为 [4,1,4] 和 [1,4,4] 虽然内容一样，但是二者存储到set候并不会被去重，除非重写 equals 和 hashcode() 方法。

class Solution { // 方式一： used 标记数组去重
class Solution {
 	private List<List<Integer>> ans = new ArrayList<>();
	private List<Integer> path = new ArrayList<>();
	private boolean[] used; //标记数组
    public List<List<Integer>> subsetsWithDup(int[] nums) {
    	used = new boolean[nums.length];
    	Arrays.fill(used, false); // 加标志数组，用来辅助判断同层节点是否已经遍历
    	Arrays.sort(nums);
    	backTracking(nums,0);
    	return ans;
    }
    private void backTracking(int[] nums, int startIndex) {
    	ans.add(new ArrayList(path));
    	if(startIndex >= nums.length) { return;}
    	
    	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);
    		path.remove(path.size()-1);
    		used[i] = false; // 注意回溯完的标记改变
    	}
    }
}
}

class Solution { // 方式二： startIndex 索引去重
 	private List<List<Integer>> ans = new ArrayList<>();
	private List<Integer> path = new ArrayList<>();
    public List<List<Integer>> subsetsWithDup(int[] nums) {
    	Arrays.sort(nums);
    	backTracking(nums,0);
    	return ans;
    }
    private void backTracking(int[] nums, int startIndex) {
    	ans.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);
    	}
    }
}

class Solution { // 方式三： set去重
 	private List<List<Integer>> ans = new ArrayList<>();
	private List<Integer> path = new ArrayList<>();
    public List<List<Integer>> subsetsWithDup(int[] nums) {
    	Arrays.sort(nums); // 若不排序依旧会出错
    	backTracking(nums,0);
        Set<List<Integer>> set = new HashSet<List<Integer>>();
        for(List<Integer> list: ans){
            set.add(list);
        }
    	return new ArrayList<List<Integer>>(set);
    }
    private void backTracking(int[] nums, int startIndex) {
    	ans.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);
    	}
    }
}