最短路径SPFA算法（邻接表存法）

queue <int> Q;
void SPFA (int s)
{
    int i, v;
    for(int i=0; i<=n; i++) 
        dist[i]=INF;                            //初始化每点i到s的距离
    
    dist[s] = 0;
    visit[s] = true;
    Q.push(s);                                  //队列初始化,s为起点
    
    while ( !Q.empty() )                        //队列非空
    {
        v=Q.front();
        Q.pop();                                //取队首元素
        visit[v]=false;                         //释放队首结点，因为这节点可能下次用来松弛其它节点，重新入队
        
        for(i=0; i<=n; i++)                     //对所有顶点
            if ( g[v][i] > 0 && dist[i] > dist[v] + g[v][i] )
            {
                dist[i] = dist[v] + g[v][i];    //修改最短路
                if ( visit[i] == false )        //如果扩展结点i不在队列中，入队
                {
                    Q.push(i);
                    visit[i] = true;
                }
            }

    }
}

图的邻接表表示可以看这篇博客，尤其理解next数组作用；

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
#define oo 0x3fffffff
using namespace std;
const int N = 10005, M = 200005;      //N表示最大点的个数 ，M表示最大边的个数

struct Edge
{
    int to;
    int wei;
    int next;                         //邻接链表的套路，to邻接顶点，wei表边的权重，next表链表指针
};

Edge edge[M];                         //储存边的信息
int head[N], k, dist[N];              //dist【i】表示起点到 i的最短距离
bool visit[N];
queue<int> Q;

void Addedge(int x,int y,int c)       //存图 ，x到y有一条权重为c的边
{
    edge[k].to=y;
    edge[k].wei=c;
    edge[k].next=head[x];
    head[x]=k++;

}

void Init( int n, int m )
{
    int x, y, c;
    memset( head, -1, sizeof(head) ); //清零，作为每个点dfs的终止标志
    fill( visit, visit+n+1, false);   //一开始都不在队列中
    while ( m-- )
    {
        cin >> x >> y >> c;
        Addedge( x, y, c );
        Addedge( y, x, c );
    }
    fill( dist, dist+n+1, oo );       //先初始化为无穷大
}

void Spfa( int s )                    //这是套路
{
    Q.push(s);
    dist[s]=0;
    visit[s]=true;
    while ( !Q.empty() )
    {
        int v = Q.front();
        Q.pop();
        visit[v] = false;

        for (int i = head[v]; i != -1; i = edge[i].next)
        {                             //遍历整张图
            int w = edge[i].to;
            if (dist[w] > dist[v] + edge[i].wei) //如果到v的距离大于到u再加上u到v的距离，就更新
            {
                dist[w] = dist[v] + edge[i].wei;
                if (visit[w] != true)
                {
                    Q.push(w);
                    visit[w]=true;    //指标记，防止重复进入，否则队列没有意义
                }
            }
        }

    }

}

void Output( int n )
{
    cout << dist[n] << endl;          //输出到终点的距离就行了，其实你想输出到哪点的最短距离都可以
}

int main()
{
    int n, m, s;
    while( cin >> n >> m )
    {
        Init( n, m );                 //输入存图
        s = 1;                        //起点
        Spfa( s );                    //算法核心
        Output( n );                  //输出答案
    }
    return 0;
}