dp之背包总结篇

前言：背包问题在dp中可以说是经典，作为一个acmer，到现在才正式学习dp，可以说是比较失败的。我个人比较认同一点，想要做一个比较成功的acmer，dp、搜索、数学必须精练，比较遗憾的是，对我我自身而言，并没有早早的认识到这个问题，不过现在知道了，还有一年，也不算晚。还有，我建议学背包的童鞋，都看背包九讲......

dp之01背包

01背包，做为背包中最基础的一类背包，必须要掌握好，当然我这里说的掌握好，并不是说，你横扫hdu或者poj等oj上01背包模板题就可以的，记得很久以前，刚开始做背包问题，一天在hdu水了七八道，就自以为背包就是个模板，唉，真心不知道当时的自己是有多肤浅..........

01背包的动态转移方程，背包九讲上有详细的讲解，这里不再复述，就想说下，一维的和二维的转移方程都需要深刻理解，不要觉得任何时候01背包都可以转化为1维的数组

dp[i][j]=max(dp[i-1][j],dp[i-1][j-v[i]]+val[i]);

dp[j]=max(dp[j],dp[j-v[i]]+val[i]);

此外，还想说下，01背包为什么体积要从v---0？这个问题，背包九讲上是说可以每件物品只拿一次，恩，我觉得可以自己推推，这样理解会更加深刻.......

1、UVA624（记录路径问题）

总得来说，不管是01背包还是完全背包，其动态转移每次只有两种状态在转移，就说这道题目，

dp[i][j]=max(dp[i-1][j],dp[i-1][j-v[i]]+val[i])    对于dp[i][j]来说，它只能使由两个状态中的一个转移过来的，要么取一件，要么不取，那么我们再开一个二维数组s[i][j]，0表示不取，1表示取，那么不取是dp[i-1][j]，取是dp[i-1][j-v[i]]+val[i]；这样，数组s[i][j]就记录下了每次动态转移的方向，在递归调用，打印路径，结果就出来了，具体可以看http://www.cnblogs.com/ziyi--caolu/archive/2013/04/10/3012578.html

2、UVA562（平分钱币问题）

题目大意：给定n个硬币，要求将这些硬币平分以使两个人获得的钱尽量多，求两个人分到的钱最小差值。

这类问题的关键就在平衡，而就这到题目而言，01背包本身求的就是在体积小于等于sum的情况下的最大值，那么这些硬币本身既当体积又当价值，把总价值求出来/2，再套用模板......可以说比较水的平衡问题，具体看：http://www.cnblogs.com/ziyi--caolu/archive/2013/04/10/3012755.html

3、组成n块钱，有多少种的问题

这类题目，一般是这样描述的：给你n块钱，有m种钱币，每种钱币只能用一次，问组成n块钱有多少种方法........

对于这类题目，我更多的感受是觉得是到递推题，其实，有好多的dp都是一个递推，然后记录更新状态的过程，要组成dp[j],那么假设有一个5快的钱币，那么首先要判断dp[j-5]有没有组成，这里我比较喜欢用0表示没有这个状态，>0表示这个状态存在，那么在初始化dp数组的时候，dp[0]=1；然后套用背包模板，其动态转移方程（倒不如说递推式）为dp[j]+=dp[j-5]；

  上面是常规题目，下面为01背包的变种题：

4、poj2184（两个属性最大和，平移问题）

题意：给定两个属性,求这两个属性的和的最大值.........

