析合树

最新推荐文章于 2023-02-01 19:17:05 发布
原创 最新推荐文章于 2023-02-01 19:17:05 发布 · 1k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

给你们一个LCA的9K代码就溜：

#include<bits/stdc++.h>

using namespace std;

const int MX=2000005,MXT=MX<<1,MXSEG=1<<20|1,inf=0x7fffffff;

int n,q;
int p[MX],a[MX];

struct seg_t{
	int ad;
	int mn;
	void add(int d){
		ad+=d;
		if(mn!=inf)mn+=d;
	}
	void set(int d){ // only for leaves
		ad=0,mn=d;
	}
	void push_down(seg_t &l, seg_t &r){
		if(ad){
			l.add(ad),r.add(ad);
			ad=0;
		}
	}
	void push_up(const seg_t &l, const seg_t &r){
		mn=min(l.mn, r.mn);
	}
}; // 前缀+1；前缀-1；区间最值；
struct separationtree_t{
	// private:
	int ip[MX];
	seg_t sg[MXSEG];
	// public
	struct snode_t{
		int fa,rson,pre,typ,l,r;
		snode_t(int _f=0,int _rs=0,int _t=0,int _l=0,int _r=0)
			:fa(_f),rson(_rs),pre(0),typ(_t),l(_l),r(_r){}
		void debug(){
			cerr<<"fa: "<<fa<<" rs: "<<rson<<" p: "<<pre<<" t: "<<typ<<" l: "<<l<<" r: "<<r<<endl;
		}
	}node[MXT];
	int nit,rot;
	void add(int no,int l,int r,int ll,int rr,int d){
		if(ll<=l&&rr>=r)sg[no].add(d);
		else{
			sg[no].push_down(sg[no<<1],sg[no<<1|1]);
			int mid=(l+r)>>1;
			if(ll<=mid)add(no<<1,l,mid,ll,rr,d);
			if(rr>mid)add(no<<1|1,mid+1,r,ll,rr,d);
			sg[no].push_up(sg[no<<1],sg[no<<1|1]);
		}
	}
	int queryL(int no,int l,int r){
		if(l==r)return l;
		else{
			sg[no].push_down(sg[no<<1],sg[no<<1|1]);
			int mid=(l+r)>>1;
			if(sg[no<<1].mn<=1)return queryL(no<<1,l,mid);
			else return queryL(no<<1|1,mid+1,r);
		}
	}
	bool check(int no,int l,int r,int x){
		if(l==r)return sg[no].mn<=1;
		else{
			sg[no].push_down(sg[no<<1],sg[no<<1|1]);
			int mid=(l+r)>>1;
			if(x<=mid)return check(no<<1,l,mid,x);
			else return check(no<<1|1,mid+1,r,x);
		}
	}
	void build(int n, int p[]){
		for(int i=1;i<=n;i++)ip[p[i]]=i;
		static int stk[MX];
		int stc=0;
		nit=n;
		for(int i=1;i<=n;i++){
			//if(i%100==0)cerr<<i<<endl;
			add(1,1,n,1,i,1);
			if(p[i]>1&&ip[p[i]-1]<i)add(1,1,n,1,ip[p[i]-1],-1);
			if(p[i]<n&&ip[p[i]+1]<i)add(1,1,n,1,ip[p[i]+1],-1);
			int L=queryL(1,1,n);
			
			node[i]=snode_t(0,0,0,i,i);
			stk[stc++]=i;
			while(stc>=2&&node[stk[stc-1]].l>L){
				snode_t &x=node[stk[stc-2]],&y=node[stk[stc-1]];
				if(x.rson&&check(1,1,n,node[x.rson].l)){ // 合点
					y.fa=stk[stc-2],y.pre=x.rson;
					x.rson=stk[stc-1];x.r=y.r;x.typ=1;
					--stc;
					continue;
				}
				for(int i=stc-2;i>=0;i--)if(check(1,1,n,node[stk[i]].l)){
					node[++nit]=snode_t(0,stk[stc-1],0,node[stk[i]].l,node[stk[stc-1]].r);
					while(stc>i){
						node[stk[--stc]].fa=nit;
						if(stc>i)node[stk[stc]].pre=stk[stc-1];
					}
					stk[stc++]=nit;
					break;
				}
			}
		}
		rot=stk[0];
	}
	void debug(){
		for(int i=1;i<=nit;i++)node[i].debug();
	}
	snode_t& operator [](const int x){return node[x];}
	const snode_t& operator[](const int x)const{return node[x];}
}sept;
struct tree1_t{
	// 析点、重儿子
	// 单点修改、区间+、区间min
	seg_t sg[MXSEG];
	
