[力扣]回溯1—基础+组合

最新推荐文章于 2024-07-19 19:25:43 发布

ChenJieYaYa

最新推荐文章于 2024-07-19 19:25:43 发布

阅读量74

点赞数

分类专栏：力扣刷题文章标签： leetcode 算法 c++

本文链接：https://blog.csdn.net/weixin_51699336/article/details/124744501

版权

力扣刷题专栏收录该内容

14 篇文章 0 订阅

订阅专栏

回溯法解决组合问题

代码随想录[原文指路]

概述

回溯函数也是递归函数

1.回溯算法效率

回溯法不是高效算法
本质是穷举所有可能性

2.回溯解决的问题

组合问题：N个数里面按某规则找出k个数的集合
切割问题：字符串按某规则有几种切割方式
子集问题：N个数的集合里有多少符合条件的子集
排列问题：N个数按某规则全排列，有几种排列方式
棋盘问题：N皇后，解数独等等

3.回溯模板

所有回溯问题可抽象成树
回溯法一般是在集合中递归搜索
集合大小构成树宽度，递归深度构成树深度
模板

public void backtracking(参数){
    if(终止条件){
        存放结果;
        return;
    }

    for(本层集合中元素(树中孩子节点数量是集合大小)){
        处理节点;
        backtracking(路径,选择列表);//递归
        回溯，撤销处理结果
    }
}

1.组合[77]

回溯所有情况

class Solution {
    List<List<Integer>> ress = new ArrayList<List<Integer>>();
    LinkedList<Integer> res = new LinkedList<Integer>();
    public List<List<Integer>> combine(int n, int k) {
        backtracking(n,k,1);
        return ress;
    }

    public void backtracking(int n,int k,int startIndex){//startIndex:递归中for循环的开始位置
        if(res.size()==k){
            ress.add(new ArrayList(res));
            return ;
        }

        for(int i=startIndex;i<=n;i++){
            res.add(i);
            backtracking(n,k,i+1);//递归
            res.removeLast();//回溯
        }
    }
}

回溯修剪分枝

class Solution {
    List<List<Integer>> ress = new ArrayList<List<Integer>>();
    LinkedList<Integer> res = new LinkedList<Integer>();
    public List<List<Integer>> combine(int n, int k) {
        backtracking(n,k,1);
        return ress;
    }

    public void backtracking(int n,int k,int startIndex){//startIndex:递归中for循环的开始位置
        if(res.size()==k){
            ress.add(new ArrayList(res));
            return ;
        }

        for(int i=startIndex;i<=n-(k-res.size())+1;i++){//优化：for循环选择的起始位置之后的元素个数不足需要的元素个数，那么就没必要搜索
            res.add(i);
            backtracking(n,k,i+1);//递归
            res.removeLast();//回溯
        }
    }
}

2.组合总和 III[216]

回溯所有情况

class Solution {
    List<List<Integer>> ress = new ArrayList<List<Integer>>();
    LinkedList<Integer> res = new LinkedList<Integer>();
    public List<List<Integer>> combinationSum3(int k, int n) {
        backtracking(k,n,1);
        return ress;
    }

    public void backtracking(int k,int n,int startIndex){//startIndex:递归中for循环的开始位置
        if(res.size()==k && n==0){
            ress.add(new ArrayList(res));
            return ;
        }

        for(int i=startIndex;i<=9;i++){
            res.add(i);
            backtracking(k,n-i,i+1);//递归
            res.removeLast();//回溯
        }
    }
}

回溯修剪分枝

class Solution {
    List<List<Integer>> ress = new ArrayList<List<Integer>>();
    LinkedList<Integer> res = new LinkedList<Integer>();
    public List<List<Integer>> combinationSum3(int k, int n) {
        backtracking(k,n,1);
        return ress;
    }

    public void backtracking(int k,int n,int startIndex){//startIndex:递归中for循环的开始位置
        if(res.size()==k && n==0){
            ress.add(new ArrayList(res));
            return ;
        }

        if(res.size()>k || n<0) return;//优化：长度大于需要长度 || 和<0

        for(int i=startIndex;i<=9-(k-res.size())+1;i++){//优化：开始位置后的长度不足k && 
            res.add(i);
            backtracking(k,n-i,i+1);//递归
            res.removeLast();//回溯
        }
    }
}

3.电话号码的字母组合[17]

