java数据结构与算法刷题-----LeetCode77. 组合

java数据结构与算法刷题目录（剑指Offer、LeetCode、ACM）-----主目录-----持续更新(进不去说明我没写完)：https://blog.youkuaiyun.com/grd_java/article/details/123063846

解题思路

1. 这种题只能暴力求解，枚举所有可能得组合
2. 例如要找2个数的组合，那么就两层for循环，3个数的就3层for循环，k层就k个for循环
3. 但是这样显然不现实，所以我们可以使用回溯的思路，利用递归，只写一层for循环，就可以实现普通方法下，k层for循环的效果。
4. 当然，效率是一样的。但是代码实现起来，嵌套for循环可没法实现，试想k = 50，就得写50层for循环。

1. 我们要进行k个数的组合，这些数字只能从1-n中去选。也就是从1-n中调出k个不同的数，组合起来。
2. 第一个位置，可以选择1-n，从1开始，每个数都需要作为第1个位置的数，进行枚举
3. 既然是穷举，如果第一个位置当前从3开始，那么第二个位置就从4开始枚举，因为前面的几个数组，一定已经在前几次第一个位置为1,2的时候就组合过了
4. 所以，每一个位置，都要尝试可选的每一种可能。

枝剪操作

1. 如果当前已经组合的数，和剩下可以参与组合的数，不够组合成一个长度为k的组合
2. 例如我们k = 4，目前组合出来的是[4,8],剩下可以组合就剩下一个9了，最多组合成一个[4,8,9],根本不够4个数
3. 遇到这种情况，就不需要继续枚举当前情况了。俗称枝剪操作。

1. 递归实现

代码：基本上是官方增加大量测试用例后，目前优化到的比较快的了。最前面4ms到9ms的，是远古时期提交的人，它们的代码，放到现在，只能跑到35ms，超越25%的人

1. 这个是比较难理解的版本，没有使用经典的回溯模版（递归套for，for套递归），但是这个做法的速度更快

class Solution {
    List<List<Integer>> result;//保存答案
    int k;//用几个数来组合
    int n;//可以参与组合的数是[1,n]
    public List<List<Integer>> combine(int n, int k) {
        this.n=n;
        this.k=k;
        result=new ArrayList<List<Integer>>();//初始化链表，保存答案
        Integer[] records = new Integer[k];//每个保存一种组合，保存当前正在处理的组合
        traversal(0,1,records);//
        
        return result;
    }
    //row表示当前是第几个数参与组合，最多k个，简单来说就是records数组的下标
    //column表示[1,n]的下标，也就是限定哪些数可以参与组合：[column,n]，简单来说是，当前用哪个数字参与组合
    //records 保存当前组合出来的数
    public void traversal(int row,int column,Integer[] records){
        if (column>n){//如果没有数可以参与组合，终止本次组合尝试
            return;
        }else if(records.length + (n-column+1)<k) {//剪枝操作，如果当前已经组合到的数，加上剩下还能参与组合的数，不够k个，说明无论如何都无法完成k个数的组合了。
            return;
        }else {//如果没啥问题，则当前数字column可以作为第row个数，参与当前的组合
            records[row]=column;//让column作为第row个数参与组合
            if (row==k-1){//如果当前组合完成后，正好k个值，说明得到一种满足条件的组合
                result.add(List.of(records));
            }else {//否则，进行下一个数字的枚举组合
                traversal(row+1,column+1, records);
            }
            //不可以排除后面其它数字，也可以作为第row个数字参与组合的情况。
            //也就是说，上面处理了用当前column作为第row个数的方案
            //这里处理，放弃column作为第row个数的方案，而试图继续向后找数字来作为第row个
            traversal(row, ++column, records);
        }

    }
}

2. 经典回溯模版
   

class Solution {
    public List<List<Integer>> combine(int n, int k) {
        List<List<Integer>> res = new ArrayList<>();
        if (k <= 0 || n < k) return res;//如果1-n根本不够k个就返回空[]
        ArrayList<Integer> path = new ArrayList<>();//用于保存当前组合路径
        dfs(n, k, 1, path, res);//从1开始组合
        return res;

    }

    void dfs(int n, int k, int begin, ArrayList<Integer> path, List<List<Integer>> res) {
        int size = path.size();
        if (size == k) {//如果当前path保存的正好是一个满足条件的组合
            res.add(new ArrayList<>(path));//将其放入结果中
            return;
        }
        //每一个位置，都要将能尝试的都尝试一遍
        for (int i = begin; i <= n - (k - size) + 1; i++) {
            path.add(i);//尝试当前位置放i
            dfs(n, k, i + 1, path, res);//下一个位置的数字选择，必须从i+1开始
            path.removeLast();//选择不尝试当前位置放i
            if(path.size()+(n-begin) < k) return;//剪枝操作，如果剩下的可选数字，不够组成k个，就终止这次组合
        }
    }
}