	void add(int no,int l,int r,int ll,int rr,int d){
		if(ll<=l&&rr>=r)sg[no].add(d);
		else{
			sg[no].push_down(sg[no<<1],sg[no<<1|1]);
			int mid=(l+r)>>1;
			if(ll<=mid)add(no<<1,l,mid,ll,rr,d);
			if(rr>mid)add(no<<1|1,mid+1,r,ll,rr,d);
			sg[no].push_up(sg[no<<1],sg[no<<1|1]);
		}
	}
	void set(int no,int l,int r,int x,int d){
		if(l==r)sg[no].set(d);
		else{
			sg[no].push_down(sg[no<<1],sg[no<<1|1]);
			int mid=(l+r)>>1;
			if(x<=mid)set(no<<1,l,mid,x,d);
			else set(no<<1|1,mid+1,r,x,d);
			sg[no].push_up(sg[no<<1],sg[no<<1|1]);
		}
	}
	int rangemin(int no,int l,int r,int ll,int rr){
		if(ll<=l&&rr>=r)return sg[no].mn;
		else{
			sg[no].push_down(sg[no<<1],sg[no<<1|1]);
			int mid=(l+r)>>1;
			int ans=inf;
			if(ll<=mid)ans=min(ans,rangemin(no<<1,l,mid,ll,rr));
			if(rr>mid)ans=min(ans,rangemin(no<<1|1,mid+1,r,ll,rr));
			return ans;
		}
	}
	int val(int no,int l,int r,int x){
		if(l==r)return sg[no].mn;
		else{
			sg[no].push_down(sg[no<<1],sg[no<<1|1]);
			int mid=(l+r)>>1;
			if(x<=mid)return val(no<<1,l,mid,x);
			else return val(no<<1|1,mid+1,r,x);
		}
	}
}tsplit,theavy;
struct bst_data_t{
	int mn[2],s;
	bst_data_t():s(0){mn[0]=mn[1]=0;}
	void set(int v){
		s=v;
		mn[0]=mn[1]=min(0,v);
	}
};
bst_data_t operator +(const bst_data_t &l, const bst_data_t &r){
	bst_data_t a;
	a.s=l.s+r.s,a.mn[0]=min(l.mn[0],l.s+r.mn[0]),a.mn[1]=min(l.mn[1]+r.s,r.mn[1]);
	return a;
}
struct bst_t{
	bst_t *s[2];
	int l,r;
	bst_data_t d;
	bst_t():l(0),r(0),d(){
		s[0]=s[1]=NULL;
	}
	bst_data_t rangequery(int ll,int rr){
		if(rr<l||ll>r)return bst_data_t();
		if((ll<=l&&rr>=r)||!s[0])return d;
		else{
			if(rr<=s[0]->r)return s[0]->rangequery(ll,rr);
			else if(ll>s[0]->r)return s[1]->rangequery(ll,rr);
			else return s[0]->rangequery(ll,rr)+s[1]->rangequery(ll,rr);
		}
	}
	void update(int x,int v){
		if(!s[0])d.set(v);
		else{
			if(x<=s[0]->r)s[0]->update(x,v);
			else s[1]->update(x,v);
			d=s[0]->d+s[1]->d;
		}
	}
	void debug(int indent=0){
		if(s[0])s[0]->debug(indent+1);
		for(int i=0;i<indent;i++)cerr<<'\t';
		cerr<<'['<<l<<", "<<r<<']'<<endl;
		if(s[1])s[1]->debug(indent+1);
	}
}tl_pool[MXT*2],*tl_it=tl_pool,*tl[MXT];
struct hld_t{
	// private:
	int sz[MXT];
	// public:
	int top[MXT],hson[MXT];
	int dfn[MXT],dfc;
	hld_t():dfc(0){}
	void dfs(separationtree_t& t, int no){
		sz[no]=1;
		for(int i=t[no].rson;i;i=t[i].pre){
			dfs(t, i);
			sz[no]+=sz[i];
			hson[no]=(hson[no]&&sz[hson[no]]>=sz[i]?hson[no]:i);
		}
	}
	void decomp(separationtree_t& t, int no, int _top){
		top[no]=_top;dfn[no]=++dfc;
		if(hson[no]){
			decomp(t, hson[no], _top);
			for(int i=t[no].rson;i;i=t[i].pre)if(i!=hson[no]){
				decomp(t, i, i);
			}
		}
	}
	void build(separationtree_t& t){
		dfs(t, t.rot);
		decomp(t, t.rot, t.rot);
	}
	int querychain(separationtree_t& t, tree1_t& sg,int x){
		int ans=inf;
		while(x){
			ans=min(ans,sg.rangemin(1,1,t.nit,dfn[top[x]],dfn[x]));
			x=t[top[x]].fa;
		}
		return ans;
	}
	void maintain_hson(separationtree_t& t, int x){
		tl[x]->update(t[hson[x]].l,tsplit.val(1,1,t.nit,dfn[hson[x]]));
	}
	int query(separationtree_t& t,int x,int s){ // 关键点位于x的子树s中的答案
		maintain_hson(t, x);
		return tsplit.val(1,1,t.nit,dfn[s])+tl[x]->rangequery(1,t[s].l-1).mn[1]+tl[x]->rangequery(t[s].r+1,inf).mn[0];
	}
	void addchain(separationtree_t& t,tree1_t& sg,int x,int v){
		while(x){
			sg.add(1,1,t.nit,dfn[top[x]],dfn[x],v);
			x=t[top[x]].fa;
		}
	}
	void updheavy(separationtree_t& t,tree1_t& sg,int x,int v){
		// 注意：v是增量. 但由于query函数只依赖于tsplit，这足够了
		while(x){
			if(top[x]!=x)sg.add(1,1,t.nit,dfn[top[x]]+1,dfn[x],v);
			if(t[top[x]].fa){
				// 更新t[top[x]].fa的轻儿子……
				tl[t[top[x]].fa]->update(t[top[x]].l,tsplit.val(1,1,t.nit,dfn[top[x]]));
				// 更新t[top[x]].fa的重儿子……
				if(t[t[top[x]].fa].typ==1)
					sg.set(1,1,t.nit,dfn[hson[t[top[x]].fa]],query(t,t[top[x]].fa,hson[t[top[x]].fa]));
			}
			x=t[top[x]].fa;
		}
	}
	int querylight(separationtree_t& t,int x){
		int ans=inf;
		while(x){
			if(t[top[x]].fa&&t[t[top[x]].fa].typ==1){
				ans=min(ans,query(t,t[top[x]].fa,top[x]));
			}
			x=t[top[x]].fa;
		}
		return ans;
	}
	void ini_heavy(separationtree_t& t,tree1_t& sg){
		for(int i=1;i<=t.nit;i++)if(top[i]==i||t[t[i].fa].typ==0)sg.set(1,1,t.nit,dfn[i],inf);
	}
	void debugpoints(separationtree_t& t, tree1_t& sg){
		for(int i=1;i<=t.nit;i++)cerr<<sg.val(1,1,t.nit,dfn[i])<<' ';
		cerr<<endl;
	}
}hld;
int query(int x){
	int ans=inf;
	ans=min(ans,hld.querychain(sept,tsplit,x)); // 查询析点
	// cerr<<"k1: "<<ans<<endl;
	ans=min(ans,hld.querychain(sept,theavy,x)); // 查询作为重儿子的祖先
	// cerr<<"k2: "<<ans<<endl;
	ans=min(ans,hld.querylight(sept,x)); // 查询作为轻儿子的祖先
	return ans;
}
void update(int x,int v){
	hld.addchain(sept,tsplit,x,v-a[x]);
	// cerr<<"add chain"<<endl;
	hld.updheavy(sept,theavy,x,v-a[x]);
	// cerr<<"upd heavy"<<endl;
	a[x]=v;
}
bst_t* bst_build(int* l,int* r){
	bst_t* t=tl_it++;
	if(r==l+1){
		t->l=sept[*l].l,t->r=sept[*l].r;
	}else{
		int* m=l+((r-l)>>1);
		t->s[0]=bst_build(l,m),t->s[1]=bst_build(m,r);
		t->l=t->s[0]->l,t->r=t->s[1]->r;
	}
	return t;
}
void ini(){
	for(int i=1;i<=sept.nit;i++)if(sept[i].rson){
		static int q[MX];int qc=0;
		for(int j=sept[i].rson;j;j=sept[j].pre)q[qc++]=j;
		reverse(q,q+qc);
		tl[i]=bst_build(q,q+qc);
		// cerr<<"tl: "<<i<<endl;
		// tl[i]->debug();
	}
	// cerr<<"bst built"<<endl;
	hld.ini_heavy(sept,theavy);
	// cerr<<"ini heavy"<<endl;
	for(int i=1;i<=n;i++){
		int t=a[i];a[i]=0;
		update(i,t);
	}
}
void solve(){
	for(int i=1;i<=q;i++){
		int op; scanf("%d",&op); //cin>>op;
		if(op==1){
			int u; scanf("%d",&u); // cin>>u;
			printf("%d\n",query(u));
//			cout<<query(u)<<endl;
		}else if(op==2){
			int i,a;
			scanf("%d%d",&i,&a);
			//cin>>i>>a;
			update(i,a);
			// hld.debugpoints(sept, tsplit);
			// hld.debugpoints(sept, theavy);
		}
	}
}
int main(){
//	ios::sync_with_stdio(false);
	scanf("%d",&n);
//	cin>>n;
	for(int i=1;i<=n;i++) scanf("%d",p+i);//cin>>p[i];
	for(int i=1;i<=n;i++) scanf("%d",a+i);//cin>>a[i];
	sept.build(n, p);
	// cerr<<"sept"<<endl;
	// sept.debug();
	hld.build(sept);
	// cerr<<"hld"<<endl;
	ini();
	// cerr<<"ini"<<endl;
	// hld.debugpoints(sept, tsplit);
	// hld.debugpoints(sept, theavy);
	scanf("%d",&q); //cin>>q;
	solve();
	return 0;
}

