洛谷 P1608 路径统计

洛谷 P1608 路径统计

Description

• “RP餐厅”的员工素质就是不一般，在齐刷刷的算出同一个电话号码之后，就准备让HZH,TZY去送快餐了，他们将自己居住的城市画了一张地图，已知在他们的地图上，有N个地方，而且他们目前处在标注为“1”的小镇上，而送餐的地点在标注为“N”的小镇。（有点废话）除此之外还知道这些道路都是单向的，从小镇I到J需要花费D[I,J]的时间，为了更高效快捷的将快餐送到顾客手中，

  他们想走一条从小镇1到小镇N花费最少的一条路，但是他们临出发前，撞到因为在路上堵车而生气的FYY，深受启发，不能仅知道一条路线，万一。。。，于是，他们邀请FYY一起来研究起了下一个问题：这个最少花费的路径有多少条？

Input

• 输入文件第一行为两个空格隔开的数N，E，表示这张地图里有多少个小镇及有多少边的信息。

  下面E行，每行三个数I、J、C，表示从I小镇到J小镇有道路相连且花费为C.（注意，数据提供的边信息可能会重复，不过保证I<>J,1<=I,J<=n）。

Output

• 输出文件包含两个数，分别是最少花费和花费最少的路径的总数.

  两个不同的最短路方案要求：路径长度相同（均为最短路长度）且至少有一条边不重合。

  若城市N无法到达则只输出一个(‘No answer’);

Sample Input

5 4

1 5 4

1 2 2

2 5 2

4 1 1

Sample Output

4 2

Data Size

• 对于30%的数据 N<=20;

  对于100%的数据 1<=N<=2000,0<=E<=N*(N-1), 1<=C<=10.

题解：

• 最短路计数。
• 第一次见，想法挺妙的！
• 就是在dij/spfa的过程中加一个cnt计数数组。
• 如果松弛成功(dis[now] + e[i].dis < dis[e[i].to])，那么cnt[e[i].to] = cnt[now]，说明原来记的数不是最短路，now记的才是，所以cnt[e[i].to] = cnt[now]
• 又如果dis[now] + e[i].dis == dis[e[i].to]，那么cnt[e[i].to] += cnt[now]，说明从now走也是最短路，所以就加上它的路径数。
• 然后输出cnt[n]即可。
• 注意，重边会对路径计数有影响，自己yy便知。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#define N 2005
#define M 2005 * 2005
using namespace std;

struct Node
{
    int val, pos;
    friend bool operator < (Node x, Node y) {
        return x.val > y.val;
    }
};
struct E {int next, to, dis;} e[M];
int n, m, num, num_edge, ans;
int h[N], head[N], dis[N], cnt[N];
bool vis[N];
bool tag[N][N][11];

int read()
{
    int x = 0; char c = getchar();
    while(c < '0' || c > '9') c = getchar();
    while(c >= '0' && c <= '9') {x = x * 10 + c - '0'; c = getchar();}
    return x;
}

void add(int u, int v, int w)
{
    e[++num].next = h[u];
    e[num].to = v;
    e[num].dis = w;
    h[u] = num;
}

int dijstra()
{
    priority_queue<Node> que;
    memset(dis, 0x3f, sizeof(dis));
    dis[1] = 0, que.push((Node){0, 1});
    while(que.size())
    {
        int now = que.top().pos; que.pop();
        if(vis[now]) continue;
        vis[now] = 1;
        for(int i = h[now]; i != 0; i = e[i].next)
        {
            if(dis[now] + e[i].dis < dis[e[i].to])
            {
                dis[e[i].to] = dis[now] + e[i].dis;
                cnt[e[i].to] = cnt[now];
                if(!vis[e[i].to]) que.push((Node){dis[e[i].to], e[i].to});
            }
            else if(dis[now] + e[i].dis == dis[e[i].to]) cnt[e[i].to] += cnt[now];
        }
    }
    return dis[n];
}

int main()
{
    cin >> n >> m;
    for(int i = 1; i <= m; i++)
    {
        int u = read(), v = read(), w = read();
        if(!tag[u][v][w]) add(u, v, w);
        tag[u][v][w] = 1;
    }
    cnt[1] = 1;
    ans = dijstra();
    if(ans == 0x3f3f3f3f) {cout << "No answer"; return 0;}
    cout << ans << ' ' << cnt[n];
    return 0;
}

转载于:https://www.cnblogs.com/BigYellowDog/p/11251547.html