背包整理模板

一 01背包

1. hdu5230，1~n连续的数每个数只能用一次，构造出和为i（在1到n范围），本来dp是dp【】【】用到哪个数，变式，用的数最多少于sqrt（n），dp【】【】i个数，和为j，然后dp转移。

2. 一共20个人，每次9 3 1的打，每人hp上限60。本身不是背包，但是搞出用9和 3 和 1分别多少次来dp很好的描述结果，中间的转移枚举+限制就好。

3. 需要排序的背包。就是顺序调整后会更优，但是可以比较两个物品就贪心的确定放的顺序。还有贪心也可能是这样，比如最后5块钱什么都能买，那么把贵的放在后面。

4. 100个仓库，有守夜人，仓库之间一样，定义dp【i】为搞定了i个仓库。然后看每个人，缩小规模。

5. 01背包装压放物品时，用更新逆着扫很好写。有题目要3个状态，那么dp【i】【j】表面上是4个状态，但是不合法的状态不作为更新点，还是3个状态。

6. 注意缩小边界上限，比如三角形周长和1600，那么一定最多一个大于800，直接dp【800】【800】。

7. 注意用longlong来状压dp的值来表示构成信息。

8. 树形依赖背包，把信息一直传下去，并且写法规定第一次dfs（u）的时候再强制买根，传下去的时候先不买根。常用的方法.

voiddfs(int u)

{

for(int i = tot;i >= price[u];i--)//强制买根

{

if(dp[u][i - price[u]] != MIN)

{

dp[u][i] = dp[u][i - price[u]] +val[u];

}

else

{

dp[u][i] = MIN;

}

}

for(int i = 0;i < price[u];i++)

{

dp[u][i] = MIN;

}

REP(i, 0, G[u].size())//遍历子树

{

int v = G[u][i];

for(int j = 0;j <= tot;j++)//先拷过去

{

dp[v][j] = dp[u][j];

}

dfs(v);//解决子树

for(int j = 0;j <= tot;j++)//取大

{

dp[u][j] = max(dp[u][j],dp[v][j]);

}

}

}

9. 不一定dp后面的值是价值，比如说是概率啊，什么的，一个物品一个物品的考虑，都看成背包吧

10. 对于一些题目，当寻找闸值来搞dp，比如爱61，又比如部分贪心。

11. 注意01背包的花费一般是正的，但是如果是负的也一定要注意扫的方向，特判一下。

12. 01背包标准求第K大:

//dp[][]改变为花费小于等于i的花费,加上一维k大

intdp[1000 + 10][50], n, tot, k, cost[110], val[110];//dp中多一维，用来记录k

inta[50], b[50];

voidgetDp()

