spfa算法

dijkstra算法讲解如上，大家不知是否注意到，这里我们每次查询的点即使与当前点没有关系，也依旧访问.通俗的说就是不存在路径，试想是否可以把与当前点相接的点通过vector来保存，我们每次遍历，只需要对当前点的相接点进行处理即可，这样在时间上优化为ne。

可能没有了解过dijkstra算法的同学可能不是很懂这个问题：https://blog.csdn.net/qq_40511966/article/details/101441270，可以先看看这个讲解。

 

模拟过程：

 

 

 

                                  

首先源点a入队，当队列非空时：

        １、队首元素（a）出队，对以a为起始点的所有边的终点依次进行松弛操作（此处有b,c,d三个点），此时路径表格状态为：

                                  

 

在松弛时三个点的最短路径估值变小了，而这些点队列中都没有出现，这些点需要入队，此时，队列中新入队了三个结点b,c,d

队首元素b点出队，对以b为起始点的所有边的终点依次进行松弛操作（此处只有e点），此时路径表格状态为：

                                 

 

在最短路径表中，e的最短路径估值也变小了，e在队列中不存在，因此e也要入队，此时队列中的元素为c，d，e

队首元素c点出队，对以c为起始点的所有边的终点依次进行松弛操作（此处有e,f两个点），此时路径表格状态为：

                                 

 

在最短路径表中，e，f的最短路径估值变小了，e在队列中存在，f不存在。因此e不用入队了，f要入队，此时队列中的元素为d，e，f

 队首元素d点出队，对以d为起始点的所有边的终点依次进行松弛操作（此处只有g这个点），此时路径表格状态为：

 

                               

在最短路径表中，g的最短路径估值没有变小（松弛不成功），没有新结点入队，队列中元素为f，g

队首元素f点出队，对以f为起始点的所有边的终点依次进行松弛操作（此处有d，e，g三个点），此时路径表格状态为：

                               

 

在最短路径表中，e，g的最短路径估值又变小，队列中无e点，e入队，队列中存在g这个点，g不用入队，此时队列中元素为g，e

队首元素g点出队，对以g为起始点的所有边的终点依次进行松弛操作（此处只有b点），此时路径表格状态为：

                           

 

在最短路径表中，b的最短路径估值又变小，队列中无b点，b入队，此时队列中元素为e，b队首元素e点出队，对以e为起始点的所有边的终点依次进行松弛操作（此处只有g这个点），此时路径表格状态为：

 

                          

 

在最短路径表中，g的最短路径估值没变化（松弛不成功），此时队列中元素为b

队首元素b点出队，对以b为起始点的所有边的终点依次进行松弛操作（此处只有e这个点），此时路径表格状态为：

                         

 

在最短路径表中，e的最短路径估值没变化（松弛不成功），此时队列为空了

最终a到g的最短路径为１４

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

const int maxn = 100000+10;
const int INF = 1<<30;

struct node
{
	int v,dis;
	
    //设置从小到大的优先级 
	bool  friend operator <  (node n1,node n2)
	{
		return n1.dis > n2.dis;
	}
};
//保存每个点所连接的一些点 
vector<node> adj[maxn];
//优先队列 
priority_queue<node> q;

bool vis[maxn];

int dis[maxn];

int n,m,s,t;

void dijkstra(int u0)
{
	dis[u0] = 0;
	node temp;
	temp.v = u0;
	temp.dis = 0;
	q.push(temp);
	
	while(!q.empty())
	{
		node topnode = q.top();
		q.pop();
		if(!vis[topnode.v])
		{
			vis[topnode.v] = 1;
			for(int i = 0;i < adj[topnode.v].size();++i)
			{
				if(!vis[adj[topnode.v][i].v] && adj[topnode.v][i].dis+dis[topnode.v] < dis[adj[topnode.v][i].v])
				{
				    dis[adj[topnode.v][i].v] = adj[topnode.v][i].dis+dis[topnode.v];
					node temp;
                    temp.v= adj[topnode.v][i].v;
                    temp.dis=  dis[adj[topnode.v][i].v];
                    q.push(temp);
				} 
			}
			
		}
		
	}
}

int main()
{
	int x,y,z;
	scanf("%d%d%d%d",&n,&m,&s,&t);
	for(int i = 0;i <= n;++i)
	    dis[i] = INF;
	memset(vis,0,sizeof(vis));
	for(int i = 0;i < m;++i)
	{
		scanf("%d%d%d",&x,&y,&z);
		node temp;
		temp.v = y;
		temp.dis = z;
		adj[x].push_back(temp);
		
		temp.v = x;
		temp.dis = z;
		adj[y].push_back(temp);
	}
	
	dijkstra(s);
	printf("%d\n",dis[t]);
	return 0;
}