算法思想之牛逼的DP

昨晚无意间浏览到一篇为何学习使用DP的文章，给了我很大的震惊，让我深深的意识到DP的重要性以及数学建模能力、实践代码解决能力、以及面向对象解决算法问题
昨晚熬夜浏览了不少关于DP的文章和详解，感觉差不多多少有点顿悟了， 然后我自己总结下如下：
1.关于使用DP可以解决哪些问题？也就是说哪些问题可以采用DP？
无非2点：
最优子结构；
重复性子问题；
因为DP思想本质是：通过你强大的数学递推能力，推导出最优解的递推式，然后反映在计算机中就是用空间换取时间来快速解决问题；空间 == 创建数组来保存已经求解得到的最优问题解，用到的时候直接用，而不是再计算一次，典型的就是费波纳契数列！
对于简单的DP可能只需要1维数组保存结果就足够，比如：费波纳契数列；
对于难点的DP可能需要2维数组，比如01背包问题，这样的问题就是比较难的了，这个时候就需要你自己推导递推公式，然后再做了。（这点是最难的！）
一般不会超出2维数组 。

1.关于为何使用DP以及入门：

从一个简单例子学习DP

2.学习01背包的思想以及代码实现：

动态规划解决01背包问题

动态规划之01背包问题（最易理解的讲解）

java代码实现

3.分享

按图索骥找到的分享下个java代码

4.代码实现与结果：

  值得提及的一个问题是，在用 JAVA 实现时， 是按算法模型建模，还是用对象模型建模呢？ 如果用算法模型，那么 背包的值、重量就直接存入二个数组里；如果用对象模型，则要对背包以及背包问题进行对象建模。思来想去，还是采用了对象模型，尽管心里感觉算法模型似乎更好一些。有时确实就是这样，对象模型虽然现在很主流，但也不是万能的，采用其它的模型和视角，或许可以得到更好的解法。

