刷题记录:牛客NC20951网络优化

传送门:牛客

题目描述:

已知该游戏中共有n名用户，编号从1到n，服务器共有m条服务线，每个用户最多只能登陆一条线，第i条线最多可以容纳v[i]名用户同时在线，且只能给编号在[l[i],r[i]]范围内的用户提供服务。现在希望找出一种合理的资源分配方案，使得同时在线人数最大化，请输出这个最大人数。
输入:
5 3
1 1 1
2 4 2
2 3 2
输出:
4

这道题有很多解法,比如网络流加线段树,优先队列,甚至还可以使用贪心来解决这道题.

先讲一下贪心的暴力做法,复杂度为N(nm),竟然可以过??

首先这道题可以简化成无数个相交或者不相交的几条区间中去取点.此时我们可以将这些区间按照右端点进行一个排序,为什么我们能这样做呢.我们想一下假设我们有这样的两段区间[L1,R1],[L2,R2],并且我们有R1<R2,那么此时我们会发现无论L1和L2的关系如何,我们都应该先去填满第一个区间.因为我们的两段区间是有重合部分的,并且我们的后一个区间是有前一个区间不存在的部分的,所以我们需要尽量的将重复的部分在第一个区间内完成.此时可能会有人发问,我们的前一个区间也有后一个区间没有的部分啊,这时不会有影响吗.答案是没有的,因为我们采用从前往后填数字的方法,这样的话重复部分将会在没有重复部分取完之后再进行取得,因此是没有影响的

下面是具体代码:

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <string.h>
#include <stack>
#include <deque>
using namespace std;
typedef long long ll;
#define inf 0x3f3f3f3f
#define root 1,n,1
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
	ll x=0,w=1;char ch=getchar();
	for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
	for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x*w;
}
#define maxn 1000000
#define ll_maxn 0x3f3f3f3f3f3f3f3f
const double eps=1e-8;
int n,m;int vis[maxn];
struct Node{
	int l,r,v;
}node [maxn];
bool cmp(Node a,Node b) {
	if(a.r!=b.r) return a.r<b.r;
	if(a.l!=b.l) return a.l<b.l;
	return a.v<b.v;
}
int main() {
	while(cin>>n>>m) {
		memset(vis,0,sizeof(vis));
		memset(node,0,sizeof(node));
		for(int i=1;i<=m;i++) {
			node[i].l=read();node[i].r=read();node[i].v=read();
		}
		sort(node+1,node+m+1,cmp);
		for(int i=1;i<=m;i++) {
			int cnt=node[i].v;
			for(int j=node[i].l;j<=node[i].r;j++) {
				if(!vis[j]&&cnt>0) {
					vis[j]=1;
					cnt--;
				}
			}
		}
		int ans=0;
		for(int i=1;i<=n;i++) ans+=(vis[i]);
		printf("%d\n",ans);
	}
	
	return 0;
}

下面是优先队列部分(复杂度近似为Nlog(N))

主要思路:

1. 这一次我们选择以区间的左端点为基础进行从小到大的排列,并且每一次循环的是人的编号,这一次我们每次碰到人的编号到我们的区间左端点时,我们就将这个区间进行入队(可能这部分讲的不是很清楚主要就是每一次都尽量的将较小的区间先进行填充操作),假设我们的小区间被大区间完全的包裹,显然此时我们先填充小区间更加优秀假设我们的小区间只与大区间有一部分的重合,例如存在[L1,R1],[L2,R2],且有L1<L2,R1<R2,那么显然我们应该先填充前面的那一个区间,因为它既包含了重复位置又可以为之后的区间的数字留有更大的可能性.而这一切我们都可以使用优先队列进行维护的操作

下面是具体的代码部分

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <string.h>
#include <stack>
#include <deque>
using namespace std;
typedef long long ll;
#define inf 0x3f3f3f3f
#define root 1,n,1
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
	ll x=0,w=1;char ch=getchar();
	for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
	for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x*w;
}
#define maxn 1000000
#define ll_maxn 0x3f3f3f3f3f3f3f3f
const double eps=1e-8;
int n,m;
struct Node{
	int l,r,v;
}node[maxn];
bool cmp(Node a,Node b) {
	if(a.l!=b.l) return a.l<b.l;
	if(a.r!=b.r) return a.r<b.r;
	return a.v<b.v;
}
struct qnode{
	int l,r,v;
	bool operator<(const qnode &rhs) const {
		if(r!=rhs.r) return r>rhs.r;
		else return v>rhs.v; 
	}
};
int main() {
	while(cin>>n>>m) {
		memset(node,0,sizeof(node));
		for(int i=1;i<=m;i++) {
			node[i].l=read();
			node[i].r=read();
			node[i].v=read();
		}
		priority_queue<qnode>q;
		sort(node+1,node+m+1,cmp);
		int cnt=1;int ans=0;
		for(int i=1;i<=n;i++) {
			while(node[cnt].l==i) {
				q.push({node[cnt].l,node[cnt].r,node[cnt].v});
				cnt++;
			}
			while(!q.empty()&&(q.top().r<i||q.top().v==0)) q.pop();
			if(q.empty()) continue;
			ans++;
			qnode f=q.top();q.pop();
			f.v--;
			q.push(f);
		}
		printf("%d\n",ans);
	}
	return 0;
}