[29] CSP模拟2

A.不相邻集合

考虑值域上连续的段，可以发现连续的长度为 \(x\) 的段的贡献必定为 \(\lceil{\frac{x}{2}}\rceil\)

考虑并查集维护值域连续的段的大小，每次询问求出全部连续段的 \(\lceil{\frac{size}{2}}\rceil\) 之和即为答案

合并操作：在值域上加入 \(x\)，尝试合并 \(x-1\) 与 \(x+1\)

复杂度不对，考虑优化

1. 记一个关于值域的 \(vis\)，若单次插入不改变 \(vis\)，则答案不变
2. 每次在并查集上合并时直接统计答案，先减去两个分别的答案，再加上总和的答案
3. 记得新加入单点时的贡献为 \(\lceil{\frac{1}{2}}\rceil=1\)

#include<bits/stdc++.h>
using namespace std;
#define endl '\n'
#define void inline void
// #define ONLINE_JUDGE
#ifndef ONLINE_JUDGE
#define test(i) cout<<"test: "<<i<<endl
#define testp(i,j) cout<<i<<" "<<j<<endl
#define testd(i) cout<<i<<" "
#define end cout<<"\n"
#define div <<" "<<
#else
#define test(i)
#define testp(i,j)
#define testd(i)
#define end false
#define div ,
#endif
template<typename T>
void read(T& x){
	x=0;bool sym=0;char c=getchar();
    while(!isdigit(c)){sym^=(c=='-');c=getchar();}
    while(isdigit(c)){x=x*10+c-48;c=getchar();}
    if(sym)x=-x;
}
template<typename T,typename... Args>
void read(T& x,Args&... args){
    read(x);read(args...);
}
vector<int>has;
int ans=0;
class dsu{
	public:
	int fa[500001],siz[500001];
	void reset(int n){
		for(int i=1;i<=n;++i){
			fa[i]=i;
			siz[i]=1;
		}
	}
	int find(int id){
		if(fa[id]==id) return id;
		fa[id]=find(fa[id]);
		return fa[id];
	}
	void connect(int x,int y){
		int fx=find(x),fy=find(y);
		if(fx!=fy){
			fa[fx]=fy;
			ans-=(siz[fy]+1)/2+(siz[fx]+1)/2;
			siz[fy]+=siz[fx];
			ans+=(siz[fy]+1)/2;
		}
	}
};
dsu d;
int a[300001];
bool vis[500001];
int tot,lastans=0;
int main(){
	int n;
	read(n);d.reset(500000);
	for(int i=1;i<=n;++i){
		read(a[i]);
		if(!vis[a[i]]){
			vis[a[i]]=true;
			has.push_back(a[i]);
			ans++;
			if(vis[a[i]-1]){
				d.connect(a[i],a[i]-1);
			}
			if(vis[a[i]+1]){
				d.connect(a[i],a[i]+1);
			}
		}
		cout<<ans<<' ';
	}
}

B.线段树

设 \(f(n,x)\) 表示对从长度为 \(n\) 的连续段建立线段树（即有 \(n\) 个叶节点），根节点的值为 \(x\)，左儿子的值为 \(2x\)，右儿子的值为 \(2x+1\) 的情况下的全部节点权值和

可以发现对于根节点儿子的权值，相对于根节点权值的变化只有两种：即乘以一个系数或者加上若干值，也即 \(f(n,x)\) 是关于 \(x\) 的一次函数

设 \(f(n,x)=k_{n}x+b_{n}\)，考虑到我们在对此线段树向下分治的时候，总会有 \(\lceil{\frac{n}{2}}\rceil\) 长度的区间被分配到左儿子，\(\lfloor{\frac{n}{2}}\rfloor\) 长度的区间被分配到右儿子，也就是说：

\[f(n,x)=f(\lceil{\frac{n}{2}}\rceil,2x)+f(\lfloor{\frac{n}{2}}\rfloor,2x+1)+x
\]

根据上设，可得

\[k_{n}x+b_{n}=k_{\lceil{\frac{n}{2}}\rceil}2x+b_{\lceil{\frac{n}{2}}\rceil}+k_{\lfloor{\frac{n}{2}}\rfloor}(2x+1)+b_{\lfloor{\frac{n}{2}}\rfloor}+x
\]

解这个方程，得到

