Day26_Backtracking, Leetcode 39, 40, 131

Leetcode 39

-Leetcode

题目的第一想法:

这道题是一道比较典型的backtracking的问题。需要注意的是要如何trim，和index的传值问题。有一点比较有趣的点是，如果需要trim，需要现sort。而不trim的话就不需要。从时间来看好像并没有什么区别。更像是为了40题做铺垫的一道题。以下是解法

class Solution {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> rlist = new ArrayList<>();
        List<Integer> list = new ArrayList<>();
        helper(candidates, target, rlist, list, 0);
        return rlist;
    }

    void helper(int[] candidates, int target, List<List<Integer>> rlist, List<Integer> list, int index){
        if(target < 0){
            return;
        }else if(target == 0){
            rlist.add(new ArrayList<Integer>(list));
            return;
        }
        for(int i = index; i < candidates.length; i++){
            list.add(candidates[i]);
            target -= candidates[i];
            helper(candidates, target, rlist, list, index++);
            target += candidates[i];
            list.remove(list.size() - 1);
        }
    }
}

Leetcode 40

-Leetcode

题目的第一想法:

这道题比前一道题要困难一些。brute force的办法既通过每次加入一个新的组合就便利现在的list来查重是可以的，但是时间会很慢。这里我们引入了一个visited[]的概念。这个visited需要解决两个问题。在纵深上，我们希望接受重复的数字，而在同一层，我们希望跳过重复的数字。使用visited可以在每次使用数组中的数字时记录下使用过的数字，于是在同一纵深，我们可以知道哪些数字是用过的。而在使用完后，我们可以把visited改回原本的数字，从而不再使用重复的数字。

class Solution {
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        List<List<Integer>> rlist = new ArrayList<>();
        List<Integer> list = new ArrayList<>();
        int[] used = new int[candidates.length]; 
        Arrays.sort(candidates);
        helper(rlist, list, used, candidates, target, 0);
        return rlist;
    }

    void helper(List<List<Integer>> rlist, List<Integer> list, int[] used, int[] candidates, int target, int index){
        if(target < 0) return;
        else if(target == 0){
            rlist.add(new ArrayList<>(list));
            return;
        }
        for(int i = index; i < candidates.length && target - candidates[i] >= 0; i++){
            if(i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == 0) continue;
            used[i] = 1;
            target -= candidates[i];
            list.add(candidates[i]);
            helper(rlist, list, used, candidates, target, i + 1);
            used[i] = 0;
            target += candidates[i];
            list.remove(list.size() - 1);
        }
    }
}

看完代码随想录之后的想法：

这里visited的逻辑还是有些吊诡的。比如我们很容易想当然认为visited设定为1就代表是用过的，于是会觉得我们可以跳过所以为visited为1的数字，并不需要再把它改回来。但这个问题是我们无法判断纵深的不跳过和横向的跳过。

Leetcode 131

-Leetcode

题目的第一想法:

这道题我的第一想法是可以把它分为几个部分：判断回文和backtracking。但需要注意的是我们需要的是list中的list。就是说我们需要的是每次切割的集合，而不单纯是所有回文的组合。判断回文可以比较轻易的拿双指针指向头尾写出来。可能有些问题的是backtracking。rlist加入的条件是当当前的index大于数组的长度是，代表我们已经穷尽了这个切割方法的所有可能。而在for循环中，可以每次找到回文以后就recurrsion，不然就continue。

class Solution {
    public List<List<String>> partition(String s) {
        List<List<String>> rlist = new ArrayList<>();
        List<String> list = new ArrayList<>();
        StringBuilder sb = new StringBuilder(s);
        helper(rlist, list, sb, 0);
        return rlist;
    }

    void helper(List<List<String>> rlist, List<String> list, StringBuilder sb, int index){
        if(index >= sb.length()){
            rlist.add(new ArrayList<>(list));
            return;
        }
        for(int i = index; i <= sb.length(); i++){
            if(isPalindrome(sb.substring(index, i))) list.add(sb.substring(index, i));
            else continue;
            helper(rlist, list, sb, i);
            list.remove(list.size() - 1);
        }
    }

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

看完代码随想录之后的想法：

这里对于判断回文的办法可以使用动态规划的方法来使其更有效率。动态规划的逻辑的式子是dp[i][j] = (dp[i] == dp[j] && dp[i+1][j - 1])也就是说如果这个字符掐头去尾的中间是回文的同时且新加入的字符和结尾的字符一致，那么我们可以判断这个字符是一个回文。而路径是从右下角走一个三角形一及一级向上。于是可以先输出一个2d数组来做一个判断，然后再backtracking的过程中使用dp来判断当前substring是否为回文。

class Solution {
    public List<List<String>> partition(String s) {
        List<List<String>> rlist = new ArrayList<>();
        List<String> list = new ArrayList<>();
        StringBuilder sb = new StringBuilder(s);
        int[][] dp = new int[s.length()][s.length()];
        isPalindrome(dp, sb);
        helper(rlist, list, sb, 0, dp);
        return rlist;
    }

    void helper(List<List<String>> rlist, List<String> list, StringBuilder sb, int index, int[][] dp){
        if(index >= sb.length()){
            rlist.add(new ArrayList<>(list));
            return;
        }
        for(int i = index; i < sb.length(); i++){
            if(dp[index][i] == 1) list.add(sb.substring(index, i + 1));
            else continue;
            helper(rlist, list, sb, i + 1, dp);
            list.remove(list.size() - 1);
        }
    }

    void isPalindrome(int[][] dp, StringBuilder sb){
        for(int i = dp[0].length - 1; i >= 0; i--){
            for(int j = i; j < dp[0].length; j++){
                if(i == j) dp[i][j] = 1;
                else if(i == j - 1){
                    if(sb.charAt(i) == sb.charAt(j)) dp[i][j] = 1;
                }else{
                    if(sb.charAt(i) == sb.charAt(j) && dp[i + 1][j - 1] == 1) dp[i][j] = 1;
                }
            }
        }
    }
}