一类贪心题乱编

PS:明天就要考数学了,好慌

我们考虑一类贪心题,它们常常是某些物品带有一定价值,若干天,每次能选一定量,但是随着一段时间可决策集合越来越窄.

对于这类题,一个比较通用的想法就是倒过来考虑,因为如果倒过来考虑,就变成决策集合单调不减,于是往往可以直接用堆之类的数据结构进行贪心.

类似一种反悔贪心?常常体现为贪心实质是在模拟费用流(然而我基本不会网络流)

例题1,[NOI2017]蔬菜

题意:太长了就不说了,自己看吧,大致就是上面的模型

发现正着做十分难做,考虑倒着贪心.

因为第p-1天答案显然是第p天减掉最劣的决策(因为p-1对于p来说决策集合单调不减,所以p能选的所有p-1都能选,所以可以随便删)

于是我们只要求出第P天的值,(P = max($p_{j}$)),然后就可以倒推1~P-1

考虑倒着推怎么做.我们发现题目一堆奇奇怪怪的限制在倒推中突然就有了意义,如果某堆食物从某天开始就不变质了,就把它加进去(又是因为决策集合单调不减,对于倒着推来说,如果当前不变质,之后就不会再变质了)

于是可以直接塞堆里,贪心

/*[NOI2017]蔬菜*/
#include<bits/stdc++.h>
using namespace std;
#define ll long long
int read(){
	char c = getchar();
	int x = 0;
	while(c < '0' || c > '9')		c = getchar();
	while(c >= '0' && c <= '9')		x = x * 10 + c - 48,c = getchar();
	return x;
}
struct Node{
	ll v,id;
	Node (ll fi = 0,ll se = 0){
		v = fi,id = se;
	}
	bool operator <(const Node &a)const{
		return v < a.v;
	} 
};
const int N = 1e5 + 10;
priority_queue<Node>q;
int a[N],s[N],c[N],x[N],n,m,k;
int P = 1e5;
vector<int>d[N];/*第i天会有哪些元素加进来*/
int sel[N];
bool vis[N];
Node st[N];int top;
ll ans[N];ll ss;
#define pb push_back
int main(){
	n = read(),m = read(),k = read();
	for(int i = 1; i <= n; ++i)		a[i] = read(),s[i] = read(),c[i] = read(),x[i] = read();
	for(int i = 1; i <= n; ++i){
		if(x[i] == 0)	d[P].pb(i);
		else	d[min(P,(c[i] - 1 + x[i]) / x[i])].pb(i);
	}
	for(int i = P; i; --i){
		for(int j = 0; j < (int)d[i].size(); ++j){
			int x = d[i][j];
			q.push(Node(a[x] + s[x],d[i][j]));
		}
		for(int j = m; j && !q.empty();){
			Node now = q.top();q.pop();
			if(!vis[now.id]){
				sel[now.id]++;
				ans[P] += now.v;
				if(c[now.id] > 1)	q.push(Node(a[now.id],now.id));
				vis[now.id] = 1;
				--j;
			}
			else{
				int res = min(1ll * j,c[now.id] - 1ll * (i - 1) * x[now.id] - sel[now.id]);
				j -= res;ans[P] += 1ll * res * now.v;
				sel[now.id] += res;if(sel[now.id] != c[now.id])		st[++top] = now;
			}
		}
		while(top)	q.push(st[top]),top--;
	}
	while(q.size())		q.pop();
	memset(vis,0,sizeof(vis));
	for(int i = 1; i <= n; ++i){
		ss += sel[i];
		if(sel[i] == 0)	continue;
		if(sel[i] == 1)		q.push(Node(-a[i]-s[i],i));
		else	q.push(Node(-a[i],i));
	}
	for(int i = P - 1; i; --i){
		ans[i] = ans[i+1];
		while(ss > i * m){
			ss--;
			Node now = q.top();q.pop();
			ans[i] -= -now.v;sel[now.id]--;
			if(sel[now.id] > 1)		q.push(now);
			if(sel[now.id] == 1)	q.push(Node(-a[now.id] - s[now.id],now.id));
		}
	}
//	return 0;
	while(k--){
		int p = read();
		printf("%lld
",ans[p]);
	} 
	return 0;
}

　　upd:还有从费用流角度的理解,先咕着

例题2.[CF505E]

首先肯定是要二分的,设当前二分的值为H,所以就变成了最大值能否不超过H

有一个极度鬼畜的max($h_{i}$ - p,0)

我们依然考虑倒着做,考虑设所有值初始位置都是H,每时刻-=a[i],任意时刻都不能<0,你可以给它加上p,是否存在一种方案,使得最终位置 >=  h[i]

只要按变成<0的顺序,优先+那些会先<0的,贪心地+p最后再检查是否全部合法就可以了.

/*CF505E Mr. Kitayuta vs. Bamboos*/
#include<bits/stdc++.h>
using namespace std;
#define ll long long
int read(){
	char c = getchar();
	int x = 0;
	while(c < '0' || c > '9')		c = getchar();
	while(c >= '0' && c <= '9')		x = x * 10 + c - 48,c = getchar();
	return x;
}
const int N = 1e5 + 10;
ll a[N],h[N],n,m,k,p;
struct NUM{
	int ed;ll v;int id,st;/*几天后会小于0*/
	bool operator <(const NUM &a)const{
		return ed > a.ed;
	}
	NUM (int _a = 0,ll _b = 0,int _c = 0,int _d = 0){
		ed = _a,v = _b,id = _c,st = _d;
	}
};
priority_queue<NUM>q;
bool check(ll x){
	while(q.size())		q.pop();
	for(int i = 1; i <= n; ++i){
		if(x - m * a[i] >= h[i])	continue;
		q.push(NUM(x / a[i],x,i,0));
//		cout<<i<<' '<<x / a[i]<<endl;
	}
	for(int i = 1; i <= m; ++i){
		ll res = m - i;
		for(int j = 1; j <= k; ++j){
			if(q.empty())	return 1;
			NUM now = q.top();q.pop();
			if(now.ed < i)	return 0;
			ll v = now.v - 1ll * (i - now.st) * a[now.id] + p;
			if(v - res * a[now.id] >= h[now.id])		continue;
			q.push(NUM(max((ll)i,i + v / a[now.id]),v,now.id,i));
		}
	}
	if(q.empty())	return 1;return 0;
}
int main(){
	n = read(),m = read(),k = read(),p = read();
	for(int i = 1; i <= n; ++i)		h[i] = read(),a[i] = read();
	ll l = 1,r = 1e15;
	ll ans = 0;
	while(l <= r){
		ll mid = (l + r) >> 1;
		if(check(mid)){
			ans = mid;
			r = mid - 1;
		}
		else	l = mid + 1;
	}
	cout<<ans<<endl;
	return 0;
}