通过dijkstra算法解决城堡问题

问题描述：

你知道黑暗城保有N个房间(1≤N≤1 000), M条可以制造的双向通道，以及每条通道的长度。
城堡是树形的并且满足下面的条件 : 如果所有的通道都被修建.设D[i]为第i号房间与第1号房间的最短路径长度; 
 而S[i]为实际修建的树形城保中第i号房间与第1号房间的路径长度; 
 要求对于所有整数i(1 <= i <= N)，有S[i] = D[i]成立。
你想知道有多少种不同的城保修建方案。当然，你只需要输出答案对2 ^ 31 - 1取模之后的结果就行了

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
//0x3f3f3f3f的十进制为1061109567，和INT_MAX一个数量级，即109数量级，而一般场合下的数据都是小于10 ^ 9的。
//0x3f3f3f3f * 2 = 2122219134，无穷大相加依然不会溢出。
// 
//可以使用memset(array, 0x3f, sizeof(array))来为数组设初值为0x3f3f3f3f，因为这个数的每个字节都是0x3f。
//memset是按字节来memset的，不是按个来memset的，int有四个字节，就会把每个字节都变成0x3f
//一般要么memset成0，要么memset成 - 1，因为int 型 0每个字节都是0， - 1每个字节都是 - 1.
// 
//你知道黑暗城保有N个房间(1≤N≤1 000), M条可以制造的双向通道，以及每条通道的长度。
//城堡是树形的并且满足下面的条件 : 如果所有的通道都被修建.设D[i]为第i号房间与第1号房间的最短路径长度; 
// 而S[i]为实际修建的树形城保中第i号房间与第1号房间的路径长度; 
// 要求对于所有整数i(1 <= i <= N)，有S[i] = D[i]成立。
//你想知道有多少种不同的城保修建方案。当然，你只需要输出答案对2 ^ 31 - 1取模之后的结果就行了

using namespace std;
typedef long long LL;
const int N = 1010;
const int mod = (1 << 31) - 1;//2^31-1
int n, m;//n个房间  m条双向通道
int w[N][N];
int d[N];
bool st[N];

void dijkstra() //dijkstra求所有点到1号点的最短距离
{
    memset(d, 0x3f, sizeof d); //初始化距离
    d[1] = 0; //起点距离为0
    memset(st, false, sizeof st); //在本函数中表示判重数组，初始化判重数组
    for (int i = 0; i < n - 1; i++) //朴素dijkstra
    {
        int t = -1;
        for (int j = 1; j <= n; j++)
            if (!st[j] && (t == -1 || d[t] > d[j]))
                t = j;
        st[t] = true;//标记t已加入最短路径生成树
        for (int j = 1; j <= n; j++)
            d[j] = min(d[j], d[t] + w[t][j]);
    }
}
//4 6  4个点  6条双向通道
//1 2 1
//1 3 2
//1 4 3
//2 3 1
//2 4 2
//3 4 1
//dijkstra算法结束后只有1点被选中，d[1]=0,d[2]=1,d[3]=2,d[4]=3
int prim() //求最短路径生成树的方案数
{
    memset(st, false, sizeof st); //在本函数中表示每个点是否在最短路径生成树中
    st[1] = true; //1号点最开始就在最短路径生成树中
    int res = 1; //记录最短路径生成树的总方案数，1号点是第一个点，只有一种方案
    for (int i = 0; i < n - 1; i++) //计算剩下 n - 1 个点的方案数
    {
        int t = -1;
        for (int j = 2; j <= n; j++)
            if (!st[j] && (t == -1 || d[t] > d[j]))
                t = j;
        //i=0时，t=2，d[2]<d[3]<d[4] t只会为2
        LL cnt = 0; //记录当前点的方案数
        for (int j = 1; j <= n; j++) //枚举t能从哪个点加入最短路径生成树
            if (st[j] && d[t] == d[j] + w[j][t]) //如果t从当前点加入满足最短路径生成树的条件
                cnt++; //方案数+1
       // j=1 if条件成立，cnt++  j=2，st[2]=false if条件不成立
        //执行下面代码，把st[2]=true,加入最小路径生成树
        //res=1*1%mod=1


        //i=2开始循环  t=3也只能是3 cnt=1+1=2  把st[3]=true,加入最小路径生成树 res=2
        st[t] = true; //标记t已加入最短路径生成树
        res = (LL)res * cnt % mod; //累乘方案数
    }
    return res;
}

int main()
{
    scanf("%d%d", &n, &m);
    memset(w, 0x3f, sizeof w); //初始化邻接矩阵
    while (m--)
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        w[a][b] = w[b][a] = min(w[a][b], c); //无向边
    }
    dijkstra(); //dijkstra求所有点到1号点的最短距离
    printf("%d\n", prim()); //求最短路径生成树的方案数
    return 0;
}

实验结果：