問題

這是一個組合問題:

圖形化表述

程式碼:

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

/// 77. Combinations
/// https://leetcode.com/problems/combinations/description/
/// 時間複雜度: O(n^k)
/// 空間複雜度: O(k)
public class liubobo_8_3 {

    private ArrayList<List<Integer>> res;

    public List<List<Integer>> combine(int n, int k) {

        res = new ArrayList<List<Integer>>();
        if(n <= 0 || k <= 0 || k > n)
            return res;

        LinkedList<Integer> c = new LinkedList<Integer>();
        generateCombinations(n, k, 1, c);

        return res;
    }

    // 求解C(n,k), 當前已經找到的組合儲存在c中, 需要從start開始搜尋新的元素
    private void generateCombinations(int n, int k, int start, LinkedList<Integer> c){

        if(c.size() == k){
            res.add((List<Integer>)c.clone());
            return;
        }

        for(int i = start ; i <= n ; i ++){
            c.addLast(i);
            generateCombinations(n, k, i + 1, c);
            c.removeLast();
        }

        return;
    }

    private static void printList(List<Integer> list){
        for(Integer e: list)
            System.out.print(e + " ");
        System.out.println();
    }

    public static void main(String[] args) {

        List<List<Integer>> res = (new liubobo_8_3()).combine(4, 2);
        for(List<Integer> list: res)
            printList(list);
    }
}
 

感受:

本題和Permutations 全排列問題看似類似,其實還是有很多差別,  可以從核心程式碼的比較上看出來

Permutations:

private void generatePermutation(int[] nums, int index, LinkedList<Integer> p){

        if(index == nums.length){//遞迴終止條件
            res.add((LinkedList<Integer>)p.clone());
            return;
        }

        for(int i = 0 ; i < nums.length ; i ++)
            if(!used[i]){//元素userd[i]沒有被使用
                used[i] = true;//使用了第i個元素
                p.addLast(nums[i]);
                generatePermutation(nums, index + 1, p );
                p.removeLast();//刪除最後的元素,這是題目性質問題,所謂的元素間在打仗
                used[i] = false;//注意實際元素陣列是和userd[]陣列繫結的,所以刪除也要同時處理
            }

        return;
    }

Combinations:
private void generateCombinations(int n, int k, int start, LinkedList<Integer> c){

        if(c.size() == k){
            res.add((List<Integer>)c.clone());
            return;
        }

        for(int i = start ; i <= n ; i ++){
            c.addLast(i);
            generateCombinations(n, k, i + 1, c);
            c.removeLast();
        }

        return;
    }

從程式碼邏輯上還是極其相似的,但主要不同的又在哪呢?

答案在於userd[]上的使用 ,看出來了吧

  if(!used[i]){//元素userd[i]沒有被使用

     used[i] = true;//使用了第i個元素

    .....

     used[i] = false;//注意實際元素陣列是和userd[]陣列繫結的,所以刪除也要同時處理

 }

如果將上面的userd相關刪除

得到的結果:

無used[]         有used[]

1 1 1                1 2 3 
1 1 2                1 3 2 
1 1 3                2 1 3 
1 2 1                2 3 1 
1 2 2                3 1 2
1 2 3                3 2 1 
1 3 1 
1 3 2 
1 3 3 
2 1 1 
2 1 2 
2 1 3 
2 2 1 
2 2 2 
2 2 3 
2 3 1 
2 3 2 
2 3 3 
3 1 1 
3 1 2 
3 1 3 
3 2 1 
3 2 2 
3 2 3 
3 3 1 
3 3 2 
3 3 3 

最後造成了遍歷上的差異

                                 Permutations                                                                                 Combinations