洛谷P2149 [SDOI2009]Elaxia的路线--两对点间最短路的最长公共路径

题目描述

最近，Elaxia和w**的关系特别好，他们很想整天在一起，但是大学的学习太紧张了，他们 必须合理地安排两个人在一起的时间。

Elaxia和w**每天都要奔波于宿舍和实验室之间，他们 希望在节约时间的前提下，一起走的时间尽可能的长。

现在已知的是Elaxia和w**所在的宿舍和实验室的编号以及学校的地图：地图上有N个路 口，M条路，经过每条路都需要一定的时间。 具体地说，就是要求无向图中，两对点间最短路的最长公共路径。
输入格式

第一行：两个整数N和M（含义如题目描述）。

第二行：四个整数x1、y1、x2、y2（1 ≤ x1 ≤ N，1 ≤ y1 ≤ N，1 ≤ x2 ≤ N，1 ≤ y2 ≤ N），分别表示Elaxia的宿舍和实验室及w**的宿舍和实验室的标号（两对点分别 x1,y1和x2,y2）。

接下来M行：每行三个整数，u、v、l（1 ≤ u ≤ N，1 ≤ v ≤ N，1 ≤ l ≤ 10000），表 u和v之间有一条路，经过这条路所需要的时间为l。
输出格式

一行，一个整数，表示每天两人在一起的时间（即最长公共路径的长度）
输入输出样例
输入 #1

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

输出 #1

3

说明/提示

对于30%的数据，N ≤ 100；

对于60%的数据，N ≤ 1000；

对于100%的数据，N ≤ 1500，输入数据保证没有重边和自环。

题解：先说明题目的一个坑点，题目没有说明两个人是从分别从宿舍到实验室还是从实验室到宿舍，所以有4种情况：
1.女从宿舍到实验室，男从宿舍到实验室
2.女从宿舍到实验室，男从实验室到宿舍
3.女从实验室到宿舍，男从宿舍到实验室
4.女从实验室到宿舍，男从实验室到宿舍

针对这4种情况分别考虑计算，我曾经做过这种类似的题目，也是两对点间求最短路的最长公共路径，不过那个题目数据量是1000，我直接暴力用迪杰斯特拉堆优化最短路直接跑了1000遍，时间复杂度就是nnlgn,这样就得到了最短路矩阵，然后再双重循环判断取哪两个点得到答案，解法简单粗暴，但是这个题目变成1500后，平方后就超时了，明显不行，所以算法得麻烦点了，这样考虑，求最长公共路径，针对情况1，我们可以先求出女生从宿舍x1到实验室y1的最短距离，然后在把能构成x1到y1最短路的所有路径记录下来，那么这些路径一定有一些是男生从x2到y2最短路的路径，好的，问题来了，女生从x1到y1的路径怎么记录，因为有很多可达方案，也就意味着很多条不同的路线，关键点来了,我们先求出x1到y1的最短距离dis[x1][y1],然后再反过来把所有的边跑一遍，如果满足

dis[x1][u]+w[u][v]+dis[v][y1]==dis[x1][y1]那么路径u->v一定是一条构成x1到y1最短路的边。

利用同样的原理，我们也计算x2到y2的最短距离dis[x2][y2]，如果某条边同时满足

dis[x1][u]+w[u][v]+dis[v][y1]==dis[x1][y1]&&dis[x2][u]+w[u][v]+dis[v][y2]==dis[x2][y2]

那么边u->v一定是x1到y1和x2到y2的最短路径中的公共边，然后记录。
记录之后怎么处理呢，我们可以拓扑排序，在找公共边的时候标记入度，以入度为0的点为起点开始拓扑排序，然后不断找其中最长的路径，输出就是答案，因为有4种情况，所以定义一个函数分别判断就行了。

AC代码

