单源最短路径算法SPFA

适用于带负权的最短路径算法 ，不带负权值则一般用Dijkstra算法

算法步骤：

• 将所有顶点标记为未访问，源点标记为已访问，并加入队列。
• 将所有点到源点的距离初始化为一个很大的数，源点到源点本身的距离初始化为0
• 只要队列不空，取队列中的队头顶点，将该顶点点标记为未访问。如果该顶点U到它所连接顶点U（可能不止一个）距离加上边的距离小于源点到顶点U的距离，则将此距离更新为源点到顶点U的距离加上U指向V的边的距离，并将顶点加入队列求标记为已访问。（每个顶点可能不不止一次入队列）
• 队列为空，算法结束

#include<cstdio>
#include<queue>
#include<cstring>
using namespace std;

const int N=1000;
const int M=10000;

struct edge
{
	int v,w,next;
	edge(){}
	edge(int _v,int _w,int _next)
	{
		v=_v;
		w=_w;
		next=_next;
	}
} e[M*2];

int head[N],size;

void initi()
{
	memset(head,-1,sizeof(head));
	size=0;
}

void insert1(int u,int v,int w)
{
	e[size]=edge(v,w,head[u]);
	head[u]=size++;
}

void insert2(int u,int v,int w)
{
	insert1(u,v,w);
	insert1(v,u,w);
}

int n,m;
int dis[N];
bool vis[N];


void spfa(int u)
{
	memset(vis,false,sizeof(vis));
	memset(dis,0x3f,sizeof(dis));
	queue<int> q;
	q.push(u);
	vis[u]=true;
	dis[u]=0;
	while(!q.empty())
	{
		int t=q.front();
		q.pop();
		vis[t]=false;
		for(int i=head[t];i!=-1;i=e[i].next)
		{
			int v=e[i].v;
			int w=e[i].w;
			if(dis[t]+w<dis[v])
			{
				dis[v]=dis[t]+w; 
				if(!vis[v]) 
				{
					q.push(v);
					vis[v]=true;
				}
			}
		}
	}
	
}

int main()
{
	initi();
	int u,v,w;
	scanf("%d%d",&n,&m);
	while(m--)
	{
		scanf("%d%d%d",&u,&v,&w);
		insert1(u,v,w);//插入无向边则调用insert2()
	} 
	spfa(1);
	printf("%d",dis[n]);
	return 0;
}