Dynamic Programming(动态规划)

Introduction

作为科班出身的程序员，算法还是得懂一点点的。------佚名(我)。
动态规划是一个看起来很高大上的名字，让人一听就很想知道这到底是个啥，所以我常常需要跟身边好奇的朋友们解释一下。成功的让朋友们理解了动态规划的基本思想后，我决定写一篇博客来帮助更多好奇的人。
动态规划既是一种数学优化方法，也是一种计算机编程方法， 该方法由理查德·贝尔曼于20世纪50年代开发，并已在航空航天工程和经济学等多个领域得到应用。
本文将以计算斐波那契数和爬楼梯问题为例，描述记忆化搜索及动态规划的基本思想，使读者对动态规划有一个基本的理解。

Top-down Approach

斐波那契数列是一个人称“兔子数列”的数列，形如1，1，2，3，5，......从数列的第n(n >= 3)个数开始，第n个数的值为第n-1和第n-2个数的和。由于斐波那契数列非常的简单直观，它常被用作讲解记忆化搜索思想的例子。
在一个斐波那契额数列中，给定任意索引n, 如何求该位置的斐波那契数呢？最简单的方法，用递归：

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

这个算法的时间复杂度是怎么样的呢，直观的来看可能看不出来，如果将递归调用使用树来进行表示的话：

使用递归计算斐波那契数的递归树

可以发现一共进行了n层的调用，每往下走一层，节点数翻一倍(当然这棵二叉树不是满的，不论是国内定义的还是国外定义的满)，这表示这个算法的时间复杂度达到了指数级别。
仔细观察递归树我们可以发现，这棵树中有很多重复的节点，或许我们可以使用缓存来减少递归调用，比如，使用某种数据结构记录n-2的值:

public class Main {
    private static int[] memoryTable;
    public static void main(String[] args) {
        int n = 0;
        memoryTable = new int[n + 1];
        if (n >= 1) memoryTable[1] = 1;
        if (n >= 2) memoryTable[2] = 1;
        System.out.println("n's Fibonacci: " + fibonacci(n));
    }

    private static int fibonacci(int n) {
        if (n <= 0) {
            return -1;
        }
        if (memoryTable[n] == 0) {
            memoryTable[n] = fibonacci(n - 1) + fibonacci(n - 2);
        }
        return memoryTable[n];
    }
}

那么，根节点的右边那个子树就可以直接被省略掉，递归树就变成了这样：

优化之后的递归树

使用一个大小为n + 1的数组来缓存计算过了的值牺牲了O(n)的空间(通常来说完全可以接受)，算法被优化到了线性时间复杂度。这种存储已计算值的方法被称为“ memoization”。在Top-down approach里我们自顶向下的将一个问题分解成子问题并逐个求解，通过记录子问题的解来进行优化。

Bottom-up Approach

给定一个楼梯，你可以一次爬一阶或者一次爬两阶，但是每一次离开第n阶的时候需要花费cost[n]的体力，求如何花费最少的体力爬到顶，你可以从第一阶或者第二阶开始网上爬。比如[30, 20, 60]。花费体力最少的方式就是从第二阶往上爬一步，共耗费20体力。通过举例分析我们可以发现这个问题有这样的几个特性：
1.该问题最终的最优解可以通过结合子问题的最优解来得到。在第n阶的时候，我们只能从第n - 1阶和第n - 2阶爬上来，所以我们只需要递归的求解爬到第n - 1阶和第n - 2阶最少需要多少步，然后取其中小的那一个就能得到爬到第n阶最少需要多少步。
2.尝试递归的求解的时候会发现我们会不断的计算重复的子问题。从1我们可以看出来这个问题的递归树和求斐波那契数的问题的递归树是一样的，所以我们可以跟之前一样通过用一个数组来存储已经计算过的值来进行优化。
这个问题的第一个特性叫做“Optimal substructure”，第二个特性叫做“Overlapping sub-problems”。同时具有这两个特性的问题才可能能够通过动态规划来进行求解。
通过以上分析，我们可以得出一个求解这个问题的规律：

状态转移方程

这个规律又叫状态转移方程，其中dp代表离开某一阶需要消耗的体力。
有了状态转移方程之后，我们其实可以不用写递归，直接用递推的方式从第一步推到第n步就可以得到结果:

 public int minCostClimbingStairs(int[] cost) {
        int[] dp = new int[cost.length];
        for (int i = 0; i < cost.length; i++) {
            if (i == 0 || i == 1)  dp[i] = cost[i];
            else                   dp[i] = cost[i] + Math.min(dp[i - 1], dp[i - 2]);
        }
        return Math.min(dp[dp.length - 1], dp[dp.length - 2]);
  }

这种根据状态转移方程从最小的子问题开始一步一步推出最终结果的方式叫做Bottom-up Approach。
观察代码我们发现每一次我们在计算一个新的状态的时候都只用前面两个状态，所以我们其实可以不用数组，直接用两个变量记录前两个状态的值就行了：

 public int minCostClimbingStairs(int[] cost) {
        int b = cost[1], c = cost[0];
        for (int i = 2, a; i < cost.length; ++i, c=b, b = a) a = cost[i] + Math.min(b, c);
        return Math.min(b, c);
  }

我们发现Bottom-up Approach比Top-down Approach更进一步，把空间复杂度从O(n)优化到了O(1)。

Conclusion and Prospect

本文通过两个例子对动态规划的思想进行了一个基本描述，重点描述了实现动态规划的Top-down Approach和Bottom-up Approach，针对具体问题进行了算法的时间复杂度和空间复杂度分析。本文还讲解了适合使用动态规划进行解法优化的问题的特性。
动态规划的应用非常广泛，而且具体问题可能会比较复杂，希望熟练掌握的同学可以去各大OJ找题自虐一下。懒得找的同学可以直接试一下这道谷歌的面试题。

References

[1] Dynamic programming的维基百科
[2]Min Cost Climbing Stairs

Acknowledgments

感谢那些在看到我读算法书的时候跑过来问我你懂动态规划吗或者是在听说动态规划后忍不住要刨根问底的好奇宝宝们，是你们引发了我的思考。