算法基础：动态规划

基本概念

从数学的视角来看，动态规划是一种运筹学方法，是在多轮决策过程中的最优方法。

动态规划与分治法的区别是：从分治法的视角来看，每个子问题必须相互独立；但在多轮决策中，这个假设显然不成立，而多轮决策就用到了动态规划方法。

多轮决策和动态规划：

策略，每轮的动作是决策，多轮决策合在一起常常被称为策略。
策略集合，由于每轮的决策动作都是一个变量，这就导致合在一起的策略也是一个变量。我们通常会称所有可能的策略为策略集合。因此，动态规划的目标，也可以说是从策略集合中，找到最优的那个策略。

算法思想

动态规划的解题方法没有那么标准化，它因题而异，需要仔细分析问题并寻找解决方案。

动态规划有宏观层面通用的方法论：

分阶段，将原问题划分成几个子问题。一个子问题就是多轮决策的一个阶段，它们可以是不满足独立性的。
找状态，选择合适的状态变量。它需要具备描述多轮决策过程的演变，更像是决策可能的结果。
做决策，确定决策变量。每一轮的决策就是每一轮可能的决策动作。
状态转移方程。这个步骤是动态规划最重要的核心。
定目标。写出代表多轮决策目标的指标函数。
寻找终止条件。

具有如下几个特征的问题，可以采用动态规划求解：

最优子结构。它的含义是，原问题的最优解所包括的子问题的解也是最优的。例如，某个策略使得 A 到 G 是最优的。假设它途径了 Fi，那么它从 A 到 Fi 也一定是最优的。
无后效性。某阶段的决策，无法影响先前的状态。可以理解为今天的动作改变不了历史。
有重叠子问题。也就是，子问题之间不独立。这个性质是动态规划区别于分治法的条件。如果原问题不满足这个特征，也是可以用动态规划求解的，但这样就是小题大做了。

案例

一个非常典型的例子，最短路径问题。每个结点是一个位置，每条边是两个位置之间的距离。如下图所示，寻找结点 A 到结点 G 的最短距离。

可以看到，需要求解的路线是由 A 到 G，这就意味着 A 要先到 B，再到 C，再到 D，再到 E，再到 F。每一轮都需要做不同的决策，而每次的决策又依赖上一轮决策的结果。

例如，做 D2 -> E 的决策时，D2 -> E2 的距离为 1，最短。但这轮的决策，基于的假设是从 D2 出发，这就意味着前面一轮的决策结果是 D2。由此可见，相邻两轮的决策结果并不是独立的。

动态规划还有一个重要概念叫作状态。在这个例子中，状态是个变量，而且受决策动作的影响。例如，第一轮决策的状态是 S1，可选的值是 A，第二轮决策的状态是 S2，可选的值就是 B1 和 B2。以此类推。

解题步骤思路

分阶段：从 A 到 G，可以拆分为 A -> B、B -> C、C -> D、D -> E、E -> F、F -> G，6 个阶段。
找状态：第一轮的状态 S1 = A，第二轮 S2 = {B1,B2}，第三轮 S3 = {C1,C2,C3,C4}，第四轮 S4 = {D1,D2,D3}，第五轮 S5 = {E1,E2,E3}，第六轮 S6 = {F1,F2}，第七轮 S7 = {G}。
做决策：决策变量就是上面图中的每条边。以第四轮决策 D -> E 为例来看，可以得到 u4(D1)，u4(D2)，u4(D3)。其中 u4(D1) 的可能结果是 E1 和 E2。
写出状态转移方程：

定目标：目标是总距离最短。定义 dk(sk,uk) 是在 sk 时，选择 uk 动作的距离，如 d5(E1,F1) = 3。本题为 n = 7，则有如下为最终要优化的目标：

寻找终止条件：起止条件分别是，s1 = A 和 s7 = G。

接下来把所有的已知条件凝练为上面的符号之后，只需要借助最优子结构，就可以把问题解决了。最优子结构的含义是，原问题的最优解所包括的子问题的解也是最优的。

如果 A -> ... -> F1 -> G 是全局 A 到 G 最优的路径，那么此处 A -> ... -> F1 也是 A 到 F1 的最优路径。此时，优化目标的含义为，从 A 到 G 的最短路径，是 A 到 F1 到 G 的路径和 A 到 F2 到 G 的路径中更短的那个。

最终输出路径为 A -> B1 -> C2 -> D1 -> E2 -> F2 -> G，最短距离为 18。

代码实现

对于输入的图，可以采用一个 m x m 的二维数组来保存。在这个二维数组里，m 等于全部的结点数，也就是结点与结点的关系图。而数组每个元素的数值，定义为结点到结点需要的距离。

public class testpath {
    public static int minPath(int[][] matrix) {
        return process(matrix, matrix[0].length-1);
    }
    // 递归
    public static int process(int[][] matrix, int i) {
        // 到达A退出递归
        if (i == 0) {
            return 0;
        }
        // 状态转移
        else{
            int distance = 999;
            for(int j=0; j<i; j++){
                if(matrix[j][i]!=0){
                    int d_tmp = matrix[j][i] + process(matrix, j);
                    if (d_tmp < distance){
                        distance = d_tmp;
                    }
                }
            }
            return distance;
        }
    }
    public static void main(String[] args) {
        int[][] m = {
            {0,5,3,0,0,0,0,0,0,0,0,0,0,0,0,0},
            {0,0,0,1,3,6,0,0,0,0,0,0,0,0,0,0},
            {0,0,0,0,8,7,6,0,0,0,0,0,0,0,0,0},
            {0,0,0,0,0,0,0,6,8,0,0,0,0,0,0,0},
            {0,0,0,0,0,0,0,3,5,0,0,0,0,0,0,0},
            {0,0,0,0,0,0,0,0,3,3,0,0,0,0,0,0},
            {0,0,0,0,0,0,0,0,8,4,0,0,0,0,0,0},
            {0,0,0,0,0,0,0,0,0,0,2,2,0,0,0,0},
            {0,0,0,0,0,0,0,0,0,0,0,1,2,0,0,0},
            {0,0,0,0,0,0,0,0,0,0,0,3,3,0,0,0},
            {0,0,0,0,0,0,0,0,0,0,0,0,0,3,5,0},
            {0,0,0,0,0,0,0,0,0,0,0,0,0,5,2,0},
            {0,0,0,0,0,0,0,0,0,0,0,0,0,6,6,0},
            {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4},
            {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3}
        };
        System.out.println(minPath(m));
    }
}

代码解读

在代码中定义了二维数组 m，对应于输入的距离图。m 是 15 x 16 维的，忽略了最后一行的全 0（即使输入也不会影响结果）。

然后调用函数 minPath。它的内部又调用了 process(matrix, matrix[0].length-1)。在这里，matrix[0].length-1 的值是 15，表示的含义是 matrix 数组的第 16 列（G）是目的地。

接着进入 process 函数中。在动态规划的过程中，是从后往前不断地推进结果，这就是状态转移的过程。

经过运行，这段代码的输出结果是 18，这与手动的推导结果一致。

总结

动态规划并不简单，动态规划的适用范围也没有那么广。如果不是专门从事运筹优化领域的工作，对它不了解也正常。如果求职的岗位与运筹优化关系不大，一般而言被面试到动态规划的可能性也是极低的。