聊聊算法——动态规划

 

既然是聊算法，我们也不必开始就去追求多么的高深复杂，从经典开始，从通俗起步，很多经典算法，比如快排、二分查找、树遍历等，

站在经典的肩膀上，往往能看得更远，理解更多，今天来说一下动态规划，属于算法中比较难的点，但深入浅出系列总是有的，我就随便

写写，希望能有所助益。

「准备：

Idea2019.03/Gradle6.0.1/Maven3.6.3/JDK11.0.4

「难度： 新手--战士--老兵--大师

「目标：

1.理解并应用动态规划算法

 

作者原创文章，谢绝一切转载，违者必究！

本文只发表在"公众号"和"博客园"，其他均属复制粘贴！如果觉得排版不清晰，请查看公众号文章。 

 

1 定义

动态规划(Dynamic Programming，DP)，是运筹学的一个分支，是求解决策过程最优化的过程。用于解决「多阶段决策问题」。有一类活动，

可将过程分成若干个互相联系的阶段，在它的每一阶段都需要作出决策，从而使整个过程达到最好的活动效果。当各个阶段决策确定后，就组

成了一个决策序列，因而也就确定了整个过程的一条活动路线，这个决策的过程是”动态”的。举例，如凑零钱、最短路径、01背包问题等。

可以用DP解决的问题，一定是能将大问题拆成几个小问题，且必须具备两个特征：「无后效性」和「最优子结构」，具体来讲，无后效性是指

如果给定某一阶段的状态，则在这一阶段以后过程的发展不受这阶段以前各段状态的影响。最优子结构是指大问题的最优解可以由小问题的最优

解推出，即子问题也是某个阶段的最优解。

DP的关键在于解决冗余，即减少子问题的重复计算，这是动态规划算法的根本目的。动态规划实质上是一种以空间换时间的技术，它在实现的过

程中，不得不存储产生过程中的各种状态，所以它的空间复杂度要大于其他的算法。

2 冗余压缩

我们以斐波那契数列问题举例来说明重叠子问题冗余压缩，先写个始祖鸟版(Java)：

static int fin(int n){
    if (n ==1 || n==2){
        return 1;
    }
    return fin(n - 1) + fin(n - 2);
}

以上代码，是通过递归来完成，但同时会发现，算法过程存在大量重复计算，分析下时间复杂度，会发现子问题规模是棵二叉树，时间复杂度

为O(2^n)，例如fin(5)=fin(4)+fin(3)，左分支 fin(4)=fin(3)+fin(2)，右分支fin(3)=fin(2)+fin(1)，如果我们使用一个数组，取名为「备忘录」，来保

存子问题的中间状态结果，然后计算子问题时，先去查找数组里面是否已经存在，这样就可以减少重复计算了(Java)：

static int fin(int n){
    // 初始化全为0的数组
    int[] temp = new int[n + 1];
    if (n ==1 || n==2){
        return 1;
    }
    // 如果存在，则不必计算
    if (temp[n] != 0){
        return temp[n];
    }
    temp[n] = fin(n - 1) + fin(n - 2);
    return temp[n];
}

以上代码分析: 通过「备忘录」来记录子问题状态，从而减少了计算冗余，如果分析时间复杂度，我们会发现每个子问题只会计算一次，从而

为O(n)。并且是「自顶向下」方法，即从目标开始向基线(Base case)计算。

3 状态转移方程

同样是斐波那契数列问题，运用DP来解决，使用「自底向上」的迭代写法，即从基线(Base case)出发向目标计算(Java):

static int fina(int n){
    if (n == 1 || n == 2){
        return 1;
    }
    int[] temp = new int[n + 1];
    temp[1] = temp[2] = 1;
    for (int i = 3; i <= n ; i++) {
        temp[i] = temp[i - 1] + temp[i - 2];
    }
    return temp[n];
}

以上代码分析: 其中的 temp[i] = temp[i-1] + temp[i-2]， 即是动态规划中的「状态转移方程」，其中的temp数组即是动态规划表，即「DP table」。

如果分析时间复杂度，会发现此迭代写法为O(n)，因为每个状态也只计算一次。

考虑一下空间优化？

同时，可以观察到斐波那契数列每次迭代都只使用了前面两个中间结果，所以可以进一步减少空间使用，使空间复杂度为O(1)，而上面的动态规划

表空间复杂度为O(n)，(Java)：

static int fibo(int n){
    if (n == 1 || n == 2){
        return 1;
    }
    // 从左到右，左小右大：fir,sec,thd
    int fir = 1,sec = 1,thd = 1;
    for (int i = 3; i <= n ; i++) {
        thd = fir + sec;
        sec = thd;
        fir = sec;
    }
    return thd;
}

