动态规划入门题之国王和金矿(0-1背包问题)

这两天研究了1篇写的比较通俗易懂的动态规划入门文章( https://wx.abbao.cn/a/4736-4b66e5f9ec584ee0.html ),

但是发现作者思路虽然是对的,但是写的代码有错误,尤其是第二个例子国王与金矿(其实就是0-1背包问题)的动态规划解法的代码中出现了如下比较严重的错误.这个错误不注意还发现不了,我也是debug了好一会才发现问题所在.

我会在下面补上这题DP解法正确的代码,另外作者没有写这道题递归解法和备忘录算法解法的代码,我也一并补上.

 

题目:

有一个国家发现了5座金矿，每座金矿的黄金储量不同，需要参与挖掘的工人数也不同。参与挖矿工人的总数是10人。每座金矿要么全挖，要么不挖，不能派出一半人挖取一半金矿。要求用程序求解出，要想得到尽可能多的黄金，应该选择挖取哪几座金矿？

 

这题建模后得到的方程组如下:

F(n,w) = 0  (n<1)

F(n,w) = 0    (n==1, w<p[0])

F(n,w) = g[0]     (n==1, w>=p[0])

F(n,w) = F(n-1,w)    (n>1, w<p[n-1])  

F(n,w) = max(F(n-1,w),  F(n-1,w-p[n-1])+g[n-1])    (n>1, w>=p[n-1])

 其中g[ ] 中存储每座金矿的金矿数,p[ ] 中存储挖g[ ] 中对应金矿所需的工人数,F(n,w)表示工人数为w时挖g[ ] 中前n座金矿所能得到的最大金矿数,

 

这题有3种解法,第一种是简单递归解法,第二种是在递归的基础上的备忘录算法解法,第三种是动态规划解法,需要注意的是,当输入的矿山数多时用动态规划解法效率高,但是当输入的工人数多时,DP的效率反而不如简单递归,所以说不同算法没有绝对的好坏,要视具体场景而定.

三种解法都是根据上面的方程组来写代码,其中动态规划解法可以画张表格来辅助分析(因为这题有2个输入维度),如下所示.

 

三种解法的完整代码如下:

package ustb.dp;

import java.util.HashMap;


public class GoldMiner {

    /**
     * 
     * @param n 
     * @param w
     * @param g 数组g中存储每座金矿的金矿数
     * @param p 数组p中存储挖每座金矿需要的工人数
     * @return 该方法返回工人数为w时挖数组g中前n座金矿所能得到的最大金矿数
     */
    //递归解法
    public static int getMostGold(int n, int w, int[] g, int[] p) { 
        if (n > g.length) 
            throw new RuntimeException("输入的n值大于给定的金矿数");
        
        if (n <= 1 && w < p[0]) 
            return 0;
        
        if (n == 1 && w >= p[0])
            return g[0];
    
        if (n > 1 && w < p[n-1]) 
            return getMostGold(n-1, w, g, p);
        
        int a = getMostGold(n-1, w, g, p);
        int b = getMostGold(n-1, w - p[n-1], g, p) + g[n-1];
        return Math.max(a, b);
        
    }
    
    
    
    /**
     * @author 26062
     * @describe 该内部类对象用于备忘录算法中作为HashMap存储的键
     */
    private static class Input{
            private int n;
            private int w;
            
            public Input(int n, int w) {
                super();
                this.n = n;
                this.w = w;
            }

            @Override
            public int hashCode() {
                final int prime = 31;
                int result = 1;
                result = prime * result + n;
                result = prime * result + w;
                return result;
            }

            @Override
            public boolean equals(Object obj) {
                if (this == obj)
                    return true;
                if (obj == null)
                    return false;
                if (getClass() != obj.getClass())
                    return false;
                Input other = (Input) obj;
                if (n != other.n)
                    return false;
                if (w != other.w)
                    return false;
                return true;
            }
        
    }

    //备忘录算法解法
    public static int getMostGold2(int n, int w, HashMap<Input, Integer> map, int[] g, int[] p) {
        if (n > g.length) 
            throw new RuntimeException("输入的n值大于给定的金矿数");
        
        if (n <= 1 && w < p[0]) 
            return 0;
        
        if (n == 1 && w >= p[0])
            return g[0];
    
        if (n > 1 && w < p[n-1]) {
            Input input = new Input(n-1, w);
            if (map.containsKey(input)) 
                return map.get(input);
            
            int value = getMostGold2(n-1, w, map, g, p);
            map.put(input, value);
            return value;
        }
            
        Input input1 = new Input(n-1, w);
        Input input2 = new Input(n-1, w-p[n-1]);
        int a = 0; //用于记录F(n-1,w)的值
        int b = 0; //用于记录F(n-1,w-p[n-1])+g[n-1])的值

        if (map.containsKey(input1)) 
            a = map.get(input1);
        a = getMostGold2(n-1, w, map, g, p);
        map.put(input1, a);
        
        if (map.containsKey(input2)) 
            b = map.get(input2) + g[n-1];
        b = getMostGold2(n-1, w-p[n-1], map, g, p);
        map.put(input2, b);
        b += g[n-1];

        return a > b ? a : b;
    }
    
    
    
    //DP解法
    public static int getMostGold3(int n, int w, int[] g, int[] p) {
        if (n > g.length) 
            throw new RuntimeException("输入的n值大于给定的金矿数");
        
        if (w < 0) {
            throw new RuntimeException("输入的工人数w不能为负数");
        }
        
        if (n < 1 || w == 0) { 
            return 0;
        }
        
        int col = w+1; ////因为F(x,0)也要用到,所以表格应该有w+1列
        int[] preResult = new int[col]; 
        int[] result = new int[col];
        
        //初始化第一行(边界)
        for (int i = 0; i < col; i++) {
            if (i < p[0])
                preResult[i] = 0;
            else 
                preResult[i] = g[0];
        }
        
        if (n == 1) {
            return preResult[w];
        }
        
        //用上一行推出下一行,外循环控制递推的轮数,内循环进行递推
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < col; j++) {
                if (j < p[i]) 
                    result[j] = preResult[j];
                else 
                    result[j] = Math.max(preResult[j], preResult[j-p[i]] + g[i]);
            }
            
            for (int j = 0; j < col; j++) { //更新上一行的值,为下一轮递推做准备
                preResult[j] = result[j];
            }            
        }
        
        return result[w];    
    }
    
    
    //测试
    public static void main(String[] args) {
        int [] g = {400, 500, 200, 300, 350}; 
        int [] p = {5, 5, 3, 4, 3};
        System.out.println(getMostGold(5, 10, g, p));
        System.out.println(getMostGold2(5, 10, new HashMap<GoldMiner.Input, Integer>(), g, p));
        System.out.println(getMostGold3(5, 10, g, p));
        
    }

}

 

最后总结一下DP算法的思路:

核心: 最优子结构、边界条件、状态转移方程 

 

解题步骤: 1,建立数学模型 2,写代码求解问题 

   如何建模?

       先写出所求问题的最优子结构,进而分析出边界和状态转移方程,数学模型即这2者的组合

       对于2输入维度动态规划 画表格帮助分析 行列分别代表1个输入维度

    如何求解?

      建好模后,根据方程组写出自底向上的动态规划代码,一维输入就是1个for循环,二维输入就是2个for循环,如果方程组比较抽象,

      可以画表格帮助分析

 

先写到这里,感谢阅读!