POJ1135 Domino Effect（SPFA）

题目大概是，普通骨牌连接两张关键骨牌，一旦一张关键骨牌倒下与其相邻的普通骨牌也倒下，普通骨牌倒下与其相邻的骨牌也倒下。给出所有有普通骨牌相连的两个关键骨牌之间普通骨牌倒下所需时间，问1号关键骨牌开始倒下后最后一张骨牌倒下的时间和位置。

居然是最短路。。记dist[u]为起点骨牌1到关键骨牌u的最短时间，跑个单源最短路可得出。最后倒下的骨牌，有两种情况：

1. 倒下的是关键骨牌u，那么倒下的时间就是dist[u]
2. 倒下的是关键骨牌u和v之间某张普通骨牌，那么倒下的时间就是 (dist[u]+dist[v]+time(u,v))/2，因为：

• • dist[u]=dist[v]显然成立，不等于的情况不妨设dist[u]<dist[v]；
  • 那么过了dist[u]的时间后，通往u点的骨牌到正好达u点，而通往v点的还需dist[v]-dist[u]的时间到达v；
  • 因而两边这时还有dist[v]-dist[u]+time(u,v)的时间长度，两边同时倒就还需要(dist[v]-dist[u]+time(u,v))/2的时间；
  • 所以总共需要(dist[v]-dist[u]+time(u,v))/2+dist[u]，即(dist[v]+dist[u]+time(u,v))/2的时间。

这样分别搞搞这两种情况，就能找到答案。

 #include<cstdio>
 #include<cstring>
 #include<queue>
 #include<algorithm>
 using namespace std;
 #define MAXN 555
 #define MAXM 555*555*2
 
 struct Edge{
     int u,v,cost,next;
 }edge[MAXM];
 int head[MAXN],NE,n;
 void addEdge(int a,int b,int c){
     edge[NE].u=a; edge[NE].v=b; edge[NE].cost=c; edge[NE].next=head[a];
     head[a]=NE++;
 }
 
 int d[MAXN];
 void SPFA(int vs){
     memset(d,,sizeof(d));
     d[vs]=;
     bool vis[MAXN]={};
     vis[vs]=;
     queue<int> que;
     que.push(vs);
     while(!que.empty()){
         int u=que.front(); que.pop();
         for(int i=head[u]; i!=-; i=edge[i].next){
             int v=edge[i].v;
             if(d[v]>d[u]+edge[i].cost){
                 d[v]=d[u]+edge[i].cost;
                 if(!vis[v]){
                     vis[v]=;
                     que.push(v);
                 }
             }
         }
         vis[u]=;
     }
 }
 int main(){
     int m,a,b,c,cse=;
     while(~scanf("%d%d",&n,&m) && (n||m)){
         NE=;
         memset(head,-,sizeof(head));
         while(m--){
             scanf("%d%d%d",&a,&b,&c);
             addEdge(a,b,c);
             addEdge(b,a,c);
         }
         SPFA();
         double res=-;
         bool flag=;
         for(int i=; i<=n; ++i){
             if(d[i]>res){
                 res=d[i];
                 a=i;
             }
         }
         for(int i=; i<NE; i+=){
             double tmp=(d[edge[i].u]+d[edge[i].v]+edge[i].cost)/2.0;
             if(tmp>res){
                 res=tmp;
                 flag=;
                 a=edge[i].u; b=edge[i].v;
                 if(a>b) swap(a,b);
             }
         }
         printf("System #%d\n",++cse);
         if(flag) printf("The last domino falls after %.1f seconds, between key dominoes %d and %d.\n\n",res,a,b);
         else printf("The last domino falls after %.1f seconds, at key domino %d.\n\n",res,a);
     }
     return ;
 }