代码随想录第27天: 回溯part03

力扣 39. 组合总和

class Solution {
    public List<List<Integer>> result = new LinkedList<>();
    public List<Integer> path = new ArrayList<>();

    public void backTracking(int[] candidates, int target, int sum, int startId) {
        if(sum == target) {
            result.add(new ArrayList<>(path));
            return;
        }
        else if(sum > target) {
            return;
        }

        for(int i = startId; i < candidates.length; i++) {
            path.add(candidates[i]);
            sum += candidates[i];
            backTracking(candidates, target, sum, i);
            path.removeLast();
            sum -= candidates[i];
        }
    }

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        backTracking(candidates, target, 0, 0);
        return result;
    }
}

力扣 40.组合总和II

class Solution {
    public List<List<Integer>> result = new LinkedList<>();
    public List<Integer> path = new ArrayList<>();
    public boolean[] used;
    public int sum;

    public void backTracking(int[] candidates, int target, int sum, int startId, boolean[] used) {
        if(sum == target) {
            result.add(new ArrayList<>(path));
            return;
        }
        else if(sum > target) {
            return;
        }

        for(int i = startId; i < candidates.length; i++) {
            if(i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) {
                continue;
            }
            path.add(candidates[i]);
            sum += candidates[i];
            used[i] = true;
            backTracking(candidates, target, sum, i + 1, used);
            path.removeLast();
            sum -= candidates[i];
            used[i] = false;
        }
    }

    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, 0, used);
        return result;
    }
}

力扣 131.分割回文串

class Solution {
    public List<List<String>> result = new LinkedList<>();
    public List<String> path = new ArrayList<>();

    public void backTracking(String s, int startId) {
        if(startId >= s.length()) {
            result.add(new ArrayList<>(path));
            return;
        }

        for(int i = startId; i < s.length(); i++) {
            String str = s.substring(startId, i + 1);
            if(isParlindrome(str)) {
                path.add(str);
            }
            else {
                continue;
            }
            backTracking(s, i + 1);
            path.removeLast();
        }
    }

    public boolean isParlindrome(String str) {
        int i = 0;
        int j = str.length() - 1;
        while(i < j) {
            if(str.charAt(i) != str.charAt(j)) {
                return false;
            }
            i++;
            j--;
        }
        return true;
    }

    public List<List<String>> partition(String s) {
        backTracking(s, 0);
        return result;
    }
}