dp入门题目

本文文旨，如题...

转载请注明出处...

---

HDOJ 1176 免费馅饼

http://acm.hdu.edu.cn/showproblem.php?pid=1176

类似数塔，从底往上推，每次都是从下面三个中选最大的

#include<cstdio>
#include<cstring>
#define MAXN 100005
int dp[MAXN][11];//第i秒第j个位置的馅饼数
int max1(int a,int b)
{
    return a>b?a:b;
}
int max2(int a,int b,int c)
{
    return a>b?(a>c?a:c):(b>c?b:c);
}
int main()
{
    int n,x,t,T;
    while(~scanf("%d",&n))
    {
        if(n==0) break;
        T=0;
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=n;i++)
        {
            scanf("%d%d",&x,&t);
            dp[t][x]++;
            if(T<t) T=t;//时间不一定递增的，找到最大的时间
        }
        for(int i=T;i>=0;i--)//从底往上一层一层的加
        {
            for(int j=0;j<=10;j++)
            {
                if(j==0) dp[i][j]+=max1(dp[i+1][0],dp[i+1][1]);
                else if(j==10) dp[i][j]+=max1(dp[i+1][9],dp[i+1][10]);
                else dp[i][j]+=max2(dp[i+1][j+1],dp[i+1][j],dp[i+1][j-1]);
            }
        }
        printf("%d
", dp[0][5]);//起始位置在5
    }
    return 0;
}

---

HDOJ 4540 威威猫系列故事--打地鼠

http://acm.hdu.edu.cn/showproblem.php?pid=4540

也是数塔，从上往下，从下往上都可以，只不过每次是在下面一层中选最优的

#include<cstdio>
#include<cstring>
int n,k,a[25][15],dp[25][15];
int abss(int a)
{
    return a>0?a:-a;
}
int main()
{
    while(scanf("%d%d",&n,&k)!=EOF)
    {
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=k;j++)
            {
                scanf("%d",&a[i][j]);//第i秒第j个位置有老鼠
            }
        }
        memset(dp,0,sizeof(dp));
        int tmp,cur,ans=1000000;
        for(int i=n-1;i>=1;i--)//从下往上选最优
        {
            for(int j=1;j<=k;j++)
            {
                tmp=1000000;
                for(int m=1;m<=k;m++)
                {
                    cur=abss(a[i][j]-a[i+1][m])+dp[i+1][m];
                    if(cur<tmp)
                    {
                        tmp=cur;
                    }
                }
                dp[i][j]+=tmp;
            }
        }
        for(int i=1;i<=k;i++)//最后在第一层中选出最小的
        {
            if(dp[1][i]<ans)
            {
                ans=dp[1][i];
            }
        }
        printf("%d
", ans);
    }
    return 0;
}

---

HDOJ 1087 Super Jumping！

http://acm.hdu.edu.cn/showproblem.php?pid=1087

各项和最大的LIS

#include<cstdio>
#define MAXN 1010
#define LL long long
LL a[MAXN],dp[MAXN],ans;
int n;
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        if(n==0) break;
        for(int i=0;i<n;i++)
        {
            scanf("%lld",&a[i]);
        }
        for(int i=0;i<n;i++)
        {
            dp[i]=a[i];//dp[i]保存的是到i为止满足题意的和的最大值
        }
        for(int i=0;i<n;i++)
        {
            ans=0;
            for(int j=0;j<i;j++)//在i前面找到一个满足题意的且和最大的
            {
                if(a[i]>a[j]&&dp[j]>ans)
                {
                    ans=dp[j];
                }
            }
            dp[i]+=ans;
        }
        ans=0;
        for(int i=0;i<n;i++)
        {
            if(dp[i]>ans)
                ans=dp[i];
        }
        printf("%lld
", ans);
    }
    return 0;
}

---

HDOJ 1160 FatMouse's speed

http://acm.hdu.edu.cn/showproblem.php?pid=1160

类似LIS，要输出序列，这份代码写的比较搓...