\[\begin{cases}k_{n}=2k_{\lceil{\frac{n}{2}}\rceil}+2k_{\lfloor{\frac{n}{2}}\rfloor}+1\\b_{n}=b_{\lceil{\frac{n}{2}}\rceil}+k_{\lfloor{\frac{n}{2}}\rfloor}+b_{\lfloor{\frac{n}{2}}\rfloor}\end{cases}
\]

关于这个递推式的初态，可以感性理解

• 当 \(n=1\) 时，线段树中只有一个节点 \(x\)，因此 \(k_{1}=1,b_{1}=0\)
• 当 \(n=2\) 时，线段树中只有三个节点 \(x,2x,2x+1\)，和为 \(5x+1\)，因此 \(k_{1}=5,b_{1}=1\)

其余开 map 记搜即可

如果你们 WA60 也有可能是 build() 里的 id 忘记取模了

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl '\n'
template<typename T>
inline T read(){
	T x=0,f=1;
	char ch=getchar();
	while(ch<'0'||ch>'9'){
		if(ch=='-')f=-1;
		ch=getchar();
	}
	while(ch>='0'&&ch<='9'){
		x=(x<<1)+(x<<3)+(ch-'0');
		ch=getchar();
	}
	return x*f;
}
template<typename T>
inline T read(T&a){
	T x=0,f=1;
	char ch=getchar();
	while(ch<'0'||ch>'9'){
		if(ch=='-')f=-1;
		ch=getchar();
	}
	while(ch>='0'&&ch<='9'){
		x=(x<<1)+(x<<3)+(ch-'0');
		ch=getchar();
	}
	return a=x*f;
}
template<typename T>
inline void write(T x){
	if(x<0)x*=-1,putchar('-');
	if(x>9)write(x/10);
	putchar(x%10+'0');
	return;
}
const int p=1e9+7;
map<int,int> K,B;
int k(int n){
	if(n==0) return 0;
	if(n==1) return 1;
	if(n==2) return 5;
	if(K.count(n)) return K[n];
	return K[n]=(2*(k((n+1)/2)+k(n/2))+1)%p;
}
int b(int n){
	if(n==0) return 0;
	if(n==1) return 0;
	if(n==2) return 1;
	if(B.count(n)) return B[n];
	return B[n]=(b((n+1)/2)+b(n/2)+k(n/2))%p;
}
int build(int id,int l,int r,int L,int R){
	if(l>R or r<L) return 0;
	if(L<=l and r<=R){
		return (k(r-l+1)*id%p+b(r-l+1))%p;
	}
    int mid=(l+r)/2;
    return (build((id*2)%p,l,mid,L,R)+build((id*2+1)%p,mid+1,r,L,R))%p;
}
signed main(){
    int T;read(T);
    while(T--){
        int n,l,r;
        read(n);read(l);read(r);
        write(build(1,1,n,l,r)%p);putchar('\n');
    }
}

C.魔法师

题目需要我们求 \(\max(a_{i}+a_{j},b_{i}+b_{j})\)

分类讨论，注意到 \(a_{i}+a_{j}\gt b_{i}+b_{j}\) 的时候，只需要令 \(a_{i}-b_{i}\gt b_{j}-a_{j}\) 即可，此时的答案即为 \(a_{i}+a_{j}\)，否则，当 \(a_{i}-b_{i}\le b_{j}-a_{j}\) 时，答案便为 \(b_{i}+b_{j}\)，这样我们就去除了 \(\max\) 符号

因此我们尝试对每个 \(u_{i}=a_{i}-b_{i},v_{i}=b_{i}-a_{i}\) 进行比较. 现在我们可以把问题转化为求满足 \(u_{i}\gt v_{j}\) 的 \((i,j)\) 的 \(a_{i}+a_{j}\) 最小值，或者满足 \(u_{i}\le v_{j}\) 的 \((i,j)\) 的 \(b_{i}+b_{j}\) 最小值，在两者中再取一个最小值即为答案.

考虑对 \(u,v\) 建一颗权值线段树，考虑到，当 \(i\) 在左子树，\(j\) 在右子树时，一定有 \(u_{i}\le v_{j}\)，因此 \((i,j)\) 可以用于更新父亲节点 \(b_{i}+b_{j}\) 的最小值，反之同理，而我们需要的整体最小值，要么就是从子节点继承上来的答案，要么就是该节点的 \(i\) 在左子树，\(j\) 在右子树时的情况或者 \(j\) 在左子树，\(i\) 在右子树时贡献的情况，可以发现这样做正好覆盖了全部合法的 \((i,j)\)

