526互联

CSP20230319-4 星际网络II 题解

发布时间 2023-03-24 15:19:02作者: 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 在一些题上能派上小用场。