题目描述
给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按 任何顺序 返回答案。

输入示例

n = 4, k = 2

输出示例

[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

解题思路
我们使用回溯、深度优先遍历的思想，我们使用一个栈 path 来记录走过的路径，使用 begin 来记录当前来到的数字位置。递归过程如下：

• 如果 path 的长度等于 k，表示已经组合成功
• 从 begin 开始遍历所有可能的搜索起点（不是从 1 开始，因为当前位置之前的数字已经走过），以下是遍历内操作：
• 向路径变量里添加一个数
• 下一轮搜索，设置起点要加 1，因为组合里不允许出现重复的元素
• 深度优先遍历有回头过程，递归之后进行逆操作
  

解题代码

class Solution {
    List<List<Integer>> ans = new ArrayList<>();
    Deque<Integer> path = new ArrayDeque<>();
    public List<List<Integer>> combine(int n, int k) {
        backtrack(n, 1, k);
        return ans;
    }

    public void backtrack(int n, int begin, int k) {
        // 终止条件
        if(path.size() == k) {
            // 收集结果
            ans.add(new ArrayList<Integer>(path));
            return;
        }
        // 尝试结果从 begin 到 n
        for(int i = begin; i<=n; i++) {
            path.addLast(i);
            backtrack(n, i+1, k);
            path.removeLast();
        }
    }
}

暴力解题思路：回溯
优化思路：剪枝，我们可以剪掉当前 i 值大于 n - (k - path.size()) + 1 的，想要得到结果必须 i 小于等于这个值。

class Solution {
    List<List<Integer>> ans = new ArrayList<>();
    Deque<Integer> path = new ArrayDeque<>();
    public List<List<Integer>> combine(int n, int k) {
        backtrack(n, 1, k);
        return ans;
    }

    public void backtrack(int n, int begin, int k) {
        // 终止条件
        if(path.size() == k) {
            // 收集结果
            ans.add(new ArrayList<Integer>(path));
            return;
        }
        // 尝试结果从 begin 到 n
        // 剪枝操作：n-(k-path.size())+1
        for(int i = begin; i <= n - (k - path.size()) + 1; i++) {
            path.addLast(i);
            backtrack(n, i+1, k);
            path.removeLast();
        }
    }
}