【算法导论】动态规划_动态规划 算法导论

动态规划这个算法，我一直都搞不明白，也许因为我数学能力太差的缘故，总是不得其要领，每次学习这个算法的时候，总是不知道所谓的状态转移方程到底是怎么样推导出来的。其实就在我写这篇博客的时候，我依然不清楚。

什么问题能用动态规划来解决呢？动态规划问题的特征就是 最优子结构，一个递归结构：

1. 该问题需要求一个最优解
2. 该问题重复包含着子问题

比如说经典的动态规划问题，最长公共子序列（如下所述），我们要求一个最长的子序列，首先这是一个最优解，其次，两个序列的最长公共序列，也同时包含着子序列的最长公共序列。

动态规划通常按以下4个步骤来设计一个算法：

1. 刻画一个最优解的结构特征
2. 递归地定义最优解的值
3. 计算最优解的值（通常采用自底向上的方法）
4. 得用计算出的信息构造一个最优解

动态规划往往还结合一些备忘方法，用于记录中间解，以免重复求解子问题。下面来看几个问题：

钢条切割问题

给定一个钢条切割的长度和价格，求出最佳的切割方案。且看下列：

假设我们切割一条长度为 4 的钢条，总共有以下几种方案：
1. 不切割，价格为 9
2. 1 和 3 ：价格为 1 + 8 = 9
3. 2 和 2 ：价格为 5 + 5 = 10
4. 3 和 1 ：价格为 8 + 1 = 9
5. 1､2､1 ：价格为 1 + 5 + 1 = 7
6. 1､1､2 ：价格为 1 + 1 + 5 = 7
7. 2､1､1 ：价格为 2 + 1 + 1 = 7

可知道分割一条长度为4的钢条，最优的切割方案为「方案2」。更通俗一点，我们可以令Rn为切割长度为n的钢条，可以很轻松的得到以下公式：

这样，代码就容易写了，如下所示：

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

int rodCut_recursive_down_to_up(int* p, int* s, int* k, int m, int n)
{
    if(s[n] > - 1)
        return s[n];
    int q = -1;

    if(n == 0)
        return 0;

    for(int i = 1; i <= n; ++i)
    {
        for(int j = 1; j <= i; ++j)
        {
            int r = *(p + j) + rodCut_recursive_down_to_up(p, s, k, m, i - j);

            if(r > q)
            {
                q = r;
                s[i] = q;
                k[i] = j;
            }
        }

    }

    return q;
}

int rodCut_recursive_up_to_down(int* p, int* s, int* k, int m, int n)
{
    if(s[n] > -1)
        return s[n];

    int q = -1;

    if(n == 0)
        return 0;

    for(int i = n; i >= 1; --i)
    {
        int r = *(p + i) + rodCut_recursive_up_to_down(p, s, k, m, n - i);

        if(r >= q)
        {
            q = r;
            s[n] = q;
            k[n] = i;
        }
    }

    return q;
}

int main(void)
{
    int m, n;

    scanf("%d", &m);
    if(m != 0)
    {
        int* p = (int*)malloc(sizeof(int) * (m + 1));
        int* s = (int*)malloc(sizeof(int) * (m + 1));
        int* k = (int*)malloc(sizeof(int) * (m + 1));
        memset(p, 0, sizeof(int) * (m + 1));
        memset(k, 0, sizeof(int) * (m + 1));

        for(int i = 1; i != m + 1; ++i)
            scanf("%d", p + i);
        while(scanf("%d", &n) != EOF)
        {
            if(n <= m)
            {
                memset(s, -1, sizeof(int) * (m + 1));
                printf("%d: ", rodCut_recursive_up_to_down(p, s, k, m, n));

                while(n)
                    printf("%d ", k[n]), n = n - k[n];
                printf("\n");
            }
        }

        free(p);
        free(k);
        free(s);
    }

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

输入价格表，然后输入切割的长度，输出最优方案，结果如下所示：

以上提供了两种方案，一种是自顶向下的递归，一种是自底向上的递归设计，从代码中我们可以看到两者的区别，自顶向下，是先求解最后的结果，然后递归求解至第一个结果，而自底向上则是先求解第一个结果，直至最后一个结果。

最长公共子序列

最长公共子序列是这样一个问题：有两个字符串S和T，求出两者最长的公共子序列，如以下字符串：

S：ABCBDAB
T：BDCABA

其中的最长公共子序列是 BDAB、BCBA、BCAB等。

令c[i, j]表示从i到j的最长公共子序列，我们可以推导出以下状态转移式：

1. 如果i到达字符串S的长度或j到达字符串T的长度，则最长公共子序列的长度为0
2. 如果S[i] == T[j]，那么最长公共子序列即为后续子序列的最长公共子序列+当前字符长度（1)
3. 如果S[i] != T[j]，那么最长公共子序列即为取S[i]的后续最长公共子序列与取T[i]的后续最长公共子序列的较大者（最后结果中未必有S[i]或T[j]）

