次短路

转载：
https://www.cnblogs.com/star-eternal/
旅行团每天固定的从S城市出发到达T城市，为了省油要求尽量走最短路径或比最短路径长1单位距离的路径，求满足条件的路径条数。

如上图：S=1，T=5，则有两条最短路，1->2->5和1->3->5 长度都为6，另外还有一条长度为7, 1->3->4->5

输入：

第一行一个数，表示数据的组数。

对于每组数据，第一行两个数，N和M，2 ≤ N ≤ 1, 000，1 ≤ M ≤ 10, 000，分别表示城市数和路的条数。

接下来M行，每行三个数A，B和L，1 ≤ A, B ≤ N，A <> B且 1 ≤ L ≤ 1, 000，表示有一条路从城市A到城市B，长度为L。道路是单向的，可能有多条路从A到B。

接下来一行，两个数S和T，1 ≤ S, F ≤ N，S<>T，表示起点城市和终点城市。

数据保证S和T间至少有一条路。

输出：

每组数据一个数，表示路径条数，答案不超过1 000 000 000.

样例：

Sample Input

2
5 8
1 2 3
1 3 2
1 4 5
2 3 1
2 5 3
3 4 2
3 5 4
4 5 3
1 5
5 6
2 3 1
3 2 1
3 1 10
4 5 2
5 2 7
5 2 7
4 1
Sample Output

3
2

• 将dist数组开成二维的,即dist[v][2],第二维分别用于记录最短路和次短路;
• 再用一个cnt二维数组分别记录最短路和次短路的条数;
• 每次更新路径的条数时,不能直接加1,应该加上cnt[u][k],k为次短路径或者最短路径的标记;
• 图有重边,不能用邻接矩阵存储;

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int inf=0x3f3f3f3f;
const int maxn=10010;
struct Edge
{
    int to;
    int next;
    int w;
}edge[maxn<<1];
int vis[maxn][2],dis[maxn][2];
int head[maxn],count[maxn][2];
int n,m,cnt;

void add(int u,int v,int w)
{
    edge[cnt].to=v;
    edge[cnt].w=w;
    edge[cnt].next=head[u];
    head[u]=cnt++;
}
void Dijkstra(int s,int d)
{
    memset(vis,0,sizeof(vis));
    memset(count,0,sizeof(count));
    int i=0;
    for(i=1;i<=n;i++)
    {
        dis[i][0]=inf;
        dis[i][1]=inf;
    }
    dis[s][0]=0;
    count[s][0]=1;
    int j,k,tmp,flag;
    for(i=1;i<=2*n-1;i++)
    {
       tmp=inf;
       for(j=1;j<=n;j++)
       {
           if(!vis[j][0]&&tmp>dis[j][0])
           {
               k=j;
               flag=0;
               tmp=dis[j][0];
           }
           else if(!vis[j][1]&&tmp>dis[j][1])
           {
               k=j;
               flag=1;
               tmp=dis[j][1];
           }
       }
       if(tmp==inf)
        break;
       vis[k][flag]=1;
       for(j=head[k];j!=-1;j=edge[j].next){ // 更新和点k相连的边
            int v=edge[j].to;
            if(dis[v][0]>tmp+edge[j].w)
            {  // 比最短路短
                dis[v][1]=dis[v][0];
                count[v][1]=count[v][0];
                dis[v][0]=tmp+edge[j].w;
                count[v][0]=count[k][flag];
            }else if(dis[v][0]==tmp+edge[j].w)
            {   // 等于最短路
                count[v][0]+=count[k][flag];
            }else if(dis[v][1]>tmp+edge[j].w)
            {    // 比次短路短
                dis[v][1]=tmp+edge[j].w;
                count[v][1]=count[k][flag];
            }else if(dis[v][1]==tmp+edge[j].w)
            {   // 等于次短路
                count[v][1]+=count[k][flag];
            }
        }
    }
    if(dis[d][1]==dis[d][0]+1)
        count[d][0]+=count[d][1];
    printf("%d\n",count[d][0]);

}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        cnt=0;
        memset(head,-1,sizeof(head));
        scanf("%d%d",&n,&m);
        int u,v,w;
        while(m--)
        {
            scanf("%d%d%d",&u,&v,&w);
            add(u,v,w);
        }
        int s,d;
        scanf("%d%d",&s,&d);
        Dijkstra(s,d);
    }
    return 0;
}