DP训练

1. HDU 1003 最大和连续子序列

状态方程：dp[i]=max(dp[j-1]+num[i],num[i]);

解：存放dp数组每个元素都是从左至右最大连续子序列的值，即dp[i]为从0～i处最大连续子序列的值

注意边界

#include<stdio.h>
#include<algorithm>
#include<string.h>
using namespace std;
#define N 100005
int dp[N];
int a[N];
int main()
{
    int t;
    while(scanf("%d",&t)!=EOF)
    {
        int c=1,T=t;
        while(t--)
        {
            memset(dp,0,N);
            int n;
            scanf("%d",&n);
            for(int i=1; i<=n; i++)
            {
                scanf("%d",&a[i]);
            }
            dp[1]=a[1];
            for(int j=2; j<=n; j++)
            {
                 dp[j]=max(dp[j-1]+a[j],a[j]);
            }

            int mx=-999999999;
            int st=0,en=0;
            for(int i=1; i<=n; i++)
                if(mx<dp[i])
                {
                    mx=dp[i];
                    en=i;
                }
            st=en;
            int sum=0;
            for(int i=en; i>=1; i--)
            {
                sum+=a[i];
                if(sum==mx)
                {
                    st=i;
                }
            }
            printf("Case %d:\n%d %d %d\n",c,mx,st,en);
            if(c!=T)printf("\n");
            c+=1;
        }
    }
    return 0;
}

 

2. HDU 1087 最大和连续递增子序列

状态方程：v[i]=max(v[i],v[j]+num[i]);//v[j]存放的为最优的递增和加上当前的

解：存放dp数组的每个元素都是从左至右最大和递增子序列的值，即dp[i]为0～i处最优最大和递增子序列的值

例如：五个数 ：5 1 2 4 6

扫描到6时，从第一开始向后扫描，5<6  v[0]=5,num[i]=6,此时v[i]=11,

　　　　　　　　　　　　　　　  1<6  v[1]=1,~~                   v[i]=11

　　　　　　　　　　　　　　　  2<6  v[2]=3~~                    v[i]=11

　　　　　　　　　　　　　　　　4<6 v[3]=7 ~~                  v[i]=13

#include<bits/stdc++.h>
using namespace std;
#define N 1005
int num[N];
int v[N];
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF&&n)
    {
        memset(v,0,sizeof(v));
        for(int i=1; i<=n; i++)
            scanf("%d",&num[i]);

        for(int i=1; i<=n; i++)
        {
            for(int j=1; j<i; j++)
            {
                if(num[i]>num[j])
                    v[i]=max(v[i],v[j]+num[i]);
            }
            v[i]=max(v[i],num[i]);
        }
        int mx=-999999;
        for(int i=1; i<=n; i++)
        {
            mx=max(mx,v[i]);
        }
        printf("%d\n",mx);
    }
    return 0;
}

 

3. 马拦卒过河(动态规划思维)

解：每个位置为上一个与左一个路径之和

#include<bits/stdc++.h>
using namespace std;
#define N 16
int dp[N][N];

void mControl(int x,int y)
{
    int xx[8]= {x-2,x-2,x-1,x-1,x+1,x+1,x+2,x+2};
    int yy[8]= {y-1,y+1,y-2,y+2,y+2,y-2,y+1,y-1};
    for(int i=0; i<8; i++)
        if(xx[i]>=0&&yy[i]>=0&&xx[i]<=15&&yy[i]<=15)
        {
            dp[xx[i]][yy[i]]=-1;
        }
    dp[x][y]=-1;
}
int main()
{
    int bx,by,mx,my;
    while(scanf("%d%d%d%d",&bx,&by,&mx,&my)!=EOF)
    {
        memset(dp,0,sizeof(dp));
        mControl(mx,my);
        dp[0][0]=1;
        for(int i=0; i<=bx; i++)
        {
            for(int j=0; j<=by; j++)
            {
                if(dp[i][j]!=-1)
                {
                    if(dp[i][j-1]!=-1&&j>0)
                        dp[i][j]+=dp[i][j-1];
                    if(dp[i-1][j]!=-1&&i>0)
                        dp[i][j]+=dp[i-1][j];
                }
            }
        }
        printf("%d\n",dp[bx][by]);
    }
    return 0;
}

 

4. HDU 1231 最大和连续子序列（同1，1输出下标，本题是输出值）

