理解经典算法：动态规划

什么是动态规划？

    先来看看《算法导论》里面的解释：

 动态规划(dynamic programming)与分治法相似，都是通过组合子问题的解来求解原问题。动态规划应用于子问题重叠的情况，即不同的子问题具有公共的子子问题。这种算法对每个子子问题只求解一次，将其解保存在一个表格中，从而无需每次求解一个子子问题时都重新计算，避免了不必要的计算工作。

    设计一个动态规划算法需要4步：

　　1. 描述最优解的结构。

　　2. 递归定义最优解的值

　   3. 按自底向上的方式计算最优解的值

　   4. 由计算出的结果构造一个最优解。

    这4步中的前3步是动态规划的基础，即前3步用自底向上的方法，从最底层的已经有解的子子问题开始，计算出所有子问题的最优解，并将其存入表格，用以求得问题的最优解。

从求解斐波那契数理解动态规划

    学习递归的时候我们都会遇到求解斐波那契数的问题，这个问题最简单的解法就是使用递归。

int Fibonacci(int n)
{
    if (n == 1 || n == 0)
        return 1;
    return Fibonacci(n - 1) + Fibonacci(n - 2);
}

    这个方法简单是简单，但却是用程序的运行时间为代价换来的。我们从n=5时，查看程序的运行过程：

　　F(5) = F(4) + F(3)

　　F(5) = (F(3) + F(2)) + (F(2) +F(1))

　　F(5) = ((F(2) + F(1)) + (F(1) + F(0))) +((F(1) + F(0)) + F(1))

　　F(5) = (((F(1) + F(0)) + F(1)) + (F(1) + F(0))) + ((F(1) + F(0)) + F(1))

    这个问题中，重复的子问题很多，但却得一个个重复的求解，重复求解这些子问题的所花费的时间可想而知。

    那我们试着用动态规划的想法来求解这个问题。首先得找到这个问题的最优解的描述，即一个数的斐波那契数为其前两个数的斐波那契数之和，前提条件为F(0) = 1,F(1) = 1。然后用递归表达式表示，则为：F(n) = F(n - 1) + F(n - 2)。再然后，我们从2开始，计算出2~n-1的斐波纳契数，保存在数组a[0...n]中。最后，我们便可轻易地算出F(n) = a[n - 1] + a[n - 2]。

int Fibonacci(int n)
{
    int *a = (int *)calloc(sizeof(int), n + 1);
    a[1] = a[0] = 1;
    for (int i = 2; i <= n; i++)
    {
        a[i] = a[i - 1] + a[i - 2];
    }
    return a[n];
}

    这个问题使用动态规划求解也同样简单，问题本身构造最优解的复杂程度决定了其使用动态规划时算法的复杂程度。

求解最长公共子序列

    动态规划的难点在于问题最优解的构造。前面的斐波纳契数问题因为其最优解不难构造，所以使用动态规划求解相当容易。而使用动态规划求解最长公共子序列，其最优解的构造则复杂一些。我们使用上面的步骤来求解这个问题：

    1. 最优解的描述

    最长公共子序列是求解两个字符串中，共有的最长的子序列。这个问题不要求子序列在两个字符串中连续存在，也就是不考虑子序列字符间在原字符串中有无字符存在。我们可以将问题分为两种情况：

　　a. 两字符串最后一个字符相等。

　　b. 两字符串最后一个字符不相等。

    对于第一种情况，我们只需将两字符串前面字符的公共子序列求出来，然后加上最后一个字符，长度加1即可。而对于第二种情况，我们则要考虑字符串1的前缀与字符2的最长公共子序列和字符串1与字符串2的前缀的最长公共子序列的长度，两者之间取最长的作为最优解。

    2. 构造递归式

    我们令两字符串分别表示为x_m和y_n，其子问题的解保存在数组c[m, n]中，则上述描述可表示为：

       

    3. 计算子问题的最优解

    通过上面的公式，代码实现为：

