算法：最优子结构、无后效性和重复子问题

什么样的问题适合用动态规划来解决呢？

理论

什么样的问题适合用动态规划来解决呢？换句话说，动态规划能解决的问题有什么规律可循呢？可以用“一个模型三个特性”来回答这个问题。

（1）什么是一个模型？

• 它指的是动态规划适合解决的问题的模型，即多阶段决策最优解模型
• 我们一般是用动态规划来解决最优问题。而仅仅问题的过程，需要经历多个决策阶段。每个决策阶段都对应着一组状态，然后我们寻址一组决策序列，经过这组决策序列，能够产生最终期望求解的最优值

（2）什么是“三个类型”

• 最优子结构指的是，问题的最优解包含子问题的最优解。反过来说就是，我们可以通过子问题的最优解，推导出问题的最优解。也就是说后面阶段的状态可以通过前面阶段的状态推导出来
• 无后效性有两层含义。第一层含义是，在推导后面阶段的状态的时候，我们只关心前面阶段的状态值，不关心这个状态是怎么一步一步推导出来的。第二层含义是，某阶段状态一旦确定，就不受之后阶段的决策影响。
• 重复子问题。用一句话概况一下就是不同的决策序列，到达某个相同阶段时，可能会产生重复的状态

实例

假设我们有一个n乘以n的矩阵$w[n][n]$。矩阵存储的都是正整数。棋子起始位置在左上角，终止位置在右下角。我们将棋子从左上角移动到右下角。每次只能向右或者向下移动一位。从左上角到右下角，会有很多不同的路径可以左。我们把每条路径经过的数字加起来看作路径的长度。那从左上角移动到右下角的最短路径长度是多少呢？

我们先来看看，这个问题是否符合“一个模型”

• 从(0，0)走到(n-1，n-1)，总共要走$2\ast (n-1)$步，也就对应着$2\ast (n-1)$个阶段。每个阶段都有向右走或者向下走两种决策，并且每个阶段都会对应一个状态集合。
• 我们把这条定义为min_dist$(i，j)$，其中i表示行，j表示列。min_dist表达式的值表示从$(0,0)$到达$(i，j)$的最短路径长度。所以，这个问题是一个多阶段决策最优解问题，符号动态规划的模型。

我们再来看，这个问题是否符合“三个特性”

• 我们可以用回溯算法来解决问题，其对应递归树有重复的节点。重复的节点表示，从左上角到节点对应的位置，有多种路线，这也能说明这个问题中存在重复子问题。

• 如果我们走到$(i,j)$这个位置，我们只能通过$(i-1，j)$，$(i，j-1)$这两个位置移动过来，也就是说，我们想要计算$(i，j)$位置对应的状态，只需要关心$(i-1，j)$，$(i，j-1)$这两个位置对应的状态，并不关心棋子是通过什么样的路线到达这两个位置的。而且，我们仅仅允许往下和往右移动，不允许后退，所以，前面阶段的状态确定之后，不会被后面阶段的决策所改变，所以，这个问题符合“无后效性”这个特性
• 刚刚定义状态的时候，我们把从起始位置(0，0)到(i，j)的最小路径，记作min_dist$(i，j)$，因为我们只能往右或者向下移动，所以，我们只有可能从$(i-1，j)$或者$(i，j-1)$两个位置到达$(i，j)$。也就是说，到达$(i，j)$的最短路径要么经过$(i-1，j)$，要么经过$(i，j-1)$，而且到达$(i，j)$的最短路径肯定包含到达这两个位置的最短路径之一。换句话说就是，min_dist$(i，j)$可以通过min_dist$(i，j-1)$和min_dist$(i-1，j)$两个状态推导出来。这就说明，这个问题符合”最优子结构“

min_dist(i, j) = w[i][j] + min(min_dist(i, j-1), min_dist(i-1, j))

动态规划解题的思路总结

解决动态规划问题，一般有两种思路。分别叫作，状态转移表法和状态转移方程法。

