#3146. 「APIO 2019」路灯

#3146. 「APIO 2019」路灯

题目描述

一辆自动驾驶的出租车正在 Innopolis 的街道上行驶。该街道上有 \(n + 1\) 个停车站点，它们将街道划分成了 \(n\) 条路段。每一路段都拥有一个路灯。当第 \(i\) 个路灯亮起，它将照亮连接第 \(i\) 与第 \(i + 1\) 个站点的路段。否则这条路段将是黑暗的。

安全起见，出租车只能在被照亮的路段上行驶。换言之，出租车能从站点 \(a\) 出发到达站点 \(b\ (a < b)\) 的条件是：连接站点 \(a\) 与 \(a + 1\)，\(a + 1\) 与 \(a + 2\)，……，\(b − 1\) 与 \(b\) 的路段都被照亮。

在经过一些意外故障或修理之后，街道上的路灯可能是亮起的，也可能是熄灭的。

现在给定 \(0\) 时刻时，街道上路灯的初始状态。之后 \(1, 2,\ldots , q\) 时刻，每时刻会发生下列两种事件之一：

- \(\texttt{toggle}\ i\)：切换第 \(i\) 个路灯的状态。具体地说，若路灯原来亮起，则现在将熄灭；若路灯原来熄灭，则现在将亮起。

- \(\texttt{query}\ a\ b\)：出租车部门的负责人想知道，从 \(0\) 时刻起到当前时刻，有多少个时刻满足：出租车能够从站点 \(a\) 出发到达站点 \(b\)。

请你帮助出租车部门的负责人回答他们的问题。

输入格式

第一行包含两个整数 \(n\) 和 \(q\)——表示路灯的数量与时刻数。

第二行包含一个字符串 \(s\) 表示路灯的初始状态，\(s_i\) 为 1 表示第 \(i\) 个路灯初始时亮起；\(s_i\) 为 0 表示第 \(i\) 个路灯初始时熄灭。

接下来 \(q\) 行每行描述一个时刻的事件。第 \(i\) 行描述时刻 \(i\) 所发生的事件：

- \(\texttt{toggle}\ i\)：该时刻切换了第 \(i\) 个路灯的状态。

- \(\texttt{query}\ a\ b\)：计算从 \(0\) 时刻起到该时刻，共有多少个时刻满足：出租车能从站点 \(a\) 出发到达站点 \(b\)。

至少有一个时刻的事件是 \(\texttt{query}\)。

输出格式

对于每个 \(\texttt{query}\) 的事件，输出一行单个整数，表示该问题的答案。

数据范围与提示

对于全部数据，\(1\le n,q\le 3\times 10^5,|s|=n,1\le i\le n,1\le a<b\le n+1\)。

我们将所有出现过的极大连续\(1\)序列都处理出来，表示为\((lp,rq,l,r)\)表示每个序列的左右端点和出现时间。可以用\(set\)维护线段的方式处理。

对于第\(i\)个询问\((l_i,r_i)\)，一个线段\((lp,rq,l,r)\)对它的答案有贡献的条件是\(lp\leq l_i,r_i\leq rp,l\geq i\)，贡献是\(\min\{i,r\}-l+1\)。

可以发现这是个三维偏序问题，可以用\(CDQ\)+线段树解决。

代码：

#include<bits/stdc++.h>
#define ll long long
#define N 300005

using namespace std;
inline int Get() {int x=0,f=1;char ch=getchar();while(ch<'0'||ch>'9') {if(ch=='-') f=-1;ch=getchar();}while('0'<=ch&&ch<='9') {x=(x<<1)+(x<<3)+ch-'0';ch=getchar();}return x*f;}

int n,m;
char s[N];
struct interval {
	int lp,rp;
	int l,r;
	interval() {}
	interval(int _lp,int _rp,int _l,int _r) {lp=_lp,rp=_rp,l=_l,r=_r;}
	bool operator <(const interval &a)const {return rp<a.rp;}
}t[N<<2];

set<int>pos;
set<int>::iterator it;
int id[N],R[N];
int tot;
int ans[N];

struct query {
	int l,r,tim,id;
}q[N];

int qt;
struct node {
	int op,id,r;
	node() {}
	node(int _op,int _id,int _r) {
		op=_op,id=_id,r=_r;
	}
};

bool cmpr(const node &a,const node &b) {
	if(a.r!=b.r) return a.r>b.r;
	return a.op<b.op;
}

bool cmpl(const node &a,const node &b) {
	if(a.op!=b.op) return a.op<b.op;
	if(a.op==1) return t[a.id].lp<t[b.id].lp;
	else return q[a.id].l<q[b.id].l;
}