void LCS(int **a, char *str1, int len1, char *str2, int len2)
{
    int i, j;
    //定义字符数组b并初始化
    int **b = (int **)malloc(sizeof(int) * (len1 + 1));
    for (i = 0; i <= len1; i++)
    {
        b[i] = (int *)calloc(sizeof(int), (len2 + 1));
    }
    //计算最长子序列
    for (i = 1; i <= len1; i++)
    {
        for (j = 1; j <= len2; j++)
        {
            if (str1[i - 1] == str2[j - 1])
            {
                a[i][j] = a[i - 1][j - 1] + 1;
                b[i][j] = DIAGONAL;
            }
            else
            {
                if (a[i - 1][j] > a[i][j])
                {
                    b[i][j] = TOP;
                    a[i][j] = a[i - 1][j];
                }
                if (a[i][j - 1] > a[i][j])
                {    
                    b[i][j] = LEFT;
                    a[i][j] = a[i][j - 1];
                }
            }
        }
    }
}

    代码中的DIAGONAL、TOP、LEFT可看成↖、↑、←，则通过上面代码求解字符串X={A,B,C,B,D,A,B}和Y={B,D,C,A,B,A}，可获得下表：

      

    由上表，我们知道这两个字符串的最长公共子序列的长度为4。但是问题还没完，我们需要求解的是最长公共子序列，而不是它的长度。

    4. 求解公共子序列

    通过上面保存的子问题的最优解，我们就可以很容易地获得原问题的解：

 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define NON 0
#define TOP 1
#define LEFT 2
#define DIAGONAL 3

void LCSPrint(int **b, char *str1, int i, int j, char *str)
{
    if (i == 0 || j == 0)
    {
        return;
    }
    if (b[i][j] == DIAGONAL)
    {
        char c[2];
        c[0] = str1[i - 1]; c[1] = '\0';
        LCSPrint(b, str1, i - 1, j - 1, str);
        strcat(str, c);
    }
    else if (b[i][j] == TOP)
    {
        LCSPrint(b, str1, i - 1, j, str);
    }
    else
    {
        LCSPrint(b, str1, i, j - 1, str);
    }
}

void LCS(int **a, char *str1, int len1, char *str2, int len2, char *str)
{
    int i, j;
    //定义字符数组b并初始化
    int **b = (int **)malloc(sizeof(int) * (len1 + 1));
    for (i = 0; i <= len1; i++)
    {
        b[i] = (int *)calloc(sizeof(int), (len2 + 1));
    }
    //计算最长子序列
    for (i = 1; i <= len1; i++)
    {
        for (j = 1; j <= len2; j++)
        {
            if (str1[i - 1] == str2[j - 1])
            {
                a[i][j] = a[i - 1][j - 1] + 1;
                b[i][j] = DIAGONAL;
            }
            else
            {
                if (a[i - 1][j] > a[i][j])
                {
                    b[i][j] = TOP;
                    a[i][j] = a[i - 1][j];
                }
                if (a[i][j - 1] > a[i][j])
                {    
                    b[i][j] = LEFT;
                    a[i][j] = a[i][j - 1];
                }
            }
        }
    }
    LCSPrint(b, str1, len1, len2, str);
    
    free(b);
}

int main(int argc, char *argv[]) 
{
    int **a, len1, len2, i;
    char *str = (char *)malloc(sizeof(char));
    char *str1 = (char *)malloc(sizeof(char));
    char *str2 = (char *)malloc(sizeof(char));
    scanf("%s", str1);
    scanf("%s", str2);
    len1 = strlen(str1);
    len2 = strlen(str2);
    a = (int **)malloc(sizeof(int *) * (len1 + 1));
    for (i = 0; i <= len1; i++)
    {
        a[i] = (int *)calloc(sizeof(int), len2 + 1);
    }
    LCS(a, str1, len1, str2, len2, str);
    printf("len: %d, string: %s", a[len1][len2], str);
    
    free(str);
    free(str1);
    free(str2);
    free(a);
    
    return 0;
}

 

     同最长公共子序列相关的问题还有：最小编辑距离、0-1背包问题等，这些问题都能展现动态规划的强大之处。