39. 组合总和
List<List<Integer>> result = new ArrayList<List<Integer>>();
LinkedList<Integer> path = new LinkedList<Integer>();
public List<List<Integer>> combinationSum(int[] candidates, int target) {
backTracking(candidates, target, 0, 0);
return result;
}
void backTracking(int[] candidates, int target, int sum, int startIndex){
if(sum > target){
return;
}else if(sum == target){
result.add(new ArrayList<Integer>(path));
return;
}
for(int i = startIndex; i < candidates.length; i++){
path.add(candidates[i]);
sum += candidates[i];
backTracking(candidates, target, sum, i);
sum -= candidates[i];
path.pollLast();
}
return;
}
40. 组合总和 II
40. 组合总和 II
LinkedList<Integer> path = new LinkedList<>();
List<List<Integer>> result = new ArrayList<List<Integer>>();
public List<List<Integer>> combinationSum2(int[] candidates, int target) {
Arrays.sort(candidates);
int[] used = new int[candidates.length];
backTracking(candidates, target, 0, 0, used);
return result;
}
void backTracking(int[] nums, int target, int sum, int startIndex, int[] used){
if(sum > target){
return;
}
if(sum == target){
result.add(new ArrayList<Integer>(path));
return;
}
for(int i = startIndex; i < nums.length; i++){
if(i > 0 && nums[i] == nums[i - 1] && used[i - 1] == 0){
continue;
}
path.add(nums[i]);
sum += nums[i];
used[i] = 1;
backTracking(nums, target, sum, i + 1, used);
path.pollLast();
sum -= nums[i];
used[i] = 0;
}
return;
}
131. 分割回文串
private final List<List<String>> ans = new ArrayList<>();
private final List<String> path = new ArrayList<>();
private String s;
public List<List<String>> partition(String s) {
this.s = s;
dfs(0);
return ans;
}
private boolean isValid(int left, int right){
while(left < right){
if(s.charAt(left++) != s.charAt(right--))
return false;
}
return true;
}
private void dfs(int i){
if(i == s.length()){
ans.add(new ArrayList<>(path));
return;
}
for(int j = i; j < s.length(); j++){
if(isValid(i, j)){
path.add(s.substring(i, j + 1));
dfs(j + 1);
path.remove(path.size() - 1);
}
}
}