Lca(倍增) 差分约束 tarjan 网络流 板子总结

具体解释
lca(转载)
模板题

#include"bits/stdc++.h"
using namespace std;
int deep[500005],fa[500005][50];
vector<int>v[500005];
int n,m,s;
void dfs(int s,int f){
	deep[s]=deep[f]+1;
	fa[s][0]=f;
	for(int i=1;i<=29;i++){
		fa[s][i]=fa[fa[s][i-1]][i-1];
	}
	for(int i=0;i<v[s].size();i++){
		int t=v[s][i];
		if(t==f)continue;
		dfs(t,s);
	}
}
int lca(int x,int y){
	if(deep[x]<deep[y])swap(x,y);
	for(int i=20;i>=0;i--){
		if(deep[y]<=deep[fa[x][i]]){
			x=fa[x][i];
		}
	}
	if(x==y)return x;
	for(int i=20;i>=0;i--){
		if(fa[x][i]!=fa[y][i]){
			x=fa[x][i];
			y=fa[y][i];
		}
	}
	return fa[x][0];
} 
int main(){
	scanf("%d %d %d",&n,&m,&s);
	for(int i=1;i<n;i++){
		int a,b;
		scanf("%d %d",&a,&b);
		v[a].push_back(b);
		v[b].push_back(a);
	}
	dfs(s,0);
	for(int i=1;i<=m;i++){
		int x,y;
		scanf("%d %d",&x,&y);
		printf("%d\n",lca(x,y));
	}
	return 0;
}

差分约束
差分约束(转载)
模板题

#include"bits/stdc++.h"
using namespace std;
int n,m;
struct node{
	int u,v,w;
};
node s[5005];
int dis[5005];
int main(){
	scanf("%d %d",&n,&m);
	for(int i=1;i<=m;i++){
		int a,b,c;
		scanf("%d %d %d",&a,&b,&c);
		s[i].u=b,s[i].v=a,s[i].w=c;	
	}
	memset(dis,0x3f3f3f3f,sizeof(dis));
	dis[1]=0;
	for(int i=1;i<n;i++){
		for(int j=1;j<=m;j++){
			dis[s[j].v]=min(dis[s[j].v],dis[s[j].u]+s[j].w);
		}
	}
	for(int i=1;i<=m;i++){
		if(dis[s[i].v]>dis[s[i].u]+s[i].w){
			cout<<"NO";
			return 0;
		}
	}
	for(int i=1;i<=n;i++){
		cout<<dis[i]<<" ";
	}
	return 0;
}

tarjan
模板题

#include"bits/stdc++.h"
using namespace std;
int n,m,num=1;
int visit[5005],low[5005],dfn[5005];
vector<int>v[5005];
stack<int>s;
vector<pair<string,int> >res;
bool cmp(pair<string,int>a,pair<string,int>b){
	if(a.second!=b.second)return a.second>b.second;
	else return a.first<b.first;
}
void tanjar(int x){
	low[x]=num;
	dfn[x]=num;
	num++;
	visit[x]=1;
	s.push(x);
	for(int i=0;i<v[x].size();i++){
		int t=v[x][i];
		if(!dfn[t]){
			tanjar(t);
			low[x]=min(low[x],low[t]);
		}
		else if(visit[t]){
			low[x]=min(low[x],dfn[t]);
		}
	}
	if(low[x]==dfn[x]){
		vector<int>ans;
		ans.clear();
		string p="";
		int cnt=0,t=0;
		while(t!=x){
			t=s.top();
			s.pop();
			visit[t]=0;
			cnt++;
			ans.push_back(t);
		}
		sort(ans.begin(),ans.end());
		for(auto &c:ans){
			p+=to_string(c)+" ";
		}
		res.push_back(make_pair(p,cnt));
	}
}
int main(){
	scanf("%d %d",&n,&m);
	for(int i=1;i<=m;i++){
		int a,b,c;
		scanf("%d %d %d",&a,&b,&c);
		if(c==1){
			v[a].push_back(b);
		}
		else{
			v[a].push_back(b);
			v[b].push_back(a);
		}
	}
	for(int i=1;i<=n;i++){
		if(dfn[i]==0)
		tanjar(i);
	}
	sort(res.begin(),res.end(),cmp);
	cout<<res[0].second<<endl;
	string q=res[0].first;
	int len=q.length();
	string s="";
	for(int i=0;i<len;i++){
		if(q[i]==' '){
			cout<<s<<" ";
			s="";
		}
		else{
			s+=q[i];
		}
	}
	return 0;
}

网络流
最大流
板子题
ek算法