思路：对于这种题目，我们可以尝试将一个属性当作容量，另一个属性当作价值，然后考虑dp.......这个题目属性还可以是负数，那么可以采取平移1000个单位，使其不存在负数问题。将第一个属性往后平移1000个单位，然后推导其动态转移方程，若是dp[i]，代表当加入第一个属性加到i时，符合题意的第二个属性的最大值......题意是两个属性的和的最大值，那么动态转移方程必然不是dp[j]=max(dp[j],dp[j-s[i][0]]+s[i][1]），因为这个动态转移方程固然可以求出第二个属性的最大值，但别忘了题意要求第一个属性与第二个属性的和的最大值，那么，第一个属性平移了1000个单位，在考虑动态转移时，是必须要将这个考虑进去的。可以开一个a数组记录路径，然后根据题意，
动态转移方程应该为dp[j]=max(dp[j]-a[j]*1000,dp[j-s[i][0]]+s[i][1]-(a[j-s[i][0]]+1)*1000),一开始a数组全部赋值为0，所以需要a[j-s[i][0]]+1.....因为它新加入了一个值。考虑这个方程，dp数组的初始全部赋值为负无穷大，dp[0]=0。

注意一点，在历遍查找最大值的时候，dp[i]>0,i-a[i]*1000>0

#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std; 
#define maxx 1000005
int s[maxx][2],dp[maxx],a[maxx];
int main()
{
    int n;
    while(scanf("%d",&n)>0)
    {
        int sum=0;
        for(int i=1;i<=n;i++)
        {
            scanf("%d %d",&s[i][0],&s[i][1]);
            if(s[i][0]<0&&s[i][1]<0)
            {
                i--;
                n--;
                continue;
            }
            s[i][0]+=1000;
            sum+=s[i][0];
        }
        memset(a,0,sizeof(a));
        for(int i=0;i<=sum;i++)
        dp[i]=-maxx;
        dp[0]=0;
        for(int i=1;i<=n;i++)
        {
            for(int j=sum;j>=s[i][0];j--)
            if(dp[j]-a[j]*1000<dp[j-s[i][0]]+s[i][1]-(a[j-s[i][0]]+1)*1000)
            {
                dp[j]=dp[j-s[i][0]]+s[i][1];
                a[j]=a[j-s[i][0]]+1;
            }
        }
        int maxn=0;
        for(int i=1;i<=sum;i++)
        if(maxn<dp[i]-a[i]*1000+i&&dp[i]>=0&&i-a[i]*1000>=0)
        maxn=dp[i]-a[i]*1000+i;
        printf("%d\n",maxn);
    }
    return 0;
}

 5、hdu2639（第k优解问题）

题意：给出一行价值，一行体积，让你在v体积的范围内找出第k大的值.......（注意，不要 和它的第一题混起来，它第一行是价值，再是体积）

思路：首先dp[i][j]代表的是在体积为i的时候第j优解为dp[i][j]......那么，我们就可以这样思考，i对应体积，那么如果只是一维的dp[i]，代表的应该是体积为i时的最大值，那么同理，dp[i][1]代表的是体积为i时的最大值，那么我们就可以退出两种动态，dp[i][m],dp[i-s[i][0]][m]+s[i][1].....然后把这两种状态开个两个数组分别保存起来，再合并出体积为i时的前k优解......依次后推，直到dp[v][k].......

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<queue>
using namespace std;
#define max(x,y) x>y? x:y
typedef int ss;
ss dp[1005][100],s[1005][2];
ss a[50],b[50];
 
int main()
{
    int text;
    scanf("%d",&text);
    while(text--)
    {
        ss n,v,k;
        scanf("%d%d%d",&n,&v,&k);
        for(ss i=1;i<=n;i++)
        scanf("%d",&s[i][1]);
        for(ss i=1;i<=n;i++)
        scanf("%d",&s[i][0]);
        memset(dp,0,sizeof(dp));
        if(k==0)
        {
            printf("0\n");
            continue;
        }
        for(int i=1;i<=n;i++)
        {
            for(int j=v;j>=s[i][0];j--)
            {
                for(int m=1;m<=k;m++)
                {
                    a[m]=dp[j][m];
                    b[m]=dp[j-s[i][0]][m]+s[i][1];
                }
                int x=1,y=1,w=1;
                a[k+1]=b[k+1]=-1;  //这个地方要注意，因为有可能a或者b数组先比较完 
                 
                while(w<=k&&(x<=k||y<=k))
                {
                    if(a[x]>b[y])
                    {
                        dp[j][w]=a[x++];
                    }
                    else 
                    {
                        dp[j][w]=b[y++];
                    }
                    if(w==1||dp[j][w]!=dp[j][w-1])       //这是去重..... 
                    w++;
                    //printf("111\n");
                }
            }
             
        }
        //for(int i=1;i<=k;i++)
    printf("%d\n",dp[v][k]);
    }
    return 0;
} 

 6、hdu3644（带限制的01背包）

题意：买东西，每个东西有三个特征值，p代表价格，q代表你手中钱必须不低于q才能买这个物品，v代表得到的价值。

mark：又是变种01背包，每做一个变种的，就是一种提高。。

按照q - p以由大到小的顺序排序，然后进行01背包的DP即可。

 

#include<stdio.h>
#include<algorithm>
#include<iostream>
using namespace std;
const int MAXN=5005;
int dp[MAXN];
struct Node
{
    int p,q,v;
}node[505];
bool cmp(Node a,Node b)
{
    return  (a.q-a.p)<(b.q-b.p);
}    
int main()
{
    int n,m;
    int i,j;
    int p,q,v;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        for(i=0;i<=m;i++)
          dp[i]=0;
        for(i=0;i<n;i++)
        {
            scanf("%d%d%d",&node[i].p,&node[i].q,&node[i].v);
        }    
        sort(node,node+n,cmp);
        for(i=0;i<n;i++)
        {
            for(j=m;j>=node[i].p;j--)
            {
                if(j>=node[i].q)
                  dp[j]=max(dp[j],dp[j-node[i].p]+node[i].v);
            }    
        }
        int ans=0;
        for(i=1;i<=m;i++)
          if(ans<dp[i])  ans=dp[i];
        printf("%d\n",ans);
               
    }    
    return 0;
}

 

 dp之完全背包

