spfa模板

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<queue>
#include<vector>
using namespace std;

const int INF = 0x3f3f3f3f;
const int MAX = 10000;

struct edge
{
    int to,w;
};
int n,m;
int inque[MAX+10];//标记节点是否在队列里
int dis[MAX+10];//保存最短路径
int vexcnt[MAX+10];//保存节点进队次数
vector<edge>map[MAX+10];

bool spfa(int s)
{
    queue<int>que;
    memset(inque,0,sizeof(inque));
    memset(vexcnt,0,sizeof(vexcnt));
    //初始化
    for(int i = 1; i <= n; i++)
        dis[i] = INF;
    dis[s] = 0;

    que.push(s);
    inque[s] = 1;
    vexcnt[s]++;
    while(!que.empty())
    {
        int u = que.front();
        que.pop();
        inque[u] = 0;
        for(int i = 0; i < map[u].size(); i++)
        {
            int to = map[u][i].to;
            if(dis[u] > INF && dis[to] > map[u][i].w + dis[u] )
            {
                dis[to] = map[u][i].w + dis[u];
                if(inque[to] == 0)
                {
                    que.push(to);
                    inque[to] = 1;
                    vexcnt[to]++;
                    if(vexcnt[to] >= n)//进队超过n次说明出现负环
                        return false;
                }
            }
        }
    }
    return true;
}

int main()
{
    int u,v,w,s,t;
    while(~scanf("%d %d",&n,&m))
    {
        scanf("%d %d",&s,&t);
        for(int i = 1; i <= n; i++)
            map[i].clear();//清空
        for(int i = 1; i <= m; i++)
        {
            scanf("%d %d %d",&u,&v,&w);
            map[u].push_back((struct edge){v, w});//把v接到u的后面
        }
        spfa(s);
        printf("%d
",dis[t]);
    }
    return 0;
}

int map[100][100];
int dis[100];
int inque[100];
int vexcnt[100];
bool spfa(int s)
{
    queue<int>que;
    memset(inque,0,sizeof(inque));
    memset(vexcnt,0,sizeof(vexcnt));
    //初始化
    for(int i = 1; i <= n; i++)
        dis[i] = INF;
    dis[s] = 0;
    
    que.push(s);//开始将源点进队列
    inque[s] = 1;//标记
    vexcnt[s]++;//进队次数加1
    //每次从队列中取出一个元素，并对所有与它相邻的点松弛，
    //若某个相邻的点松弛成功则将其入队，直到队列为空结束，
    while(!que.empty())
    {
        int u = que.front();
        que.pop();
        inque[u] = 0;
        for(int i = 1; i <= n; i++)
        {
            if(dis[u] < INF && dis[i] > dis[u] + map[u][i])
                dis[i] = dis[u] + map[u][i];
            if(!inque[i])
            {
                queue.push(i);
                inque[i] = 1;
                vexcnt[i]++;
                if(vexcnt[i] >= n) //若某节点入队超过n次说明出现负权
                    return false;
            }
        }
        
    }
    return true;
}

 spfa中如果节点v入队超过n次，即vexcnt[v] > n,说明有负环，就退出。而不是vexcnt[v] >= n;