以组合问题理解回溯

组合问题是回溯最经典的一道题，我以这道题对回溯的一些条件进行了理解。
这里是在代码随想录的讲解上进一步地理解了下。
https://www.programmercarl.com/0077.%E7%BB%84%E5%90%88.html#%E5%9B%9E%E6%BA%AF%E6%B3%95%E4%B8%89%E9%83%A8%E6%9B%B2

题目：
给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。
你可以按 任何顺序 返回答案。
输入：n = 4, k = 2
输出： [ [2,4], [3,4], [2,3], [1,2], [1,3], [1,4], ]
为了更清楚回溯的具体执行流程，我更改了回溯里的for循环的条件和递归时是否要+1，并画出了详细的执行流程，这样可以更加清楚地理解for循环是横向遍历，递归是纵向遍历。
剪枝是减少了一些不必要的循环，这样可以加快回溯的执行速度。
回溯1和回溯4是正确的，回溯4进行了剪枝

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 * https://leetcode-cn.com/problems/combinations/
 */
public class Combinations {

    public static void main(String[] args) {
        int n = 4, k = 2;
        List<List<Integer>> result1 = new ArrayList<>();
        LinkedList<Integer> path1 = new LinkedList<>();
        backtrack1(n, k, 1, result1, path1);
        System.out.println("回溯1——for(startIndex, n]，backtrack(i + 1):");
        System.out.println(result1);
        List<List<Integer>> result2 = new ArrayList<>();
        LinkedList<Integer> path2 = new LinkedList<>();
        backtrack2(n, k, 1, result2, path2);
        System.out.println("回溯2——for(1, n]，backtrack(i + 1):");
        System.out.println(result2);
        List<List<Integer>> result3 = new ArrayList<>();
        LinkedList<Integer> path3 = new LinkedList<>();
        backtrack3(n, k, 1, result3, path3);
        System.out.println("回溯3——for(1, n]，backtrack(i):");
        System.out.println(result3);
        List<List<Integer>> result4 = new ArrayList<>();
        LinkedList<Integer> path4 = new LinkedList<>();
        backtrack3(n, k, 1, result4, path4);
        System.out.println("对回溯1的剪枝——for(1, n - (k - path.size()) + 1]，backtrack(i + 1):");
        System.out.println(result4);
    }
    
    // 未剪枝的正确答案
    private static void backtrack1(int n, int k, int startIndex, List<List<Integer>> result, LinkedList<Integer> path) {
        if (path.size() == k) {
            result.add(new ArrayList(path));
            return;
        }

        for (int i = startIndex; i <= n; ++i) {
            path.add(i);
            backtrack1(n, k, i + 1, result, path);
            path.removeLast();
        }
    }

    // 与回溯1的区别在于循环从1开始取
    private static void backtrack2(int n, int k, int startIndex, List<List<Integer>> result, LinkedList<Integer> path) {
        if (path.size() == k) {
            result.add(new ArrayList(path));
            return;
        }

        for (int i = 1; i <= n; ++i) {
            path.add(i);
            backtrack2(n, k, i + 1, result, path);
            path.removeLast();
        }
    }
    
    // 与回溯1的区别在于下层递归不加一
    private static void backtrack3(int n, int k, int startIndex, List<List<Integer>> result, LinkedList<Integer> path) {
        if (path.size() == k) {
            result.add(new ArrayList(path));
            return;
        }

        for (int i = startIndex; i <= n; ++i) {
            path.add(i);
            backtrack3(n, k, i, result, path);
            path.removeLast();
        }
    }
    
    // 剪枝的正确答案
    private static void backtrack4(int n, int k, int startIndex, List<List<Integer>> result, LinkedList<Integer> path) {
        if (path.size() == k) {
            result.add(new ArrayList(path));
            return;
        }

        for (int i = startIndex; i <= n - (k - path.size()) + 1; ++i) {
            path.add(i);
            backtrack4(n, k, i + 1, result, path);
            path.removeLast();
        }
    }
}

结果：

上面四个方法的过程理解

for循环决定了每层选择的子集，backtrack(i + 1)决定了往下继续递归。
对于组合问题，如果是一个集合来求组合的话，就需要startIndex；如果是多个集合取组合，各个集合之间相互不影响，那么就不用startIndex。
剪枝是对于一些无效遍历，起始位置的之后的元素个数已经不足所需要的元素个数了，就没有必要继续搜索。建议自己画一下图。
1、已经选择的元素个数:path.size();
2、还需要的元素个数：k - path.size();
3、在集合n中至多要从该起始位置：n-(k-path.size()) + 1，开始遍历