完全背包较之01背包，唯一区别就是01背包的物品每个只能取一次，而完全背包可以取无限次

dp[i][j]=max(dp[i-1][j],dp[i][j-v[i]]+val[i])

dp[j]=max(dp[j],dp[j-v[i]]+val[i])；

1、poj3181（高精度背包）

这道题目要用到大数加法，其他的没有什么难度，当然，你的大数加法如果写的比较挫，是会超时的......解题报告：http://www.cnblogs.com/ziyi--caolu/p/3211091.html

2、poj1787（多重背包转化为完全背包，以及路径记录   推荐）

题意：有四种硬币，1分，5分，10分，25分，分别有a,b,c,d种，给出一个n分钱，要求你求出组成n分钱最多需要的硬币数量，并且输出组成它的各种硬币的数量......

学到的东西：这个题目我是用两种方法做的，一个是完全背包，一个是多重背包。做完这个题目，我对背包的理解可以说上了个层次......还有记录路径的方法，反过来求出各个硬币的数量，都是我以前做的题目没有涉及到的.......

要求出各个硬币有多少种，只需要记录路径，在开一个数组统计p-path[p]，为什么可以如此？很容易想到path[p]=p-v[i]

如此，p-path[p]==p-(p-v[i])==v[i]，而v[i]正好是硬币的价值........这道题目令我思考到一个东西，一般的背包问题的初始值都是将dp全部赋值为0的，而在这边dp[0]==1，并且在动态转移的过程中，还限制了dp[j]>0才可以转移，与背包的模板的动态转移不同啊？为什么要这样呢？

在一般的dp题目里面，有体积，价值，所要求的不是最大价值就是最小价值，而定义的dp[i][j]意义是装有i件物品，体积为j的最大值为dp[i][j]，简化为一维的dp[j]代表的是在体积为j的时候最大价值为dp[j]。仔细观察，可以发现，在dp[j-v[i]]时，dp[j]本身就可以从dp[j-v[i]]那边得到值，因为dp[j-v[i]]这个地方，它可以组成dp[j]......也就是说，它不需要去判断在dp[j-v[i]]前面是否有数可以组成dp[j-v[i]]，因此dp[j-v[i]]为不为0，不影响最终结果......

而这个题目却不同，需要赋值dp[0]=1；在动态转移的时候还得保证dp[j-v[i]]>0，这是因为题意是要求组成n分钱需要的最多硬币数量，那么你要可以组成dp[n]，dp[n-v[i]]必须要可以组成，否则就会出错.......同理，这道题目原理如此，在做给出n分钱，每种钱币有a,b,c,.....种，求组成n分钱最多的种数，也是要赋值dp[0]=1的，原理是一样的........

这告诫我，在做dp题目时，要仔细思考好其前后的关系，以及中间推导至最后的关系.....

#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
int dp[10010],ans[10010],num[10010],path[10010];
int p,c[5]={0,1,5,10,25},t[5];
int main()
{
    while(scanf("%d %d %d %d %d",&p,&t[1],&t[2],&t[3],&t[4])>0&&(p+t[1]+t[2]+t[3]+t[4]))
    {
        memset(dp,0,sizeof(dp));
        memset(ans,0,sizeof(ans));
        memset(path,0,sizeof(path));
        dp[0]=1;
        for(int i=1;i<=4;i++)
        {
            memset(num,0,sizeof(num));
            for(int j=c[i];j<=p;j++)
            if(dp[j-c[i]]&&dp[j-c[i]]+1>dp[j]&&num[j-c[i]]<t[i])   //一般来说，完全背包的硬币是没有限制的，后一个数必然可以由前面的某个数组成，所以也就不需要dp[j-c[i]]>0，<br>但是，这次用到的完全背包其硬币数受到了限制，也就导致有些数根本不可能组成，所以要把这些数排除 
            {
                dp[j]=dp[j-c[i]]+1;
                num[j]=num[j-c[i]]+1;
                path[j]=j-c[i];
            }
        }
        int i=p;
        if(dp[p]>0)
        {
            while(i!=0)
            {
                ans[i-path[i]]++;
                i=path[i];
            }
            printf("Throw in %d cents, %d nickels, %d dimes, and %d quarters.\n",ans[1],ans[5],ans[10],ans[25]);
        }
        else  printf("Charlie cannot buy coffee.\n");
    }
    return 0;
}

 

