二項分佈

問題描述：

二項分佈就是重複n次獨立的伯努利試驗。在每次試驗中只有兩種可能的結果，而且兩種結果發生與否互相對立，並且相互獨立，與其它各次試驗結果無關，事件發生與否的概率在每一次獨立試驗中都保持不變，則這一系列試驗總稱為n重伯努利實驗，當試驗次數為1時，二項分佈服從0-1分佈。

假設伯努利實驗中事件發生的概率為p，求n次獨立的伯努利實驗，事件發生k次的概率。

數學公式

我們都知道，上述問題可採用公式(1)：

我們還知道：

於是：

我們記

於是我們有：

演算法：

遞迴演算法：

演算法思想：

遞迴演算法思想就是來源於上面的公式(6)，我們只需要找到遞迴出口，也就是最基本的情況就行了。
很明顯：我們有

遞迴演算法程式碼：

    /**
     * 時間複雜度：O(2^n)
     * @param N
     * @param K
     * @param p
     * @return 伯努利實驗n次，事件發生k次的概率
     */
    public static double binomialRec(int N, int K, double p) {
        if (N == 0 && K == 0) 
            return
 
 1.0;
        if (N < 0 || K < 0) 
            return 0.0;
        return (1.0 - p) * binomialRec(N - 1, K, p) + p * binomialRec(N - 1, K - 1, p);
    }

非遞迴演算法

演算法思想：

上述遞迴演算法的時間複雜度太高，當n比較大時，可能都執行不出結果。之所以時間複雜度太高，是因為有大量的重複計算，於是很直觀的想法就是，把已經算出來的結果儲存到數組裡。由於是計算實驗n次，事件發生k次的概率，所以我們可以用二維陣列存放計算的中間結果。

非遞迴演算法程式碼：

/**
     * 
     * 伯努利實驗，實驗n次，出現k次的概率
     * 非遞迴方式實現，採用二維陣列儲存已經計算過的值
     * 時間複雜度：O(n * k)，空間複雜度：O(n * k)
     * @param n
     * @param k
     * @param p
     * @return
     */
    public static double binomialArray(int n, int k, double p) {
        double[][] array = new double[n+1][k+1];
        // Initilize array
        for (int i = 0; i <= n; i++) {
            for (int j = 0; j <= k; j++) {
                array[i][j] = 0;
            }
        }
        array[0][0] = 1.0;
        for (int i = 1; i <= n; i++) {
            for (int j = 0; j <= k; j++) {
                if (j > i) {
                    break;
                }
                if (i - 1 >= 0) {
                    array[i][j] += (1.0 - p) * array[i-1][j];
                    if (j - 1 >= 0) {
                        array[i][j] += p * array[i-1][j-1];
                    }
                }
            }
        }
        return array[n][k];
    }

非遞迴演算法改進

演算法思想： 上述非遞迴演算法中，我們使用的是二維陣列存放計算過的值，但我們發現，在計算array[i][j]時，只與其上一行的array[i-1][j]和array[i-1][j-1]有關，與其他值無關，所以我們可以使用一維陣列來實現。這樣空間複雜度可以降低到O(k).

非遞迴演算法改進程式碼：

    /**
     * 伯努利實驗，實驗n次，出現k次的概率
     * 非遞迴方式實現，採用一維陣列實現儲存計算過的值
     * 時間複雜度：O(n * k)，空間複雜度：O(k)
     * @param n
     * @param k
     * @param p
     * @return 
     */
    public static double binomial(int n, int k, double p) {
        double[] array = new double[k+1];
        for (int i = 0; i < array.length; i++) {
            array[i] = 0.0;
        }
        array[0] = 1.0;
        for (int i = 1; i <= n; i++) {
            // 這裡要倒著計算，因為正序計算新值會覆蓋掉之前的舊值
            for (int j = k; j >= 0; j--) {
                if (j - 1 >= 0) {
                    array[j] = (1.0 - p) * array[j] + p * array[j-1];
                }
                else {
                    array[j] = (1.0 - p) * array[j];
                }

            }
        }
        return array[k];

    }