SPFA算法+例题 ：问题 A: 黑暗城堡

SPFA算法

算法思想：
1） 三角形中的性质：同一三角形内两边之和大于第三边。

2）由上面那一条性质，我们可以想出一个方法来更新源点到其他点的最短的路径：用中间节点k松弛u->k->v，来更新u->v的最短路径（思想和Floy算法相似），也就是说，我们实际上每次都是在判断这条路径符不符合三角形不等式dis[v]v]，若不符合，我们就将原先的路径松弛为现在的路径，使得现在的路径满足三角形不等式。

3）但是为什么松弛后要将终点入队呢？SPFA的过程是BFS，它是不停扩展节点的。而当我们更新了这一条路径，那么可能会出现基于这一条路径的新路，我们需要判断原路与新路是否满足三角形不等式。即：有了新的最短路，就用它再去更新与他相连的点的最短路。

实现及细节：
1）用visit[ ]数组来维护已经入队的顶点；并注意：出队时消除标记

2）用队列来维护松弛过的顶点

3）用链式前向星存图（连接）

4)dis[ ]数组要初始化为INF；

上代码：

struct edge{int next,to,w;}e[10000];
bool visit[10000];
dis[10000];
int head[1005]={0};
int cnt;
void init(){ memset(dis,127,sizeof(dis));memset(visit,false,sizeof(visit));}
inline void add(int u,int v,int w)///无向边，所以加两次，若是有向边只需要加一次；
{
    e[++cnt].w=w;
    e[cnt].to=v;
    e[cnt].next=head[u];
    head[u]=cnt;
    e[++cnt].w=w;
    e[cnt].to=u;
    e[cnt].next=head[v];
    head[v]=cnt;
}
void SPFA()
{
    init();
    dis[1]=0;
    queue<int>q;///存的是松弛过的顶点
    q.push(1);visit[1]=true;
    while(!q.empty())
    {
        int u=q.front();///获取顶点/边的起点
        q.pop();visit[u]=false;///别忘记：出队了，消除标记
        for(int E=head[u];E;E=e[E].next)///遍历以u为起点的所有边
        {
            int v=e[E].to;///边E的终点v
            if(dis[v]>dis[u]+e[E].w)///顶点v可以被边E松弛
            {
                dis[v]=dis[u]+e[E].w;
                if(visit[v]==false)///且v没在队里
                {
                    visit[v]=true;
                    q.push(v);
                }
            }
        }
    }
}

例题 黑暗城堡

#include 
#include 
#include 
using namespace std;
typedef long long ll;
const int mod=2147483647;

bool visit[1005]={false};
ll dis[1005],num[1005]={0};///距离数组，num[i]代表起点i符合条件的个数
void init(){ memset(dis,127,sizeof(dis));memset(visit,false,sizeof(visit));}

struct edge
{
    int to,next,w;
}e[1000005];///边
int head[1005]={0};
int cnt;

inline void add(int u,int v,int w)///无向边，所以加两次
{
    e[++cnt].w=w;
    e[cnt].to=v;
    e[cnt].next=head[u];
    head[u]=cnt;
    e[++cnt].w=w;
    e[cnt].to=u;
    e[cnt].next=head[v];
    head[v]=cnt;
}

void SPFA()
{
    init();
    dis[1]=0;
    queue<int>q;///存的是松弛过的顶点
    q.push(1);visit[1]=true;
    while(!q.empty())
    {
        int u=q.front();///获取顶点/边的起点
        q.pop();visit[u]=false;///出队了，消除标记
        for(int E=head[u];E;E=e[E].next)///遍历以u为起点的所有边
        {
            int v=e[E].to;///边E的终点v
            if(dis[v]>dis[u]+e[E].w)///顶点v可以被边E松弛
            {
                dis[v]=dis[u]+e[E].w;
                if(visit[v]==false)///且v没在队里
                {
                    visit[v]=true;
                    q.push(v);
                }
            }
        }
    }
}

int main()
{
    ll ans=1;
    int n,m;cin>>n>>m;
    for(int i=0;i<m;i++)
    {
        int u,v,w;
        cin>>u>>v>>w;
        add(u,v,w);
    }
    SPFA();
    for(int i=1;i<=n;i++)///遍历所有顶点
    {
        for(int E=head[i];E;E=e[E].next)///遍历i为起点的所有边
        {
            int v=e[E].to;
            if(dis[i]+e[E].w==dis[v])///符合题目条件S[i]=D[i],D[i]=dis[i],S[i]=dis[i]+e[E].w
                num[v]++;
        }
    }
    for(int i=2;i<=n;i++) ans*=num[i],ans%=mod;///排列组合的乘法原理
    cout <<ans<< endl;
    return 0;
}