二进制转化为01背包：
#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
struct node
{
    int num;
    int cout;
    int dw;
}w[20001];
int dp[20001],c[5]={0,1,5,10,25},t[5],path[20001][2],ans[20001];
int p;
int main()
{
    while(scanf("%d%d%d%d%d",&p,&t[1],&t[2],&t[3],&t[4])>0&&(p+t[1]+t[2]+t[3]+t[4]))
    {
        int cnt=0;
        for(int i=1;i<=4;i++)
        {
            int k=1;
            while(t[i]-k>0)
            {
                w[cnt].num=k*c[i];
                w[cnt].cout=k;
                w[cnt++].dw=c[i];
                t[i]-=k;
                //if(i==1)
                //printf("%d\n",w[cnt-1].dw);
                k*=2;
            }
             
            w[cnt].num=t[i]*c[i];
            w[cnt].cout=t[i];
            w[cnt++].dw=c[i];
            //if(i==1)
            //    printf("%d\n",w[cnt-1].dw);
        }
        memset(dp,0,sizeof(dp));
        memset(path,0,sizeof(path));
        memset(ans,0,sizeof(ans));
        dp[0]=1;
        for(int i=0;i<cnt;i++)
        {
            for(int j=p;j>=w[i].num;j--)
            if(dp[j-w[i].num]>0&&dp[j]<dp[j-w[i].num]+w[i].cout)  //多重背包的二进制拆分其原理就是转化成01背包来处理，而01背包是从n推导至0，在i==1时，dp[n-w[i].num]+w[i].cout>dp[n]除非w[i].cout==0，否则就是必然的，但是同时，你要可以组成dp[n]，那么你首先要可以组成dp[n-w[i].num]，那么也就是说dp[n-w[i].num]必须要>0，才可以进行动态转移 
            {
                dp[j]=dp[j-w[i].num]+w[i].cout;
                //printf("%d %d %d %d\n",w[i].num,w[i].dw,w[i].cout,dp[j]);
                path[j][0]=j-w[i].num;
                path[j][1]=i;
            }
        }
        //printf("%d\n",dp[p]);
        if(dp[p]!=0)
        {
            while(p!=0)
            {
                int tmp=p-path[p][0];
                int j=path[p][1];
                ans[w[j].dw]+=w[j].cout;
                p=path[p][0];
            }
             printf("Throw in %d cents, %d nickels, %d dimes, and %d quarters.\n",ans[1],ans[5],ans[10],ans[25]);
        }
        else printf("Charlie cannot buy coffee.\n");
    }
    return 0;
}

 3、poj2063题意：求投资k年获得最大投资，每年都选最大利息的方案进行投资k年后就可以得到最多的人民币。
注意：每一年收到的利息都可以作为下一年的本金......其实从测试数据来看，是很好看出来的......
思路：将每一年的“体积”加上利息就好，当然，数据太大，可以除以100减少时间和空间复杂度......
解题报告：http://www.cnblogs.com/ziyi--caolu/p/3214100.html
 
dp之多重背包
 
1、hdu1114（水题）
2、hdu1059
题意：价值为1，2，3，4，5，6. 分别有n[1],n[2],n[3],n[4],n[5],n[6]个。求能否找到满足价值刚

好是所有的一半的方案。  思路：简单的多重背包，我建议多重背包都用二进制拆分优化下........ 解

题报告：http://www.cnblogs.com/ziyi--caolu/p/3216818.html
 
3、poj1217
题意：有现今cash，和n种钱币，每种钱币有ni个，价值为di，求各种钱币组成的不超过cash的最大钱数

.......

思路：二进制拆分转化为01背包，或者转化为完全背包都是可以的。

解题报告：http://www.cnblogs.com/ziyi--caolu/p/3216827.html

4、poj2392(推荐)

题意：有k种石头，高为hi，在不超过ai的高度下，这种石头可以放置，有ci种这个石头，求这些石头所能放置的最高高度.........

思路：以往的什么硬币种数，最大硬币数之类的，他们的硬币都已经是排好序了的，总是从小到大，但是这个题目不同，它有着最高高度的限制，那么在思考的时候，要得到最优的，那么首先就是要对ai排序......这是贪心，然后就是多重背包了........

 

#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<string.h>
using namespace std;
struct node
{
    int h;
    int a;
    int c;
}s[500];
int dp[50000],num[41000];
int cmp(const node p,const node q)
{
    return p.a<q.a;
}
int main()
{
    int n;
    while(scanf("%d",&n)>0)
    {
        int maxx=0;
        for(int i=1;i<=n;i++)
        {
            scanf("%d %d %d",&s[i].h,&s[i].a,&s[i].c);
            if(maxx<s[i].a)
            maxx=s[i].a;
        }
        sort(s+1,s+1+n,cmp);
        memset(dp,0,sizeof(dp));
        dp[0]=1;
        for(int i=1;i<=n;i++)
        {
            memset(num,0,sizeof(num));
            for(int j=s[i].h;j<=maxx;j++)
            if(dp[j-s[i].h]&&dp[j-s[i].h]+s[i].h>dp[j]&&dp[j-s[i].h]+s[i].h-1<=s[i].a&&num[j-s[i].h]<s[i].c)
            {
                dp[j]=dp[j-s[i].h]+s[i].h;
                //printf("%d %d\n",dp[j],s[i].h);
                num[j]=num[j-s[i].h]+1;
                //if(dp[j]==37)
                //printf("%d\n",num[j]);
            }
        }
        int maxn=0;
        for(int i=0;i<=maxx;i++)
        if(maxn<dp[i])
        maxn=dp[i];
        printf("%d\n",maxn-1);
    }
    return 0;
}

 

