2019.7.22 2019杭电多校 1005 Path（最短路+最大流（最小割））

现在假设受众已有 求图的所有最短路径 的前置知识

推荐阅读：白书P209 看懂最大流&最小割

今天没时间重构代码了。。。

就随便注释一下

题目呢是签到题

意思是给一个有向图

一个人要从1点走到n点

我们要阻碍他走最短路

而你堵塞一条边的代价就是这条边的长度

问最小代价

要是看懂了最小割
就知道这题几乎就是板子题

先用优先队列优化最短路，求所有最短路径的所有边
题解的方法可以学一手

采用的方法是先更新好所有点的最短距离 （题中的sp数组）
然后遍历所有边
接着如果说两个点的最短距离之差刚好是边的长度
那么这条边就是在最短路上

就是题解那个蜜汁公式的意思

for(int pos=1;pos<=n;++pos)
	for(auto &e : D::G[pos])
		if(sp[e.to]-sp[pos]==e.v)
			I::AddEdge(pos,e.to,e.v);

上图的下面的for等价于

for(int i=0;i<G[pos].size();i++){
	D::Edge e=G[pos][i];
}

学一手auto自适应类型

然后用最大流求答案。。。。

似乎就没了

#include <bits/stdc++.h>

template <class T>
bool Reduce(T &a,T const &b) {
	return a>b?a=b,1:0;
}

const int XN=1e4+11;
const int INF=2e9;
const long long oo=1e18;

int n;
long long sp[XN];

namespace D {
	struct Edge {
		int to,v;
	};

	std::vector<Edge> G[XN];
	//优先队列优化
	void Run() {
		static bool ud[XN];
		std::priority_queue<std::pair<long long,int>,std::vector<std::pair<long long,int> >,std::greater<std::pair<long long,int> > > Q;//小根堆
		std::fill(sp+1,sp+1+n,oo);
		std::fill(ud+1,ud+1+n,0);
		sp[1]=0;
		Q.push(std::make_pair(0,1));
		while(!Q.empty()) {
			int pos=Q.top().second;Q.pop();
			if(ud[pos])
				continue;
			ud[pos]=1;
			for(auto int & e : G[pos]) {
				int u=e.to;
				if(Reduce(sp[u],sp[pos]+e.v))
					Q.push(std::make_pair(sp[u],u));
			}
		}
	}
}

namespace I {
	//最大流求解
	struct Edge {
		int to,cap,v;
		Edge *rev,*pre;
	}*G[XN],*preArc[XN];

	void AddEdge(int x,int y,int c) {
		G[x]=new Edge{y,c,0,NULL,G[x]};
		G[y]=new Edge{x,0,0,G[x],G[y]};
		G[x]->rev=G[y];
	}

	int Aug() {
		int d=INF;
		for(int pos=n;preArc[pos];pos=preArc[pos]->rev->to)
			Reduce(d,preArc[pos]->cap-preArc[pos]->v);
		for(int pos=n;preArc[pos];pos=preArc[pos]->rev->to) {
			preArc[pos]->v+=d;
			preArc[pos]->rev->v-=d;
		}
		return d;
	}

	long long Run() {
		static int num[XN],d[XN];
		static Edge *cArc[XN];
		std::fill(num+1,num+n,0);
		std::fill(d+1,d+1+n,0);
		std::copy(G+1,G+1+n,cArc+1);
		num[0]=n;preArc[1]=0;
		long long flow=0;
		for(int pos=1;d[1]<n;) {
			if(pos==n) {
				flow+=Aug();
				pos=1;
			}
			bool adv=0;
			for(Edge *&e=cArc[pos];e;e=e->pre) {
				int u=e->to;
				if(e->cap>e->v && d[u]+1==d[pos]) {
					adv=1;
					preArc[pos=u]=e;
					break;
				}
			}
			if(!adv) {
				if(--num[d[pos]]==0)
					break;
				d[pos]=n;
				for(Edge *e=cArc[pos]=G[pos];e;e=e->pre)
					if(e->cap>e->v)
						Reduce(d[pos],d[e->to]+1);
				num[d[pos]]++;
				if(pos!=1)
					pos=preArc[pos]->rev->to;//cArc
			}
		}
		return flow;
	}
}