class Solution {
    List<String> res = new ArrayList<String>();
    StringBuilder temp = new StringBuilder();//迭代每一个字符串
    public List<String> letterCombinations(String digits) {
        if(digits==null||digits.length()==0) return res;
        String[] nums={"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
        //迭代处理
        backtracking(digits,nums,0);
        return res;
    }

    public void backtracking(String digits,String[] nums,int num){//num:记录digits遍历到哪个字符
        if(num==digits.length()){
            res.add(temp.toString());
            return ;
        }

        String str = nums[digits.charAt(num)-'0'];//号码对应的字符串

        for(int i=0;i<str.length();i++){
            temp.append(str.charAt(i));
            backtracking(digits,nums,num+1);//递归
            temp.deleteCharAt(temp.length()-1);//回溯
        }
    }
}

4.组合总和[39]

回溯所有情况

class Solution {
    List<List<Integer>> ress = new ArrayList<List<Integer>>();
    LinkedList<Integer> res = new LinkedList<Integer>();
    int sum = 0;
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        backtracking(candidates,target,0);
        return ress;
    }

    public void backtracking(int[] candidates,int target,int startIndex){
        if(sum >= target){
            if(sum == target){
                ress.add(new ArrayList(res));
            }
            return;
        }

        for(int i=startIndex;i<candidates.length;i++){
            sum += candidates[i];
            res.add(candidates[i]);
            backtracking(candidates,target,i);//递归,startIndex不要+1，表示可重复当前数字
            res.removeLast();//回溯
            sum -= candidates[i];
        }
    }
}

回溯修剪分枝

class Solution {
    List<List<Integer>> ress = new ArrayList<List<Integer>>();
    LinkedList<Integer> res = new LinkedList<Integer>();
    int sum = 0;
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        //优化
        Arrays.sort(candidates);//先排序
        backtracking(candidates,target,0);
        return ress;
    }

    //注意从数组内第二个数开始第一个数就不需要算进来了
    public void backtracking(int[] candidates,int target,int startIndex){
        if(sum == target){
            ress.add(new ArrayList(res));
            return;
        }

        //优化：如果sum>target就直接不要进入下一次递归了
        for(int i=startIndex;i<candidates.length;i++){
            //剪枝
            if(sum+candidates[i]>target) break;

            sum += candidates[i];
            res.add(candidates[i]);
            backtracking(candidates,target,i);//递归,startIndex不要+1，表示可重复当前数字
            res.removeLast();//回溯
            sum -= candidates[i];
        }
    }
}

5.组合总和 II[40]

回溯所有情况

class Solution {
    List<List<Integer>> ress = new ArrayList<List<Integer>>();
    LinkedList<Integer> res = new LinkedList<Integer>();
    int sum = 0;
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        //对数组排序
        Arrays.sort(candidates);
        backtracking(candidates,target,0);
        return ress;
    }

    public void backtracking(int[] candidates,int target,int startIndex){
        if(sum >= target){
            if(sum == target){
                ress.add(new ArrayList(res));
            }
            return;
        }

        for(int i=startIndex;i<candidates.length;i++){
            if(i>startIndex && candidates[i]==candidates[i-1]) continue;//去重
            
            sum += candidates[i];
            res.add(candidates[i]);
            backtracking(candidates,target,i+1);//startIndex要+1，表示不可重复当前数字
            res.removeLast();//回溯
            sum -= candidates[i];
        }
    }
}

回溯修剪分枝

class Solution {
    List<List<Integer>> ress = new ArrayList<List<Integer>>();
    LinkedList<Integer> res = new LinkedList<Integer>();
    int sum = 0;
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        //对数组排序
        Arrays.sort(candidates);
        backtracking(candidates,target,0);
        return ress;
    }

    public void backtracking(int[] candidates,int target,int startIndex){
        if(sum == target){
            ress.add(new ArrayList(res));
            return;
        }

        for(int i=startIndex;i<candidates.length;i++){
            if(sum+candidates[i]>target) break;//剪枝
            if(i>startIndex && candidates[i]==candidates[i-1]) continue;//去重
            
            sum += candidates[i];
            res.add(candidates[i]);
            backtracking(candidates,target,i+1);//startIndex要+1，表示不可重复当前数字
            res.removeLast();//回溯
            sum -= candidates[i];
        }
    }
}

ChenJieYaYa

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
[力扣]回溯1—基础+组合

回溯法解决组合问题代码随想录[原文指路]概述回溯函数也是递归函数1.回溯算法效率回溯法不是高效算法本质是穷举所有可能性2.回溯解决的问题组合问题：N个数里面按某规则找出k个数的集合切割问题：字符串按某规则有几种切割方式子集问题：N个数的集合里有多少符合条件的子集排列问题：N个数按某规则全排列，有几种排列方式棋盘问题：N皇后，解数独等等3.回溯模板所有回溯问题可抽象成树回溯法一般是在集合中递归搜索集合大小构成树宽度，递归深度构成树深度模板public..
复制链接

扫一扫