状态转义表法

一般能用动态规划解决的问题，都可以使用回溯算法的暴力搜索解决。

• 所以，当我们拿到问题的时候，我们可以先用简单的回溯算法解决，然后定义状态，每个状态表示一个节点，然后对应画出递归树。
• 从递归树中，我们很容易可以看出来，是否存在重复子问题，以及重复子问题是如何产生的。以此来寻找规律，看是否能用动态规划解决。

找到重复子问题之后，接下来，我们有两种处理思路

• 第一种是**回溯+”备忘录“**的方法，来避免重复子问题。从执行效率来讲，这跟动态规划的解决思路没有差别
• 第二种是使用动态规划的解决方法，状态转移表法。
  • 我们先画出一个状态表。状态表一般是二维的，所以你可以把它想象成二维数组。其中，每天状态包含三个变量，行、列、数组值。我们根据决策的先后过程，从前往后，根据递推关系，分阶段填充状态表中的每个状态。最后，我们将这个递推填表的过程，翻译成代码，就是动态规划代码了
  • 尽管大部分状态表都是二维的，但是如果问题的状态比较复杂，需要很多变量来表示，那对应的状态表就有可能是高维的，比如三维、四维。那这个时候，我们就不适合用状态转移表法来解决了。一方面是因为高维状态转移表不好画图表示，另一方面是因为人脑确实很不擅长思考高维的东西。

现在，我们来看一下，如何套用这个状态转移表法，来解决之前那个矩阵最短路径的问题？

从起点到终点，我们有很多种不同的走法。我们可以穷举所有走法，然后对比找出一个最短走法。不过如何才能无重复又不遗落的穷举出所有走法呢？我们可以用回溯算法这个比较有规律的穷举算法。

回溯算法的代码实现如下所示：

    private int minDist = Integer.MAX_VALUE;
    // 调用方法：minDistBacktracing(0, 0, 0, w, n);
    public void minDistBT(int i, int j, int dist, int[][] w, int n){
        if(i == n && j == n){
            if(dist < minDist){
                minDist = dist;
            }
            return;
        }

        // 往下走，更新i = i + 1， j = j
        if(i < n){
            minDistBT(i + 1, j, dist + w[i][j], w, n);
        }

        // 往右走，更新i = i，j = j + 1
        if(j < n){
            minDistBT(i, j + 1, dist + w[i][j], w, n);
        }
    }

有了回溯代码之后，其对应递归树如下。在递归树中，一个状态（也就是一个节点）包含三个状态(i，j，dist)，其中i，j分别表示行和列，dist表示从起点到达(i，j)的路径长度。从图中可以看出，尽管(i，j，dist)不存在重复的，但是(i，j)重复的有很多。对于(i，j)重复的节点，我们只需要选择dist最小的节点，继续递归求解，其他节点就可以舍弃了。

既然存在重复子问题，我们就可以尝试看下，是否可以用动态规划来解决呢？

我们画出一个二维状态表，表中的行、列表示棋子所在的位置，表中的数值表示从起点到这个位置的最短路径。我们按照决策过程，通过不断状态递推演进，将状态表填好。为了方便代码实现，我们按照行来进行依次填充。

我们将上面过程翻译成代码，如下：

 	private int minDist = Integer.MAX_VALUE;
    // 调用方法：minDistBacktracing(0, 0, 0, w, n);
    public int minDistBT(int[][] matrix, int n){
        int[][]states = new int[n][n];
        int sum = 0;
        // 初始化states的第一行数据
        for (int i = 0; i < n; i++) {
            sum += matrix[0][i];
            states[0][i] = sum;
        }
        sum = 0;
        //初始化states的第一列数据
        for (int i = 0; i < n; i++) {
            sum += matrix[i][0];
            states[i][0] = sum;
        }

        for (int i = 1; i < n; i++) {
            for (int j = 1; j < n; j++) {
                states[i][j] = matrix[i][j] + Math.min(states[i][j-1], states[i-1][j]);
            }
        }
        
        return states[n-1][n-1];
    }

