数据结构——动态规划

Posted 2020-10-05

前言

“动态规划”在大一时，就知道了这个词，当时觉得好难好高大上，从此心生畏惧，闻词色变，心理阴影一直留存到现在。

在校招时，也多次被问到动态规划相关的题目。

本篇从一道经典动态规划题目说起，慢慢展开。

从题目讲起

【换钱的方法数】

给定数组 arr，arr 中所有的值都为正数且不重复。每个值代表一种面值的货币，每种面值的货币都可以使用任意张，再给定一个整数 aim 代表要找的钱数，求换钱有多少种方法。

【举例】

arr = [5, 10, 25, 1]，aim = 15

则组成 15 元的方法共有 6 种，即 1 张 10 元和 1 张 5元、1 张 10 元 5 张 1 元、3 张 5 元、2张 5 元和 5 张 1 元、1 张 5 元和 10 张 1 元、 15 张 1 元。

【解析】

这道题目足够的经典，经典到校招时面试官面我第一个问题就是这个 = =。

之所以经典，是因为这道题通过暴力递归、记忆搜索和动态规划这 3 种方法均可以解决，同时这 3 种方法也是趋向最优解的过程。

通常情况下，可以通过暴力递归解决的问题都可以通过，暴力递归 -> 记忆搜索 -> 动态规划，这样的优化轨迹来进行优化。

从暴力递归到动态规划

暴力递归方法：

如果 arr[5, 10, 25, 1]，aim = 100，分析如下：

• 取 0 张 5 元，让剩下的 arr[1...N-1]（即 10、25、1 元）种货币，组成 100 元，求其方法数，结果记为 r1；
• 取 1 张 5 元，让剩下的 arr[1...N-1] 种货币，组成 100-5 元，求其方法数，结果记为 r2；
• 取 2 张 5 元，让剩下的 arr[1...N-1] 种货币，组成 90 元，求其方法数，结果记为 r3；
• ...
• 取 20 张 5 元，让剩下的 arr[1...N-1] 中货币，组成 0 元，求其方法数，结果记为 r21；

那么 r0 + r1 + r2 + r3 + ... + r21 即是总的方法数。

在上面的分析中，“让剩下的 arr[..]，组成。。。，求其方法数”，这句话其实就表示一个递归的过程。

可定义递归方法 solve(int index, int[] arr, int aim)，其中 index 表示用 arr[index...N-1] 种货币，组成 aim 元的方法数。源码如下：

 1     private int process(int[] arr, int aim) {
 2         if (arr == null || arr.length == 0 || aim < 0)
 3             return 0;
 4         return solve(0, arr, aim);
 5     }
 6 
 7     private int solve(int index, int[] arr, int aim) {
 8         int res = 0;
 9         if (index == arr.length) {
10             res = aim == 0 ? 1 : 0;
11         } else {
12             for (int i = 0; arr[index] * i <= aim; i++) {
13                 res += solve(index + 1, arr, aim - arr[index] * i);
14             }
15         }
16         return res;
17     }

暴力递归方法

在暴力递归的过程中，其中有很多都是不必要的重复计算，比如当计算过 0 张 5 元加 1 张 10 元后，需要进行 arr[25, 1]，aim = 90 的递归，同样的，当计算过 2 张 5 元加 0 张 10 元后，需要进行的也是 arr[25, 1]，aim = 90 的递归，显然这两次的递归方法入参是相同的，是完全不必要的计算。

如何减少不必要的计算？因为重复调用的递归方法入参是相同的（因为 arr 为全局变量，所以可以忽略，即只考虑 index 和 aim），所以将第一次调用的返回值保存起来，当下次调用递归方法时，首先判断该入参所对应的结果是否已经保存，如果存在对应的结果，则直接获取，不再进行递归计算。

记忆搜索方法：

为了保存入参对应的结果，这里通过二维数组来保存，即：dp[index][aim]。因为 dp[][] 为整数二维数组，所以其初始值为 0，这里我们就要区分是否进行过递归计算，如果入参对应的值在 dp 中没有保存，则进行递归计算，如果计算的结果为 0，则保存至 dp 中的值为 -1，以此来区分没有进行过递归计算和计算结果为0这两种情况。源码如下：

 1     private int process(int[] arr, int aim) {
 2         if (arr == null || arr.length == 0 || aim < 0)
 3             return 0;
 4         int[][] dp = new int[arr.length + 1][aim + 1];
 5         return solve(0, arr, aim, dp);
 6     }
 7 
 8     private int solve(int index, int[] arr, int aim, int[][] dp) {
 9         int res = 0;
10         if (index == arr.length) {
11             res = aim == 0 ? 1 : 0;
12         } else {
13             int dpV;
14             for (int i = 0; arr[index] * i <= aim; i++) {
15                 dpV = dp[index + 1][aim - arr[index] * i];
16                 if (dpV != 0) {
17                     res += dpV == -1 ? 0 : dpV;
18                 } else {
19                     res += solve(index + 1, arr, aim - arr[index] * i, dp);
20                 }
21             }
22         }
23         dp[index][aim] = res == 0 ? -1 : res;
24         return res;
25     }

记忆搜索方法

其实记忆搜索方法可以说是一种特别的动态规划方法，下面看经典的动态规划解决方法。

动态规划方法：

如果 arr 长度为 N，则生成行数为 N，列数为 aim + 1 的矩阵 dp。