力扣40.组合总和 II——递归+回溯+剪枝

这道题和39.组合总和十分相像。只不过前者只允许使用每个数字在每个组合中的一次。意思就是数组里有多少这个元素，就能使用他几次。而后者数组中无重复元素，且可以使用同一元素无数次。下面先给出 39.组合总和 的题解。

class Solution {
	private List<Integer> is_array = new ArrayList<>();

	public List<List<Integer>> combinationSum(int[] candidates, int target) {
		List<List<Integer>> is_List = new ArrayList<>();

		int n = candidates.length;
		Arrays.sort(candidates);
		if(n==0) {
			return is_List;
		}
		dfs(candidates, target, is_List, is_array, 0);
		return is_List;

	}

	public void dfs(int[] candidates, int target, List<List<Integer>> is_list, List<Integer> is_array, int begin) {
		if (target < 0){
			return;
		}
		if(target==0) {
		if(is_list.contain(is_array){return;}
			is_list.add(new ArrayList<>(is_array));
			return;
		}
		for(int i=begin;i<candidates.length;i++) {
			if(target-candidates[i]<0) {
				break;
			}
			is_array.add(candidates[i]);
			dfs(candidates, target-candidates[i], is_list, is_array, i);
			is_array.remove(is_array.size()-1);
		}

	}
}

主要就是递归+回溯，还有一些剪枝的操作。这个是我看了题解才会的，所以直接看力扣题解就行。主要是第下一道题，给我的第一感觉和这个就差不多，所以我想在这个的基础之上来写。其实也简单，只要把这个语句改一下就行dfs(candidates, target-candidates[i+1], is_list, is_array, i);这就表示要从下一个元素递归，这样就不会使当前元素递归无数次了，但是可能会产生重复。比如[1,1,2,5],target=8这个列子，就会出现[1,2,5],[1,2,5]这种答案，因为1有两个，但要求答案中不能有重复的。其实这也好办。

if(target==0) {
		if(is_list.contain(is_array){return;}
			is_list.add(new ArrayList<>(is_array));
			return;
		}

把这句改一下，去个重就行了。但是，大无语事件发生了。它超时了…
我花了两个小时去给这个bug，你们可以看一下我的提交记录。

我本来想直接”面向用列编程“的，但想一想实在有些羞愧。于是又肝了一个小时，终于解出来了。

class Solution {

	public List<List<Integer>> combinationSum2(int[] candidates, int target) {
		List<Integer> list = new ArrayList<>();//用于数组去重
		List<List<Integer>> is_list = new ArrayList<>();//用于存储最终符合条件的所有List
		List<Integer> is_array = new ArrayList<>();//用于存储符合条件的List
		Map<Integer, Integer> repeat = new HashMap<>();//记录每个元素重复的次数
		Map<Integer, Integer> occurrences = new HashMap<>();//记录每个元素已经出现的次数
		int x = 0;
		Arrays.sort(candidates);
		for (int i = 0; i < candidates.length; i++) {
			occurrences.put(candidates[i], 1);
			if (!list.contains(candidates[i])) {
				list.add(candidates[i]);
			}
			if (repeat.containsKey(candidates[i])) {
				x = repeat.get(candidates[i]) + 1;
				repeat.replace(candidates[i], x);
			} else {
				repeat.put(candidates[i], 1);
			}
		}
		dfs(list, target, 0, is_list, is_array, occurrences, repeat);
		return is_list;

	}

	public void dfs(List<Integer> candidates, int target, int begin, List<List<Integer>> is_list,
			List<Integer> is_array, Map<Integer, Integer> occurrences, Map<Integer, Integer> repeat) {
		if (target < 0) {
			return;
		}
		if (target == 0) {
			is_list.add(new ArrayList<>(is_array));

			// occurrences.replace(candidates.get(i), 1);
			return;
		}
		for (int i = begin; i < candidates.size(); i++) {
			if (target - candidates.get(i) < 0) {
				break;
			}
			int ocur, a;
			//当已经出现的次数小于它原有的重复数时，可以看作是39.组合总和的算法，可以递归到当前元素。
			if (occurrences.get(candidates.get(i)) < repeat.get(candidates.get(i))) {
				ocur = occurrences.get(candidates.get(i)) + 1;
				occurrences.replace(candidates.get(i), ocur);
				is_array.add(candidates.get(i));
				dfs(candidates, target - candidates.get(i), i, is_list, is_array, occurrences, repeat);
				a = occurrences.get(candidates.get(i)) - 1;

				occurrences.replace(candidates.get(i), a);
				is_array.remove(is_array.size() - 1);
			} else {//当已经出现的次数等于它原有的重复数时，需要递归到下一个元素。
				is_array.add(candidates.get(i));
				dfs(candidates, target - candidates.get(i), i + 1, is_list, is_array, occurrences, repeat);

				is_array.remove(is_array.size() - 1);
			}

		}
	}
}

主要的思想就是记录每个元素的出现次数，当这个递归中用到这个数的次数小于它在原先数组中的数量时，可以继续递归这个元素。当这个递归中用到这个数的次数等于它在原先数组中的数量时，说明这个元素已经用完了，所以要递归下一个元素。注意，要提前给原先的数组去重。