做个总结：虽然斐波那契数列问题，不是真正的动态规划例子，因没有找“最优”的过程，但很好的展示了冗余压缩和状态转移方程。另外可见，

用备忘录的递归解法已经和迭代的动态规划解法等效，而且动态规划一般都脱离了递归，而是由循环迭代完成计算，这样才能体现阶段选择和状态转移。

4 DP应用

动态规划核心，就是确定每个阶段的「状态」和「选择」，写出「状态转移方程」。

我们先用凑零钱问题来说明DP的思路，需求：钱的面额只有1元、2元和5元，数量无限，如何使用最少的钱币数凑出99元钱。

分析：采用「自顶向下」方法，如果定义f(n)为凑出总额为n的最小数量，那么求f(99)的最后一个“阶段”可以是从f(99-1)+1，f(99-2)+1，

f(99-5)+1中做选择，最小的即总数最小(这里有个思考题，即为什么大问题的最优解，一定是从小问题的最优解发展而来？有没有不

是这种情况的？这是理解DP的关键，例如要找全校成绩最好的，肯定可以先从班级中找出最好的再比较，但如果说找出全校乒乓球

双打最好的两人组，就不可以直接先从班级中找出单打最好的，再取一二名直接组合，毕竟双打还要考虑配合度，所以DP有适用条件，

见文章前面定义)，从而进一步可以去找前一个阶段f(98)，f(97)和f(95)，直到base case 处：f(0) 等于0，列出状态转移方程，其中coins={1,2,5}：

按照上面的分析，我们使用「自下而上」的方法，即可以写出DP解法(Java)：

static int money(int[] coins,int mount) {
    int[] dp = new int[mount + 1];
    // dp[i]初始化为i,即最多需要i个为1的面额
    for (int i = 0; i < mount + 1; i++) {
        dp[i] = i;
    }
    for (int i = 0; i < mount + 1; i++) {
        for (int coin : coins
        ) {
            if (i - coin < 0) continue;
            dp[i] = Math.min(dp[i],dp[i - coin] + 1);
        }
    }
    return dp[mount];
}

以上代码分析：1. dp[i]初始化为i,即最多需要i个为1的面额，作为可行解，并用于后面的状态选择做比较，从而选择最小的；

2.双层for循环，外层是目标金额的迭代，内部是coins集合的迭代；3. 外层for循环，需要计算dp[mount]的值，故i < mount + 1；

4.这里的base case就是dp[0]=0;

我们用一个图示来描述如何到达f(5)的状态：

如果我们想写个「自上而下」的方法，则可以使用带备忘录的递归写法，可参考上面的斐波那契数列问题，请看官完成，此处略！

再说个最短路径的动态规划：

需求：一个n*n的矩阵，每个矩阵点代表经过该点需耗费的精力，从[1,1]走到[n,n]最省力气的路径？每步只能向右或向下走。

分析：如果我们定义dp[i,j] 代表到达点 [i,j] 的最少精力，那肯定是从点 [i-1,j] 或点 [i,j-1]到达，只需选择其中更小的，依次往前推理，

前面的任何点都是类似；反过来，我们从基准出发，点 [1,1] 的值为1，到点 [1,2] 和点 [2,1] 都可以从[1,1]加上该点的消耗即得出，

这样，我们就可以算出矩阵中所有点的最少消耗。同时，如果使用二维数组dp[][]记录中间计算状态，就可以减少冗余计算了！

上代码(Java)：

static int path(int[][] matrix) {
    int horizontal = matrix.length;
    int vertical = matrix[0].length;
    int[][] dp = new int[horizontal][vertical];
    for (int i = 0; i < horizontal; i++) {
        for (int j = 0; j < vertical; j++) {
            if (i -1 < 0 || j -1 <0){
                continue;
            }
            int temp = 0;
            if(i > 0) temp = Math.min(dp[i][j],dp[i - 1][j] + dp[i][j]);
            if(j > 0) temp  = Math.min(dp[i][j],dp[i][j - 1] + dp[i][j]);
            dp[i][j] += temp;
        }
    }
    return dp[horizontal -1][vertical - 1];
}

以上代码分析：1.二维数组实际是一维数组的每个元素为一维数组，故矩阵横纵轴长度需要分开计算；2.当i=0或j=0时，

只有一个前置点位；3.该算法属于「自下而上」思路，当然可以有「自顶向下」的解法，请看官思考吧！

全文完！

---

我近期其他文章：

• 1 聊聊算法--堆的构建和调整
• 2 Dubbo学习系列之十九（Apollo配置中心）
• 3 聊聊算法——二分查找算法深度分析
• 4 DevOps系列——Jenkins/Gitlab自动打包部署
• 5 DevOps系列——Jenkins私服

只写原创，敬请关注