#include<cstdio>
#include<algorithm>
#define MAXN 1010
using namespace std;
struct mouse
{
    int w,s,no,l,pre;//重量、速度、编号、以此老鼠为结尾的满足题意序列的最长长度、在满足题意序列中的前驱(用于输出路径)
};
mouse mice[MAXN],tmp;
bool cmp(mouse a,mouse b)
{
    if(a.w==b.w) return a.s>b.s;
    return a.w<b.w;
}
bool cmp2(mouse a,mouse b)
{
    return a.no<b.no;
}
int main()
{
    int tot=0,cur,k;
    while(scanf("%d%d",&tmp.w,&tmp.s)!=EOF)
    {
        tmp.no=++tot;
        tmp.l=1;
        tmp.pre=tot;
        mice[tot]=tmp;
    }
    sort(mice+1,mice+tot+1,cmp);
    for(int i=1;i<=tot;i++)
    {
        cur=0; k=mice[i].no;
        for(int j=1;j<i;j++)
        {
            if(mice[j].w<mice[i].w&&mice[j].s>mice[i].s&&mice[j].l>cur)
            {
                cur=mice[j].l;
                k=mice[j].no;
            }
        }
        mice[i].l+=cur;
        mice[i].pre=k;
    }
    cur=0;k=0;
    for(int i=1;i<=tot;i++)
    {
        if(mice[i].l>cur)
        {
            cur=mice[i].l;
            k=mice[i].no;
        }
    }
    sort(mice+1,mice+tot+1,cmp2);
    printf("%d
", cur);
    tmp=mice[k];
    int top=-1,print[MAXN];
    for(int i=1;i<=cur;i++)//最后拿个栈输出的
    {
        print[++top]=tmp.no;
        tmp=mice[tmp.pre];
    }
    while(top>-1)
    {
        printf("%d
",print[top--]);
    }
    
}

---

HDOJ 1159 Common Subsequence

http://acm.hdu.edu.cn/showproblem.php?pid=1159

LCS 经典DP

#include<cstdio>
#include<cstring>
#define MAXN 1005
char str1[MAXN],str2[MAXN];
int dp[MAXN][MAXN];
int mmax(int a,int b)
{
    return a>b?a:b;
}
int main()
{
    while(~scanf("%s",str1))
    {
        scanf("%s",str2);
        memset(dp,0,sizeof(dp));
        int n=strlen(str1);
        int m=strlen(str2);
        for(int i=1;i<=n;i++)//按着状态转移方程写就行了，也没什么细节...
        {
            for(int j=1;j<=m;j++)
            {
                if(str1[i-1]==str2[j-1])
                {
                    dp[i][j]=dp[i-1][j-1]+1;
                }else
                {
                    dp[i][j]=mmax(dp[i-1][j],dp[i][j-1]);
                }
            }
        }
        printf("%d
", dp[n][m]);
    }
    return 0;
}

---

HDOJ 1423 Greatest Common Increasing Subsequence

http://acm.hdu.edu.cn/showproblem.php?pid=1423

LCIS 网上方法也很多了 这里贴个O(n^2)的...具体详细解释请看代码注释中的模拟过程...

#include<cstdio>
#include<cstring>
#define MAXN 510
#define REP(i,a,b) for(int i=a;i<b;i++)
int a[MAXN],b[MAXN],dp[MAXN],n,m,T,max;
int main()
{
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        REP(i,0,n) scanf("%d",&a[i]);
        scanf("%d",&m);
        REP(i,0,m) scanf("%d",&b[i]);
        memset(dp,0,sizeof(dp));
        /*看不懂的建议自己先动手模拟一遍
          表面上dp[]是一维的，其实它代表的是dp[i,j]
          1 4 2 6 3 8 5 9 1
          2 7 6 3 5 1
          比如上面这两个序列：
          i=0:把dp[5]置为1,因为有相等的
          i=1:虽然在b[5]时，max=1了，但是b后面并没有4了，所以也没有更新
          i=2:把dp[0]置为1
          i=3:这一步比较关键了，理解了就懂这个算法了 a[3]=6
              j=0时，把max更新为1，这代表在6之前a里面已经有一个2与b里面的匹配了
              所以此时的max=1，如果在b里面2的后面还能找到一个6，那么就把dp[2]置为2
              因为起码有个2 6是公共上升子序列了
          i=4......后面的一步步模拟 到i=6即a[6]=5的时候是最大的3 把dp[4]置为3
          ...最后遍历一遍dp数组找到最大的值即为所求
        */
        REP(i,0,n) {
            max=0;
            REP(j,0,m) {
                if(a[i]>b[j]&&dp[j]>max) max=dp[j];
                if(a[i]==b[j]) dp[j]=max+1;
            }
        }
        max=0;
        REP(i,0,m) if(dp[i]>max) max=dp[i];
        printf("%d
",max);
        if(T) printf("
");
    }
    return 0;
}

---

COJ 1120 病毒

http://122.207.68.93/OnlineJudge/problem.php?id=1120

第八届湖南省赛的题目 裸的LCIS...

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int maxn=1001;
int a[maxn],b[maxn],dp[maxn];
int n,m;
int LICS()
{
    int MAX,i,j;
    memset(dp,0,sizeof(dp));
    for(i=0;i<n;i++)
    {
        MAX=0;
        for(j=0;j<m;j++)
           {
           if(a[i]>b[j] && MAX<dp[j])
               MAX=dp[j];
           if(a[i]==b[j])
               dp[j]=MAX+1;
           }
    }
    MAX=0;
    for(i=0;i<m;i++)
        if(dp[i]>MAX)
         MAX=dp[i];
    return MAX;
}
int main()
{
    int t,i;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        for(i=0;i<n;i++)
          scanf("%d",&a[i]);
        scanf("%d",&m);
        for(i=0;i<m;i++)
            scanf("%d",&b[i]);
        printf("%d
",LICS());
    }
    return 0;
}#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int maxn=1001;
int a[maxn],b[maxn],dp[maxn];
int n,m;
int LICS()
{
    int MAX,i,j;
    memset(dp,0,sizeof(dp));
    for(i=0;i<n;i++)
    {
        MAX=0;
        for(j=0;j<m;j++)
           {
           if(a[i]>b[j] && MAX<dp[j])
               MAX=dp[j];
           if(a[i]==b[j])
               dp[j]=MAX+1;
           }
    }
    MAX=0;
    for(i=0;i<m;i++)
        if(dp[i]>MAX)
         MAX=dp[i];
    return MAX;
}
int main()
{
    int t,i;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        for(i=0;i<n;i++)
          scanf("%d",&a[i]);
        scanf("%d",&m);
        for(i=0;i<m;i++)
            scanf("%d",&b[i]);
        printf("%d
",LICS());
    }
    return 0;
}

---

HDOJ 1257 最少拦截系统

http://acm.hdu.edu.cn/showproblem.php?pid=1257

平常的导弹题是求最多拦多少导弹，就是求出一个最长的不增子序列...

这题问至少要安装多少套系统，其实就是找出最长的严格递增子序列的长度，即LIS

好像有个定理是证这个的，不过手写一个序列模拟一下也能看出来...

给出两个版本吧...一个O(n^2)的 一个O(nlogn)的...具体看代码注释

#include<cstdio>
#include<cstring>
#define MAXN 1005
int a[MAXN],dp[MAXN],n,max;//这个dp[i]存的是以i为结尾的最长递增子序列的长度
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=0;i<n;i++) scanf("%d",&a[i]);
        memset(dp,0,sizeof(dp));
        for(int i=0;i<n;i++)
        {
            max=0;
            for(int j=0;j<i;j++)//转移方程dp[i]=max{dp[j]+1} 其中j要满足的a[i]>a[j]
            {
                if(a[i]>a[j]&&dp[j]>max) max=dp[j];//因为要找到这个最大值 所以从0到i遍历了一遍
            }
            dp[i]=max+1;
        }
        for(int i=0;i<n;i++) max=max>dp[i]?max:dp[i];
        printf("%d
",max);
    }
    return 0;
}

#include<cstdio>
#include<cstring>
#define MAXN 1005
int a[MAXN],dp[MAXN],n;
/*
    这个版本的dp[i]存的就是a中长度为i的递增子序列末尾数的最小值
    比较绕口 给个序列吧：2 1 4 3 5 数组下标从1开始
    a[1]=2 dp[1]=2
    a[2]=1 dp[1]=1
    a[3]=4 dp[2]=4
    a[4]=3 dp[2]=3
    a[5]=5 dp[3]=5
    最终dp更新到第几项 最长长度就是几 而不是dp里面存的数
    更详细的模拟过程可以看这个
    http://www.cnblogs.com/mengxm-lincf/archive/2011/07/12/2104745.html
    二分部分的代码借鉴了这个
    http://www.wutianqi.com/?p=1850
*/
int BSearch(int x,int k)
{
    int low=1,high=k,mid;
    while(low<=high)
    {
        mid=(low+high)>>1;
        if(x>=dp[mid]) low=mid+1;
        else high=mid-1;
    }
    return low;
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;i++) scanf("%d",&a[i]);
        memset(dp,0,sizeof(dp));
        int k=1; dp[k]=a[1];
        for(int i=2;i<=n;i++)
        {
            if(a[i]>dp[k]) dp[++k]=a[i];
            else dp[BSearch(a[i],k)]=a[i];
        }
        printf("%d
",k);
    }
    return 0;
}

---

HDOJ 1025 Constructing Roads In JGShining's Kingdom

http://acm.hdu.edu.cn/showproblem.php?pid=1025

这题也是一个裸的LIS 不过因为n比较大(<=500000) 用n^2的算法妥妥超时(如果出题人没有偷懒的话...)

按照上面写的nlogn的算法写就OK了...

#include<cstdio>
#include<cstring>
#define MAXN 500010
#define REP(i,a,b) for(int i=a;i<b;i++)
#define MEM(a) memset(a,0,sizeof(a))
int a[MAXN],dp[MAXN],n;
int BSearch(int x,int k)
{
    int low=1,high=k,mid;
    while(low<=high)
    {
        mid=(low+high)>>1;
        if(x>=dp[mid]) low=mid+1;
        else high=mid-1;
    }
    return low;
}
int main()
{
    int cases=0,x,y;
    while(~scanf("%d",&n))
    {
        REP(i,1,n+1) {
            scanf("%d%d",&x,&y);
            a[x]=y;
        }
        MEM(dp);
        int k=1; dp[k]=a[1];
        REP(i,2,n+1) {
            if(a[i]>dp[k]) dp[++k]=a[i];
            else dp[BSearch(a[i],k)]=a[i];
        }
        printf("Case %d:
",++cases);
        printf("My king, at most %d road", k);//坑爹啊 road roads傻傻分不清楚
        if(k!=1) printf("s");
        printf(" can be built.

");
    }
    return 0;
}

---

HDOJ 2602 Bone Collector

http://acm.hdu.edu.cn/showproblem.php?pid=2602

01背包 经典动规 给出两种方法吧 一种空间二维的 一种空间一维的

#include<cstdio>
#include<cstring>
#define MAXN 1005
int n,v,c[MAXN],w[MAXN],f[MAXN][MAXN];
int mmax(int a,int b)
{
    return a>b?a:b;
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&v);
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&w[i]);
        }
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&c[i]);
        }
        memset(f,0,sizeof(f));
        for(int i=1;i<=n;i++)//经典动规 f[i][j]表示把i件物品放入容量为j的背包中能获得的最大价值
        {
            for(int j=0;j<=v;j++)//这里j要从0开始，从1开始就WA，这一点我到现在也没理解，各位大神谁看到了给我解释一下...
            {
                if(j>=c[i]) f[i][j]=mmax(f[i-1][j],f[i-1][j-c[i]]+w[i]);//按照转移方程写就OK了
                else f[i][j]=f[i-1][j];
            }
        }
        printf("%d
", f[n][v]);
    }
    return 0;
}