多维背包 

1、hdu4501

 

思路：将v1,v2，k都当作一种体积，每种物品只能取一次，求max.......

 

反思：以前写背包，由于只有一个体积，所以习惯性的在for中，就所取的最小值限制，而在这次，因为这里导致wa了，具体是因为在多个体积限制的背包里，当这个体积小于它的最小体积时，它可以不去减它的最小体积，而是作为一种状态来传递其他体积的限制的值.......

解题报告：http://www.cnblogs.com/ziyi--caolu/p/3217151.html

2、hdu2159

解题报告：http://www.cnblogs.com/ziyi--caolu/p/3222683.html

3、hdu3496

题意：给你n张电影门票，但一次只可以买m张，并且你最多可以看L分钟，接下来是n场电影，每一场电影a分钟，b价值，要求恰好看m场电影所得到的最大价值，要是看不到m场电影，输出0；

思路：这个题目可以很明显的看出来，有两个限制条件，必须看m场电影的最大价值........其实我前面在01背包时提过，对于这样的条件，要可以看第n场电影，那么相对应的第n-1场电影必须看了，否则不能进行动态转移.......我的想法是，0代表着这场电影没有看，>0代表这场电影看了。其他的就是动态转移了，很容易得到，dp[i][j]=max(dp[i][j],dp[i-1][j-v[i]]+val[i])........当然，在最开始的dp[0][0]=1，那么得到的最大值会在第m场电影里面，最大值需要减去初始值........也就是1

#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
int dp[105][1005],s[105][2];
int max(int x,int y)
{
    if(x>y)
    return x;
    else
    return y;
}
int main()
{
    int text;
    scanf("%d",&text);
    while(text--)
    {
        int N,M,L;
        scanf("%d %d %d",&N,&M,&L);
        for(int i=1;i<=N;i++)
        scanf("%d %d",&s[i][0],&s[i][1]);
        memset(dp,0,sizeof(dp));
        dp[0][0]=1;
        for(int i=1;i<=N;i++)
        {
            for(int j=M;j>=0;j--)
            {
                for(int k=L;k>=0;k--)
                {
                    if(k>=s[i][0]&&j>0&&dp[j-1][k-s[i][0]]&&dp[j][k]<dp[j-1][k-s[i][0]]+s[i][1])
                    {
                        dp[j][k]=dp[j-1][k-s[i][0]]+s[i][1];
                    }
                }
            }
        }
        int i,maxn=0;
        for(i=0;i<=L;i++)
        if(dp[M][i]>maxn)
        maxn=dp[M][i];
        if(maxn==0)
        printf("0\n");
        else
        printf("%d\n",maxn-1);
    }
    return 0;
}

 4、poj2576(推荐)

题意：有一群sb要拔河，把这群sb分为两拨，两拨sb数只差不能大于1，输出这两拨人的体重，小的在前面......

思路：把总人数除2，总重量除2，之后你会发现就是个简单的二维背包，有两个限制.....一个是人数，一个是体重，再仔细思考下，发现一定要有这么多人，也就是说一定要有总人数除以2这么多人，那么当第n个人存在，第n-1个人必须存在.........

#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
int dp[55][23000],a[105];
int main()
{
    int n;
    while(scanf("%d",&n)>0)
    {
        int m=(n+1)/2,sum=0,maxx=0;
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            sum+=a[i];
        }
        if(n==1)
        {
            printf("0 %d\n",a[1]);
            continue;
        }
        memset(dp,0,sizeof(dp));
        dp[0][0]=1;
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                for(int k=sum/2;k>=0;k--)
                {
                    if(j>0&&k-a[i]>=0&&dp[j-1][k-a[i]]&&dp[j][k]<dp[j-1][k-a[i]]+a[i])
                    dp[j][k]=dp[j-1][k-a[i]]+a[i];
                    //printf("%d\n",dp[j][k]-1);
                    if(maxx<dp[j][k])
                    maxx=dp[j][k];
                }
            }
        }
        maxx--;
        //printf("%d\n",maxx);
        int tmp=sum-maxx;
        if(tmp<maxx)
        {
            int h=tmp;
            tmp=maxx;
            maxx=h;
        }
        printf("%d %d\n",maxx,tmp);
    }
    return 0;
}

 5、poj1837（天平问题  推荐）

