CSP20230319-4 星际网络II 题解
〇、题目
题目描述
随着星际网络的进一步建设和规模的增大，一个新的问题出现在网络工程师面前——地址空间不够用了！原来，星际网络采用了传统的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}\) 能固定了，就可以解决三种操作了：
- 如果 \(w_{id}\nmid Sum_{l,r}\) 或者 \(Sum_{l,r}=(r-l+1)\times w_{id}\)，那么答案就是
NO，否则就是YES，然后直接区间把颜色改为 \(w_{id}\)。 - 单点查询颜色。
- 记录区间颜色权值的最小值（或者最大值） \(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 在一些题上能派上小用场。