这种一维的比较难理解一点，具体解释全在注释里了...

#include<cstdio>
#include<cstring>
#define MAXN 1005
int n,v,c[MAXN],w[MAXN],f[MAXN];
int mmax(int a,int b)
{
    return a>b?a:b;
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&v);
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&w[i]);
        }
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&c[i]);
        }
        memset(f,0,sizeof(f));
        /*
            状态转移方程是f[j]=max(f[j],f[j-c[i]]+w[i]) 代表背包容量为j的最大价值
            这里f是一维的，但是其实后面max里面的f[j]表示的是f[i-1,j]，要做到这一点需要以j从v到0的逆序方式遍历
            具体怎么理解呢，其实自己模拟一遍是最好的...
            我们知道，实质上01背包问题的状态转移方程是f[i][j]=max(f[i-1][j],f[i-1][j-c[i]]+w[i])
            前面是不放第i件物品的策略，后面是放第i件物品的策略 但是要选择放策略的时候 
            需要的f[i-1][j-c[i]]这个值必须是没有放第i件物品计算出来的值，否则就不是01背包了，
            因为每件物品你都可能放了多件
            只有让j从v到0的遍历方式，才能保证在计算f[j]时用到的f[j-c[i]]是第i-1次的(即没有放第i件物品的)
            比如c[i] 1 2 3 4 5//代价
                w[i] 5 4 3 2 1//价值
            如果j是从0到v的顺序遍历的，则算出来的dp[1]=5 在你算dp[2]的时候，此时调用的
            dp[j]=max(dp[j],dp[j-c[i]]+w[i]) 你会得到dp[2]=dp[2-1]+w[1]=10
            这个结果意味着容量为2的背包最大价值是10，而在01背包中这个值显然应该是4，原因就在于由于顺序遍历
            造成了在计算dp[2]时，放了两件第1件物品 这在01背包中是不允许的
            而采用逆序的方式则可以保证在计算dp[2]的时候，dp[1]还是0(在背包不要求装满的情况下，只要给dp初始化0就行)
            这样就能保证每个物品至多放一次 自己按照逆序模拟一遍就能体会到这个策略的正确性了
            ps：这里多说一句吧，其实按照j从0到v的方式遍历，刚好是另一种背包问题--完全背包的解法，这种背包问题中，
                每个物品都有无限件可选，也就是上面的计算dp[2]得到10才是正确的
                这种策略正确的原因就在于，完全背包问题实质上的转移方程是：
                f[i][j]=max(f[i-1][j],f[i][j-c[i]]+w[i])--也分为两种策略 不放、放，但是放的话可以放无限件
                细细体会吧...
            更多背包问题的资料，请参考《背包九讲》...
        */
        for(int i=1;i<=n;i++)
        {
            for(int j=v;j>=c[i];j--)
            {
                f[j]=mmax(f[j],f[j-c[i]]+w[i]);
            }
        }
        printf("%d
", f[v]);
    }
    return 0;
}

---

HDOJ 4512 吉哥系列故事——完美队形I

http://acm.hdu.edu.cn/showproblem.php?pid=4512

这题出的比较巧妙，可以另搞一个数组是原数组的逆序，然后求LCIS

对于中间点，是奇数时，简单判断一下是否用到了中间点，最后结果是2*k-1 否则就是2*k

具体见代码：

#include<cstdio>
#include<cstring>
using namespace std;
int n,ans,a[201],dp[201];
inline void Max(int &a,const int b){if(b>a) a=b;}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--){
        scanf("%d",&n);
        memset(dp,0,sizeof dp);
        for(int i=0;i<n;i++) scanf("%d",a+i);
        ans=0;
        for(int k=n-1;k>=0;k--){
            int x=a[k],mx=0;
            for(int i=0;i<=k;i++){
                if(a[i]<x) Max(mx,dp[i]);
                else if(a[i]==x) dp[i]=mx+1;
                if(i<k) Max(ans,dp[i]*2);
                else Max(ans,dp[i]*2-1);
            }
        }
        printf("%d
",ans);
    }
    return 0;
}

---

持续更新中...