洛谷 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 = 0;
};

int first[2333];

edge ed[200005];

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    = 100010;
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[1] = 1;
    for ( int a = 1; a <= n; a++ )
    {
        heap.push( rec( a, dist[a] ) );
    }
    for ( int a = 1; 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) % 9987;
                if ( dist[ed[i].zhongdian] == 0 )
                {
                    dist[ed[i].zhongdian] = 9987;
                }
                heap.push( rec( ed[i].zhongdian, dist[ed[i].zhongdian] ) );
            }
        }
    }
}


int main()
{
    cin >> n >> m;
    for ( int a = 1; 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(0);
}