模板：数据结构

最新推荐文章于 2019-11-06 21:40:06 发布
原创 最新推荐文章于 2019-11-06 21:40:06 发布 · 776 阅读 · 0 ·
CC 4.0 BY-SA版权
本文及后续更新已转到https://wu-kan.cn 本文为博主原创文章，转载需要注明来源。
文章标签：

#c++ #acm #模板 #数据结构

数据结构

以下数据结构均采用ll作为值类型，应用时根据需求调整。

typedef long long ll;
const ll INF=1e9;//表示（值）正无穷，且两个正无穷相加不会溢出
const int NPOS=-1;//表示（下标）不存在

离散化

在vector基础上的离散化，使用push_back()向其中插值，init()排序并离散化，ask查询离散化之后的值，at/[]运算符查离散前的值。

struct Ranker:vector<ll>
{
	void init()
	{
		sort(begin(),end()),resize(unique(begin(),end())-begin());
	}
	int ask(ll x)const
	{
		return lower_bound(begin(),end(),x)-begin();
	}
};

并查集

struct UnionFindSet:vector<int>
{
	int siz;//剩余连通块数量
	UnionFindSet(int n):siz(n)
	{
		for(int i=0; i<n; ++i)push_back(i);
	}
	int fa(int u)//u所在连通块上根节点
	{
		return at(u)!=u?at(u)=fa(at(u)):u;
	}
	void merge(int u,int w)//归并w所在连通块到u所在连通块
	{
		if(w=fa(w),u=fa(u),w!=u)at(w)=u,--siz;
	}
};

单调队列

typedef pair<int,ll> pil;
struct MonotoneQueue:deque<pil>
{
	void push(pil p,int k)//first插入元素下标，second插入值，插入并维护一个值单调递增的单调队列且队尾队首下标差值小于k
	{
		while(!empty()&&back().second>=p.second)pop_back();
		for(push_back(p); p.first-front().first>=k;)pop_front();
	}
};

ST表

O ( n log ⁡ n ) O(n\log n) O(nlogn)预处理， O ( 1 ) O(1) O(1)求静态区间最小值。

/*
//可选优化
#define log2(n) LOG2[n]
struct Log:vector<ll>
{
	Log(int N,ll E):vector<ll>(N,-1)
	{
		for(int i=1; i<N; ++i)at(i)=at(i/E)+1;
	}
} LOG2(N,2);
*/
struct SparseTable
{
	vector<vector<ll> > f;
	SparseTable(const vector<ll> &a):f(log2(a.size())+1,a)
	{
		for(int k=0; k+1<f.size(); ++k)
			for(int i=0; i+(1<<k)<a.size(); ++i)
				f[k+1][i]=min(f[k][i],f[k][i+(1<<k)]);
	}
	ll ask(int l,int r)
	{
		int k=log2(r-l+1);
		return min(f[k][l],f[k][r+1-(1<<k)]);
	}
};

树状数组

模板中Base是对应的基础版本，支持单点修改区间查询。

一维

struct Fenwick
{
	struct BaseFenwick
	{
		vector<ll> v;
		BaseFenwick(int last):v(last+1,0) {}
		void add(int x,ll w)
		{
			for(; x<v.size(); x+=x&-x)v[x]+=w;
		}
		ll ask(int x)
		{
			ll ans=0;
			for(; x; x-=x&-x)ans+=v[x];
			return ans;
		}
	};
	pair<BaseFenwick,BaseFenwick> p;
	Fenwick(int last):p(last,last) {}
	void add(int x,ll w)
	{
		p.first.add(x,w),p.second.add(x,x*w);
	}
	void add(int l,int r,ll w)
	{
		add(l,w),add(r+1,-w);
	}
	ll ask(int x)
	{
		return (x+1)*p.first.ask(x)-p.second.ask(x);
	}
	ll ask(int l,int r)
	{
		return ask(r)-ask(l-1);
	}
};

二维

高维的数据结构只要每一维维护低一维的数据即可。其余数据结构亦同理。

struct Fenwick2
{
	struct BaseFenwick2
	{
		vector<Fenwick> v;
		BaseFenwick2(int r,int c):v(r+1,c) {}
		void add(int x,int b,int t,ll w)
		{
			for(; x<v.size(); x+=x&-x)v[x].add(b,t,w);
		}
		ll ask(int x,int b,int t)
		{
			ll ans=0;
			for(; x; x-=x&-x)ans+=v[x].ask(b,t);
			return ans;
		}
	};
	pair<BaseFenwick2,BaseFenwick2> p;
	Fenwick2(int r,int c):p(BaseFenwick2(r,c),BaseFenwick2(r,c)) {}
	void add(int x,int b,int t,ll w)
	{
		p.first.add(x,b,t,w),p.second.add(x,b,t,x*w);
	}
	void add(int l,int b,int r,int t,ll w)//(l,b)~(r,t)
	{
		add(l,b,t,w),add(r+1,b,t,-w);
	}
	ll ask(int x,int b,int t)
	{
		return (x+1)*p.first.ask(x,b,t)-p.second.ask(x,b,t);
	}
	ll ask(int l,int b,int r,int t)
	{
		return ask(r,b,t)-ask(l-1,b,t);
	}
};

线段树