因为在 \((i,j)\) 中，一定有前者为法杖，后者为咒语。因此在增加操作中，遇到法杖 \(i\) 则在 \(a-b\) 位置插入节点 \((a_{i},b_{i})\)，遇到咒语 \(j\) 则在 \(b-a\) 位置插入节点 \((a_{j},b_{j})\)，然后按顺序向上更新每层法杖的 \(a,b\) 最小值，咒语的 \(a,b\) 最小值，然后在当前节点用左子树法杖，右子树咒语，或者左子树咒语，右子树法杖的最小值分别计算贡献并取最小值即可

关于删除操作，注意到同一个叶节点下方可能会有多个 \((a,b)\)，因此考虑建树套树，简化一点开个 set 维护，因为我们需要分别统计四个最值，因此对每个叶节点开四个 set，分别以不同关键字排序，统计答案的时候取首位维护最小值，删除的时候直接暴力搜索删除，记得删除之后要将该节点统计信息清空后重新统计一遍，防止原先较大的答案未被覆盖导致的错误.

处于空间考虑，我们只需要对每个叶节点开一个 set，因此考虑将 set 建在外面，线段树里面只存储 set 的编号来处理. 由于 \(a-b\) 可能存在负数，因此需要整体偏移，鉴于 \(a,b\in[0,2.5e5]\)，偏移量为 \(0-2.5e5=-2.5e5\)，线段树范围为 \(2.5e5-0-(-2.5e5)=5e5\)，最大值不超过 \(2.5e5+2.5e5=5e5\)，不用开 long long