前置技能：
快速计算一个排列中所有的 排序后后相邻两数后一数比前一数大一 的区间。
Codeforces 997 E 题解（不是我写的）
两个单调栈求最值配合线段树维护 M a x − M i n − L e n Max - Min - Len Max−Min−Len的最小值。
为0代表有该种区间。
可以套上求历史值和的线段树来解决CF上的题。
AC Code;

#include<bits/stdc++.h>
#define maxn 400005
#define LL long long
#define lc now<<1
#define rc lc|1
using namespace std;

int n,p[maxn],Q,l[maxn],r[maxn];
vector<int>G[maxn];

int mn[maxn<<3],cnt[maxn<<3],ad[maxn<<3],ada[maxn<<3];
LL ret[maxn],ans[maxn<<3];

void dtadd(int now){
	if(ad[now]){
		mn[now] += ad[now] , ad[lc] += ad[now] , ad[rc] += ad[now];
		ad[now] = 0;
	}
}

void dt(int now){
	if(ad[now]){
		mn[now] += ad[now] , ad[lc] += ad[now] , ad[rc] += ad[now];
		ad[now] = 0;
	}
	if(ada[now]){
		ans[now] += 1ll * cnt[now] * ada[now];
		dtadd(lc) , dtadd(rc);
		if(mn[now] == mn[lc]) ada[lc] += ada[now];
		if(mn[now] == mn[rc]) ada[rc] += ada[now];
		ada[now] = 0;
	}
}

