CSP20230319-4 星际网络II 题解

Posted 2023-03-24 cyx001

〇、题目

题目描述

随着星际网络的进一步建设和规模的增大，一个新的问题出现在网络工程师面前——地址空间不够用了！原来，星际网络采用了传统的IPv6协议，虽然有 \\(2^128\\) 级别的可用地址数量，但面对广袤无垠的宇宙和爆炸式增长的网络用户数，如此庞大的地址空间也面临了用尽的那一天。

新的通信协议的研发工作交给了著名的网络科技圣地——西西艾弗星。最终，经过2333年的不懈努力，西西艾弗星的工程师们设计出了一种新的协议——“西西艾弗IP协议”，又称IPxxaf。

在IPxxaf协议中，一个地址由 \\(n\\) 位二进制位组成，其中 \\(n\\) 是 \\(16\\) 的倍数。日常表示一个地址时，采用类似IPv6协议的十六进制表示法，每 \\(4\\) 位用 : 隔开。如 \\(n=32\\) 时，地址为 2a00:0001 ，即表示一个二进制为 0010 1010 0000 0000 0000 0000 0000 0001 的地址。注意不会出现IPv6中省略每组的前导 0 或用 :: 省略一段 0 的情况。

为方便起见，记 \\(num(s)\\) 为地址 s 按高位在前、低位在后组成的 \\(n\\) 位二进制数，称一段“连续的地址“为 \\(num(s)\\) 成一段连续区间的一系列地址。

西西艾弗星的网络管理员负责地址的分配与管理。最开始，整个地址空间都是未分配的。用户可以随时向管理员申请一些地址：

1 id l r：表示用户 \\(id\\) 申请地址在 \\(l\\sim r\\) 范围内（包含 \\(l\\) 和 \\(r\\)，下同）的一段连续地址块。

在地址申请操作中，管理员需要先检查地址是否可用。如果用户申请的地址全部未被分配，则检查通过；若地址中存在已经分配给其他用户的地址，则检查失败。

但有一种特殊情况：申请的地址中没有已经分配给其他用户的地址，但含有一些先前已分配给该用户本人的地址。此时可以认为检查通过，但若申请的地址先前已全部分配给该用户则检查失败。

如果上述检查通过，则管理员向用户返回 YES，并将申请的地址分配给该用户；若不通过，则向用户返回 NO，同时不改变现有的地址分配。

网络管理员要定期检查地址的分配情况，具体而言有如下两种操作：

2 s：检查地址 \\(s\\) 被分配给了哪个用户。若未被分配，则结果为 \\(0\\)。

3 l r：检查 \\(l\\sim r\\) 范围内的所有地址是否完整地分配给了某个用户。若是，回答该用户的编号；若否，回答 \\(0\\) 。

在整个网络的运行过程中，共出现了 \\(q\\) 次申请地址和检查地址分配的操作。作为西西艾弗星的一名重要的网络技术顾问，你要帮网络管理员依次处理每个操作，并回答相应的结果。

输入格式

从标准输入读入数据。

第一行，\\(2\\) 个正整数 \\(n,q\\)。

接下来 \\(q\\) 行，每行一个操作，格式如上所述，其中的 \\(id\\) 为正整数，\\(l,r,s\\) 均为IPxxaf地址串，其中十六进制均用数字和小写字母表示。

输出格式

输出到标准输出。

输出 \\(q\\) 行，每行一个非负整数或字符串，表示此次操作的结果。

其中，对于操作 \\(1\\)，输出 YES 或 NO；对于操作 \\(2\\)，输出一个非负整数。

样例输入1

32 12
1 1 0001:8000 0001:ffff
2 0001:a000
3 0001:c000 0001:ffff
1 2 0000:0000 000f:ffff
2 0000:1000
1 1 0001:8000 0001:8fff
1 2 0000:0000 0000:ffff
2 0000:1000
1 1 0002:8000 0002:ffff
3 0001:8000 0002:ffff
1 1 0001:c000 0003:ffff
3 0001:8000 0002:ffff

样例输出1

YES
1
1
NO
0
NO
YES
2
YES
0
YES
1

样例解释

第 \\(4\\) 个操作时，由于用户 \\(2\\) 申请的部分地址已被分配给用户 \\(1\\)，因此申请不通过；

第 \\(6\\) 个操作时，由于用户 \\(1\\) 申请的全部地址已被分配给用户 \\(1\\)，因此申请不通过；