空间优化的线段树，支持区间查询/增加/修改/合并，使用时仅需根据实际情况修改Node、push_up、maintain、ask。

struct SegmentTree
{
	struct Node
	{
		ll add,set,min,sum;
	};
	vector<Node> v;
	int LAST,L,R;//序列右端点，操作序列左右端点
	SegmentTree(int n):LAST(n),v(2*n+1) {}
	void build(ll a[],int l,int r)//快速建树，调用build(a,1,n)
	{
		if(l<r)
		{
			int m=l+(r-l)/2;
			build(a,l,m),build(a,m+1,r);
			lv(l,r).set=INF,lv(l,r).add=0;//清除本节点标记
		}
		else lv(l,r).set=a[l],lv(l,r).add=0;//两个的和为a[l]即可，根据需要自行选择
		maintain(l,r);
	}
	Node &lv(int l,int r)//[l,r]对应的树上节点
	{
		return v[l+r|l!=r];
	}
	void push_down(Node &lc,Node &rc,Node &fa)//将fa的set、add标记传到lc、rc
	{
		if(fa.set!=INF)
		{
			lc.set=rc.set=fa.set,fa.set=INF;
			lc.add=rc.add=0;
		}
		lc.add+=fa.add;
		rc.add+=fa.add;
		fa.add=0;
	}
	void push_up(const Node &lc,const Node &rc,Node &fa)//将区间左右相连的lc、rc归并到fa
	{
		fa.min=min(lc.min,rc.min);
		fa.sum=lc.sum+rc.sum;
	}
	void maintain(int l,int r)//维护[l,r]
	{
		if(l<r)
		{
			int m=l+(r-l)/2;
			push_up(lv(l,m),lv(m+1,r),lv(l,r));
		}
		if(lv(l,r).set!=INF)
			lv(l,r).sum=(r-l+1)*(lv(l,r).min=lv(l,r).set);
		lv(l,r).min+=lv(l,r).add;
		lv(l,r).sum+=lv(l,r).add*(r-l+1);
	}
	Node ask(int l,int r,ll val=0,bool out=1)//查询[L,R],val为查询路径累加的add标记,out为外部调用标记，下同 
	{
		if(out)return L=l,R=r,ask(1,LAST,val,0);
		if(lv(l,r).set!=INF)
			v[0].sum=(min(R,r)-max(l,L)+1)*(v[0].min=val+lv(l,r).add+lv(l,r).set);
		else if(L<=l&&r<=R)
			v[0].min=lv(l,r).min+val,v[0].sum=lv(l,r).sum+val*(r-l+1);
		else
		{
			int m=l+(r-l)/2;
			if(R<=m)return ask(l,m,lv(l,r).add+val,0);
			if(L>m)return ask(m+1,r,lv(l,r).add+val,0);
			push_up(ask(l,m,lv(l,r).add+val,0),ask(m+1,r,lv(l,r).add+val,0),v[0]);
		}
		return v[0];
	}
	void add(int l,int r,ll val,bool out=1)//[L,R]加上val
	{
		if(out)return L=l,R=r,add(1,LAST,val,0);
		if(L<=l&&r<=R)lv(l,r).add+=val;
		else
		{
			int m=l+(r-l)/2;
			push_down(lv(l,m),lv(m+1,r),lv(l,r));
			if(L<=m)add(l,m,val,0);
			else maintain(l,m);
			if(R>m)add(m+1,r,val,0);
			else maintain(m+1,r);
		}
		maintain(l,r);
	}
	void set(int l,int r,ll val,bool out=1)//[L,R]设为val
	{
		if(out)return L=l,R=r,set(1,LAST,val,0);
		if(L<=l&&r<=R)lv(l,r).set=val,lv(l,r).add=0;
		else
		{
			int m=l+(r-l)/2;
			push_down(lv(l,m),lv(m+1,r),lv(l,r));
			if(L<=m)set(l,m,val,0);
			else maintain(l,m);
			if(R>m)set(m+1,r,val,0);
			else maintain(m+1,r);
		}
		maintain(l,r);
	}
};

主席树

求区间第k小，可能需要离散化。

struct HJTree
{
	struct Node
	{
		int ch[2],sum;
	} v[MAXN<<5];
	int m,siz,tot,T[MAXN];//siz前缀树的个数，tot所有顶点的个数
	void build(int a[],int n,int m)//用a[1]~a[n]建树，a[i]的值不超过m
	{
		for(this->m=m,siz=tot=1; siz<=n; ++siz)
			ins(&(T[siz]=T[siz-1]),a[siz]);
	}
	void ins(int *rt,int pos,int val=1)
	{
		for(int l=1,r=m;;)
		{
			v[tot]=v[*rt],v[*rt=tot++].sum+=val;
			if(l==r)break;
			int m=l+(r-l)/2;
			if(pos>m)rt=&v[*rt].ch[1],l=m+1;
			else rt=&v[*rt].ch[0],r=m;
		}
	}
	int ask(int x,int y,int k)
	{
		for(int kx=T[x-1],ky=T[y],l=1,r=m,LR;;)
		{
			if(l>=r)return l;
			int d=v[v[ky].ch[0]].sum-v[v[kx].ch[0]].sum,m=l+(r-l)/2;
			if(k>d)k-=d,l=m+1,LR=1;
			else r=m,LR=0;
			kx=v[kx].ch[LR],ky=v[ky].ch[LR];
		}
	}
};