void upd(int now){
	mn[now] = min(mn[lc] , mn[rc]);
	ans[now] = ans[lc] + ans[rc];
	cnt[now] = (mn[now] == mn[lc]) * cnt[lc] + (mn[now] == mn[rc]) * cnt[rc];
}

void Build(int now,int l,int r){
	if(l == r){
		cnt[now] = 1;
		return;
	}
	int mid = (l+r) >> 1;
	Build(lc,l,mid) , Build(rc,mid+1,r);
	upd(now);
}

void Insert(int now,int l,int r,int ql,int qr,int x,int x2){
	dt(now);
	if(l>qr || ql>r) return;
	if(ql<=l && r<=qr){
		ad[now] += x;
		if(!mn[now]) ada[now] += x2;
		dt(now);
		return;
	}
	int mid = (l+r) >> 1;
	Insert(lc,l,mid,ql,qr,x,x2) , Insert(rc,mid+1,r,ql,qr,x,x2);
	upd(now);
}

LL Query(int now,int l,int r,int ql,int qr){
	dt(now);
	if(l>qr||ql>r) return 0;
	if(ql<=l && r<=qr)
		return ans[now];
	int mid = (l+r) >> 1;
	return Query(lc,l,mid,ql,qr) + Query(rc,mid+1,r,ql,qr);
}
int q[2][maxn],tp[2];

