day30 93.复原IP地址 78.子集 90.子集II

93.复原IP地址

切割问题就可以使用回溯搜索法把所有可能性搜出来，本题明确要求只会分成4段，所以不能用切割线切到最后作为终止条件，而是分割的段数作为终止条件。（三个切割点）

递归调用时，下一层递归的startIndex要从i+2开始（因为需要在字符串中加入了分隔符.），同时记录分割符的数量pointNum 要 +1。

判断子串是否合法

主要考虑到如下三点：

• 段位以0为开头的数字不合法（0 合法但是 01,001这种不合法）
• 段位里有非正整数字符不合法
• 段位如果大于255了不合法

class Solution {
		List<String> result = new ArrayList<>();
    public List<String> restoreIpAddresses(String s) {
        if(s.length() >12) return result;
		backtracking(s,0,0);
		return result;
    }

	public  void backtracking(String s , int index ,int pointnum){
		if(pointnum == 3){
			if(isValid(s,index,s.length()-1)){
				result.add(s);
			}
			return;
		}

		for (int i = index; i < s.length(); i++) {
			if(isValid(s,index,i)){
				s = s.substring(0,i+1) + "." + s.substring(i+1);
				pointnum++;
				backtracking(s,i+2,pointnum);
				pointnum--;
				s = s.substring(0,i+1) +  s.substring(i+2);
			}else{
				break;          //这种分割不规范后面的也都不规范
			}

		}

	}

	// 判断字符串s在左闭⼜闭区间[start, end]所组成的数字是否合法
	public Boolean isValid(String s, int start, int end) {
		if (start > end) {
			return false;
		}
	//这个条件的作用是排除类似 "01"、"001" 这样以 0 开头但不是单独的 0 的情况，因为在 IP 地址中不允许出现这样的形式。
		if (s.charAt(start) == '0' && start != end) { // 0开头的数字不合法  
			return false;
		}
		int num = 0;
		for (int i = start; i <= end; i++) {
			if (s.charAt(i) > '9' || s.charAt(i) < '0') { // 遇到⾮数字字符不合法
				return false;
			}
			num = num * 10 + (s.charAt(i) - '0');
			if (num > 255) { // 如果⼤于255了不合法
				return false;
			}
		}
		return true;
	}
}

78.子集

求取子集问题，不需要任何剪枝！因为子集就是要遍历整棵树。

组合问题和分割问题都是收集树的叶子节点，而子集问题是找树的所有节点！

其实子集也是一种组合问题，因为它的集合是无序的，子集{1,2} 和 子集{2,1}是一样的。

那么既然是无序，取过的元素不会重复取，写回溯算法的时候，for就要从startIndex开始，而不是从0开始！

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

	public void backtracking(int[] nums , int index){
		result.add(new ArrayList<>(path));
		if(index >= nums.length) return;   //在终止条件之前收集避免最后叶子节点无法收集到
		for (int i = index; i < nums.length; i++) {
			path.add(nums[i]);
			backtracking(nums,i+1);
			path.removeLast();
		}


	}
}

 

90.子集II

这道题目和78.子集 (opens new window)区别就是集合里有重复元素了，而且求取的子集要去重。

注意“树层去重”和“树枝去重”

从图中可以看出，同一树层上重复取2 就要过滤掉，同一树枝上就可以重复取2，因为同一树枝上元素的集合才是唯一子集！

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

	public void backtracking(int [] nums , int index){
		result.add(new ArrayList<>(path));
		if(index > nums.length) return;
		for (int i = index; i < nums.length; i++) {
			if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]){
				continue;
			}
			path.add(nums[i]);
			used[i] = true;
			backtracking(nums, i + 1);
			path.removeLast();
			used[i] = false;
		}
	}
}