动态主席树

struct HJTree
{
	int m,siz,tot,T[MAXN],S[MAXN],use[MAXN];
	struct Node
	{
		int ch[2],sum;
	} v[MAXN<<5];
	void build(int a[],int n,int m)//用a[1]~a[n]建树，a[i]的值不超过m
	{
		for(this->m=m,siz=tot=1; siz<=n; ++siz)
			ins(&(T[siz]=T[siz-1]),a[i]),s[siz]=0;
	}
	void ins(int *rt,int pos,int val=1)//和静态主席树一样
	{
		for(int l=1,r=m;;)
		{
			v[tot]=v[*rt],v[*rt=tot++].sum+=val;
			if(l==r)break;
			int m=l+(r-l)/2;
			if(pos>m)rt=&v[*rt].ch[1],l=m+1;
			else rt=&v[*rt].ch[0],r=m;
		}
	}
	void add(int x,int pos,int val)
	{
		for(; x<siz; x+=x&-x)
			ins(&S[x],pos,val);
	}
	int sum(int x)
	{
		int ret=0;
		for(; x; x-=x&-x)
			ret+=v[v[use[x]].ch[0]].sum;
		return ret;
	}
	int ask(int x,int y,int k)
	{
		for(int i=--x; i; i-=i&-i)use[i]=S[i];
		for(int i=y; i; i-=i&-i)use[i]=S[i];
		for(int kx=T[x],ky=T[y],l=1,r=m,LR;;)
		{
			if(l>=r)return l;
			int m=l+(r-l)/2,d=sum(y)-sum(x)+v[v[ky].ch[0]].sum-v[v[kx].ch[0]].sum;
			if(k>d)k-=d,l=m+1,LR=1;
			else r=m,LR=0;
			kx=v[kx].ch[LR],ky=v[ky].ch[LR];
			for(int i=x; i; i-=i&-i)use[i]=v[use[i]].ch[LR];
			for(int i=y; i; i-=i&-i)use[i]=v[use[i]].ch[LR];
		}
	}
};

无旋Treap

按子树大小分裂

struct FhqTreap
{
	struct Node
	{
		int ch[2],siz,rev;
		ll key,val,min,add;
		void REV()
		{
			rev^=1,swap(ch[0],ch[1]);
		}
		void ADD(ll v)
		{
			val+=v,min+=v,add+=v;
		}
	};
	vector<Node> v;
	int root;
	FhqTreap():v(1),root(0) {}
	void push_down(int k)
	{
		if(!k)return;
		for(int i=0,*ch=v[k].ch; i<2; ++i)
			if(ch[i])
			{
				v[ch[i]].ADD(v[k].add);
				if(v[k].rev)v[ch[i]].REV();
			}
		v[k].add=v[k].rev=0;
	}
	void push_up(int k)
	{
		if(!k)return;
		v[k].siz=1,v[k].min=v[k].val;
		for(int i=0,*ch=v[k].ch; i<2; ++i)
			if(ch[i])
				v[k].siz+=v[ch[i]].siz,v[k].min=min(v[k].min,v[ch[i]].min);
	}
	int merge(int a,int b)
	{
		if(!a||!b)return a+b;
		if(v[a].key<v[b].key)
			return push_down(a),v[a].ch[1]=merge(v[a].ch[1],b),push_up(a),a;
		return push_down(b),v[b].ch[0]=merge(a,v[b].ch[0]),push_up(b),b;
	}
	void split(int a,int s,int &l,int &r)
	{
		if(!s)l=0,r=a;
		else if(v[v[a].ch[0]].siz<s)
			push_down(a),split(v[a].ch[1],s-v[v[a].ch[0]].siz-1,v[a].ch[1],r),push_up(l=a);
		else
			push_down(a),split(v[a].ch[0],s,l,v[a].ch[0]),push_up(r=a);
	}
	void push_back(ll d)
	{
		v.push_back(Node {{0,0},1,0,rand(),d,d,d});
		root=merge(root,v.size()-1);
	}
	void insert(int x,ll d)
	{
		v.push_back(Node {{0,0},1,0,rand(),d,d,d});
		int a,b,c;
		split(root,x-1,a,b);
		root=merge(merge(a,v.size()-1),b);
	}
	void erase(int x)
	{
		int a,b,c;
		split(root,x,a,b),split(a,x-1,a,c),root=merge(a,b);
	}
	void add(int l,int r,ll d)
	{
		int a,b,c;
		split(root,r,b,c),split(b,l-1,a,b),v[b].ADD(d),root=merge(merge(a,b),c);
	}
	Node ask(int l,int r)
	{
		int a,b,c;
		split(root,r,b,c),split(b,l-1,a,b);
		Node ret=v[b];
		return root=merge(merge(a,b),c),ret;
	}
	void reverse(int l,int r)
	{
		int a,b,c;
		split(root,r,b,c),split(b,l-1,a,b),v[b].REV(),root=merge(merge(a,b),c);
	}
	void revolve(int l,int r,int d)
	{
		int a,b,c,e=r-l+1;
		split(root,r,b,c),split(b,l-1,a,b),split(b,(e-d%e)%e,b,e);
		root=merge(merge(a,merge(e,b)),c);
	}
};

