1. poj1163
   http://poj.org/problem?id=1163
   数塔
   dp[i][j]=max(dp[i-1][j-1],dp[i-1][j])+a[i][j];

#include <iostream>
#include <cstring>
using namespace std;

int a[105][105];
int dp[105][105];

int main()
{
    int n;
    while(cin>>n)
    {
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=i;j++)
            {
                cin>>a[i][j];
                dp[i][j]=max(dp[i-1][j-1],dp[i-1][j])+a[i][j];
            }
        }
        int ans=-1;
        for(int i=1;i<=n;i++)
        {
            if(ans<dp[n][i])
            ans=dp[n][i];
        }
        cout<<ans<<endl;
    }
    return 0;
}

可以只用一维数组存本次最优解，节省了空间

#include <iostream>
#include <cstring>
using namespace std;

int a[105][105];
int dp[105];

int main()
{
    int n;
    while(cin>>n)
    {
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=i;j++)
            {
                cin>>a[i][j];
            }
        }
        for(int i=1;i<=n;i++)
        dp[i]=a[n][i];
        for(int i=n-1;i>=0;i--)
        {
            for(int j=1;j<=i;j++)
            {
                dp[j]=max(dp[j],dp[j+1])+a[i][j];
            }
        }
        cout<<dp[1]<<endl;
    }
    return 0;
}

1. 最长连续子序列
   hdu1231
   dp[i]是以i结尾的最长连续子序列，
   dp[i]=max(dp[i-1]+a[i],a[i]);

#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;

const int maxn=10005;

int a[maxn];
int dp[maxn];
int pos[maxn];//pos[i],以i结尾序列的起始点
int n;

int main()
{
    while(cin>>n&&n)
    {
        memset(dp,0,sizeof(dp));
        memset(pos,0,sizeof(pos));
        for(int i=0;i<n;i++)
        cin>>a[i];
        int ans=-1;
        for(int i=0;i<n;i++)
        {
            if(dp[i-1]<=0)
            pos[i]=a[i];
            else
            pos[i]=pos[i-1];
            dp[i]=max(a[i],dp[i-1]+a[i]);
            ans=max(ans,dp[i]);
        }
        if(ans<0)
        {
            printf("0 %d %d\n",a[0],a[n-1]);
            continue;
        }
        for(int i=0;i<n;i++)
        {
            if(dp[i]==ans)
            {
                printf("%d %d %d\n",dp[i],pos[i],a[i]);
                break;
            }
        }
    }
    return 0;
}

hdu1003一样，只是记录下标

#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;

const int maxn=100005;

int a[maxn];
int dp[maxn];
int pos[maxn];

int main()
{
    int t;
    scanf("%d",&t);
    for(int cas=1;cas<=t;cas++)
    {
        memset(dp,0,sizeof(dp));
        memset(pos,0,sizeof(pos));
        int n;
        int ans=-100000000;
        scanf("%d",&n);
        for(int i=0;i<n;i++)
        scanf("%d",&a[i]);
        for(int i=0;i<n;i++)
        {
            if(dp[i-1]<0)
            pos[i]=i;
            else
            pos[i]=pos[i-1];
            dp[i]=max(dp[i-1]+a[i],a[i]);
            ans=max(ans,dp[i]);
        }
        for(int i=0;i<n;i++)
        {
            if(ans==dp[i])
            {
                printf("Case %d:\n",cas);
                printf("%d %d %d\n",ans,pos[i]+1,i+1);
            }
        }
        if(cas!=t)
        printf("\n");
    }
    return 0;
}

1. 最长递增子序列
   原文：http://blog.csdn.net/qq_34681949/article/details/52186675
   一.O(n*n)算法，dp[i]表示以ai为末尾的最长上升子序列的长度，而以ai结尾的最长上升子序列有两种：

1.只包含ai的子序列;  2.在满足j<i且aj<ai的以aj为结尾的上升子序列末尾，追加上ai得到的子序列。
所以有如下递推关系：

dp[i]=max{1,dp[j]+1|j<i且aj<ai} 

#include<stdio.h> 
#include<string.h> 
#include<algorithm> 
using namespace std;  
int a[10010];  
int dp[10010];  
int main()  
{  
    int n;  
    while(scanf("%d",&n)!=EOF)  
    {  
        for(int i=0;i<n;i++)  
        {  
            scanf("%d",&a[i]);  
            dp[i]=1;  
        }  
        int ans=0;  
        for(int i=1;i<n;i++)  
        {  
            for(int j=0;j<i;j++)  
            {  
                if(a[j]<a[i])  
                {  
                    dp[i]=max(dp[j]+1,dp[i]);  
                }  
            }  
            ans=max(ans,dp[i]);  
        }  
        printf("%d\n",ans);  
    }  
    return 0;  
 }   

