Sep 7, 2022 · Sep 4, 2022 · Sep 4, 2022 · Sep 4, 2022 · Sep 7, 2022 · Sep 7, 2022
diff --git a/problems/0040.组合总和II.md b/problems/0040.组合总和II.md
diff --git a/problems/0216.组合总和III.md b/problems/0216.组合总和III.md
Original file line number	Diff line number	Diff line change
Expand Up		@@ -258,40 +258,45 @@ public:
		使用标记数组
		```Java
		class Solution {
	List<List<Integer>> lists = new ArrayList<>();
	Deque<Integer> deque = new LinkedList<>();
	int sum = 0;

	public List<List<Integer>> combinationSum2(int[] candidates, int target) {
	//为了将重复的数字都放到一起,所以先进行排序
	Arrays.sort(candidates);
	//加标志数组,用来辅助判断同层节点是否已经遍历
	boolean[] flag = new boolean[candidates.length];
	backTracking(candidates, target, 0, flag);
	return lists;
	}
	LinkedList<Integer> path = new LinkedList<>();
	List<List<Integer>> ans = new ArrayList<>();
	boolean[] used;
	int sum = 0;

	public void backTracking(int[] arr, int target, int index, boolean[] flag) {
	if (sum == target) {
	lists.add(new ArrayList(deque));
	return;
	}
	for (int i = index; i < arr.length && arr[i] + sum <= target; i++) {
	//出现重复节点,同层的第一个节点已经被访问过,所以直接跳过
	if (i > 0 && arr[i] == arr[i - 1] && !flag[i - 1]) {
	continue;
	}
	flag[i] = true;
	sum += arr[i];
	deque.push(arr[i]);
	//每个节点仅能选择一次,所以从下一位开始
	backTracking(arr, target, i + 1, flag);
	int temp = deque.pop();
	flag[i] = false;
	sum -= temp;
	}
	public List<List<Integer>> combinationSum2(int[] candidates, int target) {
	used = new boolean[candidates.length];
	// 加标志数组,用来辅助判断同层节点是否已经遍历
	Arrays.fill(used, false);
	// 为了将重复的数字都放到一起,所以先进行排序
	Arrays.sort(candidates);
	backTracking(candidates, target, 0);
	return ans;
	}

	private void backTracking(int[] candidates, int target, int startIndex) {
	if (sum == target) {
	ans.add(new ArrayList(path));
	}
	for (int i = startIndex; i < candidates.length; i++) {
	if (sum + candidates[i] > target) {
	break;
	}
	// 出现重复节点,同层的第一个节点已经被访问过,所以直接跳过
	if (i > 0 && candidates[i] == candidates[i - 1] && !used[i - 1]) {
	continue;
	}
	used[i] = true;
	sum += candidates[i];
	path.add(candidates[i]);
	// 每个节点仅能选择一次,所以从下一位开始
	backTracking(candidates, target, i + 1);
	used[i] = false;
	sum -= candidates[i];
	path.removeLast();
		}
	}
		}

		```
		不使用标记数组
		```Java
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -260,6 +260,37 @@ class Solution {
		}
		}
		}

	// 上面剪枝 i <= 9 - (k - path.size()) + 1; 如果还是不清楚
	// 也可以改为 if (path.size() > k) return; 执行效率上是一样的
	class Solution {
	LinkedList<Integer> path = new LinkedList<>();
	List<List<Integer>> ans = new ArrayList<>();
	public List<List<Integer>> combinationSum3(int k, int n) {
	build(k, n, 1, 0);
	return ans;
	}

	private void build(int k, int n, int startIndex, int sum) {

	if (sum > n) return;

	if (path.size() > k) return;

	if (sum == n && path.size() == k) {
	ans.add(new ArrayList<>(path));
	return;
	}

	for(int i = startIndex; i <= 9; i++) {
	path.add(i);
	sum += i;
	build(k, n, i + 1, sum);
	sum -= i;
	path.removeLast();
	}
	}
	}
		```

		其他方法
Expand Down