#include"bits/stdc++.h"
using namespace std;
typedef long long ll;
ll n,m,s,t;
ll ans=0;
ll visit[205],pre[205],dis[205],len[205][205];
vector<ll>v[505];
bool bfs(ll s,ll t){
	memset(visit,0,sizeof(visit));
	dis[s]=0x3f3f3f3f;
	queue<ll>q;
	q.push(s);
	visit[s]=1;
	while(!q.empty()){
		ll top=q.front();
		q.pop();
		for(int i=0;i<v[top].size();i++){
			ll dv=v[top][i];
			if(visit[dv]||len[top][dv]<=0)continue;
			dis[dv]=min(dis[top],len[top][dv]);
			pre[dv]=top;
			visit[dv]=1;
			q.push(dv);
			if(dv==t)return 1;
		}
	}
	return 0;
}
int main(){
	scanf("%lld %lld %lld %lld",&n,&m,&s,&t);
	for(int i=1;i<=m;i++){
		ll a,b,c;
		scanf("%lld %lld %lld",&a,&b,&c);
		v[a].push_back(b);
		v[b].push_back(a);
		len[a][b]+=c; 
	}
	while(bfs(s,t)){
		ll p=t,mi=0x3f3f3f3f;
		while(p!=s){
			int x=pre[p];
			len[x][p]-=dis[t];
			len[p][x]+=dis[t];
			p=pre[p];
		}
		ans+=dis[t];
	}
	cout<<ans;
	return 0;
} 

dinic
更快

#include"bits/stdc++.h"
using namespace std;
typedef long long ll;
struct node{
	ll v,w,net;
}edge[10005];
ll h[405],cnt=1,cur[405];
ll n,m,s,t;
ll deep[405];
void add(ll u,ll v,ll w){
	edge[++cnt].v=v;
	edge[cnt].w=w;
	edge[cnt].net=h[u];
	h[u]=cnt;
}
bool bfs(){
	for(int i=1;i<=n;i++)deep[i]=0;
	queue<ll>q;
	deep[s]=1;
	q.push(s);
	while(!q.empty()){
		int top=q.front();
		q.pop();
		for(ll i=h[top];i!=-1;i=edge[i].net){
			ll dv=edge[i].v;
			if(edge[i].w&&deep[dv]==0){
				deep[dv]=deep[top]+1;
				q.push(dv);
				if(dv==t)return 1;
			}
		}
	}
	return 0;
}
ll dfs(ll u,ll num){
	if(u==t){
		return num;
	}
	for(int i=cur[u];i!=-1;i=edge[i].net){
		cur[u]=i;
		if(edge[i].w&&deep[edge[i].v]==deep[u]+1){
			ll di=dfs(edge[i].v,min(num,edge[i].w));
			if(di){
				edge[i].w-=di;
				edge[i^1].w+=di;
				return di;
			}
		}
	}
	return 0;
}
int main(){
	scanf("%lld %lld %lld %lld",&n,&m,&s,&t);
	memset(h,-1,sizeof(h));
	for(int i=0;i<m;i++){
		ll a,b,c;
		scanf("%lld %lld %lld",&a,&b,&c);
		add(a,b,c);
		add(b,a,0);
	}
	ll sum=0;
	while(bfs()){
		for(int i=1;i<=n;i++)cur[i]=h[i];
		while(int ans=dfs(s,0x3f3f3f3f))sum+=ans;
	}
	cout<<sum; 
	return 0;
}

最大流最小费用流
板子题

#include"bits/stdc++.h"
using namespace std;
typedef long long ll;
ll n,m,s,t;
struct node{
	ll v,w,f,nex;
}edge[100005];
ll pre[10005],last[10005],h[10005],cnt=1,maxflow,mincost,flow[10005],visit[10005],dis[10005];
void add(int u,int v,int w,int f){
	edge[++cnt].v=v;
	edge[cnt].w=w;
	edge[cnt].f=f;
	edge[cnt].nex=h[u];
	h[u]=cnt;
}
bool spfa(){
	for(int i=1;i<=n;i++)visit[i]=0,dis[i]=0x3f3f3f3f,pre[i]=0,last[i]=0;
	dis[s]=0;
	flow[s]=0x3f3f3f3f;
	queue<int>q;
	q.push(s);
	visit[s]=1;
	while(!q.empty()){
		int top=q.front();
		q.pop();
		visit[top]=0;
		for(int i=h[top];i!=-1;i=edge[i].nex){
			int dv=edge[i].v;
			if(edge[i].w&&dis[dv]>dis[top]+edge[i].f){
				flow[dv]=min(flow[top],edge[i].w);
				pre[dv]=top;
				last[dv]=i;
				dis[dv]=dis[top]+edge[i].f;
				if(visit[dv]==0){
					visit[dv]=1;
					q.push(dv);
				}
			}
		}
	}
	return pre[t]!=0;
}
int main(){
	scanf("%lld %lld %lld %lld",&n,&m,&s,&t);
	for(int i=1;i<=n;i++){
		h[i]=-1;
	}
	for(int i=0;i<m;i++){
		int a,b,c,d;
		scanf("%d %d %d %d",&a,&b,&c,&d);
		add(a,b,c,d);
		add(b,a,0,-d);
	}
	while(spfa()){
		maxflow+=flow[t];
		mincost+=flow[t]*dis[t];
		int x=t;
		while(x!=s){
			edge[last[x]].w-=flow[t];
			edge[last[x]^1].w+=flow[t];
			x=pre[x];
		}
	}
	cout<<maxflow<<" "<<mincost<<endl;
	return 0;
}