LeetCode刷题笔记-77

LeetCode-77. 组合（中等）：

给定两个整数 n 和 k，返回 1 ... n 中所有可能的 k 个数的组合。

示例:

输入: n = 4, k = 2
输出:
[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

我的解法：

这道题很自然想到了递归，就像46题中的方法，只不过不能出现重复的元素，想到用集合做（这里提一下：本来觉得应该按照顺序排列就想到用TreeSet，结果发现TreeSet无法排列集合项，但用的是Set<Set>类型，于是还是用HashSet了）。

结果发现常规做法存在很大饿循环冗余，导致n比较大的时候（比如13）程序运行超时，所以果断找了网上的解析学习一下。

下面展示的是我的垃圾方法（供大家吐槽。。。）。

public List<List<Integer>> combine(int n, int k) {
        int[] flag = new int[n];
        Arrays.fill(flag, 0);
        Set<Set<Integer>> ans = com(n, k, flag);
        List<Set<Integer>> ans1 = new ArrayList<Set<Integer>>(ans);
        List<List<Integer>> ans2 = new ArrayList<List<Integer>>();
        for (int i = 0; i < ans1.size(); i++) {
			List<Integer> tmp = new ArrayList<Integer>(ans1.get(i));
			ans2.add(tmp);
		}
        return ans2;
    }
    
    public Set<Set<Integer>> com(int n, int k, int[] flag) {
    	Set<Set<Integer>> tmp = new HashSet<Set<Integer>>();
    	Set<Set<Integer>> ans = new HashSet<Set<Integer>>();
    	if(k==1 || n==k) {
    		for (int i = 0; i < flag.length; i++) {
				if(flag[i]==0) {
					Set<Integer> t = new HashSet<Integer>();
					t.add(i+1);
					ans.add(t);
				}
			}
    		return ans;
    	}
		for (int i = 0; i < flag.length; i++) {
			if(flag[i]==1) continue;
			flag[i] = 1;
			tmp = com(n-1, k-1, flag);
			List<Set<Integer>> tmp1 = new ArrayList<Set<Integer>>(tmp);
			for (int j = 0; j < tmp1.size(); j++) {
				tmp1.get(j).add(i+1);
			}
			tmp = new HashSet<Set<Integer>>(tmp1);
			ans.addAll(tmp);
			flag[i] = 0;
		}
		return ans;
	}

 大神解法：

这个题关键在于结果中不分元素顺序，也就是说1,2和2,1是一样的，如果用集合，就要遍历所有排列的可能结果，然后让集合判断是否重复。那么我的方法为什么超时呢？1.遍历所有排列费时。2.集合判断费时。3.由于题目只给出n，要求你自己标记出1~n中哪个数字还没有遍历，这就增加了很多循环（这一点是主要原因）。

所以，下面的解法（虽然LeetCode显示这个方法并不是最优解）是我比较认同的这道题的常规解法。大体思路是：标记当前遍历的位置，找出使用当前位置元素的所有排列，然后移动到下一个位置，则之前这个元素不会再遍历了。也就是说，每次移动都缩短遍历的长度，这就直接避免了我的方法中需要标记哪个元素没有使用的情况，避免遍历标记。

其他的和我的思路基本一致，就是递归。

public class Solution {
    public List<List<Integer>> combine(int n, int k) {
        List<List<Integer>> resList=new ArrayList<>();
        List<Integer> list=new ArrayList<>();
         
        backtracking(resList, list, 1, 1,n, k);
        return resList;
    }
     
    public void backtracking(List<List<Integer>> resList,List<Integer> list,int t,int start,int n, int k) {
        if(t>k){
            resList.add(new ArrayList<>(list));
        }else{
            for(int i=start;i<=n;i++){
                list.add(i);
                backtracking(resList, list, t+1,i+1, n, k);
                list.remove(list.size()-1);
            }
        }
    }
}