代码随想录算法训练营第二十七天| 39. 组合总和 ，40.组合总和II ，131.分割回文串

代码随想录算法训练营

今日任务
39. 组合总和 ，40.组合总和II ，131.分割回文串

---

---

39. 组合总和

class Solution {
    List<List<Integer>> result=new ArrayList<>();
    List<Integer> list=new ArrayList<>();
    int sum=0;
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        int startIndex=0;
        backtracking(candidates,target,startIndex);
        return result;
    }
    public void backtracking(int[] candidates,int target,int startIndex){
        if(sum==target){
            List<Integer> res=new ArrayList<>();
            res.addAll(list);
            result.add(res);
            startIndex++;
            System.out.println(list);
            return;
        }
        if(sum>target){
            return;
        }
        for (int i = startIndex; i < candidates.length; i++) {
            list.add(candidates[i]);
            sum=sum+candidates[i];
            backtracking(candidates,target,i);
            int size = list.size();
            sum=sum-list.get(size-1);
            list.remove(size-1);
            if(list.size()==0){
                startIndex++;
            }
        }
    }
}

---

40.组合总和II

class Solution {
    List<List<Integer>> result=new ArrayList<>();
    List<Integer> list=new ArrayList<>();
    int sum=0;
    Map<Integer,Integer> map=new HashMap<>();
    Set<List<Integer>> hashSet = new HashSet<>();
    int num=0;
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        backtracking(candidates,target,0);
        return result;
    }
    public void backtracking(int[] candidates,int target,int startIndex){
        if (sum == target) {
            List<Integer> res=new ArrayList<>();
            res.addAll(list);
            Collections.sort(res);
            if(!hashSet.contains(res)){
                hashSet.add(res);
                result.add(res);
                //map.put(list.get(0),1);
            }
            return;
        }
        if(sum>target){
            return;
        }
        for (int i = startIndex; i < candidates.length; i++) {
            if(!map.containsKey(candidates[i])){
                if(candidates[i]==num){
                    //num是上一次删掉的数
                    continue;
                }
                sum=sum+candidates[i];
                list.add(candidates[i]);

                if(sum!=target){
                    backtracking(candidates,target,i+1);
                    int size=list.size();
                    num=list.get(size-1);
                    sum=sum-num;
                    list.remove(size-1);
                }else{
                    List<Integer> res=new ArrayList<>();
                    res.addAll(list);
                    Collections.sort(res);
                    if(!hashSet.contains(res)){
                        backtracking(candidates,target,i+1);
                        int size=list.size();
                        num=list.get(size-1);
                        sum=sum-num;
                        list.remove(size-1);
                        if(list.size()==0){
                            map.put(num,1);
                        }
                    }else{
                        sum=sum-candidates[i];
                        list.remove(list.size()-1);
                    }
                }

            }
        }
    }
}
class Solution {
    List<List<Integer>> result=new ArrayList<>();
    List<Integer> list=new ArrayList<>();
    int sum=0;
    Map<Integer,Integer> map=new HashMap<>();
    Set<List<Integer>> hashSet = new HashSet<>();
    int num=0;
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        backtracking(candidates,target,0);
        return result;
    }
    public void backtracking(int[] candidates,int target,int startIndex){
        if (sum == target) {
            List<Integer> res=new ArrayList<>();
            res.addAll(list);
            Collections.sort(res);
            if(!hashSet.contains(res)){
                hashSet.add(res);
                result.add(res);
                //map.put(list.get(0),1);
            }
            return;
        }
        if(sum>target){
            return;
        }
        for (int i = startIndex; i < candidates.length; i++) {
            if(!map.containsKey(candidates[i])){
                if(candidates[i]==num){
                    //num是上一次删掉的数
                    continue;
                }
                sum=sum+candidates[i];
                list.add(candidates[i]);

                backtracking(candidates,target,i+1);
                int size=list.size();
                num=list.get(size-1);
                sum=sum-num;
                list.remove(size-1);

            }
        }
    }
}

---

131.分割回文串

class Solution {
    List<List<String>> result=new ArrayList<>();
    Deque<String> deque = new LinkedList<>();
    public List<List<String>> partition(String s) {
        backtracking(s,0);
        return result;
    }
    public void backtracking(String s,int startIndex){
        if(startIndex>=s.length()){
            result.add(new ArrayList(deque));
            return;
        }
        //利用队列，整体判断思路如下，针对aab
        //1. a进队，a进队，b进队=》a a b
        //2. b出队，a出队，ab判断false，不能进队，跳出，a出队
        //3. aa进队，b进队，=》aa b
        //4. aab判断false，不能进队，结束
        for(int i=startIndex;i<s.length();i++){
            if (isPalindrome(s, startIndex, i)) {
                String str = s.substring(startIndex, i + 1);
                deque.addLast(str);
            } else {
                continue;
            }
            //起始位置后移，保证不重复
            backtracking(s, i + 1);
            deque.removeLast();
        }
    }
    public boolean isPalindrome(String str,int startIndex,int end){
        for(int i=startIndex, j=end;i<j;i++,j--){
            if(str.charAt(i)!=str.charAt(j)){
                return false;
            }
        }
        return true;
    }
}

---