题解:栈

题目传送门

题意分析

考虑正常的做法是扫时间轴,然后用数据结构维护 \([1,n]\) 的栈。

但是栈不好维护,考虑换维,扫 \([1,n]\) 的栈,然后数据结构维护整个时间轴。

操作就形如:

  • 后缀压入 \(x\) 个 \(y\),及其反操作。
  • 后缀弹出 \(x\) 个数,及其反操作。
  • 查询从栈底开始数第 \(x\sim y\) 个数之和。

考虑区间加入/弹出数还是不好维护,因此作差分,形如:

  • 单点压入 \(x\) 个 \(y\),及其反操作。
  • 单点弹出 \(x\) 个数,及其反操作。
  • 查询前缀所有操作形成的栈,第 \(x\sim y\) 个数之和。

考虑线段树维护时间轴,单点操作区间查询。

发现所有的操作都可以形如 \((\textit{del},\textit{cnt},\textit{sum})\),即先弹出 \(\textit{del}\) 个数,再压入 \(\textit{cnt}\) 个数,其总和为 \(\textit{sum}\)。

单点操作后,设 \((\textit{del}_p,\textit{cnt}_p,\textit{sum}_p)\) 是 \(p\) 的信息,可以直接对位相加。

对于合并左右子区间 \(p,q\) 的信息,有:

  • \(\textit{del}_q\geq\textit{cnt}_p\),\(p\) 插入的数都被弹空了,合并后标记为 \((\textit{del}_p+\textit{del}_q-\textit{cnt}_p,\textit{cnt}_q,\textit{sum}_q)\)。

  • \(\textit{del}_q<\textit{cnt}_p\),\(p\) 插入的数没有被弹空,\(q\) 的弹空次数消耗完了,合并后的 \(\textit{sum}\) 还需要考虑 \(p\) 中未弹空的部分。

    这时不能 \(\mathcal O(1)\) 维护,但是可以单侧递归维护。

    定义 \(\operatorname{getans}(x,\textit{del})\) 表示节点 \(x\) 弹出 \(\textit{del}\) 个元素后的和。令 \(p,q\) 分别为 \(x\) 的左右子节点,考虑如何计算 \(\operatorname{getans}(x,\textit{del})\):

    • \(\textit{del}\geq\textit{cnt}_x\),被弹空,有 \(\operatorname{getans}(x,\textit{del})=0\)。

    • \(x\) 为单点区间。

      考虑直接弹,因为是时间轴,所以一个点只会被至多压入一次若干个相同的数。

      有 \(\operatorname{getans}(x,\textit{del})=\dfrac{\textit{sum}_x}{\textit{cnt}_x}(\textit{cnt}_x-\textit{del})\)。

      特别地,如果 \(\textit{cnt}_x=0\),则弹空了,答案为 \(0\)。

    • 否则,需要递归子区间。

      因为是前缀时间轴,先考虑右子区间 \(q\) 的操作。

      • 如果 \(\textit{cnt}_q\geq\textit{del}\),则只需要在 \(q\) 里弹出。\(p\) 对 \(\textit{sum}_x\) 的贡献为 \(\textit{sum}_x-\textit{sum}_q\),有:

        \[\operatorname{getans}(x,\textit{del})=\textit{sum}_x-\textit{sum}_q+\operatorname{getans}(p,\textit{del}) \]

      • 否则 \(q\) 弹空,在 \(p\) 里弹出。还需要注意,此时 \(q\) 的弹出操作会对 \(x\) 产生贡献,因此需要计算,有:

        \[\operatorname{getans}(x,\textit{del})=\operatorname{getans}(p,\textit{del}-\textit{cnt}_q+\textit{del}_q) \]

    于是可以 \(\mathcal O(\log n)\) 单侧递归实现 \(\operatorname{getans}(x,\textit{del})\)。

    则此时合并后的信息为 \((\textit{del}_p,\textit{cnt}_p-\textit{del}_q+\textit{cnt}_q,\operatorname{getans}(p,\textit{del}_q)+\textit{sum}_q)\)。

考虑如何实现前缀查询栈底第 \(x\sim y\) 个数之和,差分一下就是查询前缀的操作形成的栈的 \(1\sim x\) 个数之和。

设查询区间为 \([1,\textit{id}]\)。

查询不能直接由每个节点的操作计算,因此需要先从右至左,确定拆分出来的 \(\mathcal O(\log n)\) 个区间的 \((\textit{del}',\textit{cnt}',\textit{sum}')\),表示该节点被后续区间弹出了 \(\textit{del}'\) 次,最终剩余元素个数为 \(\textit{cnt}'\),其和为 \(\textit{sum}'\)。这是容易维护的。计算 \(\textit{sum}'=\operatorname{getans}(p,\textit{del}')\)。

维护查询是简单的。

AC 代码

//#include<bits/stdc++.h>
#include<algorithm>
#include<iostream>
#include<cstring>
#include<iomanip>
#include<cstdio>
#include<string>
#include<vector>
#include<cmath>
#include<ctime>
#include<deque>
#include<queue>
#include<stack>
#include<list>
using namespace std;
typedef long long ll;
constexpr const int N=1e5,M=1e5;
struct operation{
	int id,op;
	ll x,y;
};
struct Val{
	ll del,cnt,sum;
};
int n,m;
vector<operation>q[M+1+1];
struct segTree{
	struct node{
		int l,r;
		Val val;
		ll del,cnt,sum;
	}t[M<<2|1];
	
