HDU3535分组背包

首先这个 是我参考别人的思路后写出来的，一开始误以为是混合背包，

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<string>
#include<vector>
#include<queue>
#include<cmath>
#include<memory.h>

using namespace std;

int dp[102][102];

void clear()
{
memset(dp,0,sizeof(dp));
}

int main()
{
int n,t;
int m,type;
int c,g;
while(cin>>n>>t)
{
clear();
for(int i=1;i<=n;i++)
{
scanf("%d %d",&m,&type);
if(type==0)
for(int l=0;l<=t;l++)
dp[i][l]=-1;//不选就为-1
else
for(int l=0;l<=t;l++)
dp[i][l]=dp[i-1][l];//传递背包的值
for(int j=1;j<=m;j++)
{
scanf("%d %d",&c,&g);
for(int k=t;k>=c;k--)
{
if(type==0)//必须一种，传递关系中不能有 （向下传且出现不选）的现象
{
if(dp[i][k-c]!=-1)
dp[i][k]=max(dp[i][k],dp[i][k-c]+g);
if(dp[i-1][k-c]!=-1)
dp[i][k]=max(dp[i][k],dp[i-1][k-c]+g);
}
if(type==1)//至多一种，传递关系中不能有（有随意选并且有随意选）的现象
{
if(dp[i-1][k]!=-1)
dp[i][k]=max(dp[i][k],dp[i-1][k]);
if(dp[i-1][k-c]!=-1)
dp[i][k]=max(dp[i][k],dp[i-1][k-c]+g);
}
if(type==2)//随意
{
if(dp[i-1][k]!=-1)
dp[i][k]=max(dp[i][k],dp[i-1][k]);
if(dp[i][k-c]!=-1)
dp[i][k]=max(dp[i][k],dp[i][k-c]+g);
if(dp[i-1][k-c]!=-1)
dp[i][k]=max(dp[i][k],dp[i-1][k-c]+g);
}
}
}
}
cout<<dp
[t]<<endl;
}
}

接下来这个是我参考思路的那个代码，自认为 大神的代码比我的好理解多了

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<memory.h>
using namespace std;
int dp[125][125],n,m;
struct node
{
int sum;
int Typ;
int c[125];
int g[125];
} p[125];
int main()
{
//int i,j,t,k;
while(scanf("%d%d",&n,&m)==2)
{
memset(dp,-1,sizeof(dp));
memset(dp[0],0,sizeof(dp[0]));
for(int i=1; i<=n; i++)
{
cin>>p[i].sum>>p[i].Typ;
for(int j=1; j<=p[i].sum; j++)
{
cin>>p[i].c[j]>>p[i].g[j];
}
}
for( int i = 1 ; i <= n ; i ++ )
{
if(p[i].Typ==0)
{
for( int j = 1 ; j<=p[i].sum; j++ )
for( int k = m ; k >= p[i].c[j] ; k-- )
{
if( dp[i][k-p[i].c[j]]!=-1 )
dp[i][k] = max(dp[i][k],dp[i][k-p[i].c[j]]+p[i].g[j]);
if( dp[i-1][k-p[i].c[j]]!=-1 )
dp[i][k] = max(dp[i][k],dp[i-1][k-p[i].c[j]]+p[i].g[j]);
}

}
if(p[i].Typ==1)
{
for(int j=0;j<=m;j++) dp[i][j] = max(dp[i-1][j],dp[i][j]);
for( int j = 1 ; j <= p[i].sum; j++ )
for( int k = m ; k >= p[i].c[j]; k-- )
{
if(dp[i-1][k-p[i].c[j]] != -1 )
dp[i][k] = max(dp[i][k],dp[i-1][k-p[i].c[j]]+p[i].g[j]);
}

}
if(p[i].Typ==2)
{
for( int j = 0 ; j <= m ; j++)
{
dp[i][j] = dp[i-1][j];
}
for( int j = 1 ; j <=p[i].sum; j++ )
for( int k = m ; k >= p[i].c[j] ; k-- )
{
if(dp[i-1][k-p[i].c[j]] != -1 )
dp[i][k] = max(dp[i][k],dp[i][k-p[i].c[j]]+p[i].g[j]);
}
}
}
cout<<dp
[m]<<endl;
}
return 0;
}