回溯相关题目-组合问题

77.组合

题目链接/文章讲解：https://programmercarl.com/0077.%E7%BB%84%E5%90%88.html

视频讲解：https://www.bilibili.com/video/BV1ti4y1L7cv

剪枝操作：https://www.bilibili.com/video/BV1wi4y157er

思路：首先就要把题目抽象的转换成树形结构，然后的思路就比较简单

1. 利用回溯纵向遍历出所有的路径（注：组合不是排列，[1,2]和[2,1]在组合中只算一个，在排列中算两个）
2. 利用path记录每条路径，只要path中的路径长度符合题目要求的k，我们就收集一次结果
   • 例如：k=2，那么从1开始遍历到2时，[1,2]就符合要求，收集结果
3. 收集一次结果后开始回溯，即退出2再返回到1，开始遍历[1,3]这条路径

for循环进行横向遍历，递归进行纵向（向下）遍历

public class Solution {
    List<List<Integer>> res = new ArrayList<>(); // 结果集
    List<Integer> path = new ArrayList<>(); // 记录路径
    public List<List<Integer>> combine(int n, int k) {
        if(n==0 || n<k) return res;
        backtracking(n,k,1);
        return res;
    }
	
    // startIndex：每次递归后的起始坐标
    public void backtracking(int n, int k, int startIndex) {
        // 当一维数组中的元素 == k时，就开始收集结果
        if(path.size() == k){
            res.add(new ArrayList<>(path));
            return ;
        }
		// 剪枝操作：i<=n可以替换成i<=n-(k-path.size())+1
        // 例如：k=2，那么以4开始的路径就没必要遍历，因为k最低都是2，而4这条路径只有一个值
        for(int i=startIndex; i<=n; i++){
            // 遍历的过程中同时收集路径，处理数据
            path.add(i);
            backtracking(n,k,i+1);
            // 回溯，每次收集完结果后，都撤销一次处理数据的操作
            // 即：[1,2]我要删除掉2，才能记录[1,3]
            path.remove(path.size()-1);
        }
    }
}

216.组合总和Ⅲ

题目链接/文章讲解：https://programmercarl.com/0216.%E7%BB%84%E5%90%88%E6%80%BB%E5%92%8CIII.html

视频讲解：https://www.bilibili.com/video/BV1wg411873x

本题思路与上题相同，只是多了一个条件

1. 利用回溯遍历所有路径
2. 再纵向遍历的过程中，记录数据并且进行求和
3. 判断遍历过程中累加的和是否等于目标值 且 路径长度是否相等
4. 最后回溯，去遍历记录下一条路径且继续求和

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

    // 参数：startIndex用来记录每次路径的起始位置
    // sum：判断Path中的路径和是否等于目标值
    public void backtracking(int n,int k,int startIndex,int sum){
        // 终止条件：如果sum==目标，且路径长度符合k，就收集结果
        if(sum==n && path.size()==k){
            res.add(new ArrayList<>(path));
            return ;
        }
		
        // 剪枝：如果计算的和大于目标值，那么就直接退出，后序的路径也不需要记录
        if(sum>n) return ;

        for(int i=startIndex; i<=9; i++){
            sum += i;
            path.add(i);
            
            backtracking(n,k,i+1,sum);
            // 回溯：要减去当前这条路径的值，用来计算下一条路径的和
            sum -= i;
            path.remove(path.size()-1);
        }
    }
}

17.电话号码的字母组合

​ 题目链接/文章讲解：https://programmercarl.com/0017.%E7%94%B5%E8%AF%9D%E5%8F%B7%E7%A0%81%E7%9A%84%E5%AD%97%E6
%AF%8D%E7%BB%84%E5%90%88.html

视频讲解：https://www.bilibili.com/video/BV1yV4y1V7Ug

思路：

1. 首先就要知道字母和数字如何映射
   • 利用Map集合将字母和数字一一进行映射
2. 如何开始组合？
   • 既然要组合，就得想到使用回溯
     • 返回值：因为使用全局变量来收集组合路径，所以返回值就可以设置成void
     • 参数：把字符串转换成整数数组传入，还有起始坐标和终止坐标
     • 终止条件：题目的要求是路径组合长度要等于字符串长度，所以只要相等就收集结果
   • 单层逻辑
     • 遍历整数数组，先取出数字，再在Map集合中根据数字取出对应字符串
     • 然后先横向循环遍历每个字符串中的字符，再纵向递归遍历开始收集路径

class Solution {
    // 可以创建全局变量，避免方法参数过长
    Map<Integer,String> map = new HashMap<>(); // 映射集合
    List<String> res = new ArrayList<>(); // 结果集
    StringBuilder path = new StringBuilder(); // 收集组合路径
    public List<String> letterCombinations(String digits) {
        if(digits == null) return null;
        // 数字和字符进行映射
        map.put(2,"abc");
        map.put(3,"def");
        map.put(4,"ghi");
        map.put(5,"jkl");
        map.put(6,"mno");
        map.put(7,"pqrs");
        map.put(8,"tuv");
        map.put(9,"wxyz");

        int[] arr = new int[digits.length()];
        // 将字符串转换成整数数组
        for(int i=0; i<digits.length(); i++){
            arr[i] = digits.charAt(i)-'0';
        }

        backtracking(arr,0,digits.length());
        return res;
    }

    public void backtracking(int[] arr,int start,int end){
        // 终止条件
        if(arr.length == 0) return ;
   
        if(path.length() == arr.length){
            // 满足条件，收集结果
            res.add(path.toString());
            return ;
        }

        for(int i=start; i<end; i++){
            // 根据数字取出字符串
            String str = map.get(arr[i]);
            // 字符串转换成char数组
            char[] c = str.toCharArray();
            // 横向遍历字符
            for(int j=0; j<c.length; j++){
                // 记录路径
                path.append(c[j]);
                // 纵向遍历路径
                backtracking(arr,i+1,end);
                // 回溯
                path.deleteCharAt(path.length()-1);
            }
        }
        
    }
}