线性结构上的动态规划

先看最长上升子序列：
用DP的思想完全可以解决：
动态规划法

经常会遇到复杂问题不能简单地分解成几个子问题，而会分解出一系列的子问题。简单地采用把大问题分解成子问题，并综合子问题的解导出大问题的解的方法，问题求解耗时会按问题规模呈幂级数增加。

为了节约重复求相同子问题的时间，引入一个数组，不管它们是否对最终解有用，把所有子问题的解存于该数组中，这就是动态规划法所采用的基本方法。

但是时间复杂度是O(n*n);

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int a[1002]={0};
int b[1002]={0};
int main()
{
    int t;
    int n,i,j,m;
    int ans=0,min=0,max=0;
    while(~scanf("%d",&n))
    {
        memset(b,0,sizeof(b));
        for(i=0;i<n;++i)
        {
            scanf("%d",&a[i]);
        }
        b[0]=1;
        for(i=1;i<n;++i)
        {
            b[i]=1;
            max=0;
            //b[i]存储的是一定要包括a[i]的子序列最长的长度
            for(j=i-1;j>=0;--j)
            {
                if(a[j]<a[i])
                    if(b[j]>max)
                        max=b[j];
            }
            b[i]=max+1;
        }
        for(i = 0;i < n;++i)
        {
            printf("%d ",b[i]);
        }
        printf("\n");
        for(i=0;i<n;++i)
        {
            if(b[i]>min)
                min=b[i];
        }
        printf("%d\n",min);
    }
    return 0;
}

有一个时间复杂度为O(n*logn)的算法

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=1e5+5;
int a[maxn],b[maxn],c[maxn];
int main()
{
    int t,n,i,cnt;
    scanf("%d",&n);
        memset(b,0,sizeof(b));
        for(i=cnt=0;i<n;i++)
            scanf("%d",a+i);
        b[cnt++]=a[0],c[0]=1;
        for(i=1;i<n;i++)
        {
            if(a[i]>b[cnt-1])//直接把大于b[cnt - 1]的数加到b数组里面
                b[cnt++]=a[i],c[i]=cnt;
            else
            //总是把较小的数往b数组前面放
            {
                int temp=lower_bound(b,b+cnt,a[i])-b;
                b[temp]=a[i];
                //c[i]代表a[i]这个数放到了第C[i]个位置
                //通过c[i]来找到这个最长上升子序列
                c[i]=temp+1;
            }
        }
        for(i = 0;i < n;++i)
        {
            printf("%d ",b[i]);
        }
        printf("\n");
        for(i = 0;i < n;++i)
        {
            printf("%d ",c[i]);
        }
        printf("\n");
    printf("%d\n",cnt);
    return 0;
}

他变成最长非递减子序列，只需将a[i]>b[cnt-1]改成a[i]>=b[cnt-1]，还有把lower_bound（找到第一个大于等于a[i]的值）改成upper_bound（找到第一个大于a[i]的值）。

最长公共子序列：
用DP求解：经常会遇到复杂问题分解出一系列的子问题。简单地采用把大问题分解成子问题，并综合子问题的解导出大问题的解的方法。
求解：

引进一个二维数组c[][]，用c[i][j]记录X[i]与Y[j] 的LCS 的长度，b[i][j]记录c[i][j]是通过哪一个子问题的值求得的，以决定搜索的方向。
我们是自底向上进行递推计算，那么在计算c[i,j]之前，c[i-1][j-1]，c[i-1][j]与c[i][j-1]均已计算出来。此时我们根据X[i] = Y[j]还是X[i] != Y[j]，就可以计算出c[i][j]。

问题的递归式写成：

回溯输出最长公共子序列过程：

算法分析：
由于每次调用至少向上或向左（或向上向左同时）移动一步，故最多调用(m + n)次就会遇到i = 0或j = 0的情况，此时开始返回。返回时与递归调用时方向相反，步数相同，故算法时间复杂度为Θ(m + n)。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define MAX 10010
char arr1[MAX];
char arr2[MAX];
int b[MAX][MAX];
int c[MAX][MAX];
void LCS()
{
    int n = strlen(arr1);
    int m = strlen(arr2);
    int i,j;
    //边界处理
    memset(b,0,sizeof(b));
    memset(c,0,sizeof(c));
    for(i = 1;i <= n;++i)
    {
        for(j = 1;j <= m;++j)
        {
            if(arr1[i - 1] == arr2[j - 1])
            {
                c[i][j] = c[i - 1][j - 1] + 1;
                b[i][j] = 0;
            }
            else{
                if(c[i - 1][j] >= c[i][j - 1])
                {
                    c[i][j] = c[i - 1][j];
                    b[i][j] = 1;
                }
                else{
                    c[i][j] = c[i][j - 1];
                    b[i][j] = -1;
                }
            }
        }
    }
}
//递归回溯得找到需要找的最长公共子序列
void PrintLCS(int i,int j)
{
    if(i == 0 || j == 0)
        return;
    if(b[i][j] == 0)
    {
        PrintLCS(i - 1,j - 1);
        printf("%c ",arr1[i - 1]);
    }
    else{
        if(b[i][j] == 1)
            PrintLCS(i - 1,j);
        else
            PrintLCS(i,j - 1);
    }
}
int main()
{
    scanf("%s",arr1);
    scanf("%s",arr2);
    LCS();
    PrintLCS(strlen(arr1),strlen(arr2));
    return 0;
}