	void build(int p,int l,int r){
		t[p]={l,r};
		if(l==r){
			return;
		}
		int mid=l+r>>1;
		build(p<<1,l,mid);
		build(p<<1|1,mid+1,r);
	}
	ll getans(int p,ll del){
		if(del>=t[p].val.cnt){
			return 0;
		}
		if(t[p].l==t[p].r){
			if(!t[p].val.cnt){
				return 0;
			}
			return t[p].val.sum/t[p].val.cnt*(t[p].val.cnt-del);
		}
		if(t[p<<1|1].val.cnt>=del){
			return getans(p<<1|1,del)+t[p].val.sum-t[p<<1|1].val.sum;
		}
		del-=t[p<<1|1].val.cnt;
		return getans(p<<1,del+t[p<<1|1].val.del);
	}
	Val up(int p,int q){
		if(t[q].val.del>=t[p].val.cnt){
			return {t[p].val.del+t[q].val.del-t[p].val.cnt,t[q].val.cnt,t[q].val.sum};
		}else{
			return {t[p].val.del,t[q].val.cnt+t[p].val.cnt-t[q].val.del,getans(p,t[q].val.del)+t[q].val.sum};
		}
	}
	void update(int p,int x,Val val){
		if(t[p].l==t[p].r){
			t[p].val.del+=val.del;
			t[p].val.cnt+=val.cnt;
			t[p].val.sum+=val.sum;
			return;
		}
		if(x<=t[p<<1].r){
			update(p<<1,x,val);
		}else{
			update(p<<1|1,x,val);
		}
		t[p].val=up(p<<1,p<<1|1); 
	}
	void getdel(int p,int l,int r,ll &del){
		t[p].cnt=0;t[p].sum=0;
		if(l<=t[p].l&&t[p].r<=r){
			if(t[p].val.cnt>=del){
				t[p].del=del;
				t[p].cnt=t[p].val.cnt-del;
				t[p].sum=getans(p,del);
				del=t[p].val.del;
			}else{
				t[p].del=t[p].val.cnt;
				del=del-t[p].val.cnt+t[p].val.del;
				t[p].cnt=0;
				t[p].sum=0;
			}
			return;
		}
		if(t[p<<1|1].l<=r){
			getdel(p<<1|1,l,r,del);
		}
		if(l<=t[p<<1].r){
			getdel(p<<1,l,r,del);
		}
	}
	ll query(int p,int l,int r,ll &cnt){
		if(cnt<=0){
			return 0;
		}
		if(l<=t[p].l&&t[p].r<=r){
			if(t[p].cnt>=cnt){
				ll cnt2=cnt;
				cnt=0;
				return getans(p,t[p].cnt-cnt2+t[p].del);
			}else{
				cnt-=t[p].cnt;
				return t[p].sum;
			}
		}
		ll ans=0;
		if(l<=t[p<<1].r){
			ans+=query(p<<1,l,r,cnt);
		}
		if(t[p<<1|1].l<=r){
			ans+=query(p<<1|1,l,r,cnt);
		}
		return ans;
	}
}t;
int main(){
	/*freopen("test.in","r",stdin);
	freopen("test.out","w",stdout);*/
	
	ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	
	cin>>n>>m;
	for(int i=1;i<=m;i++){
		int op;
		ll l,r,x,y;
		cin>>op;
		switch(op){
			case 1:
				cin>>l>>r>>x>>y;
				q[l].push_back({i,1,x,y});
				q[r+1].push_back({i,-1,x,y});
				break;
			case 2:
				cin>>l>>r>>x;
				q[l].push_back({i,2,x,0});
				q[r+1].push_back({i,-2,x,0});
				break;
			case 3:
				cin>>x>>l>>r;
				q[x].push_back({i,0,l,r});
				break;
		}
	}
	vector<pair<int,ll>>ans;
	t.build(1,1,m);
	for(int i=1;i<=n;i++){
		for(auto [id,op,x,y]:q[i]){
			ll del,cnt,pl;
			switch(op){
				case 0:
					del=0,cnt=y;
					t.getdel(1,1,id,del);
					pl=t.query(1,1,id,cnt);
					cnt=x-1;
					pl-=t.query(1,1,id,cnt);
					ans.push_back({id,pl});
					break;
				case -1:
					t.update(1,id,{0,-x,-x*y});
					break;
				case 1:
					t.update(1,id,{0,x,x*y});
					break;
				case 2:
					t.update(1,id,{x,0,0});
					break;
				case -2:
					t.update(1,id,{-x,0,0});
					break;
			}
		}
	}
	sort(ans.begin(),ans.end());
	for(auto [id,x]:ans){
		cout<<x<<'\n';
	}
	
	cout.flush();
	
	/*fclose(stdin);
	fclose(stdout);*/
	return 0;
}
posted @ 2026-10-25 15:42  TH911  阅读(17)  评论(0)    收藏  举报