根据上述说明，写出的代码如下所示：

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

int LongestCommonSubSequence(char* S, char* T, char** U, int ss, int ts)
{
    if(ss == strlen(S) || ts == strlen(T))
        return 0;
    else if(U[ss][ts] != 0)
        return U[ss][ts];
    else if(S[ss] == T[ts])
    {
        int r = LongestCommonSubSequence(S, T, U, ss + 1, ts + 1);
        U[ss][ts] = r + 1;

        return U[ss][ts];
    }
    else
    {
        int l1 = LongestCommonSubSequence(S, T, U, ss, ts + 1);
        int l2 = LongestCommonSubSequence(S, T, U, ss + 1, ts);

        U[ss][ts] = (l1 >= l2 ? l1: l2);

        return U[ss][ts];
    }

    return 0;
}

int main (void)
{
    int m, n;
    while(scanf("%d %d", &m, &n) == 2)
    {
        char* S = (char*)malloc(sizeof(char) * (m + 1));
        char* T = (char*)malloc(sizeof(char) * (n + 1));
        char** U = (char**)malloc(sizeof(char*) * m);
        for(int i = 0; i != m + 1; ++i)
        {
            U[i] = (char*)malloc(sizeof(char) * (n + 1));
            memset(U[i], (char)0, sizeof(char) * (n + 1));
        }

        scanf("%s", S);
        scanf("%s", T);

        printf("%d\n\n", LongestCommonSubSequence(S, T, U,  0, 0));

        for(int i = 0; i <= m; ++i)
        {
            for(int j = 0; j <= n; ++j)
                printf("%d ", U[i][j]);
            printf("\n");
        }

        int l = 0, r = 0;
        while(U[l][r])
        {
            if(S[l] == T[r])
            {
                printf("%c", S[l]);
                ++l, ++r;
            }else if(U[l][r] == U[l][r + 1])
                ++r;
            else
                ++l;
        }

        printf("\n");

        free(S);
        free(T);

        for(int i = 0; i != m + 1; ++i)
            free(U[i]);
        free(U);
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

输入字符串S和T，ss表示S串的起点，ts表示T串的起点，U记录当前位置的最长公共子序列长度。输出的结果如下所示：

从以上图表可以看到，我们要拿到最长的公共子序列，则需要从【0, 0】点开始遍历表，我们只能往右或往下遍历，如果【i, j】点的两个字符S[i]和T[j]相等，那么我们应该走对角线，如果【i, j】== 【i, j + 1】那么我们应该往右走，否则应该往下走。如以上代码所示。

最大连续子序列和

给定一个整数序列，求其中的一个连续子序列，使其和最大。如给定以下序列：

-2 11 -4 13 -5 -2, 其最大连续子序列和为: 11 -4 + 13 = 20

定义sum[i]为最大子序列和，可以推导出以下状态转移方程：

其实，这个方程，我并不知道是怎么样推导出来的，前面一个好理解，不过为什么要和当前值做比较取较大者，我真的不明白。希望有人能给我指点迷津。根据以上方程，我写出的代码如下所示：

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

int maxSum = 0;
int maxSequenceSum(int* num, int s, int e)
{
    if(s == e)
        return 0;

    int sum = maxSequenceSum(num, s + 1, e) + num[s];

    if(sum > 0)
    {
        if(sum > maxSum)
        {
            maxSum = sum;
            return sum;
        }

        return sum;
    }
    return 0;
}

int main(void)
{
    int m;

    while(scanf("%d", &m) != EOF)
    {
        int* n = (int*)malloc(sizeof(int) * m);

        for(int i = 0; i != m; ++i)
            scanf("%d", n + i);

        maxSum = 0;
        maxSequenceSum(n, 0, m);
        printf("%d\n", maxSum);
        free(n);
    }

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

程序的输出结果，如下图所示：

还有一种更简单的写法：

int MaxSumSubSequence(const int A[], int N)
{
    int ThisSum,MaxSum,j;
    ThisSum = MaxSum =0;
    for(j = 0;j < N;j++)
    {
        ThisSum += A[j];

        if(ThisSum > MaxSum)
            MaxSum = ThisSum;
        else if(ThisSum < 0)
            ThisSum = 0; 
    }
    return MaxSum; 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

这段代码是网上抄的，我一开始真没想到这么写。我的水平还有很大的提升空间。

以上代码本人亲自编写，经本人测试基本无误，也许编写方式和网上流传有所不同，如有错漏，请批评指正。

动态规划这个算法真的实用性很大，可惜我依然是半知半解，之所以厚脸皮写出这篇文章，也是希望有一日能被某个高人碰巧看到这篇拙劣的博文，指点一下我这个苦苦自学，身边没朋友咨询的小弟，在此感谢先。