int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++) scanf("%d",&p[i]);
	scanf("%d",&Q);
	for(int i=1;i<=Q;i++){
		scanf("%d%d",&l[i],&r[i]);
		G[r[i]].push_back(i);
	}
	
	Build(1,1,n);
	for(int i=1;i<=n;i++){
		for(;tp[0] && p[q[0][tp[0]]] < p[i];) Insert(1,1,n,q[0][tp[0]-1]+1,q[0][tp[0]],p[i]-p[q[0][tp[0]]],0),tp[0]--;
		for(;tp[1] && p[q[1][tp[1]]] > p[i];) Insert(1,1,n,q[1][tp[1]-1]+1,q[1][tp[1]],p[q[1][tp[1]]]-p[i],0),tp[1]--;
		q[0][++tp[0]] = q[1][++tp[1]] = i;
		Insert(1,1,n,1,i,0,1);
		for(int u:G[i])
			ret[u] = Query(1,1,n,l[u],i);
		Insert(1,1,n,1,i,-1,0);
	} 
	
	for(int i=1;i<=Q;i++) 
		printf("%lld\n",ret[i]);
}

然后学习简便易懂的 O ( n log ⁡ n ) O(n\log n) O(nlogn)构造析合树的方法

就是在数列构成的析合树森林中，后面插入新数，新数看做一个连续段（或没有儿子的特殊合点）（采用上述博客中的定义）。
如果前面的点是合点，你就可能可以变成它的儿子（和他的所有儿子（也就是它自己所代表的连续段）合并，用线段树判断）
如果不能，但是你可以和它代表的连续端合并，就新建一个合点，这个合点的儿子是它和你，再让这个合点如一个新点般往前合并。
如果都不能，就新建一个析点，这个析点的儿子是它和你，往前拓展，
如果不能拓展了，就有两种：
1.这个析点代表的区间是一个连续段，那么就退出，什么都不用管。
2.这个析点代表的区间不是一个连续段，删掉析点，这个新点是不能合并的 ，成为森林中的一颗树。