#include<bits/stdc++.h>
using namespace std;
#define endl '\n'
template<typename T>
void read(T& x){
	x=0;bool sym=0;char c=getchar();
    while(!isdigit(c)){sym^=(c=='-');c=getchar();}
    while(isdigit(c)){x=x*10+c-48;c=getchar();}
    if(sym)x=-x;
}
template<typename T,typename... Args>
void read(T& x,Args&... args){
    read(x);read(args...);
}
#define tests int cases;read(cases);while(cases--)
#define pb push_back
int Q,T;
const int N=5e5+10,dx=N/2;
const int inf=1e8;
int lastans=0;
struct node{
	int a,b;
	bool operator <(const node &A)const{
		if(a==A.a) return b<A.b;
		return a<A.a;
	}
};
struct node2{
	int a,b;
	bool operator <(const node2 &A)const{
		if(b==A.b) return a<A.a;
		return b<A.b;
	}
};
struct setpair{
	set<node> pa,qa;
	set<node2> pb,qb;
};
vector<setpair>store;
namespace Stree{
	#define tol (id*2)
	#define tor (id*2+1)
	#define mid(l,r) mid=(l+r)/2
	struct tree{
		int l,r;
		int store_id;
		int minap,minaq,minbp,minbq;
		int minansa,minansb;
	}t[4*N];
	void pushup(int id){
		t[id].minap=inf;
		t[id].minaq=inf;
		t[id].minbp=inf;
		t[id].minbq=inf;
		t[id].minansa=t[id].minansb=inf;
		if(t[tol].l){
			t[id].minap=min(t[tol].minap,t[id].minap);
			t[id].minaq=min(t[tol].minaq,t[id].minaq);
			t[id].minbp=min(t[tol].minbp,t[id].minbp);
			t[id].minbq=min(t[tol].minbq,t[id].minbq);
			t[id].minansa=min(t[tol].minansa,t[id].minansa);
			t[id].minansb=min(t[tol].minansb,t[id].minansb);
		}
		if(t[tor].l){
			t[id].minap=min(t[tor].minap,t[id].minap);
			t[id].minaq=min(t[tor].minaq,t[id].minaq);
			t[id].minbp=min(t[tor].minbp,t[id].minbp);
			t[id].minbq=min(t[tor].minbq,t[id].minbq);
			t[id].minansa=min(t[tor].minansa,t[id].minansa);
			t[id].minansb=min(t[tor].minansb,t[id].minansb);
		}
		if(t[tol].l and t[tor].l){
			t[id].minansa=min({t[tol].minansa,t[tor].minansa,t[tol].minaq+t[tor].minap});
			t[id].minansb=min({t[tol].minansb,t[tor].minansb,t[tol].minbp+t[tor].minbq});
		}
	}
	void build(int id,int l,int r){
		t[id].l=l;t[id].r=r;
		t[id].minap=inf,t[id].minaq=inf;
		t[id].minbp=inf,t[id].minbq=inf;
		t[id].minansa=inf;t[id].minansb=inf;
		if(l==r){
			store.push_back({});
			t[id].store_id=(int)store.size()-1;
			return;
		}
		int mid(l,r);
		build(tol,l,mid);
		build(tor,mid+1,r);
	}
	void update(int id,bool isp){
		if(!store[t[id].store_id].pa.empty()) t[id].minap=store[t[id].store_id].pa.begin()->a;
		else t[id].minap=inf;
		if(!store[t[id].store_id].pb.empty()) t[id].minbp=store[t[id].store_id].pb.begin()->b;
		else t[id].minbp=inf;
		if(!store[t[id].store_id].qa.empty()) t[id].minaq=store[t[id].store_id].qa.begin()->a;
		else t[id].minaq=inf;
		if(!store[t[id].store_id].qb.empty()) t[id].minbq=store[t[id].store_id].qb.begin()->b;
		else t[id].minbq=inf;
		t[id].minansa=min(inf,t[id].minap+t[id].minaq);
		t[id].minansb=min(inf,t[id].minbp+t[id].minbq);
	}
	void update2(int id,bool isp,int a,int b){
		if(isp){
			t[id].minap=min(t[id].minap,a);
			t[id].minbp=min(t[id].minbp,b);
		}
		else{
			t[id].minaq=min(t[id].minaq,a);
			t[id].minbq=min(t[id].minbq,b);
		}
		t[id].minansa=min(inf,t[id].minap+t[id].minaq);
		t[id].minansb=min(inf,t[id].minbp+t[id].minbq);
	}
	void change(int id,int pos,bool isp,int a,int b){
		if(t[id].l==t[id].r){
			if(isp){
				store[t[id].store_id].pa.insert({a,b});
				store[t[id].store_id].pb.insert({a,b});
			}
			else{
				store[t[id].store_id].qa.insert({a,b});
				store[t[id].store_id].qb.insert({a,b});
			}
			update2(id,isp,a,b);
			return;
		}
		if(pos<=t[tol].r) change(tol,pos,isp,a,b);
		else change(tor,pos,isp,a,b);
		pushup(id);
	}
	void remove(int id,int pos,int isp,int a,int b){
		if(t[id].l==t[id].r){
			if(isp){
				auto it1=store[t[id].store_id].pa.lower_bound(node{a,b});
				auto it2=store[t[id].store_id].pb.lower_bound(node2{a,b});
				if(it1!=store[t[id].store_id].pa.end() and it1->a==a and it1->b==b){
					store[t[id].store_id].pa.erase(it1);
					store[t[id].store_id].pb.erase(it2);
				}
			}
			else{
				auto it1=store[t[id].store_id].qa.lower_bound(node{a,b});
				auto it2=store[t[id].store_id].qb.lower_bound(node2{a,b});
				if(it1!=store[t[id].store_id].qa.end() and it1->a==a and it1->b==b){
					store[t[id].store_id].qa.erase(it1);
					store[t[id].store_id].qb.erase(it2);
				}
			}
			update(id,isp);
			return;
		}
		if(pos<=t[tol].r) remove(tol,pos,isp,a,b);
		else remove(tor,pos,isp,a,b);
		pushup(id);
	}
	int solve(){
		return min(t[1].minansa,t[1].minansb);
	}
}
using namespace Stree;
signed main(){
	read(Q,T);
	build(1,1,N);
	for(int i=1;i<=Q;++i){
		int op,t,a,b;read(op,t,a,b);
		if(T==1){
			a^=lastans;b^=lastans;
		}
		if(op==1){
			if(t==0){
				change(1,a-b+dx,true,a,b);
			}
			else{
				change(1,b-a+dx,false,a,b);
			}
		}
		else{
			if(t==0){
				remove(1,a-b+dx,true,a,b);
			}
			else{
				remove(1,b-a+dx,false,a,b);
			}
		}
		int res=solve();
		cout<<(lastans=(res==inf?0:res))<<endl;
	}
}