lintcode: k Sum 解題報告

K SUM

My Submissions 

http://www.lintcode.com/en/problem/k-sum/ 題目來自九章算法

13%

Accepted

Given n distinct positive integers, integer k (k <= n) and a number target.

Find k numbers where sum is target. Calculate how many solutions there are?

Example

Given [1,2,3,4], k=2, target=5. There are 2 solutions:

[1,4] and [2,3], return 2.

Tags  Expand 

 

SOLUTION 1:

唉媽，主頁君做這題搞了2，3小時差點吐血。不過，做出來還是很爽嘀！

取自黃老師（九章算法）的思想：

 

 

 

 

 

后面的優化主頁君沒有管。 F[0][0][0]表示在一個空集中找出0個數，target為0，則有1個解，就是什么也不挑嘛！

其實應該這樣寫，也就是說，找0個數，目標為0，則一定是有1個解：

if (j == 0 && t == 0) {
　　// select 0 number from i to the target: 0
　　D[i][j][t] = 1;
}

1. 狀態表達式：

D[i][j][t] = D[i - 1][j][t];
if (t - A[i - 1] >= 0) {
D[i][j][t] += D[i - 1][j - 1][t - A[i - 1]];
}

意思就是：

（1）我們可以把當前A[i - 1]這個值包括進來，所以需要加上D[i - 1][j - 1][t - A[i - 1]]（前提是t - A[i - 1]要大於0）

（2）我們可以不選擇A[i - 1]這個值，這種情況就是D[i - 1][j][t]，也就是說直接在前i-1個值里選擇一些值加到target.

代碼：

/**
     * @param A: an integer array.
     * @param k: a positive integer (k <= length(A))
     * @param target: a integer
     * @return an integer
     */
    public int  kSum1(int A[], int k, int target) {
        // write your code here
        if (target < 0) {
            return 0;
        }
        
        int len = A.length;
        
        int[][][] D = new int[len + 1][k + 1][target + 1];
        
        for (int i = 0; i <= len; i++) {
            for (int j = 0; j <= k; j++) {
                for (int t = 0; t <= target; t++) {
                    if (j == 0 && t == 0) {
                        // select 0 number from i to the target: 0
                        D[i][j][t] = 1;
                    } else if (!(i == 0 || j == 0 || t == 0)) {
                        D[i][j][t] = D[i - 1][j][t];
                        if (t - A[i - 1] >= 0) {
                            D[i][j][t] += D[i - 1][j - 1][t - A[i - 1]];
                        }
                    }
                }
            }
        }
        
        return D[len][k][target];
    }

 

SOLUTION 2:

我們可以把最外層的Matrix可以省去。

這里最優美的地方，在於我們把target作為外層循環，並且從右往左計算。這里的原因是：

D[i][j][t] += D[i - 1][j - 1][t - A[i - 1]];

這個表達式說明D[i][j][t]是把上一級i的結果累加過來。這里我們省去了i這一級，也就是說在D[j][t]這個表里就地累加。而且t - A[i - 1]小於t。

在以下圖表示就是說D[j][t]是來自於上一行的在t左邊的這些值中挑一些加起來。

所以我們就必須從右往左逐列計算來避免重復的累加。

1. 如果你從左往右按列計算，每一列會被重復地加總，就會有重復計算。我們可以想象一下，len = 0為上表，len = 1為下表。

現在我們只有一個表，就是下面這個（因為第一個維度被取消了），現在如果你從左往右計算，被sum的區域會被填掉，覆蓋

len = 0 那張表留下的值，下一個值的計算就不會准確了。

2. 或者如果你逐行計算，也是不可以的。因為你也是把生成D[j][t](在圖里寫的是D[i][j])的被sum的區域覆蓋，也會造成結果不准確。

3. 所以，只要我們逐列計算，並且順序是從右往左，即使我們只有一個二維表，我們的被sum區域也可以保持潔凈，從空間角度來想，

就相當於從len=0那張表中取值。

總結：這種思維方式可能在面試里很難遇到，不過，可以開拓我們思維，這里同樣是動規時如果取得上一級的值的問題，並且它考慮了省

去一級，就地利用二維空間的值，那么就要考慮我們上一級的舊表不要被覆蓋。可以在大腦中構思一個三維空間，一個三維表由多個二維

表構成，如果把它們用一個表來做，再思考一下即可。

// 2 dimension
    public int  kSum(int A[], int k, int target) {
        // write your code here
        if (target < 0) {
            return 0;
        }
        
        int len = A.length;
        
        // D[i][j]: k = i, target j, the solution.
        int[][] D = new int[k + 1][target + 1];
        
        // only one solution for the empty set.
        D[0][0] = 1;
        for (int i = 1; i <= len; i++) {
            for (int t = target; t > 0; t--) {
                for (int j = 1; j <= k; j++) {
                    if (t - A[i - 1] >= 0) {
                        D[j][t] += D[j - 1][t - A[i - 1]];
                    }
                }
            }
        }
        
        return D[k][target];
    }

 

https://github.com/yuzhangcmu/LeetCode/blob/master/lintcode/dp/KSum.java