algorithm/leetcode-master
1
0
Fork 0
mirror of https://github.com/youngyangyang04/leetcode-master.git synced 2025-07-09 03:34:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

0040 组合总和II

Browse Source 
简化原来的代码逻辑, 提高可读性。
This commit is contained in:
AronJudge
2022-09-04 12:55:50 +08:00
parent e601c0c729
commit e1e22edf47
1 changed files with 35 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
problems/0040.组合总和II.md
View File

@ -258,40 +258,45 @@ public:
**使用标记数组** **使用标记数组**
```Java ```Java
class Solution { class Solution {
List<List<Integer>> lists = new ArrayList<>(); LinkedList<Integer> path = new LinkedList<>();
Deque<Integer> deque = new LinkedList<>(); List<List<Integer>> ans = new ArrayList<>();
int sum = 0; boolean[] used;
int sum = 0;
public List<List<Integer>> combinationSum2(int[] candidates, int target) { public List<List<Integer>> combinationSum2(int[] candidates, int target) {
//为了将重复的数字都放到一起，所以先进行排序 used = new boolean[candidates.length];
Arrays.sort(candidates); // 加标志数组，用来辅助判断同层节点是否已经遍历
//加标志数组，用来辅助判断同层节点是否已经遍历 Arrays.fill(used, false);
boolean[] flag = new boolean[candidates.length]; // 为了将重复的数字都放到一起，所以先进行排序
backTracking(candidates, target, 0, flag); Arrays.sort(candidates);
return lists; backTracking(candidates, target, 0);
} return ans;
}
public void backTracking(int[] arr, int target, int index, boolean[] flag) { private void backTracking(int[] candidates, int target, int startIndex) {
if (sum == target) { if (sum == target) {
lists.add(new ArrayList(deque)); ans.add(new ArrayList(path));
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;
}
} }
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 ```Java