HDOJ 3466【Proud Merchants】

原题链接

思路：

• 本题核心是，在01背包的基础上为每件物品加一个限制（在买它之前必须拥有不少于Q的钱）。简单想想，发现顺序对结果有影响。按贪心的思路稍加分析：其他条件相同时，应先与要求高的商人交易。

• 但这显然是不完美的，受MrMission的启发，策略如下：
  设想同时买两个物品A和B：在金钱足够的情况下，若先买A，需要钱(A.p + B.q)；若先买B，需要钱（B.p + A.q）。因为我们想花最少的钱，那么假设A.p + B.q < B.p + A.q，即先买物品A，经过略微移项，发现获得结论A.q - A.p > B.q -B.p。那要是金钱可能会不够呢？不影响。因为若A.p + B.q < A.q , 则A.q - A.p一定更大。

• 因此我们得出结论，应当按（q-p）为物品由大到小排序，再依次进行交易。

坑：

• 在打背包的时候，由转移方程可以看出来每次都是先装新物品，再看剩下的容量装之前的东西能装多少。因此应该对物品的（q-p）从小到大排序。但如何做到之前的东西不受影响？注意：我们所采用的一维01背包的内层循环，其逆序原理就是新装的物品不会对之前的值产生影响，在这里虽然略有不同，但实际亦保证了我们所采用的任意 dp[j-THING[i].p] 的值与新装的物品 i 无关。

存疑：

• 在一开始从大到小排序时，我使用了cost【】来辅助判断，干脆地WA之后惊讶地发现写的代码竟然变回了贪心，之后也并没有想到解决方法。
• 我仍然认为cmp函数应写成（AC代码2）中去掉注释的形式更加严谨，但不知为何加上反而会WA。

代码：

• WA代码：46MS 1488K

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int maxn = 505 ;
const int maxw = 5005; 

int dp  [maxw];
int cost[maxw];
struct Thing{
	int w;
	int v;
	int q;
}things[maxn];

bool cmp (Thing a , Thing b)
{
	/* 
	if(a.q - a.w == b.q - b.w)
		if(a.q == b.q)
			return a.v > b.v;
		else
			return a.q > b.q;
	*/ 
	return a.q - a.w > b.q - b.w;//(q-w)大的放前面，先使用 
}

void init(){
	memset(dp,0,sizeof(dp));
	memset(cost,0,sizeof(cost));
	return ;
}

int main(){
	int num,W;
	while(cin>>num>>W){
		init();
		for(int i=0 ; i<num ; i++)
		 	cin>>things[i].w>>things[i].q>>things[i].v;
		sort(things,things+num,cmp);
		for(int i=0 ; i<num ; i++){
			for(int j=W ; j >= things[i].q ; j--){
				
				//WA后发现这种想法是能买则买，就没有01背包的思想了 
				if(j - cost[j] >= things[i].q){
					//这里因为是先买之前的，再买新物品i，
					//所以各种条件都要想好；
					
					//比如我一开始想的就有些复杂而且不对，
					//但是通过打表是很快就能发现错误的；
					
					//并且，打印cost数组进行观察比较合适 
						dp[j]   += things[i].v;
						cost[j] += things[i].w;
					}
				
			}
		}
		cout<<dp[W]<<endl;
	}
	return 0;
}​

• AC代码1（结构体排序：46MS 1472K）

​//46MS		1472K


#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;
const int maxw = 5005;
const int maxn = 505 ;

int dp[maxw];
struct THING
{
	int p,q,v;
}things[maxn];

bool cmp(THING a,THING b)
{
	return a.q - a.p < b.q -b.p ;
}

void init(){
	memset(dp,0,sizeof(dp));
	return ;
}

int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	int num,W;
	while(cin>>num>>W){
		init();
		for(int i=0;i<num;i++)
			cin>>things[i].p>>things[i].q>>things[i].v;
		sort(things,things+num,cmp);
		for(int i=0;i<num;i++)
			for(int j=W;j>=things[i].q;j--)
				dp[j] = max(dp[j] , dp[j-things[i].p] + things[i].v);
		cout<<dp[W]<<endl;
	}
	return 0;
}​

• AC代码2（优先队列：46MS 1468K）

​//46MS		1468K
//62MS		1468K(深入判断) 

#include <iostream>
#include <algorithm>
#include <queue>
#include <cstring>

using namespace std;
const int maxw = 5005;

int dp[maxw];
struct THING
{
	int p,q,v;
	friend bool operator >(const THING &a,const THING &b)
	{
		if(a.q - a.p == b.q - b.p)
		/*	if(a.q == b.q)
				return a.v > b.v; */
			//加这层判断不知为何会 WA，并且发现多加的一条判断时间开销很大 
			return a.q > b.q;
		return a.q - a.p > b.q - b.p;
	}
};

priority_queue <THING , vector<THING> , greater<THING> > Q;
//如果结构体没有';'，会在此报错'invalid declarator before'Q' ' 

void init(){
	memset(dp , 0 , sizeof(dp));
	return ;
}

int main(){
	ios::sync_with_stdio(false);
	int num,W;
	THING tp;
	while(cin>>num>>W){
		init();
		for(int i=1;i<=num;i++){
			cin>>tp.p>>tp.q>>tp.v;
			Q.push(tp);
		}
		while(!Q.empty()){
			tp = Q.top();
			Q.pop();
			for(int j=W ; j>=tp.q ; j--)
				dp[j] = max(dp[j] , dp[j-tp.p] + tp.v);
		}
		cout<<dp[W]<<endl;
	}
	return 0;
}​

补充：

• 不要忘记关同步。
• 不要忘记初始化dp【】，这对动态规划问题尤其重要。
• 优先队列和STL中的sort()用时相似，当然这也可能和本题数据量不大有关。