算法 ------- 动态规划（1）最小硬币找零矩阵链相乘背包问题

最小硬币找零

function MinCionChange(someCoins) {    
    var coins = someCoins;    
    var cache = {};    
    this.makeChange = function (amount) {        
        var me = this;        
        if (!amount) {            
            return [];        
        }        
        if (cache[amount]) {            
            return cache[amount];        
        }        
        var min = [], newMin, newAmount;        
        for (var i = 0; i < coins.length; i++) {            
            var coin = coins[i];            
            newAmount = amount - coin;            
            if (newAmount >= 0) {                
                newMin = me.makeChange(newAmount);            
            }            
            if (newAmount >= 0 && (newMin.length < min.length-1 || !min.length)                && (newMin.length || !newAmount)) {                
                min = [coin].concat(newMin);                
                console.log('new Min' + min + ' for ' + amount);            
            }        
        }        
        return (cache[amount] = min);     
    }
}

矩阵链相乘

function MatrixChainOrder() {    
    this.matrixChainOrder = function (p, n) {        
    var i, j, k, l, q, m = [];        
    var s = [];        
    for (var i = 0; i <= n ; i++) {            
        s[i] = [];            
        for (var j = 0; j <= n; j++) {                
            s[i][j] = 0;            
        }        }                
        for (i = 1; i <= n; i++) {            
            m[i] = [];            
            m[i][i] = 0;        
        }
        for (l = 2; l < n; l++) {            
            for (i = 1; i <= n-l+1; i ++) {                
                j = i+l-1;                
                m[i][j] = Number.MAX_SAFE_INTEGER;                
                for (k = i; k <= j-1; k++ ) {                    
                    q = m[i][k] + m[k+1][j] + p[i-1]*p[k]*p[j];   
                    if (q < m[i][j]) {                        
                        m[i][j] = q;                        
                        s[i][j] = k;                    
                    }                
                }            
            }        
        }        
        printOptimalParenthesis(s, 1, n-1)        
        return m[1][n-1];    
    }
    function printOptimalParenthesis(s, i, j) {        
        if (i == j) {            
            console.log('A[' + i + ']');        
        }else {            
            console.log('(');            
            printOptimalParenthesis(s, i, s[i][j]);            
            printOptimalParenthesis(s, s[i][j] + 1, j);            
            console.log(')');        
        }    
    }
}

背包问题

function KnapSack(capacity, weights, values, n) {   
    this.knapSack = function () {    
    var a, b, ks = [];        
    for (var i = 0; i <= n; i++) {        
        ks[i] = [];    
    }        
    for (var i = 0; i <= n; i++) {        
        for (var w = 0; w <= capacity; w++) {            
            if (i == 0 || w == 0) {                
                ks[i][w] = 0;            
            } else if (weights[i-1] <= w) {                
                a = values[i-1] + ks[i-1][w-weights[i-1]];                
                b = ks[i-1][w];                
                ks[i][w] = (a > b)? a : b;            
            } else {                
                ks[i][w] = ks[i-1][w];            
            }        
        }    
    }    
    findValues(n, capacity, ks, weights, values);    
        return '总价值：' + ks[n][capacity];   
    }   
    function findValues(n, capacity, ks, weights, values) {        
        var i = n,            
        k = capacity;        
        console.log("解决方案如下：");        
        while (i > 0 && k > 0) {            
            if (ks[i][k] != ks[i-1][k]) {                
                console.log('物品' + i + ' ，重量：' + 
                            weights[i-1] + ' ，价值：' + 
                            values[i-1]);                
                i--;                
                k = k - weights[i-1];            
            } else {                
                i --;            
            }        
        }   
    }
}