LeetCode（77）：組合 Combinations（Java）

2019.12.1 LeetCode 從零單刷個人筆記整理（持續更新）

github：https://github.com/ChopinXBP/LeetCode-Babel

這題可以很容易想到用剪枝回溯法求解，不過還有一種字典序的思路：

1.將數字序列nums初始化爲[1…k, n+1]，一共k+1個元素，最後一位n+1用於作爲哨兵。

2.循環將nums從最小排列[1…k, n+1]更新至最大排列[n-k…n-1, n+1]。每次添加前k個元素至結果數組（除去末尾哨兵元素）。

3.更新nums：遍歷nums找出第一個與下一個數不連續的數字下標idx，將其數字加1（nums[idx]++）；idx之前的元素與其下標i一致（nums[i]=i+1）。

4.當num更新至最大排列[n-k…n-1, n+1]時，數組連續，idx=k跳出循環。

---

傳送門：組合

Given two integers n and k, return all possible combinations of k numbers out of 1 … n.

給定兩個整數 n 和 k，返回 1 … n 中所有可能的 k 個數的組合。

示例:
輸入: n = 4, k = 2
輸出:
[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

---

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

/**
 *
 * Given two integers n and k, return all possible combinations of k numbers out of 1 ... n.
 * 給定兩個整數 n 和 k，返回 1 ... n 中所有可能的 k 個數的組合。
 *
 */

public class Combinations {

    //回溯法
    public List<List<Integer>> combine(int n, int k) {
        List<List<Integer>> result = new ArrayList<>();
        if(k > n){
            return result;
        }
        for(int i = 1; i <= n - k + 1; i++){
            LinkedList<Integer> list = new LinkedList<>();
            list.add(i);
            Solution(n, k - 1, list, result);
            list.pollLast();
        }
        return result;
    }

    private void Solution(int n, int k, LinkedList<Integer> list, List<List<Integer>> result){
        if(k == 0){
            result.add(new LinkedList<>(list));
            return;
        }
        for(int i = list.getLast() + 1; i <= n; i++){
            list.add(i);
            Solution(n, k - 1, list, result);
            list.pollLast();
        }
    }

    //字典序
    public List<List<Integer>> combine2(int n, int k) {
        //將數字序列nums初始化爲[1…k, n+1]，一共k+1個元素，最後一位n+1用於作爲哨兵
        ArrayList<Integer> nums = new ArrayList<Integer>();
        for(int i = 1; i <= k; i++){
            nums.add(i);
        }
        nums.add(n + 1);

        List<List<Integer>> result = new ArrayList<>();
        //循環將nums從最小排列[1…k, n+1]更新至最大排列[n-k…n-1, n+1]
        int idx = 0;
        while(idx < k){
            //每次添加前k個元素至結果數組（除去末尾哨兵元素）
            result.add(new ArrayList<>(nums.subList(0, k)));
            //遍歷nums找出第一個與下一個數不連續的數字下標idx，將其數字加1（nums[idx]++）；idx之前的元素與其下標i一致（nums[i]=i+1）
            //當num更新至最大排列[n-k…n-1, n+1]時，數組連續，idx=k跳出循環
            idx = 0;
            while(idx < k && nums.get(idx + 1) == nums.get(idx) + 1){
                nums.set(idx, idx + 1);
                idx++;
            }
            nums.set(idx, nums.get(idx) + 1);
        }
        return result;
    }
}

---

#Coding一小時，Copying一秒鐘。留個言點個讚唄，謝謝你#