洛谷—— P2149 [SDOI2009]Elaxia的路线

https://www.luogu.org/problem/show?pid=2149

题目描述

最近，Elaxia和w的关系特别好，他们很想整天在一起，但是大学的学习太紧张了，他们 必须合理地安排两个人在一起的时间。Elaxia和w每天都要奔波于宿舍和实验室之间，他们 希望在节约时间的前提下，一起走的时间尽可能的长。 现在已知的是Elaxia和w**所在的宿舍和实验室的编号以及学校的地图：地图上有N个路 口，M条路，经过每条路都需要一定的时间。 具体地说，就是要求无向图中，两对点间最短路的最长公共路径。

输入输出格式

输入格式：

 

第一行：两个整数N和M（含义如题目描述）。 第二行：四个整数x1、y1、x2、y2（1 ≤ x1 ≤ N，1 ≤ y1 ≤ N，1 ≤ x2 ≤ N，1 ≤ ≤ 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个点跑4遍最短路，

确定每条同时在在于两点间最短路上的边，更新ans

  1 #include <cstdlib>
  2 #include <cstring>
  3 #include <cstdio>
  4 #include <queue>
  5 
  6 #define max(a,b) (a>b?a:b)
  7 #define min(a,b) (a<b?a:b)
  8 inline void read(int &x)
  9 {
 10     x=0; register char ch=getchar();
 11     for(; ch>'9'||ch<'0'; ) ch=getchar();
 12     for(; ch>='0'&&ch<='9'; ch=getchar()) x=x*10+ch-'0';
 13 }
 14 const int INF(0x3f3f3f3f);
 15 const int N(1500+5);
 16 const int M(2e6+15);
 17 int n,m,s1,s2,t1,t2;
 18 int head[N],sumedge,hed[N],sum;
 19 struct Edge {
 20     int v,next,w;
 21     Edge(int v=0,int next=0,int w=0):v(v),next(next),w(w){}
 22 }edge[M<<1],e[M];
 23 struct Road {
 24     int u,v,w;
 25     Road(int u=0,int v=0,int w=0):u(u),v(v),w(w){}
 26 }road[M];
 27 inline void ins(int u,int v,int w)
 28 {
 29     edge[++sumedge]=Edge(v,head[u],w);
 30     head[u]=sumedge;
 31     edge[++sumedge]=Edge(u,head[v],w);
 32     head[v]=sumedge;
 33 }
 34 
 35 bool vis[N];
 36 int dis[N][5];
 37 struct Node {
 38     int pos,dis;
 39     Node() { pos=0; dis=0; }
 40     bool operator < (const Node &x)const
 41     {
 42         return dis>x.dis;
 43     }
 44 }u,v;
 45 inline void Dijkstra(int s,int op)
 46 {
 47     memset(vis,0,sizeof(vis));
 48     std::priority_queue<Node>que;
 49     for(int i=1; i<=n; ++i)    dis[i][op]=INF;
 50     u.pos=s; u.dis=dis[s][op]=0; que.push(u);
 51     for(; !que.empty(); )
 52     {
 53         u=que.top(); que.pop();
 54         if(vis[u.pos]) continue;    vis[u.pos]=1;
 55         for(int i=head[u.pos]; i; i=edge[i].next)
 56         {
 57             v.pos=edge[i].v;
 58             if(dis[v.pos][op]>dis[u.pos][op]+edge[i].w)
 59             {
 60                 v.dis=dis[v.pos][op]=dis[u.pos][op]+edge[i].w;
 61                 que.push(v);
 62             }
 63         }
 64     }
 65 }
 66 
 67 int rd[N],val[N],ans;
 68 inline void add(int u,int v,int w)
 69 {
 70     e[++sum]=Edge(v,hed[u],w);
 71     hed[u]=sum; rd[v]++;
 72 }
 73 inline int Top_sort()
 74 {
 75     int ret=0;
 76     std::queue<int>que;
 77     for(int i=1; i<=n; ++i)
 78         if(!rd[i]) que.push(i);
 79     for(int u,v; !que.empty(); )
 80     {
 81         u=que.front(); que.pop();
 82         for(int i=hed[u]; i; i=e[i].next)
 83         {
 84             v=e[i].v;
 85             if(val[v]<val[u]+e[i].w)
 86                 val[v]=val[u]+e[i].w,ret=max(ret,val[v]);
 87             if(--rd[v]==0) que.push(v);
 88         }
 89     }
 90     return ret;
 91 }
 92 
 93 inline bool check(int x)
 94 {
 95     return (dis[x][1]+dis[x][3]==dis[t1][1])&&(dis[x][2]+dis[x][4]==dis[t2][2]);
 96 }
 97 
 98 int Presist()
 99 {
100     read(n),read(m),read(s1);
101     read(t1),read(s2),read(t2);
102     for(int u,v,w,i=1; i<=m; ++i)
103         read(u),read(v),read(w),
104         ins(u,v,w),road[i]=Road(u,v,w);
105     Dijkstra(s1,1); Dijkstra(s2,2);
106     Dijkstra(t1,3); Dijkstra(t2,4);
107     for(int i=1; i<=n; ++i) if(check(i))
108         for(int j=i+1; j<=n; ++j) if(check(j))
109            ans=max(ans,std::abs(dis[i][1]-dis[j][1]));
110     printf("%d\n",ans);
111     return 0;
112 }
113 
114 int Aptal=Presist();
115 int main(int argc,char*argv[]){;}

 

posted @ 2017-09-26 16:51  Aptal丶  阅读(245)  评论(0)  编辑  收藏  举报