#include<bits/stdc++.h>
using namespace std;
int a[100005];
int dp[100005];
int main()
{

    int n;
    while(scanf("%d",&n)!=EOF&&n)
    {
        for(int i=0; i<n; i++)
            scanf("%d",&a[i]);
        dp[0]=a[0];
        for(int i=1; i<n; i++)
        {
            dp[i]=max(dp[i-1]+a[i],a[i]);
        }
        int mx=-9999999;
        int st,en;
        for(int i=0; i<n; i++)
        {
            if(dp[i]>mx)
            {
                mx=dp[i];
                en=i;
            }
        }
        int sum=0;
        for(int i=en;i>=0;i--)
        {
            sum+=a[i];
            if(sum==mx)
            st=i;
        }
        if(mx<0)printf("%d %d %d\n",0,a[0],a[n-1]);
        else
        printf("%d %d %d\n",mx,a[st],a[en]);
    }
    return 0;
}

 

5.HDU 1176 免费馅饼

状态方程：

　　特判:dp[time][0]+=max(dp[time+1][0],dp[time+1][1];

　　　　dp[time][point]+=max(dp[time+1][point-1],dp[time+1][point],dp[time+1][point+1]) //这里没有特判最后一个位置（当位置为10，辉加到11这个位置），只要将数组多一位即可，该位置默认存放的是0，所以不会影响　　

解：用一个二位数组存放dp[time][point],从最后落下的时间向前扫描，每次存放的是 下一秒与当前 该位置能获得的最多的馅饼。

#include<bits/stdc++.h>
using namespace std;
#define N 100005
#define maxx(a,b,c) (max(max(a,b),c))
int dp[N][12];
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF&&n)
    {
        memset(dp,0,sizeof(dp));
        int point,time,maxT=0;
        for(int i=1;i<=n;i++)
        {
            scanf("%d%d",&point,&time);
            dp[time][point]+=1;
            maxT=max(maxT,time);
        }
        for(int i=maxT-1;i>=0;i--)
        {
            dp[i][0]+=max(dp[i+1][0],dp[i+1][1]);
            for(int j=1;j<=10;j++)
            {
                dp[i][j]+=maxx(dp[i+1][j],dp[i+1][j+1],dp[i+1][j-1]);
            }
        }
        printf("%d\n",dp[0][5]);
    }
    return 0;
}

 

6. POJ 1458 最长公共子序列

参考链接：http://blog.csdn.net/u012102306/article/details/53184446

#include<iostream>
#include<string.h>
#include<string>
#include<algorithm>
using namespace std;
#define MAX 1002
int dp[MAX][MAX];
int main()
{
    string a,b;
    int i,j;
    while(cin>>a>>b){
        memset(dp,0,sizeof(dp));
        for(i=0;i<a.length();i++)
            for(j=0;j<b.length();j++)
                if(a[i]==b[j])
                    dp[i+1][j+1]=dp[i][j]+1;
                else
                    dp[i+1][j+1]=max(dp[i][j+1],dp[i+1][j]);
        cout<<dp[i][j]<<endl;
    }
    return 0;
}

#include<stdio.h>
#include<algorithm>
#include<string>
#include<iostream>
using namespace std;
#define N 10005
int dp[N][N];
int main()
{
    string s1,s2;
    while(cin>>s1>>s2)
    {
        int i=s1.length(),j=s2.length();
        for(int i1=0; i1<=i; i1++)
        {
            for(int j1=0; j1<=j; j1++)
            {
                if(i1==0||j1==0)
                    dp[i1][j1]=0;
                else if(s1[i1-1]==s2[j1-1])
                {
                    dp[i1][j1]=dp[i1-1][j1-1]+1;
                }
                else
                {
                    dp[i1][j1]=max(dp[i1-1][j1],dp[i1][j1-1]);
                }
            }
        }
        printf("%d\n",dp[i][j]);
    }
    return 0;
}

 

7. VIJOS 魔族密码 最大递增序列数

#include<cstdio>
#include<algorithm>
#include<string>
#include<string.h>
#include<iostream>
using namespace std;
#define N 2005
int dp[N];
string s[N];
int check(string a,string b)
{
    int len=min(a.length(),b.length());
    for(int i=0; i<len; i++)
        if(a[i]!=b[i])return 0;
    return 1;
}
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF&&n)
    {
        for(int i=0; i<n; i++)
            cin>>s[i];
        memset(dp,0,sizeof(dp));

        for(int i=0; i<n; i++)
        {
            for(int j=0; j<i; j++)
                if(check(s[i],s[j]))
                    dp[i]=max(dp[i],dp[j]+1);
        }
        int ans=-1e8;
        for(int i=0; i<n; i++)
            ans=max(ans,dp[i]);
        cout<<ans+1<<endl;
    }
    return 0;
}

 8. VIJOS 合唱队列 左向右递增，右向左递增*

