【笔记】CF1251E Voting 及相关

题目传送门

贪心：

一个人 $i$ 要投票，两种情况：花钱，或当前的人数达到了 $m_i$。

而当前达到 $m_i$ 的话所有 $m_j\le m_i$ 也就达到要求了。

所以考虑将所有人按 $m$ 从小到大排序。用 $vetcor$ 当桶。

其次考虑如何贿赂最优。当前如果要达到 $m_i$，优先考虑贿赂 $m$ 更大的。因为贿赂比他小的可以达到的还是 $m_i$，贿赂比他大的就可以达到 $m_i+1$。同时，后面的要求比前面高，不用再考虑，会更优。

而在比 $m_i$ 大的所有人中，贪心贿赂 $p_i$ 更小的显然更好。所以，需要维护比 $m_i$ 大的所有人中 $p_i$ 的最小值。考虑用小根堆维护。

堆：

没怎么用过，补

用 $stl$ 中的优先队列。

小根堆：

priority_queue< 数据类型 ,vector< 数据类型 >,greater< 数据类型 > > q;

大根堆：

priority_queue< 数据类型 > q;

或

priority_queue< 数据类型 ,vector< 数据类型 >,less< 数据类型 > > q;

基本操作：

empty()  //判断一个队列是否为空
pop()  //删除队顶元素
push(x)  //加入一个元素 x
size()  //返回优先队列中拥有的元素个数
top()  //返回优先队列的队顶元素

其存取时间复杂度 $O(logn)$

板：

P3378

#include<bits/stdc++.h>
#define ll long long
using namespace std;
int n,op;
ll x;
priority_queue<ll,vector<ll>,greater<ll> > q;
int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		scanf("%d",&op);
		if(op==1){
			scanf("%lld",&x);
			q.push(x);
		}
		else if(op==2) printf("%lld\n",q.top());
		else q.pop();
	}
	return 0;
}

P1334 瑞瑞的木板

将分割看成合成。每次选取两块长度最小的合答案最小。

用小根堆维护当前最小两块板，合完删掉这两块，并加入他们的和。

#include<bits/stdc++.h>
#define ll long long
using namespace std;
int n,a,_1,_2;
ll ans;
priority_queue<int,vector<int>,greater<int> > q;
int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		scanf("%d",&a);
		q.push(a);
	}
	for(int i=1;i<n;i++){
		_1=q.top(),q.pop();
		_2=q.top(),q.pop();
		q.push(_1+_2);
		ans+=(ll)_1+(ll)_2;
	}
	printf("%lld",ans);
	return 0;
}

双倍经验：合并果子

对顶堆：

对顶堆用于维护第 $k$ 大的数。

是堆顶相对的一个大根堆和一个小根堆，其中小根堆存较大的一部分数，大根堆存较小的一部分数。大根堆堆顶一般是第 $k$ 大数。插入：根据需要插到插到大根堆或小根堆，然后调整堆顶。

P1801 黑匣子

用对顶对维护第 $i$ 大的数。插入到大根堆，若还不到 $get$ 就把大根堆堆顶调到小根堆。每次 $get$ 后调整一位堆顶，达到 $i++$ 的效果。

#include<bits/stdc++.h>
using namespace std;
int n,m,a[200005],u[200005],now;
priority_queue<int> b;
priority_queue<int,vector<int>,greater<int> > s;
int main(){
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++) scanf("%d",&a[i]);
	for(int i=1;i<=m;i++) scanf("%d",&u[i]);
	for(int i=1;i<=m;i++){
		while(now<u[i]){
			b.push(a[++now]);
			s.push(b.top());
			b.pop();
		}
		printf("%d\n",s.top());
		b.push(s.top());
		s.pop();
	}
	return 0;
}

P1168 中位数

若当前数 $>mid$，则放到小根堆，否则放到大根堆。

每次奇数个都要查询并更新 $mid$，所以两个堆的大小差不超过 $2$。所以每次奇数个时，判断。若小根堆更大就更新 $mid$ 为小根堆堆顶，并向大根堆调整。若大根堆更大，就更新 $mid$ 为大根堆堆顶，并向小根堆调整。若大小相等， $mid$ 不变。

#include<bits/stdc++.h>
using namespace std;
int n,a,mid;
priority_queue<int> b;
priority_queue<int,vector<int>,greater<int> > s;
int main(){
	scanf("%d%d",&n,&a);
	printf("%d\n",a);
	mid=a;
	for(int i=2;i<=n;i++){
		scanf("%d",&a);
		if(a>mid) s.push(a);
		else b.push(a);
		if(i%2==0) continue;
		if(b.size()>s.size()){
			s.push(mid);
			mid=b.top();
			b.pop();
		}
		else if(b.size()<s.size()){
			b.push(mid);
			mid=s.top();
			s.pop();
		}
		printf("%d\n",mid);
	}
	return 0;
}

重载运算符

用于结构体中的比较。

P1878 舞蹈课

删除后补位，用链表实现。