题意：给你c（2<=c<=20）个挂钩，g（2<=g<=20）个砝码，求在将所有砝码（砝码重1~~25）挂到天平(天平长  -15~~15)上，并使得天平平衡的方法数.......

思路：（这是我木有想到的）将g个挂钩挂上的极限值：15*25*20==7500

那么在有负数的情况下是-7500~~7500   以0为平衡点......

那可以将平衡点往右移7500个单位，范围就是0~~15000......这样就好处理多了

其实我觉得以后的题目中不仅仅天平问题可以这样处理，在有负数的以及要装入数组处理的题目中，我们都可以尝试着平移简化问题......

这题目是要将所有的砝码都挂到天平上后的最多方法数，同时砝码自带质量，也就是说，这不仅仅有着“容量”的限制，还有着“件数”的限制，很明显的二维费用背包......

每个砝码只能用一次，果断01背包，并且在处理这一状态前，先判断前一状态是否存在......我喜欢用>0表示存在，用0表示不存在，而这个题目又是求方法数，不需要再减去1........

#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
int dp[25][16000],s[25],t[25];
int main()
{
    int n,m;
    while(scanf("%d %d",&n,&m)>0)
    {
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&s[i]);
        }
        for(int i=1;i<=m;i++)
        scanf("%d",&t[i]);
        memset(dp,0,sizeof(dp));
        dp[0][7500]=1;
        int sum=0;
        for(int i=1;i<=m;i++)             //m个砝码 
        {
            for(int j=15000;j>=1;j--)    //01背包，每个砝码只能用一次 
            for(int k=1;k<=n;k++)
            if(j+s[k]*t[i]>=0&&j+s[k]*t[i]<=15000&&dp[i-1][j+s[k]*t[i]])   //判断前一状态是否存在........ 
            {
                dp[i][j]+=dp[i-1][j+s[k]*t[i]];
                //printf("j==%d   dp==%d   %d\n",j,dp[i][j],j+s[k]*t[i]);
            }
            //sum++;
        }
        printf("%d\n",dp[m][7500]);
    }
    return 0;
}

 分组背包

1、hdu1712

 

题意：有n门课程，和m天时间，完成a[i][j]得到的价值为第i行j列的数字，求最大价值......

 

思路：分组背包，就是第n门课程，可以做一天，可以做两天，但它们相斥，你做了一天，就不能再做一天...也就是不能再做这门课程了......

 

 

当然这是最多取一个的算法.......

#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
int dp[150],a[150][150];
int main()
{
    int n,m;
    while(scanf("%d%d",&n,&m)>0&&(n+m))
    {
        for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
        scanf("%d",&a[i][j]);
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=n;i++)      分成n组 
        {
            for(int j=m;j>=1;j--)         体积 
            {
                for(int k=1;k<=m;k++)       第i组内的各个数据 
                if(j-k>=0&&dp[j]<dp[j-k]+a[i][k])
                dp[j]=dp[j-k]+a[i][k];
            }
        }
        printf("%d\n",dp[m]);
    }    
    return 0;
} 

 2、hdu3033(最少取一次   推荐)

题意：有n双鞋子，m块钱，k个品牌，（一个品牌可以有多种价值不同的鞋子），接下来n种不同的鞋子，a为所属品牌，b为要花费的钱，c为所能得到的价值。每种价值的鞋子只会买一双，有个人有个伟大的梦想，每个品牌的鞋子至少买一双，问他这个梦想可以实现不？不可以实现输出Impossible，可以实现输出最大价值......

思路：很容易看出来这是个分组背包题，当然这个分组背包有些不同于每组最多取一个的分组背包......但我是觉得，分组背包就这么几种问法吧

1、最常见的、最水的，每组最多取1个.........（一般是隐性的，需要自己分析）

2、每组至少取1个........（就是本题）

3、随意选，可以选，可以不选，可以只选1个，也可以选多个......（暂时还未学，马上会学）.....

对于第一种，模板题，只要你可以分析出来，那么可以水过.....

对于第二种，我想说也是模板题，当然是以本题为基础的模板.........

好吧，这道题目，首先，每组至少取一个，就是说必须要取一个，那么数组dp[i][j]，代表的含义就是 前i组容量为j的情况下所得到的最大价值为dpi][j]；