按值大小分裂，即排序树

struct FhqTreap
{
	struct Node
	{
		int ch[2],siz;
		ll key,val;
	};
	vector<Node> v;
	int root;
	FhqTreap():v(1),root(0) {}
	void push_up(int k)
	{
		v[k].siz=v[v[k].ch[0]].siz+v[v[k].ch[1]].siz+1;
	}
	int merge(int a,int b)
	{
		if(!a||!b)return a+b;
		if(v[a].key<v[b].key)
			return v[a].ch[1]=merge(v[a].ch[1],b),push_up(a),a;
		return v[b].ch[0]=merge(a,v[b].ch[0]),push_up(b),b;
	}
	void splitVal(int a,ll w,int &l,int &r)//按值将树划分，使得左子树上的值恰小于w
	{
		if(!a)l=r=0;
		else if(v[a].val>w)splitVal(v[a].ch[0],w,l,v[a].ch[0]),push_up(r=a);
		else splitVal(v[a].ch[1],w,v[a].ch[1],r),push_up(l=a);
	}
	void insert(ll x)
	{
		int a,b;
		v.push_back(Node {{0,0},1,rand(),x});
		splitVal(root,x,a,b),root=merge(merge(a,v.size()-1),b);
	}
	void erase(ll x)
	{
		int a,b,c;
		splitVal(root,x,a,b),splitVal(a,x-1,a,c);
		root=merge(merge(a,merge(v[c].ch[0],v[c].ch[1])),b);
	}
	ll kth(int k)
	{
		for(int u=root,ls;;)
		{
			if(ls=v[v[u].ch[0]].siz,ls+1==k)
				return v[u].val;
			if(ls<k)k-=ls+1,u=v[u].ch[1];
			else u=v[u].ch[0];
		}
	}
	int lower_bound(ll x)
	{
		return upper_bound(x-1);
	}
	int upper_bound(ll x)
	{
		int a,b,ret;
		return splitVal(root,x,a,b),ret=v[a].siz+1,root=merge(a,b),ret;
	}
};

珂朵莉树

Willem, Chtholly and Seniorious

区间加减、第k大、k次方和。数据随机。

#include<bits/stdc++.h>
#define mul(a,b,c) ((a)*(b)%(c))
using namespace std;
typedef long long ll;
typedef pair<int,ll> pil;
ll pow(ll a,ll b,ll m)
{
	ll r=1;
	for(a%=m; b; a=mul(a,a,m),b>>=1)
		if(b&1)r=mul(r,a,m);
	return r;
}
struct ChthollyTree:map<int,pil>
{
	iterator split(int pos)
	{
		iterator it=lower_bound(pos);
		if(it!=end()&&it->first==pos)return it;
		--it;
		if(pos>it->second.first)return end();
		pair<int,pil> p=*it;
		erase(it);
		insert(make_pair(p.first,pil(pos-1,p.second.second)));
		return insert(make_pair(pos,p.second)).first;
	}
	void add(int l,int r,ll val)
	{
		for(iterator b=split(l),e=split(r+1); b!=e; ++b)b->second.second+=val;
	}
	void set(int l,int r,ll val)
	{
		erase(split(l),split(r+1)),insert(make_pair(l,pil(r,val)));
	}
	ll rank(int l,int r,int k)
	{
		vector<pair<ll,int> > v;
		for(iterator b=split(l),e=split(r+1); b!=e; ++b)
			v.push_back(make_pair(b->second.second,b->second.first-b->first+1));
		sort(v.begin(),v.end());
		for(int i=0; i<v.size(); ++i)
			if(k-=v[i].second,k<=0)return v[i].first;
		return -1;
	}
	ll sum(int l,int r,ll ex,ll m)
	{
		ll res=0;
		for(iterator b=split(l),e=split(r+1); b!=e; ++b)
			res=(res+mul(b->second.first-b->first+1,pow(b->second.second,ex,m),m))%m;
		return res;
	}
} t;
ll n,m,seed,vmax,M=1e9+7;
ll rnd()
{
	ll ret=seed;
	seed=(seed*7+13)%M;
	return ret;
}
int main()
{
	scanf("%lld%lld%lld%lld",&n,&m,&seed,&vmax);
	for(int i=1; i<=n; ++i)
		t.insert(make_pair(i,pil(i,rnd()%vmax+1)));
	for(int i=1; i<=m; ++i)
	{
		int op=rnd()%4+1,l=rnd()%n+1,r=rnd()%n+1;
		if(l>r)swap(l,r);
		ll x=rnd()%(op==3?r-l+1:vmax)+1;
		if(op==1)t.add(l,r,x);
		if(op==2)t.set(l,r,x);
		if(op==3)printf("%lld\n",t.rank(l,r,x));
		if(op==4)printf("%lld\n",t.sum(l,r,x,rnd()%vmax+1));
	}
}

脑洞治疗仪

把一段连续区间的01移动到到另一段区间上，求在某个区间中最大的连续0序列有多大。