#include<bits/stdc++.h> 
using namespace std;
typedef long long ll;
const int N=200000;
struct Node{
	int v,next;
	ll w;
}edge[4*N];
int head[N],cnt;
void add_edge(int u,int v,ll w)
{
	edge[cnt].v=v;
	edge[cnt].w=w;
	edge[cnt].next=head[u];
	head[u]=cnt++;
}
bool vis[N];
ll dis[10][2000];
int n,m;
struct Sode{
	int v;
	ll dis;
	Sode(int v1,ll dis1)
	{
		v=v1;
		dis=dis1;
	}
	bool operator<(const Sode &t)const
	{
		return dis>t.dis;
	}
};
//最小堆优化迪杰斯特拉算法 
priority_queue<Sode>q;
void dij(int st,int sign)
{
	while(!q.empty())
	q.pop();
	memset(vis,0,sizeof(vis));
	for(int i=1;i<=n;i++)
	dis[sign][i]=1e18;
	dis[sign][st]=0;
	q.push(Sode(st,0));
	while(!q.empty())
	{
		Sode t=q.top();
		q.pop();
		if(vis[t.v])continue;
		vis[t.v]=true;
		for(int i=head[t.v];i!=-1;i=edge[i].next)
		{
			int v=edge[i].v;
			ll w=edge[i].w;
			if(dis[sign][v]>dis[sign][t.v]+w)
			{
				dis[sign][v]=dis[sign][t.v]+w;
				q.push(Sode(v,dis[sign][v]));
			}
		}
	}
}
int d[N];
//记录拓扑排序中最长的路径 
ll cis[N];
ll ans;
//定义新的边关系 
struct Code
{
	int v;
	ll w;
};
vector<Code>adge[N];
queue<Code>qt;
void solve(int s1,int s2,int s3,int s4,int x1,int y1,int x2,int y2)
{
	for(int i=1;i<=n;i++)
	adge[i].clear();
	//标记每个点的入度，如果点入度为-1，说明这个点没有参与公共边中 
	memset(d,-1,sizeof(d));
	for(int i=1;i<=n;i++)
	{
		for(int j=head[i];j!=-1;j=edge[j].next)
		{
			int u=i;
			int v=edge[j].v;
			ll w=edge[j].w;
			//同时满足一定为公共边 
			if(dis[s1][u]+w+dis[s2][v]==dis[s1][y1])
			{
				if(dis[s3][u]+w+dis[s4][v]==dis[s3][y2])
				{
					//标记入度 
					if(d[u]==-1)
					d[u]=0;
					if(d[v]==-1)
					d[v]=0;
					d[v]++;
					//记录公共边 
					Code t;
					t.v=v,t.w=w;
					adge[u].push_back(t);
				}
			}
		}
	}
	while(!qt.empty())
	qt.pop();
	//开始拓扑排序 
	for(int i=1;i<=n;i++)
	if(d[i]==0)
	{
		Code t;
		t.v=i,t.w=0;
		qt.push(t);
	}
	memset(cis,0,sizeof(cis));
	while(!qt.empty())
	{
		Code t=qt.front();
		qt.pop();
		int u=t.v;
		for(int i=0;i<adge[u].size();i++)
		{
			int v=adge[u][i].v;
			ll w=adge[u][i].w;
			//入度为-1，说明不是公共边中的点，直接跳过 
			if(d[v]==-1)continue;
			//记录最长路径 
			cis[v]=max(cis[v],cis[u]+w);
			//记录答案 
			ans=max(ans,cis[v]);
			d[v]--;
			if(d[v]==0)
			{
				qt.push(adge[u][i]);
			}
		}
	}
}
int main()
{
	scanf("%d%d",&n,&m);
	int x1,y1,x2,y2;
	scanf("%d%d%d%d",&x1,&y1,&x2,&y2);	
	memset(head,-1,sizeof(head));
	cnt=0;
	while(m--)
	{
		int u,v,w;
		scanf("%d%d%d",&u,&v,&w);
		add_edge(u,v,w);
		add_edge(v,u,w);
	}
	//分别计算4个点到其他所有点的距离 
	dij(x1,1);
	dij(y1,2);
	dij(x2,3);
	dij(y2,4);
	ans=0;
	//分4种情况处理 
	solve(1,2,3,4,x1,y1,x2,y2);
	solve(1,2,4,3,x1,y1,y2,x2);
	solve(2,1,3,4,y1,x1,x2,y2);
	solve(2,1,4,3,y1,x1,y2,x2);
	cout<<ans<<endl;
	return 0;
}