第 \\(11\\) 个操作时，用户 \\(1\\) 申请的部分地址已被分配给用户 \\(1\\)，其余地址尚未被分配，申请通过；

数据范围

对于所有数据，\\(n\\leq 512,q\\leq 5\\times10^4\\)，\\(n\\) 为 \\(16\\) 的倍数，\\(id\\leq q\\)，对于操作 \\(1,3\\) 保证 \\(num(l)\\leq num(r)\\)。

测试点编号	\\(n\\leq\\)	\\(q\\leq\\)	特殊性质
\\(1\\sim4\\)	\\(16\\)	\\(200\\)	无
\\(5\\sim6\\)	\\(64\\)	\\(200\\)	无
\\(7\\sim9\\)	\\(512\\)	\\(200\\)	无
\\(10\\sim11\\)	\\(16\\)	\\(20000\\)	无
\\(12\\sim13\\)	\\(64\\)	\\(50000\\)	无
\\(14\\sim16\\)	\\(512\\)	\\(50000\\)	所有操作 1 的 \\(id\\) 互不相同
\\(17\\sim20\\)	\\(512\\)	\\(50000\\)	无

一、思路

首先看到这个离谱的 IP 表示方法，我们就想把它离散化。

这个东西有一个好处：因为长度相等而且数字的 ASCII 码小于字母的，所以我们可以直接比较字符串。

在离散化的时候，注意到他要判断是否连续，所以在离散化的时候要注意当前 IP 和上一个是否相邻。

于是整个问题就转化为了给你一个不超过 \\(2\\times 10^5\\) 大小的数组，进行区间涂色和查询。

这个时候有一个类似于哈希的思路：给每个颜色一个权值 \\(w_i\\)，记一个区间的和 \\(Sum_l,r\\) 为这个区间内所有点的颜色的 \\(w_i\\) 之和。

那么这时一个区间 \\(l,r\\) 的颜色如果都是 \\(i\\)（或者没有颜色），那么显然 \\(Sum_l,r\\) 一定是 \\(i\\) 的倍数。

但是我们发现有可能 出现 \\(x\\times w_1=y\\times w_2\\) 的情况，这个时候可能和就没法代表一个固定的东西了。

为了避免上面情况的发生，因为 \\(x\\) 和 \\(y\\) 实际上只能是长度，不超过 \\(2\\times 10^5\\)。于是，我们很容易想到选取大于 \\(2\\times 10^5\\) 的 \\(2\\times 10^5\\) 个质数作为 \\(w_i\\) 即可，大约 \\(4\\times 10^6\\) 就可以筛出这么多。

那既然 \\(Sum_l,r\\) 能固定了，就可以解决三种操作了：

1. 如果 \\(w_id\\nmid Sum_l,r\\) 或者 \\(Sum_l,r=(r-l+1)\\times w_id\\)，那么答案就是 NO，否则就是 YES，然后直接区间把颜色改为 \\(w_id\\)。
2. 单点查询颜色。
3. 记录区间颜色权值的最小值（或者最大值） \\(Min_l,r\\)，而显然在一个区间颜色都相等的情况下一定有 \\(Sum_l,r=(r-l+1)\\times Min_l,r\\)（因为所有颜色都是一样的），这个时候就输出 \\(Min_l,r\\) 对应的颜色，否则就是 \\(0\\)。

直接线段树维护即可。

这个思路是不是十分抽象，我也觉得这很抽象。这个奇妙的思路来源于 小 H。OrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrz

二、代码

#include<bits/stdc++.h>
using namespace std;
int n,q;
struct op//离散化所以要记录操作
	int opt;
	string x,y;
	int l,r;
	int user;