这个2代表失配，每次失配是 O ( n ) O(n) O(n)的，所以可能复杂度变为 O ( n 2 ) O(n^2) O(n2)。
为了避免这个情况，我们用线段树求出新点往左最远可以到x使得[x,now location]是一个连续段。
只要枚举的前面析合树左端点小于这个x，我们就不合并了，反正都一定会失配。

这样复杂度就是 O ( n log ⁡ n ) O(n\log n) O(nlogn)

细心的读者可以发现这个方法只适用与数列为排列的情况。
数列为任意数的情况就可以参考LCA大佬的9K代码，尽情享受代码的魅力。
LCA题解：

比较容易的实现是在从左到右扫描右端点时同时维护一棵线段树表示当前每个左端点对应的区
间内元素个数减权值相邻关系对数的值。连续段此值为 ，否则 。那么可以维护区间最小值来支持查询以当前位
置为右端点的连续段。

相场法模拟二元合金中考虑溶质偏析的comsol枝晶生长研究,comsol枝晶生长相场法模拟 二元合金 考虑溶质偏析 ,comsol;枝晶生长;相场法模拟;二元合金;溶质偏析,COMSOL二元合金溶质偏
01-29
具体来说，通过COMSOL软件进行的枝晶生长相场法模拟研究，可以对二元合金中的溶质偏析进行定量分析，观察不同偏析条件下枝晶的形态变化，并对枝晶生长的动力学和热力学过程进行解析。这些模拟研究不仅可以预测实际...
数理逻辑辅助工具-合取范式&析取范式生成器
01-22
在这个领域中，合取范式（Conjunctive Normal Form, CNF）和析取范式（Disjunctive Normal Form, DNF）是两种重要的逻辑表达方式。它们在计算机科学，尤其是人工智能和软件工程中有着广泛的应用，例如在电路设计、...
【学习笔记】析合树
weixin_34056162的博客
06-14 412
定义 为了方便，下面的定义都是对一个\(n\)阶排列 定义一个段的值域$ran[l,r] = [min a_i , max a_i] (l \le i \le r) $ ，对于一个排列\(ran[l,r] \ge r-l+1\) 定义1 一个段是连续的，当且\(|ran[l,r]|= r-l+1\) ，显然$ \varnothing ,[1,n],[i,i]$都是连续的 性质1： 对于两...
析合树学习笔记
ez_lcw的博客
11-02 773
析合树 对于一个 nnn 阶排列 ppp，定义其一个区间 [l,r][l,r][l,r] 是连续的，当且仅当 pl,pl+1,⋯ ,prp_{l},p_{l+1},\cdots,p_rpl​,pl+1​,⋯,pr​ 值域连续。我们用下标区间 [l,r][l,r][l,r] 来代表这个连续段，用 f(l,r)f(l,r)f(l,r) 表示这个连续段的值域区间。 我们称排列 ppp 的所有连续段构成的集合为 IpI_pIp​。 连续段有几个显而易见的性质： 对于任意两个有交且互不包含的连续段 A,B∈IpA
数理逻辑程序：生成合取与析取范式工具
它使用二叉树作为内部表示和处理结构，这表明算法可能涉及到将逻辑表达式转换为二叉树形式，然后遍历这棵树以提取出构成合取范式或析取范式的基础子句。文件信息中提到了“比较详细的说明文档”，意味着用户需要参考...
Tutte对图论的贡献
05-30
这是一篇博士论文，专门介绍Tutte 教授对于图论和组合数学的贡献，罕见的材料。
实验1-利用真值表法求取主析取范式以及主合取范式的实现1
08-08
实验目的是通过实践加深对析取、合取范式以及它们与二进制对应关系的理解。 在传统的表达式计算中，我们通常会为每个命题变元建立一个映射，然后通过栈或表达式树来计算表达式的值。然而，这种方法存在一些局限性：...
析合树学习小记
Cold_Chair的博客
06-10 3039
析合树……怎么说呢，应该是一个排列的一种划分方法，用于处理连续段有关问题。 首先定义连续段： 对于一个排列的一个区间[x,y][x,y][x,y]，如果把这个区间的数拿出来排序，是连续的若干个数，即y−x+1=max(x..y)−min(x..y)+1y-x+1=max(x..y)-min(x..y)+1y−x+1=max(x..y)−min(x..y)+1，则称[x,y][x,y][x,y]为...
Codeforces Round #493 (Div. 1) E. Good Subsegments 析合树
MTS_ZX的博客
02-26 279
原题链接 题目描述：给定一个长度为n的排列，每次询问一个区间，有多少个子区间是连续段 解法：建出析合树，考虑询问区间是[l,r][l,r][l,r],设L=l−1,R=r+1;K=lca(L,R)L=l-1,R=r+1; K=lca(L,R)L=l−1,R=r+1;K=lca(L,R)。K的儿子中L的祖先为SLSLSL,R的祖先为SRSRSR。 需要统计以下信息： tottottot:以iii为根的子树内连续段数目 lnlnln:iii所在的儿子序列中，只使用下标小于iii的儿子及其后代组成的连续段数目 r
析合树形态计数 dp
Four's
03-10 857
  正儿八经的用析合树本身的题没见着，析合树形态计数倒是一大堆。。。   名词注释：   子段：一个排列中的连续子序列   非平凡子段：长度大于 111、且不为排列本身的子段   连续段：若把一个子段的元素重排后是连续的，那么这个子段是一个连续段。 V1 题源：【2018-2019 ICPC, NEERC, Northern Eurasia Finals】I. Interval-Free Per...
