图论技巧之反向建图 (P1629题解)

反向建图(P1629题解)

对于单源最短路径无论是迪杰斯特拉还是SPFA，都只可以求出一个点到其他各它n-1个点的最短路径，但是假如现在需要求n-1个点到达某个点的最短路径一般会采用floyd算法，但是floyd算法的复杂度是$O(n^3)$因此很有可能会超时，因此此时可以采用反向建图，即边反向。

对于邻接矩阵反向建图swap(g[i][j],g[j][i])

对于邻接表反向建图将原本add(a,b,c)变成add(b,a,c)即可，但是由于假如题目需要既有正向又有反向此时我们可以通过设置一个较大的数n，然后add(b+n,a+n,c)这样可以不印象正常建表

邮递员送信

题目描述

有一个邮递员要送东西，邮局在节点 $1$。他总共要送 $n-1$ 样东西，其目的地分别是节点 $2$ 到节点 $n$。由于这个城市的交通比较繁忙，因此所有的道路都是单行的，共有 $m$ 条道路。这个邮递员每次只能带一样东西，并且运送每件物品过后必须返回邮局。求送完这 $n-1$ 样东西并且最终回到邮局最少需要的时间。

输入格式

第一行包括两个整数，$n$ 和 $m$，表示城市的节点数量和道路数量。

第二行到第 $(m+1)$ 行，每行三个整数，$u,v,w$，表示从 $u$ 到 $v$ 有一条通过时间为 $w$ 的道路。

输出格式

输出仅一行，包含一个整数，为最少需要的时间。

样例 #1

样例输入 #1

5 10
2 3 5
1 5 5
3 5 6
1 2 8
1 3 8
5 3 4
4 1 8
4 5 3
3 5 6
5 4 2

样例输出 #1

83

提示

对于 $30\%$ 的数据，$1\le n\le 200$。

对于 $100\%$ 的数据，$1\le n\le 10^3$，$1\le m\le 10^5$，$1\le u,v\le n$，$1\le w\le 10^4$，输入保证任意两点都能互相到达。

#include<iostream>
#include<string.h>
#include<queue>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 200010;
int h[N],ne[N],e[N],w[N],idx;
int hn[N],nen[N],en[N],wn[N],idxn;
int dist[N];
int n,m;
bool stu[N];
typedef pair<int,int> PII;
void init(){
	idx = 0;
	memset(h,-1,sizeof h);
}

void add(int a,int b,int c){
	e[idx] = b;
	w[idx] = c;
	ne[idx] = h[a];
	h[a] = idx;
	idx++;
}
void addn(int a,int b,int c){
	en[idxn] = b;
	wn[idxn] = c;
	nen[idxn] = hn[a];
	hn[a] = idxn;
	idxn++;
}

int djsit(int index,int end){
	memset(dist,INF,sizeof dist);
	priority_queue<PII,vector<PII>,greater<PII>> heap;
	heap.push({0,index});
	dist[index] = 0;
	memset(stu,false,sizeof stu);
	while(heap.size()){
		auto node = heap.top();
		heap.pop();
		int index = node.second;
		int distance = node.first;
		if(stu[index]) continue;
		for(int i=h[index];i!=-1;i = ne[i]){
			int j = e[i];
			int mid = dist[index] + w[i];
			if(dist[j] > mid){
				dist[j] = mid;
				heap.push({dist[j],j});
			}
		}
		stu[index] =true;
	}
	if(dist[end] == INF) return -1;
	else return dist[end];
}
 #反向建图求n-1个点到某点最短路径
int djsitn(int index,int end){
	memset(dist,INF,sizeof dist);
	memset(stu,false,sizeof stu);
	priority_queue<PII,vector<PII>,greater<PII>> heap;
	heap.push({0,index});
	dist[index] = 0;
	while(heap.size()){
		auto node = heap.top();
		heap.pop();
		int index = node.second;
		int distance = node.first;
		if(stu[index]) continue;
		for(int i=hn[index];i!=-1;i = nen[i]){
			int j = en[i];
			int mid = dist[index] + w[i];
			if(dist[j] > mid){
				dist[j] = mid;
				heap.push({dist[j],j});
			}
		}
		stu[index] =true;
	}
	if(dist[end] == INF) return -1;
	else return dist[end];
}

int spfa(int index,int end){
	memset(dist,INF,sizeof dist);
	dist[index] = 0;
	queue <int> heap;
	heap.push(index);
	while(!heap.empty()){
		int node = heap.front();
		heap.pop();
		for(int i=h[node];i!=-1;i = ne[i]){
			int j = e[i];
			int mid = dist[node] + w[i];
			if(dist[j] > mid){
				dist[j] = mid;
				if(!stu[j]){
					heap.push(j);
				}
			}
		}
	}
	if(dist[end] == INF) return -1;
	else return dist[end];
}


int main(){
	scanf("%d%d",&n,&m);
	init();
	memset(hn,-1,sizeof hn);
	idxn = 0;
	for(int i=0;i<m;i++){
		int a,b,c;
		scanf("%d%d%d",&a,&b,&c);
		add(a,b,c);
		addn(b,a,c); 
	}
	int count = 0;
	djsit(1,2);
	for(int i=2; i<= n;i++){
		int begin = dist[i];
		count += begin;
	}
	djsitn(1,2);
	for(int i=2; i<= n;i++){
		int end = dist[i];
		count = count  + end;
	}
	printf("%d",count);
	return 0;
}