JavaScript 動態規劃 & 貪心算法

時間 2019-11-16

原文原文鏈接

原文連接javascript

前言

這一章，咱們將介紹另外兩種經常使用的算法：動態規劃和貪心算法。動態規劃常被人比做是遞歸的逆過程，而貪心算法在不少求優問題上，是不二之選。下面，咱們針對這兩種算法，展開詳細的學習。java

動態規劃

動態規劃有時爲何被認爲是一種與遞歸相反的技術呢？是由於遞歸是從頂部開始將問題分解，經過解決掉全部分解出小問題的方式，來解決整個問題。動態規劃解決方案從底部開始解決問題，將全部小問題解決掉，而後合併成一個總體解決方案，從而解決掉整個大問題。git

使用遞歸去解決問題雖然簡潔，但效率不高。包括 JavaScript 在內的衆多語言，不能高效地將遞歸代碼解釋爲機器代碼，儘管寫出來的程序簡潔，可是執行效率低下。但這並非說使用遞歸是件壞事，本質上說，只是那些指令式編程語言和麪向對象的編程語言對遞歸的實現不夠完善，由於它們沒有將遞歸做爲高級編程的特性。github

斐波拉契數列

斐波拉契數列定義爲如下序列：算法

0，1，1，2，3，5，8，13，21，34，55，......
複製代碼

能夠看到，當 n >= 2，a_n = a_{n - 1} + a_{n - 2}。這個數列的歷史很是悠久，它是被公元700年一位意大利數學家斐波拉契用來描述在理想狀態下兔子的增加狀況。編程

不難看出，這個數列能夠用一個簡單的遞歸函數表示。數組

function fibo (n) {
    if (n <= 0)  return 0;
    if (n === 1) return 1;
    return fibo(n - 1) + fibo(n - 2);
}
複製代碼

這種實現方式很是耗性能，在n的數量級到達千級別，程序就變得特別慢，甚至失去響應。若是使用動態規劃從它能解決的最簡單子問題着手的話，效果就很不同了。這裏咱們先用一個數組來存取每一次產生子問題的結果，方便後面求解使用。編程語言

function fibo (n) {
    if (n <= 0) return 0;
    if (n <= 1) return 1;
    var arr = [0, 1];
    for (var i = 2; i <= n; i++) {
        arr[i] = arr[i - 1] + arr[i - 2];
    }
    return arr[n];
}
複製代碼

細心的同窗發現，這裏的數組能夠去掉，換作局部變量來實現能夠省下很多內存空間。函數

function fibo (n) {
    if (n <= 0) return 0;
    if (n <= 1) return 1;
    var res, a = 0, b = 1;
    for (var i = 2; i <= n; i++) {
        res = a + b;
        a = b;
        b = res;
    }
    return res;
}
複製代碼

這裏實現方式還有沒有可能更簡潔呢？答案是確定的，我能夠再節省一個變量。性能

function fibo (n) {
    if (n <= 0) return 0;
    if (n <= 1) return 1;
    var a = 0, b = 1;
    for (var i = 2; i <= n; i++) {
        b = a + b;
        a = b - a;
    }
    return b;
}
複製代碼

尋找最長公共子串

另外一個適合使用動態規劃去解決的問題是尋找兩個字符串的最長公共子串。例如，在單詞 raven 和 havoc中，最長的公共子串是「av」。尋找最長公共子串經常使用於遺傳學中，用於使用核苷酸中鹼基的首字母對DNA分子進行描述。

咱們能夠用暴力法去解決這個問題，但顯得很笨拙。

function maxSubString (str1, str2) {
    if (!str1 || !str2) return '';
    var len1 = str1.length,
        len2 = str2.length;
    var maxSubStr = '';
    for (var i = 0; i < len1; i++) {
        for (var j = 0; j < len2; j++) {
            var tempStr = '',
                k = 0;
            while ((i + k < len1) && (j + k < len2) && (str1[i + k] === str2[j + k])) {
                tempStr += str1[i + k];
                k++;
            }
            if (tempStr.length >  maxSubStr.length) {
                maxSubStr = tempStr;
            }
        }
    }
    return maxSubStr;
}
複製代碼

求最長公共子串的動態規劃算法，咱們並不展開，有興趣的同窗能夠跳轉至如下連接：

揹包問題

揹包問題是算法研究中的一個經典問題。試想你是一個保險箱大盜，打開了一個裝滿奇珍異寶的保險箱，可是你必須將這些寶貝放入你的一個小揹包中。保險箱中的物品規格和價值不一樣。你但願本身的揹包裝進的寶貝總價值最大。

固然，暴力計算能夠解決這個問題，可是動態規劃會更爲有效。使用動態規劃來解決揹包問題的關鍵思路是計算裝入揹包的每個物品的最大價值，直到揹包裝滿。

若是在咱們例子中的保險箱中有 5 件物品，它們的尺寸分別是三、四、七、八、9，而它們的價值分別是四、五、十、十一、13，且揹包的容積爲 16，那麼恰當的解決方案是選取第三件物品和第五件物品，他們的總尺寸是 16，總價值是 23。

表1：0-1揹包問題

物品	A	B	C	D	E
價值	4	5	10	11	13
尺寸	3	4	7	8	9

首先，咱們看看遞歸方式怎麼去解決這個問題：

function knapsack (capacity, objectArr, order) {
    if (order < 0 || capacity <= 0) {
        return 0;
    }
    if (arr[order].size > capacity) {
        return knapsack(capacity, objectArr, order - 1);
    }
    return Math.max(arr[order].value + knapsack(capacity - arr[order].size, objectArr, order - 1),
                    knapsack(capacity, objectArr, order - 1));
}