opts[50005];
string plusone(string s)int w;//IP地址+1
	s[w=s.length()-1]++;
	while(w>=0&&s[w]==\'g\')
		s[w]=\'0\';
		if(s[w-1]==\':\') s[w-2]++,w-=2;
		else s[w-1]++,w--;
	
	if(s[w]==58) s[w]=\'a\';
	return s;

struct LSH//离散化
	set<string> s;int cnt;
	unordered_map<string,int> toNum;
	inline void pls(string str)s.insert(str);
	inline void run()
		auto it=s.begin(),ti=s.end();//ti是it的上一个
		for(;it!=s.end();it++)
			if(it!=s.begin())
				if(ti==s.end()) ti=s.begin();
				else ti++;
				if(plusone(*ti)!=(*it)) cnt++;
			
			toNum[*it]=++cnt;
		
	
	inline int gNum(string s)return toNum[s];
lsh;
bitset<4000005> isnp;int pr[400005],prcnt;int W[200005],anscnt;
map<int,int> ni;
void shai(int n)//筛出足够多的质数
	isnp[1]=1;
	for(int i=2;i<=n;i++)
		if(!isnp[i])
			pr[++prcnt]=i;
			if(i>200000) W[++anscnt]=i,ni[i]=anscnt;//记录一下倒过来是什么
			if(anscnt>=200000) return;
		
		for(int j=1;j<=prcnt&&1ll*i*pr[j]<=n;j++)
			isnp[i*pr[j]]=1;
			if(i%pr[j]==0) break;
		
	

#define ll long long
ll MIN(ll a,ll b)return a==0?b:b==0?a:a<b?a:b;//这里建议没有数的时候min就是 0，方便输出但是要自己定义一下新的min
#define ls (p<<1)
#define rs (p<<1|1)
#define mid (l+r>>1)
struct node//下面是线段树
	ll sum,mn,lazy,len;
	node operator +(node b)return sum+b.sum,MIN(mn,b.mn),0,len+b.len;
	node operator =(ll b)return sum=b*len,mn=b,lazy=b,len;
tr[800005];
void build(int p,int l,int r)
	if(l==r)tr[p]=0,0,0,1;return;
	build(ls,l,mid);build(rs,mid+1,r);tr[p]=tr[ls]+tr[rs];

void pushdown(int p)if(tr[p].lazy) tr[ls]=tr[p].lazy,tr[rs]=tr[p].lazy,tr[p].lazy=0;
void chg(int p,int l,int r,int L,int R,ll c)
	if(l>=L&&r<=R)tr[p]=c;return;
	pushdown(p);
	if(L<=mid) chg(ls,l,mid,L,R,c);
	if(R>mid) chg(rs,mid+1,r,L,R,c);
	tr[p]=tr[ls]+tr[rs];

ll qsum(int p,int l,int r,int L,int R)
	if(l>=L&&r<=R) return tr[p].sum;
	ll ans=0;
	pushdown(p);
	if(L<=mid) ans+=qsum(ls,l,mid,L,R);
	if(R>mid) ans+=qsum(rs,mid+1,r,L,R);
	return ans;

ll qmin(int p,int l,int r,int L,int R)
	if(l>=L&&r<=R) return tr[p].mn;
	ll ans=0;
	pushdown(p);
	if(L<=mid) ans=MIN(ans,qmin(ls,l,mid,L,R));
	if(R>mid) ans=MIN(ans,qmin(rs,mid+1,r,L,R));
	return ans;

int main()
	shai(4000000);
	cin>>n>>q;
	for(int i=1;i<=q;i++)
		cin>>opts[i].opt;
		if(opts[i].opt==1) cin>>opts[i].user>>opts[i].x>>opts[i].y;
		else if(opts[i].opt==2) cin>>opts[i].x;
		else cin>>opts[i].x>>opts[i].y;
		lsh.pls(opts[i].x);
		if(opts[i].opt!=2) lsh.pls(opts[i].y);
	
	lsh.run();
	for(int i=1;i<=q;i++) opts[i].l=lsh.gNum(opts[i].x),(opts[i].opt!=2)&&(opts[i].r=lsh.gNum(opts[i].y));
	n=lsh.cnt;//相当于一共就这么多节点
	build(1,1,n);
	for(int i=1;i<=q;i++)int op=opts[i].opt,l=opts[i].l,r=opts[i].r,id=opts[i].user;//按照思路写出来非常轻松
		if(op==1)
			ll sum=qsum(1,1,n,l,r);
			if((sum%W[id])||sum/W[id]==r-l+1) cout<<"NO"<<endl;
			else
				chg(1,1,n,l,r,W[id]);
				cout<<"YES"<<endl;
			
		
		if(op==2)
			cout<<ni[qmin(1,1,n,l,l)]<<endl;
		
		if(op==3)
			ll sum=qsum(1,1,n,l,r),mn=qmin(1,1,n,l,r);
			if(mn==0||sum%mn==0&&sum/mn==r-l+1) cout<<ni[mn]<<endl;
			else cout<<0<<endl;
		
	
	return 0;

三、总结

题目很抽象，思路也很抽象（

不过感觉似乎这个 trick 在一些题上能派上小用场。