#include<bits/stdc++.h>
using namespace std;
typedef int ll;
typedef pair<int,ll> pil;
struct ChthollyTree:map<int,pil>
{
	iterator split(int pos)
	{
		iterator it=lower_bound(pos);
		if(it!=end()&&it->first==pos)return it;
		--it;
		if(pos>it->second.first)return end();
		pair<int,pil> p=*it;
		erase(it);
		insert(make_pair(p.first,pil(pos-1,p.second.second)));
		return insert(make_pair(pos,p.second)).first;
	}
	void set(int l,int r,ll val)
	{
		erase(split(l),split(r+1)),insert(make_pair(l,pil(r,val)));
	}
	void scure(int l,int r,int x,int y)
	{
		iterator e=split(r+1),b=split(l),it=b;
		int sum=0;
		for(; b!=e; ++b)
			if(b->second.second)
				sum+=b->second.first-b->first+1;
		erase(it,e);
		insert(make_pair(l,pil(r,0)));
		if(!sum)return;
		e=split(y+1),b=split(x),it=b;
		if(sum>=y-x+1)
		{
			erase(b,e);
			insert(make_pair(x,pil(y,1)));
			return;
		}
		for( ; b!=e; ++b)
			if(!b->second.second)
			{
				sum-=b->second.first-b->first+1;
				if(sum<0)return set(b->first,b->second.first+sum,1);
				b->second.second=1;
			}
	}
	ll MAX(int l,int r)
	{
		iterator e=split(r+1),b=split(l);
		ll res=0,now=0;
		for(; b!=e; ++b)
			if(!b->second.second)
				now+=b->second.first-b->first+1;
			else if(now)res=max(res,now),now=0;
		return max(res,now);
	}
} t;
int main()
{
	int n,m;
	scanf("%d%d",&n,&m);
	t.insert(make_pair(1,pil(n,1)));
	for(int op,l,r,x,y; m--;)
	{
		scanf("%d%d%d",&op,&l,&r);
		if(op==0)t.set(l,r,0);
		else if(op==1)scanf("%d%d",&x,&y),t.scure(l,r,x,y);
		else printf("%d\n",t.MAX(l,r));
	}
}

莫队

普通莫队

struct Mo
{
	struct Query
	{
		int l,r,id;
		bool operator<(const Query& n)const
		{
			return l/BS!=n.l/BS?l<n.l:r<n.r;
		}
	};
	vector<Query> q;
	int L,R;
	void query(int l,int r)
	{
		q.push_back(Query {l,r,q.size()});
	}
	void rev(int x) {}
	void cal(int id) {}
	void ask()
	{
		L=0,R=-1;
		sort(q.begin(),q.end());
		for(int i=0; i<q.size(); ++i)
		{
			while(L<q[i].l)rev(L++);
			while(L>q[i].l)rev(--L);
			while(R<q[i].r)rev(++R);
			while(R>q[i].r)rev(R--);
			cal(q[i].id);
		}
	}
};

动态莫队

struct Mo
{
	struct Update
	{
		int pos,NEW,OLD;
	};
	struct Query
	{
		int t,l,r,id;
		bool operator<(const Query& n)const
		{
			return l/BS!=n.l/BS?l<n.l:
			       r/BS!=n.r/BS?r<n.r:t<n.t;
		}
	};
	vector<Update> cq;
	vector<Query> q;
	int T,L,R;
	Mo():cq(1) {}
	void query(int x,int y)
	{
		q.push_back(Query {cq.size()-1,x,y,q.size()});
	}
	void update(int x,int y)
	{
		cq.push_back(Update {x,y,t[x]}),t[x]=y;
	}
	void set(int x,int d)
	{
		if(vis[x])return rev(x),a[x]=d,rev(x);
		a[x]=d;
	}
	void rev(int x) {}
	void cal(int id) {}
	void ask()
	{
		T=L=0,R=-1;
		sort(q.begin(),q.end());
		for(int i=0; i<q.size(); ++i)
		{
			while(T<q[i].t)++T,set(cq[T].pos,cq[T].NEW);
			while(T>q[i].t)set(cq[T].pos,cq[T].OLD),--T;
			while(L<q[i].l)rev(L++);
			while(L>q[i].l)rev(--L);
			while(R<q[i].r)rev(++R);
			while(R>q[i].r)rev(R--);
			cal(q[i].id);
		}
	}
};

树上莫队

按照欧拉序分块，使用Tarjan在生成欧拉序的同时预处理所有询问的lca，预处理时间复杂度 O ( n + q ) O(n+q) O(n+q)。
h为查询图，即如果有一个询问(u,v)，即在h上连 u → v , v → u u\to v,v\to u u→v,v→u。多个询问边有序插入h。

