2021-12-25 216. 组合总和 III 17. 电话号码的字母组合 39. 组合总和

最新推荐文章于 2025-12-06 07:43:37 发布

原创最新推荐文章于 2025-12-06 07:43:37 发布 · 444 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #深度优先 #算法

力扣专栏收录该内容

64 篇文章

订阅专栏

本文介绍了三种编程问题的解决方案：组合总和III中使用回溯法处理组合问题，电话号码字母组合通过StringBuilder优化递归，而组合总和II则涉及数组排序与深度优先搜索。这些算法展示了在不同场景下处理组合和递归问题的技巧。

216. 组合总和 III

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

    public void backtracking(int n,int k,int start){
        if(path.size()==k){
            int sum=0;
            for(int i=0;i<k;i++){
                sum+=path.get(i);
            }
            if(sum==n) list.add(new ArrayList<>(path));
            return;
        }
        //因为题目要求是组合类，所以利用strat确保选取时不会有重复的情况
        for(int i=start;i<=9;i++){
            path.add(i);
            backtracking(n,k,i+1);
            path.remove(path.size()-1);
        }
    }
}

17. 电话号码的字母组合

class Solution {
    List<String> res=new ArrayList<>();
    public List<String> letterCombinations(String digits) {
        //错因：对字符串的拼接没有想到用StringBuilder
        //并且对StringBuilder对字符操作的方法不熟，导致未想到回溯怎么处理

        //注意这里判断字符串为空和判断字符串长度为0是分开的操作
        if(digits == null || digits.length()==0) return res;
    String[] n_str={"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
     backtracking(digits,0,n_str);
     return res;

    }

    StringBuilder temp=new StringBuilder();
    public void backtracking(String digits,int index,String[] n_str ){
        if(index==digits.length()){
            res.add(temp.toString());
            return;
        }
        String s2=n_str[digits.charAt(index)-'0'];
        int n=s2.length();
        for(int i=0;i<n;i++){
          
            temp.append(s2.charAt(i));
            backtracking(digits,index+1,n_str);
            //删除StringBuilder的最后一个字符的方法
            temp.deleteCharAt(temp.length()-1);
        }
       
    }
}

39. 组合总和

class Solution {
    List<List<Integer>> list = new ArrayList<>();
    List<Integer> path=new ArrayList<>();
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        Arrays.sort(candidates);
         backtracking(candidates,target,0);
         return list;
    }

    public void backtracking(int[] candidates,int target,int index){
        if(target==0){
            list.add(new ArrayList<>(path));
            return;
        }
        //已经小于0了，一定不会出现符合条件的值了，
        if(target < 0){
            return;
        }
        
        for(int i=index;i<candidates.length;i++){
            path.add(candidates[i]);
            target-=candidates[i];

            //非常关键的一点，元素可以重复使用，所以下次搜索不是i+1还是i
            backtracking(candidates,target,i);
            path.remove(path.size()-1);
            target+=candidates[i];
        }

    }
}