洛谷 P1629 邮递员送信 题解

P1629 邮递员送信

题目描述

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

输入格式

第一行包括两个整数N和M。

第2到第M+1行，每行三个数字U、V、W，表示从A到B有一条需要W时间的道路。 满足1<=U,V<=N,1<=W<=10000,输入保证任意两点都能互相到达。

【数据规模】

对于30%的数据，有1≤N≤200;

对于100%的数据，有1≤N≤1000,1≤M≤100000。

输出格式

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

输入输出样例

输入 #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

【两种方法】

【SPFA】

SPFA

【注意注意】

这是单向路单向路单向路！！！

重要的事情说三遍！！！

（题目中没点出这点但是我的全WA经历让我深刻的认识到了这一点）

【思路】

去和来这是两个完全相反的东西

SPFA跑一个方向是很轻松的

然后另一个方向就很难办了

该怎么办呢？

n遍SPFA？

不太可能这就是一道黄题

对了！可以反向建图！

将方向反过来建出来的图就是完全相反的

某个点到x的距离恰好就是回家的最短距离

这样和正向建图一结合

就能求出去和回的最短路径了

然后求和就可以了

【完整代码】

#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
using namespace std;
const int Max = 100005;
struct node
{
	int y;
	int ne;
	int z;
}a1[Max << 1],a2[Max << 1];
int n,m,x;
const int M = 1002;
int head1[M],head2[M];
int sum = 0;
void add1(int x,int y,int z)
{
	a1[++ sum].y = y;
	a1[sum].z = z;
	a1[sum].ne = head1[x];
	head1[x] = sum;
}
void add2(int x,int y,int z)
{
	a2[++ sum].y = y;
	a2[sum].z = z;
	a2[sum].ne = head2[x];
	head2[x] = sum;
}
int d1[M],d2[M];
bool use[M];
void SPFA1()
{
	memset(use,false,sizeof(use));
	queue<int>q;
	for(register int i = 1;i <= n;++ i)
		d1[i] = 999999;
	d1[x] = 0;
	q.push(x);
	while(!q.empty())
	{
		int qwq = q.front();
		q.pop();use[qwq] = false;
		for(register int i = head1[qwq];i != 0;i = a1[i].ne)
		{
			int awa = a1[i].y;
			if(d1[awa] > d1[qwq] + a1[i].z)
			{
				d1[awa] = d1[qwq] + a1[i].z;
				if(use[awa] == false)
				{
					use[awa] = true;
					q.push(awa);
				}
			}
		}
	}
}
void SPFA2()
{
	memset(use,false,sizeof(use));
	queue<int>q;
	for(register int i = 1;i <= n;++ i)
		d2[i] = 999999;
	d2[x] = 0;
	q.push(x);
	while(!q.empty())
	{
		int qwq = q.front();
		q.pop();use[qwq] = false;
		for(register int i = head2[qwq];i != 0;i = a2[i].ne)
		{
			int awa = a2[i].y;
			if(d2[awa] > d2[qwq] + a2[i].z)
			{
				d2[awa] = d2[qwq] + a2[i].z;
				if(use[awa] == false)
				{
					use[awa] = true;
					q.push(awa);
				}
			}
		}
	}
}
int main()
{
	scanf("%d%d",&n,&m);
	x = 1;
	int xx,yy,zz;
	for(register int i = 1;i <= m;++ i)
	{
		scanf("%d%d%d",&xx,&yy,&zz);
		add1(xx,yy,zz);
		add2(yy,xx,zz);
	}
	SPFA1();
	SPFA2();
	int MM = 0;
	for(register int i = 1;i <= n;++ i)
		MM = MM + d1[i] + d2[i];
	cout << MM << endl;
	return 0;
}

【dijkstra】

dijkstra + 堆优化

【说在前面的话】

通过这道题发现我真是个可爱的孩子

用dijkstra做的时候

开开心心打一个反向建图

轻轻松松提交上去

然后拿了70分……

堆优化之后的复杂度是O((N+M)logN)完全不会超时

然后我就开始思考各种可能出现的玄学问题

最后焦灼了一个小时

终于发现是数组开小了……

鬼知道为什么数组开小会超时……

【核心思路】

有去有回

如果只是去的话单源最短路径就可以轻轻松松解决掉

但是来回的话

首先想到的是多源最短路径

但是好像跑不过去

这就用到了和上面SPFA一样的思路了

就是反向建图

这样只需要两遍dijkstra就可以解决掉

最后再求个和就没有问题了

【完整代码】

#include<iostream>
#include<cstdio>
#include<queue>
using namespace std;
const int Max = 100004;
const int M = 1003;
struct point
{
	int w;
	int x;
	bool operator < (const point & xx)const
	{
		return xx.w < w;
	}
};
int n,m;
struct node
{
	int y,ne;
	int z;
}a1[Max << 1],a2[Max << 1];
int sum1 = 0,sum2 = 0;
int head1[M],head2[M];
inline int read()
{
     int x=0; char ch=getchar();
     while (ch<'0' || ch>'9') ch=getchar();
     while (ch>='0' && ch<='9'){ x=x*10+ch-'0'; ch=getchar(); }
     return x;
}   
void add1(int x,int y,int z)
{
	a1[++ sum1].y = y;
	a1[sum1].z = z;
	a1[sum1].ne = head1[x];
	head1[x] = sum1;
}
void add2(int x,int y,int z)
{
	a2[++ sum2].y = y;
	a2[sum2].z = z;
	a2[sum2].ne = head2[x];
	head2[x] = sum2;
}
int dis1[M],dis2[M];
bool use1[M],use2[M];
priority_queue<point>q;
void dj1()
{
	for(register int i = 2;i <= n;++ i)
		dis1[i] = 999999;
	dis1[1] = 0;
	q.push((point){0,1});
	while(!q.empty())
	{
		point qwq = q.top();
		q.pop();
		int x = qwq.x;
		if(use1[x] == true)
			continue;
		use1[x] = true;
		for(register int i = head1[x];i != 0;i = a1[i].ne)
		{
			int awa = a1[i].y;
			if(dis1[awa] > dis1[x] + a1[i].z)
			{
				dis1[awa] = dis1[x] + a1[i].z;
				if(use1[awa] == false)
					q.push((point){dis1[awa],awa});
			}
		}
	}
}
void dj2()
{
	for(register int i = 2;i <= n;++ i)
		dis2[i] = 999999;
	dis2[1] = 0;
	q.push((point){0,1});
	while(!q.empty())
	{
		point qwq = q.top();
		q.pop();
		int x = qwq.x;
		if(use2[x] == true)
			continue;
		use2[x] = true;
		for(register int i = head2[x];i != 0;i = a2[i].ne)
		{
			int awa = a2[i].y;
			if(dis2[awa] > dis2[x] + a2[i].z)
			{
				dis2[awa] = dis2[x] + a2[i].z;
				if(use2[awa] == false)
					q.push((point){dis2[awa],awa});
			}
		}
	}
}
int main()
{
	n = read();m = read();
	int x,y,z;
	for(register int i = 1;i <= m;++ i)
	{
		x = read();y = read();z = read();
		add1(x,y,z);add2(y,x,z);
	}
	dj1();
	dj2();
	int ans = 0;
	for(register int i = 2;i <= n;++ i)
		ans += dis1[i] + dis2[i];
	cout << ans << endl;
	return 0;
}