struct TreeMo:Graph
{
	struct Query
	{
		int l,r,lca,id;
		bool operator<(const Query &b)const
		{
			return l/BS!=b.l/BS?l<b.l:r<b.r;
		}
	};
	vector<Query> q;
	vector<int> dfp,dfi,dfo;
	UnionFindSet ufs;
	Graph h;
	int L,R;
	TreeMo(int n):Graph(n),h(n),dfp(n*2+1),dfi(n),dfo(n),ufs(n) {}
	void query(int x,int y)
	{
		h.add(Edge {x,y}),h.add(Edge {y,x});
		q.push_back(Query {0,0,0,q.size()});
	}
	void rev(int x) {}
	void cal(int id) {}
	void dfs(int u,int &cnt)
	{
		dfp[dfi[u]=++cnt]=u;
		for(int i=0,k,to; i<v[u].a.size(); ++i)
			if(k=v[u].a[i],to=e[k].to,!dfi[to])
				dfs(to,cnt),ufs.merge(u,to);
		dfp[dfo[u]=++cnt]=u;
		for(int i=0,k,to,id; i<h.v[u].a.size(); ++i)
			if(k=h.v[u].a[i],id=k/2,to=h.e[k].to,dfo[to])
			{
				q[id].lca=ufs.fa(to);
				q[id].l=q[id].lca!=u?dfo[u]:dfi[u];
				q[id].r=dfi[to];
			}
	}
	void ask(int root=1)
	{
		dfs(root,BS=0),BS=sqrt(BS);
		sort(q.begin(),q.end());
		L=0,R=-1;
		for(int i=0; i<q.size(); ++i)
		{
			while(L<q[i].l)rev(dfp[L++]);
			while(L>q[i].l)rev(dfp[--L]);
			while(R<q[i].r)rev(dfp[++R]);
			while(R>q[i].r)rev(dfp[R--]);
			if(q[i].lca!=dfp[L])rev(q[i].lca);
			cal(q[i].id);
			if(q[i].lca!=dfp[L])rev(q[i].lca);
		}
	}
};

动态树上莫队

struct CapitalTreeMo:Graph
{
	struct Update
	{
		int pos,NEW,OLD;
	};
	struct Query
	{
		int t,l,r,lca,id;
		bool operator<(const Query &b)const
		{
			return l/BS!=b.l/BS?l<b.l:
			       r/BS!=b.r/BS?r<b.r:t<b.t;//在BZOJ4129上去掉r/BS还快100ms?
		}
	};
	vector<Update> cq;
	vector<Query> q;
	vector<int> dfp,dfi,dfo;
	UnionFindSet ufs;
	Graph h;
	int T,L,R;
	CapitalTreeMo(int n):cq(1),Graph(n),h(n),dfp(n*2+1),dfi(n),dfo(n),ufs(n) {}
	void query(int x,int y)
	{
		h.add(Edge {x,y}),h.add(Edge {y,x});
		q.push_back(Query {cq.size()-1,0,0,0,q.size()});
	}
	void update(int x,int y)
	{
		cq.push_back(Update {x,y,t[x]}),t[x]=y;
	}
	void dfs(int u,int &cnt)
	{
		dfp[dfi[u]=++cnt]=u;
		for(int i=0,k,to; i<v[u].a.size(); ++i)
			if(k=v[u].a[i],to=e[k].to,!dfi[to])
				dfs(to,cnt),ufs.merge(u,to);
		dfp[dfo[u]=++cnt]=u;
		for(int i=0,k,to,id; i<h.v[u].a.size(); ++i)
			if(k=h.v[u].a[i],id=k/2,to=h.e[k].to,dfo[to])
			{
				q[id].lca=ufs.fa(to);
				q[id].l=q[id].lca!=u?dfo[u]:dfi[u];
				q[id].r=dfi[to];
			}
	}
	void set(int u,int d)
	{
		if(vis[u])return rev(u),a[u]=d,rev(u);
		a[u]=d;
	}
	void rev(int u) {}
	void cal(int id) {}
	void ask(int root=1)
	{
		dfs(root,BS=0),BS=sqrt(BS);
		sort(q.begin(),q.end());
		T=L=0,R=-1;
		for(int i=0; i<q.size(); ++i)
		{
			while(T<q[i].t)++T,set(cq[T].pos,cq[T].NEW);
			while(T>q[i].t)set(cq[T].pos,cq[T].OLD),--T;
			while(L<q[i].l)rev(dfp[L++]);
			while(L>q[i].l)rev(dfp[--L]);
			while(R<q[i].r)rev(dfp[++R]);
			while(R>q[i].r)rev(dfp[R--]);
			if(q[i].lca!=dfp[L])rev(q[i].lca);
			cal(q[i].id);
			if(q[i].lca!=dfp[L])rev(q[i].lca);
		}
	}
};

匹配

KMP

struct KMP
{
    const string s;
    vector<int> next;
    KMP(const string &s):s(s),next(s.size()+1,0)
    {
        for(int i=1,j; i<s.size(); ++i)
        {
            for(j=next[i]; j&&s[i]!=s[j]; j=next[j]);
            next[i+1]=s[i]==s[j]?j+1:0;
        }
    }
    bool find_in(const string &t)
    {
        for(int i=0,j=0; i<t.size(); ++i)
        {
            for(; j&&s[j]!=t[i]; j=next[j]);
            if(s[j]==t[i])++j;
            if(j==s.size())return 1;//不return可得到t中s的所有匹配地址i+1-s.size()
        }
        return 0;
    }
};

AC自动机

ask之前需要调用getFail()生成失配函数。