/** * 求解背包问题： * 给定 n 个背包，其重量分别为 w1,w2,……,wn, 价值分别为 v1,v2,……,vn * 要放入总承重为 totalWeight 的箱子中，  * 求可放入箱子的背包价值总和的最大值。 *  *  * NOTE: 使用动态规划法求解 背包问题 * 设 前 n 个背包，总承重为 j 的最优值为 v[n,j], 最优解背包组成为 b[n]; * 求解最优值： * 1. 若 j < wn, 则 ： v[n,j] = v[n-1,j]; * 2. 若  j >= wn, 则：v[n,j] = max{v[n-1,j], vn + v[n-1,j-wn]}。 *  * * 求解最优背包组成： * 1. 若 v[n,j] > v[n-1,j] 则 背包 n 被选择放入 b[n],  * 2. 接着求解前 n-1 个背包放入 j-wn 的总承重中，  *    于是应当判断 v[n-1, j-wn] VS v[n-2,j-wn], 决定 背包 n-1 是否被选择。 * 3. 依次逆推，直至总承重为零。 *  *  *    重点： 掌握使用动态规划法求解问题的分析方法和实现思想。 *    分析方法： 问题实例 P(n) 的最优解S(n) 蕴含 问题实例 P(n-1) 的最优解S(n-1); *              在S(n-1)的基础上构造 S(n)  *    实现思想： 自底向上的迭代求解 和 基于记忆功能的自顶向下递归 */package dp;import java.util.ArrayList;public class DPTest {    // 对象建模：也就是背包模型 static class Knapsack {        private int weight;        private int value;        public Knapsack(int weight, int value) {            this.weight = weight;            this.value = value;        }        public int getWeight() {            return weight;        }        public void setWeight(int weight) {            this.weight = weight;        }        public int getValue() {            return value;        }        public void setValue(int value) {            this.value = value;        }        @Override        public String toString() {            return "Knapsack [weight=" + weight + ", value=" + value + "]";        }    }    // 应用背包的动态规划算法  static    class KnapsackProblem {        // 组合背包        private Knapsack[] bags;        // 定义总承重        private int totalWeight;        // 定义背包数量        private int n;        // 前 n 个背包，总承重为 totalWeight 的最优值矩阵        private int[][] bestValues;        // 前 n 个背包，总承重为 totalWeight 的最优值        private int bestValue;        // 前 n 个背包，总承重为 totalWeight 的最优解的物品组成        private ArrayList<Knapsack> bestSolution;        public KnapsackProblem(Knapsack[] bags, int weight) {            this.bags = bags;            this.totalWeight = weight;            this.n = bags.length;            System.err.println(n);            if (bestValues == null) {                bestValues = new int[n + 1][totalWeight + 1];            }        }        /**         * 求解前 n 个背包、给定总承重为 totalWeight 下的背包问题         */        public void solve() {            System.out.println("给定背包：");            for (Knapsack b : bags)                System.out.println(b);            System.out.println("给定总承重: " + totalWeight);            // 重头戏：            for (int j = 0; j <= totalWeight; j++) {                for (int i = 0; i <= n; i++) {                    if (i == 0 || j == 0)                        bestValues[i][j] = 0;                    else {                        // 如果第 i 个背包重量大于总承重，则最优解存在于前 i-1 个背包中，                        // 注意：第 i 个背包是 bags[i-1]                        if (j < bags[i - 1].getWeight())                            bestValues[i][j] = bestValues[i - 1][j];                        else {                            // 如果第 i 个背包不大于总承重，则最优解要么是包含第 i 个背包的最优解，                            // 要么是不包含第 i 个背包的最优解， 取两者最大值，这里采用了分类讨论法                            // 第 i 个背包的重量 iweight 和价值 ivalue                            int iweight = bags[i - 1].getWeight();                            int ivalue = bags[i - 1].getValue();                            bestValues[i][j] = Math.max(bestValues[i - 1][j], ivalue + bestValues[i - 1][j - iweight]);                        } // else                    } // else                } // for            } // for            // 求解背包组成            if (bestSolution == null) {                bestSolution = new ArrayList<Knapsack>();            }            int tempWeight = totalWeight;            for (int i = n; i >= 1; i--) {                if (bestValues[i][tempWeight] > bestValues[i - 1][tempWeight]) {                    bestSolution.add(bags[i - 1]);                    tempWeight -= bags[i - 1].getWeight();                }                if (tempWeight == 0)                    break;            }            //记录一下最优价值而已            bestValue = bestValues[n][totalWeight];        }        /*         * * 获得前  n 个背包， 总承重为 totalWeight 的背包问题的最优解值     * 调用条件： 必须先调用 solve 方法         */        public int getBestValue(){            return bestValue;        }        /*         * * 获得前  n 个背包， 总承重为 totalWeight 的背包问题的最优解值矩阵     * 调用条件： 必须先调用 solve 方法         */        public int[][] getBestValues(){            return bestValues;        }        /*         *    * 获得前  n 个背包， 总承重为 totalWeight 的背包问题的最优解值矩阵     * 调用条件： 必须先调用 solve 方法         */        public ArrayList<Knapsack> getBestSolution(){            return bestSolution;        }    }    //测试方法    public static void main(String[] args) {        Knapsack[] bags ={                new Knapsack(2,6),                new Knapsack(2,3),                new Knapsack(6,5),                new Knapsack(5,4),                new Knapsack(4,6),        };        int totalWeight = 10;        KnapsackProblem kp = new KnapsackProblem(bags,totalWeight);        kp.solve();          System.out.println(" -------- 该背包问题实例的解: --------- ");          System.out.println("最优解："+kp.getBestValue());          System.out.println("最优解【选取的背包】: ");           System.out.println(kp.getBestSolution());          System.out.println("最优值矩阵：");            int[][] bestValues = kp.getBestValues();            for (int i=1; i < bestValues.length; i++) {                 for (int j=1; j < bestValues[i].length; j++) {                     System.out.printf("%-5d", bestValues[i][j]);                 }                 System.out.println();             }     }}

运行结果：给定背包：Knapsack [weight=2, value=6]Knapsack [weight=2, value=3]Knapsack [weight=6, value=5]Knapsack [weight=5, value=4]Knapsack [weight=4, value=6]给定总承重: 10 -------- 该背包问题实例的解: --------- 最优解：15最优解【选取的背包】: [Knapsack [weight=4, value=6], Knapsack [weight=2, value=3], Knapsack [weight=2, value=6]]最优值矩阵：0    6    6    6    6    6    6    6    6    6    0    6    6    9    9    9    9    9    9    9    0    6    6    9    9    9    9    11   11   14   0    6    6    9    9    9    10   11   13   14   0    6    6    9    9    12   12   15   15   15   **总结：**动态规划法总结：1. 动态规划法用于求解非最优化问题：当问题实例P(n)的解由子问题实例的解构成时，比如 P(n) = P(n-1) + P(n-2) [斐波那契数列] ，而 P(n-1) 和 P(n-2)可能包含重合的子问题，可以使用动态规划法，通过自底向上的迭代，求解较小子问题实例的解，并作为求解较大子问题实例的解的基础。关键思想是： 避免对子问题重复求解。比如： 求斐波那契数 F(5)：F(5)  = F(4) + F(3);子问题： F(4) = F(3) + F(2)                         F(3) = F(2) + F(1);                                  F(2) = F(1) + F(0)                        F(2) = F(1) + F(0);子问题： F(3) = F(2) + F(1)                        F(2) = F(1) + F(0)由上面的计算过程可知，如果单纯使用递归式，则子问题 F(2) 被重复计算了2次；当问题实例较大时，这些重复的子问题求解就会耗费大量不必要的时间。 若使用动态规划法，将 F(2) 的值存储起来，当后续计算需要的时候，直接取出来， 就可以节省不少时间。另一个比较典型的例子是： 求解二项式系数  C(n, k) = C(n-1, k) + C(n-1, k-1)2. 动态规划法求解最优化问题：      当问题实例P(n) 的最优解 可以从 问题实例 P(n-1) 的最优解 构造出来时，可以采用动态规划法，一步步地构造最优解。      关键是掌握动态规划法求解问题时的分析方法，如何从问题导出 解的递推式。 实际上，当导出背包问题的递归式后，后来的工作就简单多了，如何分析背包问题，导出其最优解的递推式，我觉得，这才是最关键的地方！问题分析很重要！