洛谷 P2384 最短路题解

题目背景

狗哥做烂了最短路，突然机智的考了Bosh一道，没想到把Bosh考住了...你能帮Bosh解决吗？

他会给你100000000000000000000000000000000000%10金币w

题目描述

给定n个点的带权有向图，求从1到n的路径中边权之积最小的简单路径。

输入格式

第一行读入两个整数n，m，表示共n个点m条边。 接下来m行，每行三个正整数x，y，z，表示点x到点y有一条边权为z的边。

输出格式

输出仅包括一行，记为所求路径的边权之积，由于答案可能很大，因此狗哥仁慈地让你输出它模9987的余数即可。

废话当然是一个数了w

//谢fyszzhouzj指正w

对于20%的数据，n<=10。

对于100%的数据，n<=1000，m<=1000000。边权不超过10000。

输入输出样例

输入 #1复制

3 3
1 2 3
2 3 3
1 3 10

输出 #1复制

9

说明/提示

好好看一看再写哟w

---

题解

这道题目和通常的最短路的最大差别在于它计算的不是边权之和，二是边权乘积。代码如下。里面只有一个小坑就是有两个测试例的数据中边长可能为9987，所以如果直接将边的成绩去模9987会产生0，从而出现错误结果。程序中对这种情况进行了特判，如果出现模后的结果为0，则将模后的结果指定为9987。

 #include <iostream>
 #include <queue>
 #include <string.h>

 using namespace std;

 struct edge
 {
     int    zhongdian, changdu;
     int    next = ;
 };

 int first[];

 edge ed[];

 int n, m, en;

 void add_edge( int s, int e, int d )
 {
     en++;
     ed[en].next        = first[s];
     first[s]        = en;
     ed[en].zhongdian    = e;
     ed[en].changdu        = d;
 }

 const int    MAXN    = ;
 const int    INF    = 0x3f3f3f3f;
 int        dist[MAXN];

 bool use[MAXN];

 struct rec
 {
     int p, dist;

     rec()
     {
     }
     rec( int a, int b )

     {
         p = a, dist = b;
     }
 };

 bool operator < (const rec &a, const rec &b)

 {
     return(a.dist > b.dist);
 }

 priority_queue<rec> heap;

 void dijkstra_heap()

 {
     memset( dist, 0x3f3f, sizeof(dist) );

     dist[] = ;
     for ( int a = ; a <= n; a++ )
     {
         heap.push( rec( a, dist[a] ) );
     }
     for ( int a = ; a <= n; a++ )
     {
         while ( use[heap.top().p] )
         {
             heap.pop();
         }
         rec now = heap.top();
         heap.pop();
         int p = now.p;
         use[p] = true;
         for ( int i = first[p]; i; i = ed[i].next )
         {
             if ( dist[p] * ed[i].changdu < dist[ed[i].zhongdian] )

             {
                 dist[ed[i].zhongdian] = (dist[p] * ed[i].changdu) % ;
                 if ( dist[ed[i].zhongdian] ==  )
                 {
                     dist[ed[i].zhongdian] = ;
                 }
                 heap.push( rec( ed[i].zhongdian, dist[ed[i].zhongdian] ) );
             }
         }
     }
 }

 int main()
 {
     cin >> n >> m;
     for ( int a = ; a <= m; a++ )
     {
         int s, e, d;
         cin >> s >> e >> d;
         add_edge( s, e, d );
         add_edge( e, s, d );
     }
     dijkstra_heap();
     cout << dist[n] << endl;
     return();
 }