学习利用动态规划解决若干问题

学习了一下动态规划算法，按正统的描述此类问题应该是具有“最优子结构”和“重叠子问题”的一大类问题，很多地方有非常规范的描述，这里不赘述。

简单的说，我的理解就是：

（1）大的思想是空间换时间

（2）首先分析是否“有规律”，然后定义一个状态，即为一维或二维子结点的状态，这个状态，往往是问题的解，但是也可能是隐含了解的数据，比如，求最长子串时，这个状态就是当前最长子串长度

（3）在定义状态的同时，也要分析转移方程，也叫递推公式，其实就是本结点和前面的那些已经处理过的结点之间，存在什么关系，往往是前面的结点中的最好的与当前结点存在非常特殊的关系。

（4）最后是要分析如何回溯求解，这就要配合转移方程，一般是倒序回溯，从后往前找满足转移方程的前一个结点

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

using namespace std;

int min_of_three(int a, int b, int c)
{
    if(a < b)
        if(a < c)
            return a;
        else
            return c;
    else if(b < c)
        return b;
    else
        return c;
}

int max_of_three(int a, int b, int c)
{
    if(a > b)
        if(a > c)
            return a;
        else
            return c;
    else if(b > c)
        return b;
    else
        return c;
}


int main()
{
    // ① 斐波纳契数列
    // 问题定义：f(0) = 0; f(1) = 1; f(n) = f(n-1) + f(n-2); (n > 1)，输入n，求f(n)
    {
        // 状态定义：a[i] 是当前f(i)
        // 转移方程：a[i] = a[i-1] + a[i-2]
        const int n = 7;
        int* aux = new int[n+1];
        aux[0] = 0;
        aux[1] = 1;
        for (int i = 2; i <= n; i++)
            aux[i] = aux[i-1] + aux[i-2];        // 根据转移方程，求出每一步的状态
        printf(">> 斐波纳契数列问题
");
        printf("n = %d
", n);
        printf("result = %d
", aux[n]);
        delete[] aux;
    }
    // ② 取硬币问题
    // 问题定义：有币值为1、3、5的硬币，数量不限，输入n，求总币值为n时至少需要多少枚硬币
    {
        // 状态定义：a[i] 是当前币值下最小硬币数
        // 转移方程：a[i] = 1 + min(a[i-1]:if(i>1), a[i-3]:if(i>3), a[i-5]:if(i>5))
        const int n = 18;
        int* aux = new int[n+1];
        aux[0] = 0;
        aux[1] = 1;
        for (int i = 2; i <= n; i++)            // 根据转移方程，求出每一步的状态
        {
            if(i < 3)
                aux[i] = aux[i-1]+1;
            else if(i < 5)
                aux[i] = (aux[i-1]<aux[i-3]?aux[i-1]:aux[i-3])+1;
            else
                aux[i] = min_of_three(aux[i-1], aux[i-3], aux[i-5])+1;
        }
        printf(">> 取硬币问题
");
        printf("n = %d
", n);
        printf("result = %d
", aux[n]);

        // O(n)时间找出选择的硬币
        printf("coins are : ");
        for (int i = n, j = n; i >= 0; i--)
        {
            if(aux[j] - aux[i] == 1)
            {
                printf("%d ", j-i);
                j = i;
            }
        }
        printf("
");
        delete[] aux;
    }

    // ③ 最长递增子序列问题
    // 问题定义：在一个字符串序列中，找出一个成递增状态的子序列，如314253，最长递增子序列为：123
    {
        // 状态定义：a[i] = 当前最长子序列长度
        // 转移方程：a[i] = 1+max(a[j]:(s[j]<s[i]),j<i) 
        char* str = "AETBDTCSEEDFJEIFUGHEISDGUYUEGHSJDHDFJSDJFJKESJKJFSJFJLASDKJIWMJIFNVHISYIOSDFPEAQDMRSDYICNSHYUIYUTIIPUSDFEIVASDFWETIAZXETYLALZLQPKDPWQOWI";
        const int n = strlen(str);
        int* aux = new int[n];
        memset(aux, 0, n*sizeof(int));
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < i; j++)
                if ((str[i] > str[j]) && (aux[i] < aux[j]))
                    aux[i] = aux[j];
            aux[i]++;
        }
        int len = 0;
        for (int i = 0; i < n; i++)
            if (aux[i] > len)
                len = aux[i];
        printf(">> 最长递增子序列问题
");
        printf("str = %s
", str);
        printf("result = %d
", len);

        // 回溯数组，找出最长子序列
        printf("substring is : ");
        char* sub = new char[n];
        memset(sub, 0, n);
        for (int i = n-1, j = 0; i >= 0 && len; i--)
            if (aux[i] == len && len)        // 找到满足长度条件，而且递减的下一个字符，存入缓冲区
                sub[--len] = str[i];
        printf("%s
", sub);
        delete[] aux;
        delete[] sub;
    }
    // ④ 最长公共子序列问题
    // 问题定义：两个字符串序列，找出他们公共的子序列中最长的那个，例如41253和42125，最长公共子序列为4125
    {
        // 状态定义：a[i][j] = str1[0:i]与str2[0:j]的最长公共子序列长度
        // 转移方程：a[i][j] = max(a[i-1][j], a[i][j-1], a[i-1][j-1] + 1:if(str1[i] == str2[j]))
        char* str1 = "1208347018256081230951823759028375830182837518END";
        char* str2 = "0827508375812398789738636472734865098127398572396239E0ERND7";
        const int m = strlen(str1);
        const int n = strlen(str2);
        int* aux = new int[m*n];
        memset(aux, 0, m*n*sizeof(int));
        for (int i = 0; i < m; i++)
            for (int j = 0; j < n; j++)
            {                                    // 利用转移方程，计算每一步的最长子序列长度
                if(i == 0 || j == 0)
                    aux[i*n+j] = str1[i]==str2[j]?1:0;
                else
                    aux[i*n+j] = max_of_three(aux[(i-1)*n+j-1] + (str1[i]==str2[j]?1:0), aux[(i-1)*n+j], aux[i*n+j-1]);
            }
        printf(">> 最长公共子序列问题
");
        printf("str1 = %s
str2 = %s
", str1, str2);
        printf("result = %d
", aux[m*n-1]);

        // 回溯矩阵，找出最长公共子序列
        printf("substring is : ");
        int len = aux[m*n-1];
        char* sub = new char[m];
        memset(sub, 0, m);
        int i = m-1;
        int j = n-1;
        while (i&&j&&len)
        {
            while(i && (aux[(i-1)*n+j]==len))    // 找左上角，向上移动
                i--;
            while(j && (aux[i*n+j-1]==len))        // 找左上角，向左移动
                j--;                            
                                                // 到此处时，找到了左上角，锁定一个字符，该字符一定满足str1[i] == str2[j]
            sub[--len] = str1[i];                // 因此可以不写条件：if(str1[i] == str2[j])
            
            i--;j--;                            // 向左上方移动一格
        }
        printf("%s
", sub);
        delete[] aux;
        delete[] sub;
    }
    // ⑤ 格子取数问题
    // 问题定义，有一个m列n行的格子，其中一部分格子中放有数字，只能从左上角开始，向右或下方向移动至右下角，问：如何移动才能使经过的格子中的数之和最大
    {
        // 状态定义：a[i][j] = 从左上角到a[i][j]的最优路径所取数字之和
        // 转移方程：a[i][j] = max(a[i-1][j], a[i][j-1]) + num[i][j]
        const int m = 8;
        const int n = 10;
        int* num = new int[m*n];
        int* aux = new int[m*n];
        srand(time(0));
        for (int i = 0; i < m*n; i++)
            num[i] = (rand()%5 == 0)?rand()%4+1:0;
        
        aux[0] = num[0];
        for (int i = 1; i < m; i++)
            aux[i*n] = aux[(i-1)*n] + num[i*n];
        for (int j = 1; j < n; j++)
            aux[j] = aux[j-1] + num[j];
        for (int i = 1; i < m; i++)
            for (int j = 1; j < n; j++)
                aux[i*n+j] = (aux[(i-1)*n+j]>aux[i*n+j-1]?aux[(i-1)*n+j]:aux[i*n+j-1]) + num[i*n+j];

        printf(">> 格子取数问题
");
        printf("num = 
");
        for (int i = 0; i < m; i++)
        {
            for (int j = 0; j < m; j++)
                printf(" %2d ", num[i*n+j]);
            printf("
");
        }
        printf("
");

        // 回溯数组，找出沿路所取的数字
        printf("the path is : ");
        int sum = aux[m*n-1];
        int* path = new int[m+n];
        memset(path, 0, (m+n)*sizeof(int));
        int i = m-1;
        int j = n-1;
        while (sum)
        {
            while(i && (aux[(i-1)*n+j]==sum))    // 找左上角，向上移动
                i--;
            while(j && (aux[i*n+j-1]==sum))        // 找左上角，向左移动
                j--;                            
            // 到此处时，找到了左上角，再比较哪个数最大
            path[i+j] = num[i*n+j];
            sum -= num[i*n+j];
            if(aux[(i-1)*n+j]==sum)                // 跳到前面一个最优路径上的格子里
                i--;
            else
                j--;
        }
        for (int i = 0; i < m+n; i++)
            if(path[i] != 0)
                printf(" %d ", path[i]);
        printf("
");
        delete[] aux;
        delete[] path;


    }

    system("pause");
    return 0;
}

 输出结果：

>> 斐波纳契数列问题
n = 7
result = 13
>> 取硬币问题
n = 18
result = 4
coins are : 3 5 5 5
>> 最长递增子序列问题
str = AETBDTCSEEDFJEIFUGHEISDGUYUEGHSJDHDFJSDJFJKESJKJFSJFJLASDKJIWMJIFNVHISYIOSDFPEAQDMRSDYICNSHYUIYUTIIPUSDFEIVASDFWETIAZXETYLALZLQPKDPWQOWI
result = 26
substring is : ABCDEFGHIJKLMNOPQRSTUVWXYZ
>> 最长公共子序列问题
str1 = 1208347018256081230951823759028375830182837518END
str2 = 0827508375812398789738636472734865098127398572396239E0ERND7
result = 26
substring is : 20837581239879837583823END
>> 格子取数问题
num =
  0   0   4   0   0   0   2   2
  4   2   0   0   0   0   0   0
  0   3   0   0   0   0   0   0
  0   0   0   0   0   0   0   0
  0   0   0   0   2   0   0   0
  0   0   0   0   0   0   0   0
  0   0   1   0   4   2   0   0
  0   0   0   1   0   1   0   3

the path is :  4  2  3  2  4  2  1  3
请按任意键继续. . .