#include<iostream>
#include<string.h>
#include<algorithm>
#define MAX 105
using namespace std;
int a[MAX],l[MAX],r[MAX];
int main()
{
    int n;
    cin>>n;
    memset(l,0,sizeof(l));
    memset(r,0,sizeof(r));
    for(int i=0; i<n; i++)
        cin>>a[i];
    for(int i=0; i<n; i++)
        for(int j=0; j<i; j++)
            if(a[i]>a[j])
                l[i]=max(l[i],l[j]+1);

    for(int i=n-1; i>=0; i--)
        for(int j=n-1; j>i; j--)
            if(a[i]>a[j])
                r[i]=max(r[i],r[j]+1);
    int ans=-1e8;
    for(int i=0; i<n; i++)
        ans=max(ans,r[i]+l[i]);
    cout<<n-(ans+1)<<endl;
    return 0;
}

 9. VIJOS 小胖的水果 最长公共子序列

#include<iostream>
#include<string.h>
using namespace std;
#define MAX 1005
int dp[MAX][MAX];
string a,b;
int main()
{
    while(cin>>a>>b)
    {
        int alen=a.length();
        int blen=b.length();
        for(int i=0; i<alen; i++)
        for(int j=0; j<blen; j++)
        {
            if(a[i]==b[j])
                dp[i+1][j+1]=dp[i][j]+1;
            else
                dp[i+1][j+1]=max(dp[i][j+1],dp[i+1][j]);
        }
        cout<<alen+blen-dp[alen][blen]<<endl;
    }
    return 0;
}

 10. VIJOS 神秘的咒语 最长递增公共子序列**

#include<iostream>
#include<string.h>
using namespace std;
#define ll long long
#define MAX 505
ll a1[MAX],b1[MAX];
int f[MAX];
int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        int a,b;
        cin>>a;
        for(int i=1; i<=a; i++)
            cin>>a1[i];
        cin>>b;
        for(int i=1; i<=b; i++)
            cin>>b1[i];
        memset(f,0,sizeof(f));
        int ans=0;
        for(int i=1; i<=a; ++i)
        {
            int maxx=0;
            for(int j=1; j<=b; ++j)
            {
                if(b1[j]<a1[i])maxx=max(maxx,f[j]);
                if(b1[j]==a1[i])
                {
                    f[j]=maxx+1;
                    ans=max(ans,f[j]);
                }
            }
        }
        cout<<ans<<endl;
    }
    return 0;
}

 11. VIJOS 难解的问题 最长递增子序列（包含特定项）***

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <vector>
#define Maxn 3200000
using namespace std;
vector<int>v;
int save[Maxn];
int main()
{
    int n = 0, k = 0, knum = 0;
    scanf("%d%d",&n,&k);
    for(int i=1; i<=n; i++)
    {
        scanf("%d",&save[i]);
        if(i==k)
            knum=save[i];
    }
    for(int i=1; i<=n; i++)
    {
        if(i<k&&save[i]>=knum)
            continue;
        if(i>k&&save[i]<=knum)
            continue;
        if(v.size()==0||save[i]>v[v.size()-1])
            v.push_back(save[i]);
        else
        {
            vector<int>::iterator it=lower_bound(v.begin(),v.end(),save[i]);
            *it=save[i];
        }
    }
    printf("%d\n",(int)v.size());
    return 0;
}

 12. VIJOS 雷曼兔 递减最大价值和

#include<iostream>
#include<cstdio>
#include<string.h>
#include<algorithm>
#include<cmath>
using namespace std;
#define INF 0x7fffffff
#define MAX 3002
#define LL long long
struct P
{
    int x,y,h;
} p[MAX];
int dp[MAX];
bool cmp(const P a,const P b)
{
    return a.h<b.h;
}
int main()
{
    int n;
    cin>>n;
    int l = 1;
    for(int i = 1; i <= n; ++i)
        for(int j = 1; j <= n; ++j)
        {
            cin>>p[l].h;
            p[l].x=i;
            p[l].y=j;
            l++;
        }
    sort(p,p+l,cmp);
    dp[1]=0;
    for(int i = 2; i <= n*n; ++i)
    {
        int tem = 0;
        for(int j = 1; j < i; ++j)
        {
            int t = abs(p[i].x-p[j].x)+abs(p[i].y-p[j].y);
            t *= t;
            tem = max( tem,t+dp[j]);
        }
        dp[i] = tem;
    }
    cout<<dp[n*n]<<endl;
    return 0;
}