Codeforces 500E New Year Domino （并查集+单调队列维护）

参考自大佬Patrickpwq, 这题感觉还是挺好的，这里还是写一下供自己以后翻开吧

题目链接：New Year Domino

题意：n个杆子在x轴上，给定每个杆子的位置和高度,杆子i可以压倒杆子i+1当且仅当杆子i高度大于二者间距，杆子可以通过花费1美元提高一个单位，给定q次询问，问要使[l,r]内杆子都能倒下，最少要多少美元(各询问互不干扰)

题解：我们可以将每个能相互到达的杆子用并查集维护到一起，枚举每个杆子到达最后一根杆子的花费，将询问离线下来，从后往前枚举排除前面杆子过高影响后面的答案，用单调队列维护每个并查集的最左边节点下标

代码如下，不懂可以看注释~

#include<iostream>
#include<stack>
#include<list>
#include<set>
#include<vector>
#include<algorithm>
#include<math.h>
#include<numeric>
#include<map>
#include<cstring>
#include<queue>
#include<iomanip>
#include<cmath>
#include<queue>
#include <bitset>
#include<unordered_map>
	#ifndef local
	#define endl '\n'
#endif 
#define mkp make_pair
using namespace std;
using std::bitset;
typedef long long ll;
typedef long double ld;
const int inf=0x3f3f3f3f;
const ll MAXN=2e6+10;
const ll N=1e6+100;
const ll mod=1e9+7;
const ll hash_p1=1610612741;
const ll hash_p2=805306457;
const ll hash_p3=402653189;
//-----------------------------------------------------------------------------------------------------------------*/
// ll head[MAXN],net[MAXN],to[MAXN],edge[MAXN]/*流量*/,cost[MAXN]//费用;
/* 
void add(ll u,ll v,ll w,ll s){
	to[++cnt]=v;net[cnt]=head[u];edge[cnt]=w;cost[cnt]=s;head[u]=cnt;
	to[++cnt]=u;net[cnt]=head[v];edge[cnt]=0;cost[cnt]=-s;head[v]=cnt;
}
struct elemt{
	int p,v;
};
struct comp{
	public:
		bool operator()(elemt v1,elemt v2){
			return v1.v<v2.v;
		}
};
-----------------------------------
求[1,MAXN]组合式和逆元 
ll mi(ll a,ll b){
	ll res=1;
	while(b){
		if(b%2){
			res=res*a%mod;
		}	
		a=a*a%mod;
	}
	return res;
}
ll fac[MAXN],inv[MAXN]
fac[0]=1;inv[0]=1;
for(int i=1;i<=MAXN;i){
	fac[i]=(fac[i-1]*i)%mod;
	inv[i]=mi(fac[i],mod-2);
}
ll C(int m,int n){//组合式C(m,n); 
	if(!n){
		return 1;
	}
	return fac[m]*(inv[n]*inv[m*-n]%mod)%mod;
}
---------------------------------
 unordered_map<int,int>mp;
//优先队列默认小顶堆 ， greater<int> --小顶堆  less<int> --大顶堆  
priority_queue<elemt,vector<elemt>,comp>q;
	set<int>::iterator it=st.begin();
*/
// vector<vector<int>>edge; 二维虚拟储存坐标 
//-----------------------------------------------------------------------------------------------------------------*/
  //map<int,bool>mp[N]; 
struct elemt{
	int p,l;
};
elemt a[N];//存元素
int f[N];
vector<int>ask[N];
int find(int x){//并查集 
	return x==f[x]?x:f[x]=find(f[x]);
}
int x[N],y[N];//存询问
int cost[N];//记录各个点到终点的花费
int ans[N]; 
int main(){
/*cout<<setiosflags(ios::fixed)<<setprecision(8)<<ans<<endl;//输出ans（float）格式控制为8位小数（不含整数部分）*/
/*cout<<setprecision(8)<<ans<<endl;//输出ans（float）格式控制为8位小数（含整数部分）*/
	ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);//同步流
	int n,q;
	cin>>n;
	for(int i=1;i<=n;i++){
		f[i]=i;
		cin>>a[i].p>>a[i].l;
	}
	cin>>q;
	for(int i=1;i<=q;i++){
		cin>>x[i]>>y[i];
		ask[x[i]].push_back(i);//存询问对应下标 
	}
	stack<pair<int,int> >st;//单调栈存之前已经形成的联通块的 pair分别维护最左边元素下标，和能到达的最远点 
	st.push({n,a[n].l+a[n].p});
	for(int i=n-1;i>=1;i--){
		int r=a[i].p+a[i].l;
		while(st.size()&&a[st.top().first].p<=r){//当前点可以和上一个连通块合并
			r=max(r,st.top().second); 
			f[st.top().first]=i;//合并连通块
			st.pop();
		}
		if(!st.empty()){//st为空说明能走到低，即花费为0，就博弈更新了
			cost[i]=cost[st.top().first]+a[st.top().first].p-r;//当前点到终点花费==到下一个块花费+下一个块到终点花费
		}
		st.push({i,r});
		for(int j=0;j<ask[i].size();j++){
			int tmp=ask[i][j];
			ans[tmp]=cost[i]-cost[find(y[tmp])];//一定得是减去find(tmp)的花费，因为在i减小的过程中可能这个连通块的花费也会减小 
		}
	}
	/*for(int i=1;i<=n;i++){
		cout<<"i="<<i<<" cost="<<cost[i]<<endl;
	}*/
	for(int i=1;i<=q;i++){
		cout<<ans[i]<<endl; 
	}
	return 0;
}

，和能到达的最远点，每次更新一个点就求一下从这个点出发的询问，并求出答案，