C.How_to_Fail_at_Programming_Contest

---

title: C.How_to_Fail_at_Programming_Contest
date: 2019-10-05 22:20:11
categories:

• ACM
  tags:
• 背包
• 基础dp

---

最近比赛碰到了一道背包问题，大意就是在背包尽可能装的多的情况下
获取最小价值。给?整蒙⚪了。我就决定复习一下背包问题。

首先，回顾一下01背包和完全背包的转移方程

01背包

状态转移方程： F[i][j] = max{ F[i-1][j], F[i-1][j- C[i]] + W[i] }

//倒着滚
void ZeroOnePack(F,C,W){
    for(v = V to C){
        F[v] = max(F[v],F[v-C] + W)
    }
}

就是拿和不拿

完全背包

状态转移方程： F[i][j] = max{ F[i-1][j], F[i][j-C[i]] + W[i] }

//顺着滚
void CompletePack(F,C,W){
    for(v = C to V){
        F[v] = max(F[v],F[v-C] + W)
    }
}

因为可以拿多个所以直接在第i层滚动就可以了，不用去i-1层

所以01背包用滚动数组的时候是 倒着滚，因为要用前一层的。
而完全背包用滚动数组的时候要 正着滚 。

多重背包

就是物品有多个，但是有限。

def MultiplePack(F,C,W,M){ //M件物品
    if (C*M >= V){ //足够多，可以视为完全背包
        CompletePack(F,C,W)
        return
    }
    k = 1       //二进制思想
    while(k < M){
        ZeroOnePack(kC,kW)
        M = M - k
        k = 2k
    }
}

害，简单的复习了一下。
背包九讲还有好多没有看完，还要再慢慢琢磨琢磨。

其实主要就是补一下昨天的C题。

题意上面说了。

解题思路： 维护 F[i][j] 的同时 再维护一个 left[i][j]
F[i][j] 表示前 i 个物品的时候的最小价值，left[i][j] 表示前 i 个物品的时候取最小价值的时候所剩余的空间

转移的时候，当left[i-1][j] >= C[i] 的时候，此时必须选第i道题目，如果不选，和题意违背
这点很重要！！

在转移的时候分两种情况
选和不选

选

则

F[i][j] = F[i-1][j - C[i]] + W[i];
left[i][j] = left[i-1][j - C[i]]; //选了后剩余的空间不变,多出来的空间被选的物品占满了

不选

F[i][j] = F[i-1][j];
left[i][j] = F[i-1][j-1];

用滚动数组优化后

核心代码

for (int v = V; v >= C[i]; v--) {
    if (L[v] >= C[i] || F[v - C[i]] + W[i] < F[v]) {
        F[v] = F[v - C[i]] + W[i];
        L[v] = L[v - C[i]];
    }
}

当然，处理前要按C[i]从小到大排序

完整代码

话说这样的排序就很懒。

#include<bits/stdc++.h>
using namespace std;

int C[3000], W[3000];
int r[3000];
int n, V;
int L[3000], F[3000];

bool cmp(int x, int y) {
	return(C[x] < C[y]);
}

int main() {
	cin >> n >> V;
	for (int i = 1; i <= n; i++) {
		cin >> C[i] >> W[i];
		r[i] = i;
	}
	sort(r + 1, r + 1 + n, cmp);

	for (int i = 0; i < 2050; i++) {
		F[i] = 0;
		L[i] = i;
	}
	for (int k = 1; k <= n; k++) {
		int i = r[k];
		for (int v = V; v >= C[i]; v--) {
			if (L[v] >= C[i] || F[v - C[i]] + W[i] < F[v]) {
				F[v] = F[v - C[i]] + W[i];
				L[v] = L[v - C[i]];
			}
		}
	}
	cout << F[V] << endl;
}