二.O(nlogn)算法，dp[i]=长度为i+1的上升子序列中末尾元素的最小值（不存在的话就是INF）
这种算法中，运用STL中的lower_bound()函数很方便。

#include<stdio.h> 
#include<string.h> 
#include<algorithm> 
using namespace std;  
#define INF 0x3f3f3f 
int dp[10010];//dp[i]表示长度为i+1的子序列末尾元素最小值； 
int a[10010];  
int main()  
{  
    int n;  
    while(scanf("%d",&n)!=EOF)  
    {  
        for(int i=0;i<n;i++)  
        {  
            scanf("%d",&a[i]);  
            dp[i]=INF;//不可以用memset对数组赋值INF,只能赋值0或-1； 
                      //可以用fill(dp,dp+n,INF); 
        }  
        for(int i=0;i<n;i++)  
        {  
            *lower_bound(dp,dp+n,a[i])=a[i];//找到>=a[i]的第一个元素，并用a[i]替换； 
        }  
        printf("%d\n",lower_bound(dp,dp+n,INF)-dp);//找到第一个INF的地址减去首地址就是最大子序列的长度； 
    }  
    return 0;  
}  

hdu1257 最长非递增子序列
http://acm.hdu.edu.cn/submit.php?pid=1257

dp[i]=max(dp[i],dp[j]+1) ( 0<=j

#include <iostream>
#include <cstdio>

using namespace std;

const int maxn=1010;

int a[maxn];
int dp[maxn];

int main()
{
    int n;
    while(scanf("%d",&n)!=-1)
    {
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            dp[i]=1;
        }
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=i;j++)
            {
                if(a[i]>a[j])
                dp[i]=max(dp[i],dp[j]+1);
            }
        }
        int ans=0;
        for(int i=1;i<=n;i++)
        ans=max(ans,dp[i]);
        printf("%d\n",ans);
    }
    return 0;
}

4.最长公共子序列
dp[i,j] = 0 i=0 || j=0
dp[i,j] = dp[i-1][j-1]+1 i>0,j>0, a[i] = b[j]
dp[i,j] = max(dp[i-1][j],dp[i][j-1]) i>0,j>0, a[i] != b[j]

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;

char a[1005],b[1005];
int dp[1005][1005];

int main()
{
    while(cin>>a>>b)
    {
        int len1=strlen(a);
        int len2=strlen(b);
        memset(dp,0,sizeof(dp));
        for(int i=1; i<=len1; i++)
            for(int j=1; j<=len2; 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[len1][len2]<<endl;
    }
    return 0;
}

1. 最长回文子序列
   最长回文子序列 LPS（Longest Palindromic Subsequence），该问题为动态规划的
   经典题目。分析后可以得到该问题的实质如下：
   对任意字符串，如果头和尾相同，那么它的最长回文子序列一定是去头去尾之后
   的部分的最长回文子序列加上头和尾。如果头和尾不同，那么它的最长回文子序
   列是去头的部分的最长回文子序列和去尾的部分的最长回文子序列的较长的那
   一个。
   转化为 DP 的状态转移方程如下：
   设字符串为s，dp[ i ][ j ]表示s[i….j]的LPS；
   状态转移方程：
   当 i > j 时，dp[ i ][ j ]=0；
   当 i = j 时，dp[ i ][ j ]=1；
   当 i < j 且s[ i ] = s[ j ] 时，dp[ i ][ j ] = dp[ i-1 ][ j-1]+2；
   当 i < j 且s[ i ] != s[ j ] 时，dp[ i ][ j ] = max( dp[ i+1][ j ] , dp[ i ][ j-1] )；

时间复杂度O(n*n)，只适合数据较小时，较大时马拉车

#include <iostream>
#include <cstring>
using namespace std;

int dp[400][400];

void LPS(char s[],int len)
{
    for(int i=len-1;i>=0;i--)
    {
        dp[i][i]=1;
        for(int j=i+1;j<len;j++)
        {
            if(s[i]==s[j])
            dp[i][j]=dp[i+1][j-1]+2;
            else
            dp[i][j]=max(dp[i+1][j],dp[i][j-1]);
        }
    }
}
int main()
{
    char s[305];
    while(cin>>s)
    {
        memset(dp,0,sizeof(dp));
        int len=strlen(s);
        LPS(s,len);
        cout<<dp[0][len-1]<<endl;
    }
    return 0;
}