状态转移方程法

状态转移方程法有点类似递归的解题思路。我们需要分析，某个问题如何通过子问题来递归求解，也就是所谓的最优子结构。根据最优子结构，写出递归公式，也就是所谓的状态转移方程。有了状态转移方程，代码实现就非常简单了。一般情况下，我们有两种代码实现方式，一种是递归+备忘录，一种是迭代递推。

比如，上面例子的状态转移方程：min_dist(i, j) = w[i][j] + min(min_dist(i, j-1), min_dist(i-1, j))

状态转移方程是解决动态规划的关键。如果我们能写出状态转移方程，那动态规划问题基本上就解决一大半了。这里用递归+备忘录实现这个状态转移方程

  private int[][] matrix =
            {{1, 3, 5, 9}, {2, 1, 3, 4}, {5, 2, 6, 7}, {6, 8, 4, 3}};
    private int n = 4;
    private int[][] mem = new int[4][4];
    public int minDist(int i, int j){
        if(i == 0 && j == 0){
            return matrix[0][0];
        }
        if(mem[i][j] > 0){
            return  mem[i][j];
        }
        int minLeft = Integer.MAX_VALUE;
        if(j - 1 >= 0){
            minLeft = minDist(i, j - 1);
        }
        int minUp = Integer.MAX_VALUE;
        if(i - 1 >= 0){
            minUp = minDist(i - 1, j);
        }
        
        int currMinDist = matrix[i][j] + Math.min(minLeft, minUp);
        mem[i][j] = currMinDist;
        return currMinDist;
    }

注意，不是每个问题都同时适合这两种解题思路。有的问题可能用第一种思路更清晰，而有的问题可能用第二种思路更清晰，所以，要结合具体的题目来看，到底选择用哪种解题思路。

对比

• 状态转移表法解题思路大致可以概括为，回溯算法实现 - 定义状态 - 画递归树 - 找重复子问题 - 画状态转移表 - 根据递推关系填表 - 将填表过程翻译成代码。
• 状态转移方程法的大致思路可以概括为，找最优子结构 - 写状态转移方程 - 将状态转移方程翻译成代码。

四种算法思想比较分析

一般来说，常用有四种算法思想，贪心、分治、回溯和动态规划。其中，贪心、回溯、动态规划可以归为一类，而分治单独作为一类，因为它跟其他三个都不太一样。前三个算法解决问题的模型，都可以抽象成多阶段决策最优解模型，而分治算法解决的问题尽管大部分也是最优解问题，但是，大部分都不能抽象成多阶段决策模型。

回溯算法是个”万金油“，基本上能用动态规划、贪心解决的问题，我们都可以用回溯算法解决。回溯算法相当于穷举搜索。然后对比得到最优解。不过，回溯算法的时间复杂度非常高，是指数级别的，只能用来解决小规模数据的问题。对于大规模数据的问题，用回溯算法解决的执行效率就非常低了。

尽管动态规划比回溯算法高效，但是，并不是所有所有问题，都可以用动态规划来解决。能用动态规划解决的问题，需要满足三个特性，最优子结构、无后效性和重复子问题。在重复子问题这一点上，动态规划和分治算法的区分非常明显。分治算法要求分隔成子问题，不能有重复子问题，而动态规划刚好相反，动态规划之所以高效，就是因为回溯算法实现中存在大量的重复子问题。

贪心算法实际上是动态规划算法的一种特殊情况。它解决问题起来更加高效，代码实现也更加简洁。不过，它可以解决的问题也更加有限，其问题必须满足三个条件：最优子结构、无后效性、贪心选择性。

其中，最优子结构、无后效性跟动态规划中的相同。”贪心选择性“的意思是，通过局部最优的选择，能产生全局最优的选择。每一个阶段，我们都选择当前看起来最优的决策，所有阶段的决策完成之后，最终由这些局部最优解构成全局最优解。