{

for(int i = 0;i <= tot;i++)

{

dp[i][1] = 0;//初始化的不同，体积i之内能够达到的最大体积

for(int j = 2;j <= k;j++)

{

dp[i][j] = -1;//第二三等等之后目前都是-1，因为不能够重复,根据题意

}

}

for(int i = 1;i <= n;i++)

{

for(int j = tot;j >= 0;j--)//前两层和01背包正常的是一样的。

{

for(int m = 1;m <= k;m++)//需要k个一起来，因为分成了强制使用i和不使用i的情况。

{

a[m] = dp[j][m];

if(j>=cost[i]&&dp[j-cost[i]][m]!=-1)

b[m] =dp[j-cost[i]][m]+val[i];

else

b[m] = -1;

}

int a_i = 1, b_i = 1, c_i = 1;//把a和b两种情况合并成一个，能够保证a和b一定不会大于k

while(c_i<=k)

{

int l = a[a_i];

int r = b[b_i];

if(l == r)//相等时只能够算一个

{

dp[j][c_i] = l;

a_i++;

b_i++;

}

else if(l < r)

{

dp[j][c_i] = r;

b_i++;

}

else

{

dp[j][c_i] = l;

a_i++;

}

c_i++;

}

}

}

注意,如果是完全背包,倒着扫.

如果是多重背包,2进制01背包.但是不能够解决允许重复的k大.

13. 没有明确的给定物品,自己构造出物品后去dp.比如:10个东西,每一趟能够搞若干个东西,问最少的趟数.先把每一趟能够搞的物品预处理出来,价值是他们,花费是1,然后dp背包,只是花费用2进制搞而已.小物品根据问法搞出大物品.(其实也是思考最后一趟搞定哪些).

14. Dp时候可能爆longlong,稍微测下边界数据,然后用两个longlong可能就ok了

15. 01背包,必须要买的东西,直接买,,选择要买的东西就是01背包,如果分组,组内至少选一个,将第一个强制买,组内只能买1个每次用上一组的更新,如果额外有免费卷的机会,增加一位描述是否用过免费卷.

16. 多少种方案数使得剩下的物品都放不下. 注意不是剩余的空间最少,而是剩下的物品放不下.那么去枚举那个物品放不下,这时候发现排序之后可以利用很多.从小到大枚举,那么划分成两部分,一部分必须选,越来越少,一部分随意选,越来越多,用01背包处理就好.然后该物品放不下有多少种呢?就是:tot-一定要用的范围在0到放不下这个物品之间的和.注意特殊情况,一个都不能放特判为没有…

17. 注意分组背包的处理.注意如果有花费为0的东西,那么不能滚动更新.

18. 一道很好的树形dp和背包问题:机器人搞资源.重点是定状态:dp[u][i]指在u中停留了i个机器人.这样的转移就不会重复了.之后:每个点都必须要走到,至少选一个,其次,倒着扫背包.再者:更新的时候0的附加值是2*l,一个机器人跑进去再跑出来,其余的都是j*l.

二 完全背包

1. 有使用东西个数的限制，加一维。Dp【i】【j】用了i个物品了。

2. 如果物品有特殊性质是连续的，比如容量【l，r】的都有，这些还都是无限的，那么有一个闸值之后的容量都可以满足。因为【kl，kr】和【（k+1）l，（k+1）r】有重合。

3. 部分贪心。保证能够产生%max的值的个数大于max后就找到闸值了。

4. 高于闸值抵消个数。结论是：当物品长度小于max时，如果两种达到长度为l（l要保证大于max*max，max*max来保证使用的物品个数大于max），那么一定有共同的一段可以消去。

三 多重背包

1. 首先一个思路转换：有很多个能力值，要求生出来的每一个个体和另一个个体相比都有一个值大，那么最多生几个个体。这种交错属性转换为属性和为sum/2的容量背包的组成总情况数，结果就是最好的。然后要对多重背包求容量C的情况数。

下面写出求法：主要是红色的dp

void getDp()

{

memset(dp, 0, sizeof(dp));

now = 0;

last = 1;

dp[last][0] = 1;

REP_D(i, 1, n) {

for(int j = 0;j <= tot;j++)

{

if(j < 1)

{

dp[now][j] = dp[last][j];

}

else if(j <= t[i])

{

dp[now][j] = dp[last][j] +dp[now][j-1];

}

else

{

dp[now][j]= dp[last][j] + dp[now][j-1] - dp[last][j-t[i] - 1];

}

}

swap(now, last);

}

}

2. 单调队列搞多重背包。其实就是一个变换

F[i][j] = max { F[i - 1] [j – k * v[i] ] + k * w[i] } (0 <= k <= m[i])

d = v[i]，a = j/ d，b = j % d，即 j
= a * d + b，k替换a –k。

变成了

F[i][j] = max { F[i - 1] [b + k * d] - k *w[i] } + a * w[i] (a– m[i] <= k <= a)

这样之后就可以很快的搞了

const intMAX_K = 1e4 + 100;

intq_front, q_tail;

structnode

{

int no, number;

};

nodeq[MAX_K];

void pack(intdp[], int tot, int cost, int val, int num)

{

for(int j = 0;j < cost;j++)

{

q_front = 1;

q_tail = 0;

int i = 0;

for(int k = j;k <= tot;k = k + cost)

{

while(q_front <=q_tail&&q[q_front].no < i - num)

{

q_front++;

}

if(dp[k]!=-1)//当前的点能够作为更新的点

{

int tt = dp[k] - i*val;

while(q_front<=q_tail&&q[q_tail].number<tt)//这个看情况

{

q_tail--;

}

q_tail++;

q[q_tail].number = tt;

q[q_tail].no = i;

}

if(q_front<=q_tail)//出现没有合法情况的时候

{

dp[k] = q[q_front].number +i*val;

}

else

{

dp[k] = -1;

}

i++;

}

}

}

3. 有时如果可以用一个used多少来记录当前硬币用了几个,而只为能不能达到某个值,或者达到某个值用的硬币最多或最少,可以先按题目将硬币排序,然后used来记录当前最少用的当前的硬币数目.

4. 二进制多重背包

voidzeroOneP(int val, int cost)//cost是v，val是n，01背包的逆序更新

{

for(int j =tot;j >= cost;j--)

{

dp_buy[j] = min(dp_buy[j], dp_buy[j -cost] + val);

}

}

voidgetDpBuy()//多重背包

{

fill(dp_buy, dp_buy + key + 1, INF);

dp_buy[0] = 0;

for(int i = 1;i <= n;i++)

{

int k = 1;//k先1

while(k < num[i])//小的时候

{

zeroOneP(k, k*val[i]);

num[i] -= k;

k *= 2;

}

zeroOneP(num[i], num[i]*val[i]);//剩下的都弄

}

}