动态规划题解一

刚开始接触，简单题也写题解了，便于自己更好理解吧
一、连续的
1、最大的连续子序列
普通的

for(int i=1;i<n;i++)//状态转移方程
		dp[i]=max(A[i],dp[i-1]+A[i]);

给出一串数字，求其连续的最大和。因为需要标记这一子序列的开头和结尾，就没用公式写。

也算是分解成小问题，用一个中间量来标记当前这一段的和，如果当前这一段一直大于零，就可以加，否则就换一个开头，然后一直更新最大值。

#include<iostream>
#include<algorithm>
using namespace std;
int maxx(int a[],int n,int &begin,int &end)
{
    int sum=-1000000,x=0,b=1,i=1,k=0;
    
    for(; i<=n; i++)
    {
        if(x>=0)
        {
            x+=a[i];
        }
        else 
        {
            x=a[i];
            b=i;
        }
        if(x>sum)
        {
             begin=b;
             sum=x;
             end=i;
        }
        
    }
     return sum;
}
int main()
{
    int t,n,s=0;
    cin >> t;
    while(t--)
    {
        cin >> n;
        int a[1000005],k=0;
        int sum,begin,end;
        for(int i=1; i<=n; i++)
        {
            cin >> a[i];
        }
        sum=maxx(a,n,begin,end);
        cout << "Case " <<++s<<":"<< endl;
        cout << sum<<' '<<begin<<' '<<end << endl;
        if(t) cout << endl;
    }
    return 0;
}

二、可以间断的子序列
1、最长公共子序列
给出两个字符串，让你比较最长的相同的字符的个数
这是一个二维问题，就需要一个二维的数组来标记，其实就是把行坐标表示成第一段字符串，纵坐标表示成另一端，然后每个小格都比较行列是否相同，相同的话就取这一对角线上上一个值再加一，否则就取上边或者左边的最大值，。他是按照一列一列来比较的，比较抽象，第一次先画个图瞅瞅吧。
一顿操作猛如虎，什么原理也解释不清楚。总之他会一直保存之前步骤求过的每一种情况的个数的情况，下两个比较的时候直接使用前面求过的值来进行加加就可以。

#include<iostream>
#include<algorithm>
#include<string>
using namespace std;
int main()
{
    int t,n,s=0;
    string a,b;
    while(cin >> a>>b)
    {
        int l1=a.length(),l2=b.length();
        int dp[1005][1005]={0};
        int sum,begin,end;
        for(int i=1; i<=l1; i++)
        {
            for(int j=1;j<=l2;j++)
            {
                if(a[i-1]==b[j-1])   dp[i][j]=dp[i-1][j-1]+1;
                else  dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
            }
        }
        cout << dp[l1][l2]<< endl;
    }
    return 0;
}

2、最长上升子序列
给出一串数字，找出它的子序列是严格上升的，并且最长
一般是用二维数组
（1）单纯的子序列
求出最长上升子序列的长度，最基础套路，

memset(b,0,sizeof(b));
b[1]=a[1];
for(int i=2;i<=n;i++)
        {
            for(int j=i-1;j>=1;j--)
            {
                if(a[i]>a[j])   b[i]=max(b[i],b[j]+1);
            }
        }
        sort(b+1,b+1+n);
        cout << b[n] << endl;

（2）外加求出最长上升子序列的和（U题）

for(int i=2;i<=n;i++)
        {
            b[i]=a[i];
            for(int j=i-1;j>=1;j--)
            {
                if(a[i]>a[j])  b[i]=max(b[j]+a[i],b[i]);//同原理，不过转移方程的限定条件改变了
            }
        }

（3）外加求出最长上升子序列的所有对应位置（C题）
稍微有点麻烦，去看另一篇专门的题解吧