同时，优先取插值较小的一对，可以用小根堆维护每一对的差值。同时要记录两人的编号，要用结构体。

首先把初始的相邻男女插到堆中，之后每次取堆顶记录答案，取完后标记掉，并更新左右编号（链表）。若出现的新的可行的一对，就再入队，直到队列为空。

重载运算符中，第一关键字为差值，第二关键字为左边人的编号。

#include<bits/stdc++.h>
using namespace std;
int n,a[200005],cnt=0,ans[2][200005];
int l[200005],r[200005],x,y;
bool fl=1,mark[200005];
struct node{
	int w,c,d;
};
bool operator<(node a,node b){
	if(a.w!=b.w) return a.w>b.w;
	else return a.c>b.c;
}
priority_queue<node> q;
string s;
int main(){
	scanf("%d",&n);
	cin>>s;
	for(int i=1;i<=n;i++) scanf("%d",&a[i]);
	for(int i=1;i<n;i++){
		if(s[i-1]!=s[i]){
			node k;
			k.w=abs(a[i]-a[i+1]),k.c=i,k.d=i+1;
			q.push(k);
		}
	}
	for(int i=1;i<=n;i++) l[i]=i+1,r[i]=i-1;
	while(q.size()){
		node t=q.top();
        q.pop();
		x=t.c,y=t.d;
		if(mark[x]!=0||mark[y]!=0) continue;
		l[r[x]]=l[y];
		r[l[y]]=r[x];
		ans[0][++cnt]=x,ans[1][cnt]=y;
		mark[x]=mark[y]=1;
		if(mark[r[x]]==0&&mark[l[y]]==0){
			if((s[r[x]-1]+s[l[y]-1])==('G'+'B')){
				node k;
				k.w=abs(a[r[x]]-a[l[y]]),k.c=r[x],k.d=l[y];
				q.push(k);
            }
		}
	}
	printf("%d\n",cnt);
	for(int i=1;i<=cnt;i++) printf("%d %d\n",ans[0][i],ans[1][i]);
	return 0;
}

P1631 序列合并

因为两数列按顺序给出，所以可以得到：

不管怎么样，$A$ 序列中的第一个数绝对要选，那么这个数可能和 $B$ 序列中的任何一个数组成的数对被选，全部加入优先队列中，这样处理了 $i,j+1$ 的情况。

还有 $i+1,j$ 的情况，每次输出一个和之后，将 $B$ 序列中的第 $i$ 个数对应的 $A$ 序列中的第 $j$ 个数的 $j++$，组成数对。

但是这样数对还是容易重复。可以用一个数组记录一下，$id[i]$ 表示 $B$ 序列中的第 $i$ 个数与 $A$ 序列中的第几个数相加，每次入队的时候累加 $id$ 数组就不会造成重复了。

用结构体存和与序号。但 priority_queue<node> 是大根堆，而本题需要小根堆。所以重载运算符：

bool operator<(node a,node b){
	return a.v>b.v;
}

将小于强制定义为大于即可。

#include<bits/stdc++.h>
using namespace std;
struct node{
	int v,c;
};
bool operator<(node a,node b){
	return a.v>b.v;
}
priority_queue<node> q;
node k;
int a[100005],b[100005],id[100005],n;
int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++) scanf("%d",&a[i]);
	for(int i=1;i<=n;i++){
		scanf("%d",&b[i]);
		id[i]=1;
		k.v=a[1]+b[i],k.c=i;
		q.push(k);
	}
	for(int i=1;i<=n;i++){
		printf("%d ",q.top().v);
		int tmp=q.top().c;
		q.pop();
		k.v=a[++id[tmp]]+b[tmp],k.c=tmp;
		q.push(k);
	}
	return 0;
}

解决：

首先按 $m$ 的大小，分别放在 $vector$ 中。

然后 $i$ 从 $n-1$ 开始（从大到小），每次先把 $m$ 值为 $i$ 的人的贿赂花费放到小根堆中，然后比较堆的大小和 $n-i$。若 $q.size()>n-i$ ，则说明人数不够，就挑堆顶贿赂，直到够了为止。

#include<bits/stdc++.h>
#define ll long long
using namespace std;
ll T,n,p,m,ans;
vector<ll> a[200005];
priority_queue<ll,vector<ll>,greater<ll> > q;
void cl(){
	ans=0;
	for(int i=0;i<=n;i++) a[i].clear();
	while(q.size()) q.pop();
}
void solve(){
	scanf("%lld",&n);
	cl();
	for(int i=1;i<=n;i++){
		scanf("%lld%lld",&m,&p);
		a[m].push_back(p);
	}
	for(int i=n-1;i>=0;i--){
		for(int j=0;j<a[i].size();j++){
			q.push(a[i][j]);
		}
		while(q.size()>n-i){
			ans+=q.top();
			q.pop();
		}
	}
	printf("%lld\n",ans);
	return ;
}
int main(){
	scanf("%lld",&T);
	while(T--) solve();
	return 0;
}