int main() {
	//freopen("test1.in","r",stdin);
	std::ios::sync_with_stdio(0);
	std::cin.tie(0);
	int T;std::cin>>T;
	while(T--) {
		int m;std::cin>>n>>m;
		for(int i=1;i<=n;++i) {
			D::G[i].clear();
			I::G[i]=0;
		}
		for(int i=1;i<=m;++i) {
			int x,y,v;
			std::cin>>x>>y>>v;
			D::G[x].push_back({y,v});
		}
		
		D::Run();

		if(sp[n]==oo)
			std::cout<<0<<'\n';
		else {
			//蜜汁公式 求出所有最短路径边
			for(int pos=1;pos<=n;++pos)
				for(auto &e : D::G[pos])
					if(sp[e.to]-sp[pos]==e.v)
						I::AddEdge(pos,e.to,e.v);

			std::cout<<I::Run()<<'\n';
		}
	}
	return 0;
}

附上蒟蒻重写的代码

#include<bits/stdc++.h>
#define ll long long 
#define MAX_V 10005
#define MAX_E 10005
using namespace std;
struct node{
	int to,cost;
};
struct edge{
	int to,cap,rev;
};
vector<edge> E[MAX_E];
int level[MAX_V];
int iter[MAX_V];
vector<node>G[MAX_E];//存边 
const ll INF=1e18,INF2=2e9;
ll d[MAX_V];//储存最短距离 
bool vis[MAX_V];//访问数组，如果还没访问就是0 
int V,Ed;//点数和边数 
//维护d数组 
void shortest_path(int s){
	priority_queue<pair<ll,int>/*储存和起始点最短距离&当前点*/,vector<pair<ll,int> >,greater<pair<ll,int> > >q;//小根堆优化 
	fill(d+1,d+1+V,INF);
	fill(vis+1,vis+1+V,0);
	d[1]=0;
	q.push(make_pair(0,1));
	while(!q.empty()){
		int pos=q.top().second;
		q.pop();
		if(vis[pos]){
			continue;
		}
		vis[pos]=1;
		for(int i=0;i<G[pos].size();i++){
			node e=G[pos][i];
			int u=e.to;
			if(d[u]>d[pos]+e.cost){
				d[u]=d[pos]+e.cost;
				q.push(make_pair(d[u],u));//把新状态压入队列 
				//cout<<"you";
			}
		}
	} 
} 
//最大流模板 
void add_edge(int from,int to,int cap){
	E[from].push_back((edge){to,cap,E[to].size()});
	E[to].push_back((edge){from,0,E[from].size()-1}); 
} 
void bfs(int s){
	memset(level,-1,sizeof(level));
	queue<int>que;
	level[s]=0;
	que.push(s);
	while(!que.empty()){
		int v=que.front();
		que.pop();
		for(int i=0;i<E[v].size();i++){
			edge &e=E[v][i];
			if(e.cap>0&&level[e.to]<0){
				level[e.to]=level[v]+1;
				que.push(e.to);
			}
		}
	}
}
int dfs(int v,int t,int f){
	if(v==t)return f;
	for(int &i=iter[v];i<E[v].size();i++){
		edge &e=E[v][i];
		if(e.cap>0&&level[v]<level[e.to]){
			int d=dfs(e.to,t,min(f,e.cap));
			if(d>0){
				e.cap-=d;
				E[e.to][e.rev].cap+=d;
				return d;
			}
		}
	}
	return 0;
}
//注意是ll 
ll max_flow(int s,int t){
	ll flow=0;
	for(;;){
		bfs(s);
		if(level[t]<0)return flow;
		memset(iter,0,sizeof(iter));
		int f;
		while((f=dfs(s,t,INF2))>0)flow+=f;
	}
}

int main(){
	//freopen("02.in","r",stdin);
	//freopen("02.out","w",stdout);
	int t,x,y,c;
	scanf("%d",&t);
	while(t--){
		scanf("%d%d",&V,&Ed);
		for(int i=1;i<=V;i++){
			vector<node>().swap(G[i]);//清空内存 
			vector<edge>().swap(E[i]);
		}
		for(int i=0;i<Ed;i++){
			scanf("%d%d%d",&x,&y,&c);
			node now;
			now.to=y,now.cost=c;
			G[x].push_back(now);
		} 
		shortest_path(1);
		if(d[V]==INF){
			printf("0\n");
		}else {
			for(int pos=1;pos<=V;pos++){
				for(int j=0;j<G[pos].size();j++){
					node e=G[pos][j];
					//如果一条边要到达的点和起点的最短距离之差 刚好为边的长度 
					if(d[e.to]-d[pos]==e.cost){
						add_edge(pos,e.to,e.cost);
						//cout<<"you";
					}	
				}
			}
			printf("%lld\n",max_flow(1,V));//求解1到n的最小割 
		}
	} 
	return 0;
}