同样的，我们首先思考它的状态，每组必须要取一个，那么第i组存在的情况下，第i-1组也必须存在，也是回到了前面所做背包所说的那种“一定”、“必须”的状态，那么同样的在动态转移的时候，要判断它的前一个状态合不合法，我个人比较喜欢用0来判断不合法，>0判断合法.......初始化dp[0][0]=1，最后得到的结果减去1......我想说的是，最后的结果不一定会集中在dp[k][m]上，因为这个状态它不一定存在，也就是说，这个状态不一定合法，当然，也没有关系，我们考虑第k组一定要存在，那么扫描下dp[k][i]，取最大值就好.....

 

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
int dp[15][10005],s[105][2],num[15][105];
queue<int>Q[105];
int main()
{
    int n,m,k;
    while(scanf("%d %d %d",&n,&m,&k)>0)
    {
           
          for(int i=0;i<105;i++)
          while(!Q[i].empty())
          Q[i].pop();
          for(int i=1;i<=n;i++)
          {
               int a,b,c;
               scanf("%d %d %d",&a,&b,&c);
               Q[a].push(i);
               s[i][0]=b;
               s[i][1]=c;
          }
           
          for(int i=1;i<=k;i++)
          {
               int j=1;
               while(!Q[i].empty())
               {
                    num[i][j++]=Q[i].front();
                    //printf("i==%d %d\n",i,Q[i].front()); 
                    Q[i].pop();
               }
               num[i][0]=j;
          }                                 //前面都是将数据处理好 
          memset(dp,0,sizeof(dp));       //初始化dp 
          dp[0][0]=1;
          int flag=1;
          for(int i=1;i<=k;i++)        //这是分组 
          {
              if(num[i][0]==1)        //要是有一组没有数据，那么说明，它不可能满足每组必须取一个这条件....... 
              {
                    flag=0;
                    break;
              }
              for(int f=1;f<num[i][0];f++)     //不同于最多取一个的分组背包，这里是先放每组有的物品，后放容积....... 
              {
                   int xx=num[i][f];;
                   for(int j=m;j>=0;j--)        //至于为什么这么放？我是认为，它是一种模板....... 
                   {
                        if(j-s[xx][0]>=0&&dp[i][j-s[xx][0]]&&dp[i][j-s[xx][0]]+s[xx][1]>dp[i][j]) //这个判断必须放到第一，以免重复 
                        dp[i][j]=dp[i][j-s[xx][0]]+s[xx][1];
                         
                        if(j-s[xx][0]>=0&&dp[i-1][j-s[xx][0]]&&dp[i-1][j-s[xx][0]]+s[xx][1]>dp[i][j])//这个必须放在上一个判断下面..... 
                        dp[i][j]=dp[i-1][j-s[xx][0]]+s[xx][1];
                         
                   }
              }
          }
          int maxx=0;
          for(int i=0;i<=m;i++)
          if(maxx<dp[k][i])
          maxx=dp[k][i];
          if(maxx==0||flag==0)
          printf("Impossible\n");
          else
          printf("%d\n",maxx-1);//最大值记得减去1 
    }
    return 0;
}

 

 3、hdu3535（必做，三种状态都有：最少取一次，最多取一次，随意取  推荐）

题意：有0,1,2三种任务，0任务中的任务至少得完成一件，1中的任务最多完成1件，2中的任务随便做。每一个任务最多只能做一次 。n代表有n组任务，t代表有t分钟，m代表这组任务有m个子任务，s代表这m个子任务属于0,1,2中的哪种类型，接下来是m个子任务，第一个数代表要花费的时间，第二个数代表得到的愉悦度......求在可以完成工作的情况的最大愉悦度....要是不能完成，输出-1(题意要求每个子任务只能被取一次)

错误思路：我一开始想，把0，1，2这三大组任务的子任务先统计好，在dp的时候，我开dp[3][105],代表在完成3组任务体积为105的情况的最大愉悦度.......这种思路是错的，因为题目给出的n组任务是有其固定顺序，只能是按照它给出来的解决问题.......

ac思路：分为n组，每一组判断这一组是属于0,1,2三种任务中的哪一组......

若是属于0，那么将这一组的dp[i][j],j从0~~t全部置为负无穷大，然后开始动态转移.....为什么要置为负无穷大？因为只有这样才能不出现一个都不选择的情况.....其动态转移方程，，在我前一个分组背包题目已经详细推导过，就是dp[i][j]=max(dp[i][j-v[i]]+val[i],dp[i-1][j-v[i]]+val[i],dp[i][j])

若是属于1，先将第i-1的状态传递到第i状态，在开始分组背包的模板......最多取一个dp[i][j]=max(dp[i-1][j],dp[i-1][j-v[i]]+val[i]);

若是属于2，先将第i-1的状态传递到第i状态,随意取，那么可以不取，取任意个子任务......dp[i][j]=max(dp[i-1][j],dp[i][j-v[i]]+val[i],dp[i-1][j-v[i]]+val[i]);

 

