poj 1135 有点弯的最短路运用

题意：有n个关键骨牌 ， 每个两个相连的关键骨牌之间有一些普通牌 ， 然后下面给出 m 行数据 ， 每行有3个整数 a b t ， 表示从关键骨牌a、b之间连有一些普通牌 ， 并且从a倒向b需要时间t ，

要求出最后开始倒下的哪一张张牌、什么时候开始倒下 。 最后开始倒下的有可能是一张关键骨牌 ， 或是两张关键骨牌中间的某一张普通骨牌 。

解法：我们首先要求出每个关键骨牌开始倒下的最短（最早）时间 ， 然后求出每两个关键骨牌之间所有普通骨牌倒下的时间 ， 然后求它们的最大值 。

注意：如果是两张关键骨牌中间的某一张普通骨牌最后倒下 ， 那么我输出的时候是输出这两张关键骨牌 ， 并且它们的序号必须是从小到大。

代码：
#include
#include
#include
#include
using namespace std;

#define max(u , v)  (u)>(v)?(u):(v)
#define min(u , v)  (u)<(v)?(u):(v)     
const int INF = 0xfffffff;
const int maxn = 510;
int grap[maxn][maxn] , dist[maxn] , pre[maxn];
int n , m ;

void init()
{
      int i , j;
      for(i = 1; i <= n; i++)
            for(j = 1; j <= n; j++)
                  grap[i][j] = INF;
      memset(pre , 0 , sizeof(pre));
}

bool cmp(int x , int y)
{
      return dist[x]
}

void dijkstra()
{
      int i , j;
      for(i = 1; i <= n; i++)
            dist[i] = grap[1][i];
      pre[1] = 1;
      dist[1] = 0;

      int x = 1;
      for(j = 1; j < n; j++)
      {
            int maxs = INF;
            for(i = 1; i <= n; i++)
                  if(!pre[i] && dist[i] < maxs)
                  {
                        maxs = dist[i];
                        x = i;
                  }
            pre[x] = 1;

            for(i = 1; i <= n; i++)
                  if(!pre[i] && dist[x]+grap[x][i] < dist[i])
                        dist[i] = dist[x] + grap[x][i];
      }
}

int main()
{
      int gh = 1;
      while(scanf("%d %d" , &n , &m) != EOF)
      {
            if(n == 0 && m == 0)  break;
            init();
            int i , j , x , y , t;
            for(i = 1; i <= m; i++)
            {
                  scanf("%d %d %d" , &x , &y , &t);
                  grap[x][y] = grap[y][x] = t;
            }
            dijkstra();
           
            for(i = 0; i <= n; i++)
                  pre[i] = i;

            sort(pre+1 , pre+n+1 , cmp);

            //for(i = 1; i <= n; i++)
            //      cout<<pre[i]<<endl;

            int u = -1 , v = -1;
            double mint = -1.0 , xy;
            for(i = n; i >= 1; i--)
            {
                  x = pre[i];
                  for(j = i-1; j >= 1; j--)
                  {
                        y = pre[j];
                        if(grap[x][y] < INF && dist[x]-dist[y] < grap[x][y])
                        {
                        //      if()  break;
                              xy = grap[x][y]-(dist[x]-dist[y]);
                              xy = xy/2 + dist[x];
                              if(xy > mint)
                              {
                                    mint = xy;
                                    u = x;
                                    v = y;
                              }
                        }
                  }

            }

            x = pre[n];
            xy = dist[x]*1.0;
            if(xy > mint)
                  u = -1;
            if(u == -1)
            {
                 
                  //cout<<x<<endl;
                  printf("System #%d\n" , gh++);
                  //cout<<dist[x]<<x<<endl;
                  printf("The last domino falls after %.1lf seconds, at key domino %d.\n" , dist[x]*1.0 , x);
            }
            else
            {
                  printf("System #%d\n" , gh++);
                  printf("The last domino falls after %.1lf seconds, between key dominoes %d and %d.\n" , mint , min(u , v) , max(u , v));
            }
            cout<<endl;
      }
      return 0;
}