学习析合树小记
RainbowCrown_CGH's blog
12-12 388
前言 心态崩了 这玩意不仅比较猎奇，而且网上有关资料还是参差不齐的。 看WC2019LCA的ppt也是一头雾水（尤其是那个定义） 最后在三个地方终于找到了有价值的东西。（自己看到下面的参考资料） 然后想想还是写写博客加强印象以免忘记吧。 正题 引入 我们看一道题： 让我们来想想这题怎么做？ 有一个十分方便的方法—— 对于每次询问，我们考虑选出询问区间内的最大值与最小值。 然后再找出选取最大到最小...
Codeforces-Round#548(Div.2)-C-Edgy Trees-快速幂
weixin_30488085的博客
03-23 109
这个题没想出来，好菜QAQ... 题目要求至少经过一段黑色的边的答案，那么我们可以求总数减去不经过黑色的，这样就是答案了。 那么也就是求出每个只有红色边的连通块中有几个点。 总数就是n的k次方，设连通块有i个点，那么每次减去i的k次方就行了。 #include <iostream> #include <cmath> #include <cstdio&g...
析合树是你的谎言
七代目鸽影
09-12 311
Hail the PRINCIPAL! Heil dem Schulleiter! Salut au proviseur!
【清华夏令营模拟2019.5.22】连续段（析合树+多项式牛顿迭代）
Cold_Chair的博客
05-22 743
Description： n<=1e5，P是NTT模数 题解： 析合树见WC2019LCA营员交流讲稿 我们考虑把一个序列划分成本源连续段。 怎么划分呢？就是极大划分，假设划分成了x段。 这x段需要满足任取一个区间的段，要么可以全部可以拼起来(1)，要么除了最大的那一个其它都不行(2)。 仔细思考这样就能表示所有的段了。 (1)就是析点，(2)就是合点。 考虑x=2、3时只能是合点 设F表...
[BZOJ]5259: [Cerc2017]区间 线段树
TYB的博客
03-25 480
Description 给定一个1到n的排列a1, . . . , an。 对于一个区间[l, r]，我们称该区间是连续的，如果将al, . . . , ar排列之后得到的是一列连续的数。 （换句话说，如果x,y都在该区间中，那么所有介于x,y之间的数也在该区间中） 现在有m(1 ≤ n, m ≤ 100000)个询问，每个询问给出一个区间[xi, yi], 你需要找到一个长度最短的连续区间[li...
数据结构之二叉树
m0_65503491的博客
02-01 827
数据结构之二叉树 概念及代码实现
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值