console.log(knapsack(16, [
    {value: 4, size: 3},
    {value: 5, size: 4},
    {value: 10, size: 7},
    {value: 11, size: 8},
    {value: 13, size: 9}
], 4)); // 23
複製代碼

爲了提升程序的運行效率，咱們不妨將遞歸實現方式改爲動態規劃。這個問題有個專業的術語：0-1揹包問題。0-1揹包問題，dp解法從來都困擾不少初學者，大多人學一次忘一次，那麼，此次咱們努力💪將它記在內心。

注意，理解0-1揹包問題的突破口，就是要理解「0-1」這個含義，這裏對於每一件物品，要麼帶走（1），要麼留下（0)。

基本思路

0-1揹包問題子結構：選擇一個給定第 i 件物品，則須要比較選擇第 i 件物品的造成的子問題的最優解與不選擇第 i 件物品的子問題的最優解。分紅兩個子問題，進行選擇比較，選擇最優的。

若將 f[i][w] 表示前 i 件物品恰放入一個容量爲 w 的揹包能夠得到的最大價值。則其狀態轉移方程即是：

f[i][w] = max{ f[i-1][w], f[i-1][w-w[i]]+v[i] }
複製代碼

其中，w[i] 表示第 i 件物品的重量，v[i] 表示第 i 件物品的價值。

function knapsack (capacity, objectArr) {
    var n = objectArr.length;
    var f = [];
    for (var i = 0; i <= n; i++) {
        f[i] = [];
        for (var w = 0; w <= capacity; w++) {
            if (i === 0 || w === 0) {
                f[i][w] = 0;
            } else if (objectArr[i - 1].size <= w) {
                var size = objectArr[i - 1].size,
                    value = objectArr[i - 1].value
                f[i][w] = Math.max(f[i - 1][w - size] + value, f[i - 1][w]);
            } else {
                f[i][w] = f[i - 1][w];
            }
        }
    }
    return f[n][capacity];
}
複製代碼

以上方法空間複雜度和時間複雜都是O(nm)，其中 n 爲物品個數，m 爲揹包容量。時間複雜度沒有優化的餘地了，可是空間複雜咱們能夠優化到O(m)。首先咱們要改寫狀態轉移方程：

f[w] = max{ f[w], f[w-w[i]]+v[i] }
複製代碼

請看代碼示例：

function knapsack (capacity, objectArr) {
    var n = objectArr.length;
    var f = [];
    for (var w = 0; w <= capacity; w++) {
        for (var i = 0; i < n; i++) {
            if (w === 0) {
                f[w] = 0;
            } else if (objectArr[i].size <= w) {
                var size = objectArr[i].size,
                    value = objectArr[i].value
                f[w] = Math.max(f[w - size] + value, f[w] || 0);
            } else {
                f[w] = Math.max(f[w] || 0, f[w - 1]);
            }
        }
    }
    return f[capacity];
}
複製代碼

貪心算法

前面研究的動態規劃算法，它能夠用於優化經過次優算法找到的解決方案——這些方案一般是基於遞歸方案實現的。對許多問題來講，採用動態規劃的方式去處理有點大材小用，每每一個簡單的算法就夠了。

貪心算法就是一種比較簡單的算法。貪心算法老是會選擇當下的最優解，而不去考慮這一次的選擇會不會對將來的選擇形成影響。使用貪心算法一般代表，實現者但願作出的這一系列局部「最優」選擇可以帶來最終的總體「最優」選擇。若是是這樣的話，該算法將會產生一個最優解，不然，則會獲得一個次優解。然而，對不少問題來講，尋找最優解很麻煩，這麼作不值得，因此使用貪心算法就足夠了。

揹包問題

若是放入揹包的物品從本質上說是連續的，那麼就可使用貪心算法來解決揹包問題。換句話說，該物品必須是不能離散計數的，好比布匹和金粉。若是用到的物品是連續的，那麼能夠簡單地經過物品的單價除以單位體積來肯定物品的價值。在這種狀況下的最優是，先裝價值最高的物品直到該物品裝完或者將揹包裝滿，接着裝價值次高的物品，直到這種物品也裝完或將揹包裝滿，以此類推。咱們把這種問題類型叫作「部分揹包問題」。

表2：部分揹包問題

物品	A	B	C	D	E
價值	50	140	60	60	80
尺寸	5	20	10	12	20
比率	10	7	6	5	4

咱們不能經過貪心算法來解決離散物品問題的緣由，是由於咱們沒法將「半臺電視」放入揹包。換句話說，貪心算法不能解決0-1揹包問題，由於在0-1揹包問題下，你必須放入整個物品或者不放入。

function knapsack (capacity, objectArr) {
    // 首先按性價比排序, 高 -> 低
    objectArr.sort(function (a, b) {
        return parseFloat(b.value / b.size) - parseFloat(a.value / a.size);
    });
    // 記錄物品個數
    var n = objectArr.length;
    // 記錄已經選中尺寸，已選最大的最大價值
    var selected = 0,
        maxValue = 0;
    for (var i = 0; i < n && selected < capacity; i++) {
        var size = objectArr[i].size,
            value = objectArr[i].value;
        if (size <= capacity - selected) {
            maxValue += value;
            selected += size;
        } else {
            // 計算比例
            maxValue += value * ((capacity - selected) / size);
            selected  = capacity;
        }
    }
    return maxValue;
}
複製代碼