一些DP经典问题：HDU(hdoj) 2126，1176，2546，1159

    今天开始做DP（动态规划）的题了，按照刘汝佳大叔的话来说，动态规划不是严格意义上的算法，而是一种解决问题的策略。果然，这个叫策略的东西真是变化多样，不过呢还是有一些规律可以寻找的。像网上有许多大牛们总结的背包问题，还是挺不错的。下面贴几道今天刚做的背包转换的问题，还有个入门级的的lcs题。

   第一题：http://acm.hdu.edu.cn/showproblem.php?pid=2126

大意：大家出去旅游，想买纪念品，但是带的钱有限，问问带的钱最多能在N种商品中买几种。给出每件商品的价格，求出有几种方案买到最多的纪念品种类。

虽然没说买几件，但想一下：他是要求种类，不是总题的数量，所以自然想到了0/1背包，但是要求记录种类，所以我们可以多创建个数组Kinds，再每次dp的时候对kinds数组也进行滚动操作，以下给出内存优化0/1背包写法。

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

int dp[500+10],kinds[500+10];//kinds用来记录种类数
int w[500+10];

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int n,k;
        scanf("%d%d",&n,&k);
        for(int i=0;i<n;i++)
            scanf("%d",&w[i]);
        memset(dp,0,sizeof(dp));
        for(int i=0;i<=k+1;i++)
            kinds[i]=1;        //初始值记1，不然结果会全为0的
        for(int i=0;i<n;i++)
        {
            for(int j=k;j>=w[i];j--)
            {
                if(dp[j]==dp[j-w[i]]+1)             //这里是0/1背包的经典决策方式
                    kinds[j]=kinds[j-w[i]]+kinds[j];
                else if(dp[j]<dp[j-w[i]]+1)
                {
                    dp[j]=dp[j-w[i]]+1;             //找到更优解则更新数组
                    kinds[j]=kinds[j-w[i]];
                }
            }
        }
        if(dp[k])
            printf("You have %d selection(s) to buy with %d kind(s) of souvenirs.\n",kinds[k],dp[k]);
        else
            printf("Sorry, you can't buy anything.\n");
    }
    return 0;
}

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

刚开始做成了min的0/1背包，果断错了。。。感觉到了不懂脑筋的后果。

这题大概这么解：总之最后拿5块钱来买最贵的菜maxp元，剩下的m-5块钱在剩下的菜中尽可能地多买，最好用完，然后用总钱数减去5元，再减最贵的就是（m-5-maxp)最少价格了,下面给出代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int dp[1000+10];
int w[1000+10];
int main()
{
    int n;
    while(~scanf("%d",&n)&&n)
    {
        memset(dp,0,sizeof(dp));
        memset(w,0,sizeof(w));
        for(int i=0;i<n;i++)
            scanf("%d",&w[i]);
        sort(w,w+n);
        int maxf=w[n-1],tn=n-1;
        int m;
        scanf("%d",&m);
        if(m<5) printf("%d\n",m);
        else
        {
            int tm=m-5;
            for(int i=0;i<tn;i++)
                for(int j=tm;j>=w[i];j--)
                    dp[j]=max(dp[j],dp[j-w[i]]+w[i]);
            printf("%d\n",m-dp[tm]-maxf);
        }
    }
    return 0;
}

下面这题，类似经典的塔类问题：http://acm.hdu.edu.cn/showproblem.php?pid=2546

采用自底向上的做法，用dp[ i ][ j ]来表示第i个坐标第j秒下落的馅饼数。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#define MAXN 100000+10
using namespace std;

int dp[15][MAXN];
int t=0;
int main()
{
    int n;
    while(~scanf("%d",&n)&&n){
        t=0;
        memset(dp,0,sizeof(dp));
        for(int i=0;i<n;i++){
            int x,tt;
            scanf("%d%d",&x,&tt);
            dp[x+1][tt]++;
            t=max(tt,t);
        }
        for(int i=t-1;i>=0;i--)
            for(int j=1;j<=11;j++)
                dp[j][i]+=max(dp[j][i+1],max(dp[j+1][i+1],dp[j-1][i+1]));
        printf("%d\n",dp[6][0]);
    }
    return 0;
}

最后一题是最长公共子序列问题，我还在研究怎么输出来这个最长串：

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

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

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

int dps(int len1,int len2,char a[],char 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]);
            }
        }
    }
    return dp[len1][len2];
}


int main()
{
    while(~scanf("%s%s",a,b)&&strlen(a)){
        int len1=strlen(a);
        int len2=strlen(b);
        printf("%d\n",dps(len1,len2,a,b));
    }
    return 0;
}

继续学习DP ！