[小明学算法]1.动态规划--最长递增子序列问题

一.概念介绍

　　动态规划(Dynamic Programming),简称DP.是把多阶段过程转化为一系列单阶段问题，利用各阶段之间的关系，逐个求解，创立了解决这类过程优化问题的新方法.

二.特点　

　　动态规划算法通常基于一个递推公式及一个或多个初始状态。当前子问题的解将由上一次子问题的解推出。使用动态规划来解题只需要多项式时间复杂度，因此它比回溯法、暴力法等要快许多。

　　在解决问题时,推导出状态转移方程是关键所在.

三.举例

　　1.最少硬币问题

　　待续...

　　2.LCS问题

　　最长公共子序列的长度问题的推导公式为:

　　

　　从公式可知,这个问题可以用递归的方式来实现,代码:

//递归实现方法  LCS(i,j)即公式中的C[i,j]
int LCS(int i, int j)
{
    //第一段
    if (i==lena || j == lenb)
        return 0;

    //第二段
    if (a[i] == b[j])
        return 1 + LCS(i + 1, j + 1);
    else
    {
        //第三段
        int x = LCS(i + 1, j);
        int y = LCS(i, j + 1);
        return x > y ? x : y;
    }
}

　　递归实现虽然好理解,但是存在缺陷,不能记录所有的数据改变的记录,而数据改变的记录可以在长度外,帮助找到子序列.

　　用数组pd代替公式中的二维数组c[i][j],完成上述公式的代码如下:

#include<stdio.h>
#include<iostream>
#include<string.h>
using namespace std;
char a[10], b[10];
int lena, lenb;

void LCS();
int main()
{
    strcpy_s(a, "ABCBDAB");
    strcpy_s(b, "BDCABA");
    lena = strlen(a);
    lenb = strlen(b);

    LCS();

    int a;
    cin >> a;
    return 0;
}
void LCS()
{
    int m = lena, n = lenb;

    //dp[i][j]存储的是a[i]与b[j]的最长公共子序列的长度 即公式中c[i][j]
    int dp[11][11];

    //公式第一段
    dp[0][0] = 0;
    for (int i = 0; i < m; i++)
    {
        for (int j = 0; j < n; j++)
        {
            //如果当前字符相等,公式第二段
            if (a[i] == b[j])
            {
                dp[i + 1][j + 1] = dp[i][j] + 1;
            }
            else
            {
                //如果当前的字符不相等 公式第三段
                dp[i + 1][j + 1] = dp[i + 1][j]>dp[i][j + 1] ? dp[i + 1][j] : dp[i][j + 1];
            }
        }
    }

    cout << dp[m][n];
    cout << endl;
}

　　用数组实现的时候,有一个好处,我们发现了一个规律,相同字符所对应的c[i][j]的赋值一定是它左上侧c[i-1][j-1]的值加一得来的,如下图所示,所以我们通过倒序遍历数组c的赋值过程,可以得到最长自序列.

　　

　　倒序遍历时,我们需要记载当前c[i][j]被赋值时的方向,引入了一个数组来记载c[i][j]的赋值方向.然后倒序遍历则可以得到结果,代码如下:

#include<stdio.h>
#include<iostream>
#include<string.h>
using namespace std;
char a[10], b[10];
int lena, lenb;

int LCS(int, int); ///两个参数分别表示数组a的下标和数组b的下标
void LCS();
int main()
{
    strcpy_s(a, "ABCBDAB");
    strcpy_s(b, "BDCABA");
    lena = strlen(a);
    lenb = strlen(b);

    LCS();

    int a;
    cin >> a;
    return 0;
}

void LCS()
{
    int m = lena, n = lenb;

    //dp[i][j]存储的是a[i]与b[j]的最长公共子序列的长度 即公式中c[i][j]
    int dp[11][11] = { {0} };
    //用来记录赋值的方向
    char dpd[11][11];


    //公式第一段
    dp[0][0] = 0;
    for (int i = 0; i < m; i++)
    {
        for (int j = 0; j < n; j++)
        {
            //如果当前字符相等,公式第二段
            if (a[i] == b[j])
            {
                dp[i + 1][j + 1] = dp[i][j] + 1;
                //记录方向 0是左上
                dpd[i + 1][j + 1] = 0;
            }
            else
            {
                //如果当前的字符不相等 公式第三段
                int t;
                if (dp[i + 1][j]>dp[i][j + 1])
                {
                    t = dp[i + 1][j];
                    //记录方向,1是左边
                    dpd[i + 1][j + 1] = 1;

                }
                else
                {
                    t = dp[i][j + 1];
                    //记录方向,2是上边
                    dpd[i + 1][j + 1] = 2;
                }

                dp[i + 1][j + 1] = t;
            }
        }
    }

    cout << dp[m][n];
    cout << endl;

    while (m>=0&&n >= 0)
    {
        //增加子串  
        if (dpd[m][n] == 0 && dp[m][n] > dp[m - 1][n - 1])
        {
            //可以用堆栈记录下来
            //TODO
            cout << a[m - 1]<<" "<<b[n-1]<<" "<<endl;
        }

        switch (dpd[m][n])
        {
        case 0:
            m--;
            n--;
            break;
        case 1:
            m--;
        case 2:
            n--;
        default:
            break;
        }
    }

}

　　结果:

　　

　　

　　

　　3.递增子序列问题

　　递推公示:length[i]=a[i]>a[0...i-1]?length[i-1]+1:max{length[i-1],1}