题 解 CF1398E 【Dos tipos de hechizos】

Solución $CF1398E$

Significado del tema

Portal de temas

$Sol$

Siento que este es el EE más difícil que he hecho recientemente.$E$ , hay tantos detalles

Suponemos aquí que $A$ es un hechizo que se puede duplicar,$B$ enfrente

Primero tenemos una idea codiciosa es cada $Un$ intento para que coincida con el gran peso, y el uso deAA primeraEl peso de$A\; en$ sí mismo es lo más pequeño posible, porque no puede producir una contribución que se duplique.

Consideramos usar set para mantener $Un$ conjunto de pesos (garantizado que no se repetirán y ordenados de pequeños a grandes para facilitar la operación). Y supongamos que ahora hay$s$ dos$A$ entonces contamos$s1$ significa elssanterior$s$ gran suma de pesos,$s2$ significa el anterior$s+1$ gran suma de pesos y$S$ es la suma de los valores de propiedad actuales.

Entonces clasificamos y discutimos:

• Suponiendo AA actualEl valor mínimo de$A$ mi mirango de$m$$i$ en valor de propiedad$\le s$ entonces la contribución es$(S+pre2-mi)$ . En concreto, este más pequeño esAAEl comienzo de$A$ y luego$s$ dos$A$ sí mismo está conectado y utilizado, con una$B$ .

• La contribución a otras situaciones es $(S+pre1)$ Es decir, se pueden emparejar uno por uno.

Para la clasificación de pesos, podemos mantener directamente el árbol de equilibrio (div2E usará el árbol de equilibrio / moda, solo felicite a fhq)

Complejidad del tiempo: $O\left(nlogn\right)$

$Code$

const int N=1e6+5;

int n,m,noden,tot,cnt,pre1,pre2;
int ans,sum;
set<int> S;
 
struct node
{
    
    
	int lc,rc,rnd,val,sz;
}a[N];
 
struct fhq{
    
    
	#define new NEW
	int rt;
	void pushup(int x){
    
    
		a[x].sz=a[a[x].lc].sz+a[a[x].rc].sz+1;
	}
	
	int new(int val){
    
    
		a[++noden]=(node){
    
    0,0,rand(),val,1};
		return noden;
	}
	void split(int now,int val,int &x,int &y){
    
    
		if(!now){
    
    
			x=y=0;
			return ;
		}
		if(a[now].val>=val){
    
    
			x=now;
			split(a[now].rc,val,a[now].rc,y);
		}
		else{
    
    
			y=now;
			split(a[now].lc,val,x,a[now].lc);
		}
		pushup(now);
	}
	int merge(int x,int y){
    
    
		if(!x||!y) return x|y;
		if(a[x].rnd<a[y].rnd){
    
    
			a[x].rc=merge(a[x].rc,y);
			pushup(x);
			return x;
		}
		else{
    
    
			a[y].lc=merge(x,a[y].lc);
			pushup(y);
			return y;
		}
	}
	int getk(int x,int k){
    
    
		if(!k||k>a[rt].sz) return 0;
		for(;;){
    
    
			if(k<=a[a[x].lc].sz) x=a[x].lc;
			else if(k==a[a[x].lc].sz+1) return x;
			else{
    
    
				k-=a[a[x].lc].sz+1;
				x=a[x].rc;
			}
		}
	}
	void insert(int val){
    
    
		int x,y;
		split(rt,val,x,y);
		rt=merge(merge(x,new(val)),y);
	}
	void Del(int val){
    
    
		int x,y,z;
		split(rt,val,x,z);
		split(x,val+1,x,y);
		y=merge(a[y].lc,a[y].rc);
		rt=merge(merge(x,y),z); 
	}
	int Find(int val){
    
    
		int res,x,y;
		split(rt,val+1,x,y);
		res=a[x].sz+1;
		rt=merge(x,y);
		return res;
	}
	int Kth(int rank){
    
    
		return a[getk(rt,rank)].val;
	}
}T;

signed main()
{
    
    
	io.read(n);
	for (;n--;)
	{
    
    
		int op,x;
		io.read(op),io.read(x);
		int y=abs(x);
		sum+=x;
		int rk=T.Find(y);
		if(x>0) 
		{
    
    
			if(rk<=cnt) pre1+=(y-T.Kth(cnt));
			if(rk<=cnt+1) pre2+=(y-T.Kth(cnt+1));
			T.insert(y);
			if(op==1)
			{
    
    
				cnt++;
				pre1+=T.Kth(cnt);
				pre2+=T.Kth(cnt+1);
				S.insert(y);
			}
			if(T.Find(*S.begin())==cnt) ans=sum+pre2-*S.begin();
			else ans=sum+pre1;
		}
		else 
		{
    
    
			if(rk<=cnt) pre1-=(y-T.Kth(cnt+1));
			if(rk<=cnt+1) pre2-=(y-T.Kth(cnt+2));
			T.Del(y);
			if(op==1)
			{
    
    
				pre1-=T.Kth(cnt);
				pre2-=T.Kth(cnt+1);
				cnt--;
				S.erase(y);
			}
			if(cnt&&T.Find(*S.begin())==cnt) ans=sum+pre2-*S.begin();
			else ans=sum+pre1;
		}
		io.write(ans);
		puts("");
	}
	return 0;
}