struct AhoCorasick
{
	struct Node
	{
		int ch[26],val,f,last;
		int &to(char c)
		{
			return ch[c-'a'];
		}//如果不确定c的范围，使用map
	};
	vector<Node> v;
	AhoCorasick():v(1) {}
	void getFail()
	{
		for(deque<int> q(1,v[0].last=v[0].f=0); !q.empty(); q.pop_front())
			for(char c='a'; c<='z'; ++c)
			{
				int r=q.front(),u=v[r].to(c),w=v[r].f;
				if(!r&&u)
				{
					q.push_back(u);
					v[u].f=v[u].last=0;
					continue;
				}
				if(!u)
				{
					v[r].to(c)=v[w].to(c);
					continue;
				}
				q.push_back(u);
				while(w&&!v[w].to(c))w=v[w].f;
				v[u].f=v[w].to(c);
				v[u].last=v[v[u].f].val?v[u].f:
				          v[v[u].f].last;
			}
	}
	void add(const string &s,int val,int u=0)
	{
		for(int i=0; i<s.size(); u=v[u].to(s[i++]))
			if(!v[u].to(s[i]))
			{
				v[u].to(s[i])=v.size();
				v.push_back(Node());
			}
		v[u].val=val;
	}
	bool find_in(const string &s,int u=0)
	{
		for(int i=0; i<s.size(); ++i)
			if(u=v[u].to(s[i]),
			        v[u].val||v[u].last)
				return 1;
		return 0;
	}
};

后缀数组

m：字符集大小。
s：字符串，其中最后一位为加入的0。
sa[i]：字典序第i小的是哪个后缀。
rk[i]：后缀i的排名。
h[i]：lcp(sa[i],sa[i−1])。

struct SufArr
{
	vector<int> sa,rk,h;
	SufArr(const vector<int> &s,int m):sa(s.size(),0),rk(s),h(s.size(),0)
	{
		vector<int> cnt(s.size()+m,0);
		for(int i=0; i<s.size(); ++i)++cnt[rk[i]];
		for(int i=1; i<m; ++i)cnt[i]+=cnt[i-1];
		for(int i=0; i<s.size(); ++i)sa[--cnt[rk[i]]]=i;
		for(int k=1,j=0; k<=s.size()&&j<s.size()-1; k<<=1)
		{
			for(int i=0; i<s.size(); ++i)
			{
				if(j=sa[i]-k,j<0)j+=s.size();
				h[cnt[rk[j]]++]=j;
			}
			cnt[0]=sa[h[0]]=j=0;
			for(int i=1; i<s.size(); ++i)
			{
				if(rk[h[i]]!=rk[h[i-1]]||rk[h[i]+k]!=rk[h[i-1]+k])
					cnt[++j]=i;
				sa[h[i]]=j;
			}
			swap(rk,sa),swap(sa,h);
		}
		for(int i=0,k=0,j=rk[0]; i<s.size()-1; ++i,++k)
			for(; ~k&&s[i]!=s[sa[j-1]+k]; j=rk[sa[j]+1],--k)
				h[j]=k;
	}
};

暴力回文

时间复杂度 O ( n 2 ) O(n^2) O(n2)，常数低，但会被ababababa这样的数据卡。

int palindrome(const char *s)
{
	int ans=0;
	for(int i=0,b,e; s[i]; ++i)
	{
		for(b=i; s[i]==s[i+1];)++i;
		for(e=i+1; b&&s[b-1]==s[e];)--b,++e;
		if(ans<e-b)ans=e-b;//此时[b,e)为最大回文区间
	}
	return ans;
}

Manacher线性回文

对于一个位置i，[i−f[i]+1,i+f[i]−1]是最长的以i为中心的奇回文串，g[i]−i是最长的以i为开头的回文串长度。