#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
#define M -1000000000
int dp[105][105],s[105][2];
int main()
{
    int n,t;
    while(scanf("%d %d",&n,&t)>0)
    {
        int m,k;
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=n;i++)
        {
            scanf("%d %d",&m,&k);
            for(int j=1;j<=m;j++)
            scanf("%d %d",&s[j][0],&s[j][1]);
            if(k!=0)
            for(int j=0;j<=t;j++)        // 传递状态 
            dp[i][j]=dp[i-1][j];
            if(k==0)                        //至少取一个 ，分组背包变形模板....... 
            {
                for(int tmp=0;tmp<=t;tmp++) 
                dp[i][tmp]=M;
                for(int tmp=1;tmp<=m;tmp++)  //这层for循环必须在前面...... 
                {
                    for(int j=t;j>=0;j--)             
                    {
                        if(j-s[tmp][0]>=0&&dp[i][j-s[tmp][0]]+s[tmp][1]>dp[i][j])
                        dp[i][j]=dp[i][j-s[tmp][0]]+s[tmp][1];
                         
                        if(j-s[tmp][0]>=0&&dp[i-1][j-s[tmp][0]]+s[tmp][1]>dp[i][j])
                        dp[i][j]=dp[i-1][j-s[tmp][0]]+s[tmp][1];
                    }
                }
            }
            else if(k==1)               //最多取一个 ，分组背包模板 
            {
                for(int j=t;j>=0;j--)
                {
                    for(int tmp=1;tmp<=m;tmp++)
                    {    
                        if(j-s[tmp][0]>=0)
                        {
                            if(dp[i-1][j-s[tmp][0]]+s[tmp][1]>dp[i][j])
                            dp[i][j]=dp[i-1][j-s[tmp][0]]+s[tmp][1];
                        }    
                    }
                }
            }
            else if(k==2)                     //随意取 ，01背包，每个子任务只能取一次，却可以取任意个不同的子任务 
            {
                for(int tmp=1;tmp<=m;tmp++)
                {
                    for(int j=t;j>=s[tmp][0];j--)
                    {
                        if(dp[i][j-s[tmp][0]]+s[tmp][1]>dp[i][j])
                        dp[i][j]=dp[i][j-s[tmp][0]]+s[tmp][1];
                         
                        if(dp[i-1][j-s[tmp][0]]+s[tmp][1]>dp[i][j])
                        dp[i][j]=dp[i-1][j-s[tmp][0]]+s[tmp][1];
 
                    }
                }
            }
        }
        if(dp[n][t]<0)
        printf("-1\n");
        else
        printf("%d\n",dp[n][t]);
    }
    return 0;
}

 

混合背包

总得来说，混合背包很容易理解，就是有的物品只能取一次，有的物品能取无限次，有的物品取得次数有限制，这样的话分别对对应情况采用01、完全、多重背包即可。但是题目往往没有那么简单、赤裸裸的，让你一看就知道是混合背包的，比如说下面这道题：

poj1742

 

题意：给你价值为a1,a2.....的货币，每种有c1,c2.......个，求这些货币所能组成的价值小于等于m有多少个.....

 

思路：很像一道多重背包题？那我一开始的确是用多重背包的思路编写的......TLE了，原来其中隐藏着一个被我忽视的一个问题，当ai*ci>=m时，我们没有必要去拆分ci了，就直接把这种情况当作完全背包处理.......

#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
int dp[100005],t[300][2];
int n,m;
int sum;
void deal1(int x)
{
        for(int j=m;j>=x;j--)
        if(dp[j-x]&&dp[j-x]+x>dp[j]&&dp[j-x]+x-1<=m)
        {
                if(!dp[j])   sum++;
                dp[j]=dp[j-x]+x;
        }
}
int main()
{
       
      while(scanf("%d%d",&n,&m)>0&&(n+m))
      {
           for(int i=1;i<=n;i++)
           {
                   scanf("%d",&t[i][0]);
           }
           memset(dp,0,sizeof(dp));
           dp[0]=1;
           sum=0;
           for(int i=1;i<=n;i++)
           {
                   scanf("%d",&t[i][1]);
                   if(t[i][1]*t[i][0]<m)
                   {
                        int k=1;
                        while(t[i][1]-k>0)
                        {
                            deal1(k*t[i][0]);
                            t[i][1]-=k;
                            k*=2;
                        }
                        deal1(t[i][1]*t[i][0]);
                    }
                    else
                    {
                        for(int j=t[i][0];j<=m;j++)
                        if(dp[j-t[i][0]]&&dp[j]<dp[j-t[i][0]]+t[i][0])
                        {
                            if(!dp[j])   sum++;
                            dp[j]=dp[j-t[i][0]]+t[i][0];
                        } 
                    }
           }
           printf("%d\n",sum);
      }
      return 0;
}

 

 

此次的背包总结到此结束了，我是做完区间dp才来写这个总结的，dp说起来是很神奇，但是要是你可以推导出状态，根据状态设置好初始化，那么就不算是难......