最短路（dijkstra+SPFA）

图结构练习——最短路径
Time Limit: 1000 ms Memory Limit: 65536 KiB

Problem Description
给定一个带权无向图，求节点1到节点n的最短路径。

Input
输入包含多组数据，格式如下。
第一行包括两个整数n m，代表节点个数和边的个数。(n<=100)
剩下m行每行3个正整数a b c，代表节点a和节点b之间有一条边，权值为c。

Output
每组输出占一行，仅输出从1到n的最短路径权值。（保证最短路径存在）

Sample Input
3 2
1 2 1
1 3 1
1 0
Sample Output
1
0
Hint

Source
赵利强
Dijkstra算法就是先找到离源点最近的点，然后这个点的距离就是一个确定值了，再拿这个点去更新其他的点；用优先队列优化版；

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<queue>
using namespace std;
const int M=5e5+5;
const int N=4e6+5;
const int inf=0x3f3f3f3f;
int head[M],vis[M],cnt,n;
struct EDGE
{
    int to,w,next;
}edge[M];
struct node
{
    int dis,num;
    bool operator<(const node&b)const
    {
        return dis>b.dis;//从小到大排序得建立最大堆；
    }
}d[M];//这个数组是用来存放所有顶点的，顶点包括数值和到源点的距离；
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 e)
{
    for(int i=1;i<=n;i++)
    {
        vis[i]=0;
        d[i].dis=inf;
        d[i].num=i;
    }//对所有的初始化；
    d[s].dis=0;
    priority_queue<node>q;//从小到大排序用了一个函数重载；结构体类型
    q.push(d[s]);//把整个点都压进去；
    while(!q.empty())
    {
        int u=q.top().num;
        q.pop();
        vis[u]=1;//既然出来更新别人了，就说明它的最短路已经确定了；
        for(int i=head[u];~i;i=edge[i].next)//对与这个点相连的所有的边进行遍历，看看是否需要更新；
        {
            int to=edge[i].to,w=edge[i].w;
            if(d[to].dis>d[u].dis+w)
            {
                d[to].dis=d[u].dis+w;
                q.push(d[to]);
            }
        }
    }
    printf("%d\n",d[e].dis);
}
int main()
{
    int m;
    while(~scanf("%d%d",&n,&m))
    {
        cnt=0;
        for(int i=1;i<=n;i++)
        {
            head[i]=-1;
        }//初始化为-1，用memset会wa
        while(m--)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            add(u,v,w);
            add(v,u,w);
        }
        dijkstra(1,n);
    }
    return 0;
}

SPFA:
SPFA是一个点被更新了，就有可能去更新其他的点，可以解决负权边问题；利用队列优化；

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<queue>
using namespace std;
const int M=5e5+5;
const int N=4e6+5;
const int inf=0x3f3f3f3f;
int head[M],vis[M],cnt,n;
struct EDGE
{
    int to,w,next;
}edge[M];
void add(int u,int v,int w)
{
    edge[cnt].to=v;
    edge[cnt].w=w;
    edge[cnt].next=head[u];
    head[u]=cnt++;
}
struct node
{
    int dis,num;
}d[M];
void SPFA(int s,int e)
{
    for(int i=1;i<=n;i++)
    {
        vis[i]=0;
        d[i].num=i;
        d[i].dis=inf;
    }
    d[s].dis=0;
    queue<node>q;
    q.push(d[s]);
    vis[s]=1;
    while(!q.empty())
    {
        int u=q.front().num;
        q.pop();
        vis[u]=0;
        for(int i=head[u];~i;i=edge[i].next)
        {
            int to=edge[i].to,w=edge[i].w;
            if(d[to].dis>d[u].dis+w)
            {
                d[to].dis=d[u].dis+w;
                if(!vis[to])//这里在队列里的顶点也可能会被更新，但是这时候就不要再重复入队；
                {
                   vis[to]=1;
                   q.push(d[to]);
                }
            }
        }
    }
    printf("%d\n",d[e].dis);
}
int main()
{
    int m;
    while(~scanf("%d%d",&n,&m))
    {
        cnt=0;
        for(int i=1;i<=n;i++)
        {
            head[i]=-1;
        }
        while(m--)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            add(u,v,w);
            add(v,u,w);
        }
        SPFA(1,n);
    }
    return 0;
}