dijkstra朴素版堆优化

今天了解了一下dijstra的实现原理同时学习了堆优化的dijstra

之前对dijstra的疑惑是为什么这个算法是基于贪心，并且疑惑这个算法的正确性

朴素版基于贪心的原理每次找出距离原点最近的点然后用它来更新她所连接的点

为什么这样呢，是因为已经没有比他更小的点可以去更新它了

//Dijkstra朴素版 
#include<bits/stdc++.h>
#define N 1000+10
using namespace std;

int n/*点数*/,m /*边数*/;
int g[N][N];//邻接矩阵，存储边 
int dist[N];//存储每条边到原点的距离
bool st[N];//记录当前点是否已被用来更新 

void dijkstra(){
    memset(dist,0x3f,sizeof(dist));//每条边到原点的距离初始化成正无穷
    dist[1]=0;

    for(int i=0;i<n-1;i++){
        //找出剩下点中距离原点最小的点 
        int t=-1;
        for(int j=1;j<=n;j++)
            if(!st[j]&&(t==-1||dist[j]<dist[t]))
                t=j;

        st[t]=true; 
        //从1号点到j号点的距离能否用经过t的一条路径来更新
        //即1->j能否用1->t和t->j路径来更新 
        for(int j=1;j<=n;j++)
            dist[j]=min(dist[j],dist[t]+g[t][j]);
    }
}

int main(){
    cin>>m>>n;

    memset(g,0x3f,sizeof(g));//邻接矩阵初始化 

    while(m--){//存储每条边 
        int a,b,c;
        cin>>a>>b>>c;
        g[a][b]=g[b][a]=min(g[a][b],c);//可能有重边，两点之间只需保留长度最小的边 
    } 

    dijkstra();
    cout<<dist[n];//输出1号点到n号点的最短距离 

    return 0; 
} 

通过今天的学习我知道每次找出来最小的边来松弛

我们可以保证我们选出来的点距离起点的距离最短因为我们无法找到更近的点去松弛它

剩下的点都是在它的基础上拓展的，所以距离也比他的大故无法拓展

保证了选出来的点都是距离起点的距离最近

我们要知道我们选出来的点都是已经无法拓展的

dijkstra算法适用于无向图（已经被改变的点已经最小因此不会被改变），但不适用于有负权边的图

复杂度O(n+m)logm

#include<bits/stdc++.h>
using namespace std;
int n,m,s,t;
int head[1100]; 
int dis[1100];
int vis[1100];
struct ty
{
	int t,l,next;
}edge[200010];
int tot=0;
void addedge(int x,int y,int z)
{
	edge[++tot].t=y;edge[tot].l=z;
	edge[tot].next=head[x];
	head[x]=tot;
} 
struct ty2
{
	int x,dis;
	bool operator < (const ty2 &a)const
	{
		return dis>a.dis;
	}
};
priority_queue<ty2>q;
int dij(int s,int t)
{
	memset(dis,0x3f,sizeof(dis));
	memset(vis,0,sizeof(vis));
	dis[s]=0;
	ty2 tmp;
	tmp.x=s;tmp.dis=0;
	q.push(tmp);
	while(!q.empty())
	{
		ty2 tmp=q.top();
		q.pop();
		if(vis[tmp.x]) continue;
		vis[tmp.x]=1;
		for(int i=head[tmp.x];i!=-1;i=edge[i].next)
		{
			int y=edge[i].t;
			if(vis[y]) continue;
			if(dis[y]>dis[tmp.x]+edge[i].l)
			{
				dis[y]=dis[tmp.x]+edge[i].l;
				ty2 tmp1;
				tmp1.x=y;tmp1.dis=dis[y];
				q.push(tmp1);
			}
		}
	}
	if(dis[t]==0x3f3f3f3f) return -1;
	else
	return dis[t];
}
int main()
{
	cin>>n>>m>>s>>t;
	memset(head,-1,sizeof(head));
	for(int i=1;i<=m;i++)
	{
		int x,y,z;
		cin>>x>>y>>z;
		addedge(x,y,z);
		addedge(y,x,z);
	}
	cout<<dij(s,t)<<endl;
}