node st[N<<2];
int top;

struct tree {
	int l,r;
	int sum,tag;
}tr[N<<2];

void update(int v) {tr[v].sum=tr[v<<1].sum+tr[v<<1|1].sum;}
void Add(int v,int f) {tr[v].sum+=(tr[v].r-tr[v].l+1)*f,tr[v].tag+=f;}
void down(int v) {
	if(tr[v].tag) {
		Add(v<<1,tr[v].tag);
		Add(v<<1|1,tr[v].tag);
		tr[v].tag=0;
	}
}
void build(int v,int l,int r) {
	tr[v].l=l,tr[v].r=r;
	if(l==r) return ;
	int mid=l+r>>1;
	build(v<<1,l,mid),build(v<<1|1,mid+1,r);
}

void Modify(int v,int l,int r,int f) {
	if(tr[v].l>r||tr[v].r<l) return ;
	if(l<=tr[v].l&&tr[v].r<=r) {
		Add(v,f);
		return ;
	}
	down(v);
	Modify(v<<1,l,r,f),Modify(v<<1|1,l,r,f);
	update(v);
}

int query(int v,int l,int r) {
	if(tr[v].l>r||tr[v].r<l) return 0;
	if(l<=tr[v].l&&tr[v].r<=r) return tr[v].sum;
	down(v);
	return query(v<<1,l,r)+query(v<<1|1,l,r);
}

void solve(int l,int r) {
	if(l==r) return ;
	int mid=l+r>>1;
	solve(l,mid),solve(mid+1,r);
	int tag=l;
	for(int i=mid+1;i<=r;i++) {
		if(st[i].op==1) continue ;
		while(tag<=mid&&st[tag].op==1&&t[st[tag].id].lp<=q[st[i].id].l) {
			Modify(1,t[st[tag].id].l,t[st[tag].id].r,1);
			tag++;
		}
		ans[st[i].id]+=query(1,1,q[st[i].id].tim);
	}
	for(int i=l;i<tag;i++) Modify(1,t[st[i].id].l,t[st[i].id].r,-1);
	inplace_merge(st+l,st+mid+1,st+r+1,cmpl);
}

int main() {
	n=Get(),m=Get();
	scanf("%s",s+1);
	char op[20];
	build(1,1,m);
	for(int i=1;i<=n;i++) {
		if(s[i]=='0') continue ;
		int j;
		for(j=i;j<=n&&s[j]=='1';j++);
		j--;
		R[i]=j;
		pos.insert(i);
		t[id[i]=++tot]=interval(i,j,1,m);
		i=j;
	}

	for(int i=1;i<=m;i++) {
		scanf("%s",op+1);
		int x;
		if(op[1]=='t') {
			x=Get();
			if(i==m) continue ;
			s[x]^=1;
			if(s[x]=='0') {
				it=pos.upper_bound(x);it--;
				int LL=*it,RR=R[LL];
				t[id[LL]].r=i;
				if(LL<x) {
					t[id[LL]=++tot]=interval(LL,x-1,i+1,m);
					R[LL]=x-1;
				} else pos.erase(LL);
				if(x<RR) {
					t[id[x+1]=++tot]=interval(x+1,RR,i+1,m);
					R[x+1]=RR;
					pos.insert(x+1);
				}
			} else {
				int nowl=x,nowr=x;
				it=pos.upper_bound(x);
				if(it!=pos.end()) {
					int y=*it;
					if(y==x+1) {
						nowr=R[y];
						t[id[y]].r=i;
						pos.erase(y);
					}
				}
				it=pos.lower_bound(x);
				if(it!=pos.begin()) {
					int y=*(--it);
					if(R[y]==x-1) {
						nowl=y;
						t[id[y]].r=i;
						pos.erase(y);
					}
				}
				t[id[nowl]=++tot]=interval(nowl,nowr,i+1,m);
				R[nowl]=nowr;
				pos.insert(nowl);
			}
		} else {
			q[++qt].l=Get(),q[qt].r=Get()-1;
			q[qt].id=qt,q[qt].tim=i;
		}
	}
	for(int i=1;i<=tot;i++) {
		st[++top]=node(1,i,t[i].rp);
	}
	for(int i=1;i<=qt;i++) {
		st[++top]=node(2,i,q[i].r);
	}
	sort(st+1,st+1+top,cmpr);
	solve(1,top);
	for(int i=1;i<=qt;i++) cout<<ans[i]<<"\n";
	return 0;
}