struct Manacher
{
	vector<int> t,f,g;
	Manacher(const string &s):t(s.size()+1<<1,0),f(t),g(t)//t初始值为s中没有出现过的值，g开始为0
	{
		for(int i=0; i<s.size(); ++i)t[i+1<<1]=s[i];
		for(int i=1,p=0,m=0; i<t.size(); ++i)
		{
			for(f[i]=i<m?min(f[2*p-i],m-i):1;
			        0<i-f[i]&&i+f[i]<t.size()&&
			        t[i-f[i]]==t[i+f[i]];)
				++f[i];
			if(m<i+f[i])m=i+f[p=i];
		}
		for(int i=2; i<t.size(); ++i)
			if(g[i-f[i]+1]<i+1)g[i-f[i]+1]=i+1;
		for(int i=1; i<t.size(); ++i)
			if(g[i]<g[i-1])g[i]=g[i-1];
	}
	int ask(int l,int r)//多次询问可做一个ST表
	{
		int ans=0;
		for(int i=l+1<<1,e=r+1<<1; i<=e; i+=2)
			if(ans<g[i]-i)ans=g[i]-i;
		return ans;
	}
};
数据结构模板
03-24
数据结构课程考试模板，包括常用数据结构简单实现方法
常用代码模板2——数据结构
橘嘉禾
07-24 310
目录KMP —— 模板Trie树 —— 模板并查集 —— 模板题 AcWing 836. 合并集合堆 —— 模板题 AcWing 838. 堆排序一般哈希 —— 模板字符串哈希C++ STL简介 KMP —— 模板 // s[]是长文本，p[]是模式串，n是s的长度，m是p的长度 求模式串的Next数组： for (int i = 2, j = 0; i <= m; i ++ ){...
模板之数据结构
LOI_Skyline的博客
11-16 601
再来一波模板整理~线段树：#include<iostream> #include<cstring> #include<cstdio> #include<algorithm> #define L(x) (x<<1) #define R(x) (x<<1|1) #define sz(x) (tree[x].r-tree[x].l+1) using namespace std; typedef long
上海交大ACM算法模板：数据结构与算法实现
12-16
内容概要：本文档是上海交通大学 ACM 团队提供的一份算法和数据结构实现模板。文档详细描述了各种常用数据结构（如高精度运算、分数类、二叉堆、赢家树、字典树、线段树等）以及图论相关算法（如最短路径、最小生成...
22  数据结构模板：如何让解题变成搭积木？.mp4
05-30
22 数据结构模板：如何让解题变成搭积木？.mp4
数据结构与算法面试宝典2021
04-10
22:数据结构模板：如何让解题变成搭积木？.mp4 23:算法模板：如何让高频算法考点秒变默写题？.mp4 彩蛋 聊聊我的大厂面试经历，谈谈我对算法学习的看法.mp4 结束语 算法的精进之路.mp4 下载地址：
数据结构（C++模板实现）-C++资源
最新发布
02-16
本资源集是一个关于C++语言实现的数据结构的综合性集合，涵盖了数据结构的核心概念、理论知识以及C++模板的实践应用。它专门为Windows、Linux和Mac操作系统上的用户准备，允许开发者在不同的平台上有相同的编程体验...
基于C++模板 实现的数据结构代码.zip
06-17
本压缩包“基于C++模板实现的数据结构代码.zip”显然是一份关于如何利用C++模板来设计和实现各种数据结构的资源集合。 首先，我们来看看C++模板。模板是C++中的泛型编程，允许我们编写参数化的类型代码。这意味着...
模板(数据结构)
wangzhuo0978的专栏
04-19 765
数据结构： 链式前向星（存储结构） 矩阵快速幂 树状数组 RMQ问题 线段树 manacher算法 链式前向星（存储结构） http://blog.youkuaiyun.com/acdreamers/article/details/16902023  // 具体解析; [cpp] view
数据结构：模板
weixin_43460331的博客
09-21 395
数据结构：模板 模板概述： (1)模板是对具有相同特性的函数或类的再抽象，模板是一种参数化的多态性工具。 (2)所谓参数化多态性，是指将程序所处理的对象的类型参数化，使一段程序代码可以用于处理多种不同类型的对象。 (3)采用模板编程，可以为各种逻辑功能相同而数据类型不同的程序提供一种代码共享的机制。 模板分类： 函数模板、类模板 模板的实例化： 模板通过参数实例化可以构...
基本数据结构模板
a765528534的博客
08-13 343
单链表 // head存储链表头，e[]存储节点的值，ne[]存储节点的next指针，idx表示当前用到了哪个节点 int head, e[N], ne[N], idx; // 初始化 void init() { head = -1; idx = 0; } // 在链表头插入一个数a void insert(int a) { e[idx] = a, ne[idx] = ...
数据结构_模板（template）
AMWICD的博客
09-17 1219
1.模板是对具有相同特性的函数或类的再抽象，模板是一种参数化的多态性工具。所谓参数化多态性，是指将程序所处理的对象的类型参数化，使一段程序代码可以用于处理多种不同类型的对象。 2.模板分为：函数模板、类模板。模板通过参数实例化可以构建具体的函数或类，称为模板函数和模板类。而模板类参数实例化可以构建对象。 3.如果要对一个数求绝对值，当变量类型分别为int和double时，所写代码十分相似，只略微有...
简单数据结构模板
FIVE
08-01 503
1，树状数组 int C[maxn<<4] , a[maxn] , n; int lowbit(int x){ return x&(-x); } int Sum(int pos){ int ans = 0; while(pos>0) ans += C[pos] , pos -= lowbit(pos); return ans ; }...
数据结构模板合集
weixin_30344131的博客
12-05 355
1、线段树 线段树Lazy操作模板(区间修改,区间查询) class Segment_Tree_Lazy{ private: #define ls (p<<1) #define rs ((p<<1)|1) #define mid ((l+r)>>1) int val[100010],cnt[100010]; inl...
模板——数据结构（笔记）
qq_43627355的博客
09-23 228
一、模板是具有相同特性的函数或类的再抽象，模板是一种参数化的多态性工具。采用模板编程，可以为各种逻辑功能相同但数据类型不同的程序提供一种代码共享的机制。 二、模板的分类：函数模板和类模板 模板的实例化：模板通过参数实例化可以构建具体的函数或类，称为模板函数和模板类。 （一）、函数模板 1、函数模板的定义： template<模板形参数> 返回值类型 函数名（参数表）{ 函...
【数据结构】模板
qq_45653724的博客
11-06 407
笔记【数据结构】模板 模板：对具有相同特性的函数或类的再抽象。模板是一种参数化的多态工具。 模板分为：函数模板，类模板 函数模板的定义： 例：求绝对值功能的函数模板定义 ...
C++自定义类模板：实现数据结构与算法应用
- mySTL.h：这个头文件可能是一个自制的STL（标准模板库）的实现，里面包含了一些基本的类模板和函数模板的定义，为其它文件提供数据结构和算法的支持。 通过上述知识点的整理，读者可以对C++中自定义类模板的编写...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值