LeetCode刷题——回溯算法1

回溯是递归的副产品，只要有递归就会有回溯。回溯的本质是穷举，穷举所有可能，然后选出我们想要的答案。回溯法并不高效，它解决的问题都可以抽象为树形结构。

题目1：组合总和lll

题目：

问题分析：这道题采用递归加回溯的方法来求解。同时加入剪枝的操作，path中的元素个数为path.size()，还需要找k-path.size()个元素，现在搜寻到第i个，可以搜9-i+1个，所以必须要满足9-i+1>=k-path.size()，即i<=9-(k-path.size())+1。

代码：

class Solution {
    List<List<Integer>> result=new ArrayList<>();
    LinkedList<Integer> path=new LinkedList<>();
    public List<List<Integer>> combinationSum3(int k, int n) {
        backTracking(k,n,1,0);
        return result;
    }
    private void backTracking(int k,int n,int startIndex,int sum){
        if(sum>n)return;//属于剪枝操作，当和已经大于给定目标和，就没有计算的必要了
        if(path.size()==k){
            if(sum==n){
                result.add(new ArrayList(path));
            }
            return;
        }
        for(int i=startIndex;i<=9-(k-path.size())+1;i++){
            path.add(i);
            sum+=i;
            backTracking(k,n,i+1,sum);
            path.removeLast();//回溯的操作
            sum-=i;
        }
    }
}

时间复杂度O(1).

题目2：组合总和ll

题目：

问题分析：这道题的难点在于candidates中的元素是有重复的，但是解集中的组合不能重复。一开始的做法中并没有考虑重复组合的问题，看了代码随想录的讲解才明白要对数组进行排序，対重复出现的数组元素进行去重。

代码

class Solution {
    List<List<Integer>> result=new ArrayList<>();
    List<Integer> path=new ArrayList<>();
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        if(candidates==null||candidates.length==0)return result;
        Arrays.sort(candidates);//对数组进行排序
        backTracking(candidates,target,0);
        return result;
    }
    int sum=0;
    private void backTracking(int[] candidates,int target,int startIndex){
        if(sum>target) return;
        if(sum==target){
            result.add(new ArrayList<>(path));
            return;
        }
        
        for(int i=startIndex;i<candidates.length;i++){
            if(i>startIndex&&candidates[i]==candidates[i-1])continue;
            path.add(candidates[i]);
            sum+=candidates[i];
            backTracking(candidates,target,i+1);
            path.removeLast();
            sum-=candidates[i];
        }
    }
}

时间复杂度O(2^N).

题目3：分割回文串

题目：

问题分析：这道题的难点在于分析回文子串分割的逻辑，然后再想着怎么分割。每次递归都重新定义了一个StringBuilder类的对象。

代码：

class Solution {
    List<List<String>> result=new ArrayList<>();
    List<String> cur=new ArrayList<>();
    public List<List<String>> partition(String s) {
        backTracking(s,0,new StringBuilder());
        return result;
    }
    private void backTracking(String s,int start,StringBuilder sb){
        if(start==s.length()){
            result.add(new ArrayList<>(cur));//因为cur是一个引用变量，不copy一份的话，cur的动态变化会影响到result的结果，造成污染
            return;
        }
        for(int i=start;i<s.length();i++){
            sb.append(s.charAt(i));
            if(check(sb)){//判断当前的sb是否是回文串
                cur.add(sb.toString());//[start,i]之间的字符串为回文串，接着判断后面的子串是否为回文串
                backTracking(s,i+1,new StringBuilder());
                cur.remove(cur.size()-1);
            }
        }
    }
    private boolean check(StringBuilder sb){
        for(int i=0,j=sb.length()-1;i<j;i++,j--){
            if(sb.charAt(i)!=sb.charAt(j))return false;
        }
        return true;
    }
}

时间复杂度O(2^N)