dijstra优化(优先队列+邻接表)

以poj2387为例

dijstra的思想是每次在dis数组里面找出最小的那一条边,然后用这一条边去松弛其他的边,在这里我们把dis数组保存在一个优先队列里面,同时把图存在邻接表里面,每次通过优先队列得出dis数组里面最小的那条边,然后通过邻接表去松弛与这条边相连的其他的边,然后把更新的dis数组存入优先对列,直到队列为空时结束。

ac代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<string>
#include<algorithm>
#include<vector>
#include<set>
#include<cstdlib>
#include<map>
#include<deque>
#include<queue>
#include<list>
const int inf=0x3f3f3f3f;
const int MOD=1e9+7;
const int inff=999999;
const int N=1005;
const int M=2005;
#define LL long long
#define ME0(x) memset(x,0,sizeof(x))
#define MEF(x) memset(x,-1,sizeof(x))
#define MEI(x) memset(x,inf,sizeof(x))
using namespace std;
int n,m,cnt;
struct LX
{
    int ed,di,next;
}lx[M*2];
int first[N];
int dis[N],vis[N];
void add(int s,int e,int d)
{
    cnt++;
    lx[cnt].ed=e;
    lx[cnt].di=d;
    lx[cnt].next=first[s];
    first[s]=cnt;
}
struct cmp
{
    bool operator ()(const int a,const int b)
    {
        return dis[a]>dis[b];
    }
};
int dijstra(int s)
{
    priority_queue<int,vector<int>,cmp> pq;
    for(int n1=1;n1<=n;n1++)
    {
        dis[n1]=inff;
    }
    dis[s]=0;
    ME0(vis);
    pq.push(s);
    while(!pq.empty())
    {
        int xe=pq.top();
        pq.pop();
        if(vis[xe])
        {
            continue;
        }
        vis[xe]=1;
        for(int i=first[xe];i;i=lx[i].next)
        {
            int ie=lx[i].ed;
            int di=lx[i].di;
            if(!vis[ie]&&dis[ie]>dis[xe]+di)
            {
                dis[ie]=dis[xe]+di;
                pq.push(ie);
            }
        }
    }
    return dis[n];
}
int main()
{
    int s,e,d;
    scanf("%d%d",&m,&n);
    cnt=0;
    ME0(first);
    for(int m1=1;m1<=m;m1++)
    {
        scanf("%d%d%d",&s,&e,&d);
        add(s,e,d);
        add(e,s,d);
    }
    printf("%d\n",dijstra(1));
}

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Dijkstra算法是解决单源最短路径问题的一种经典算法,其基本思想是利用贪心的思想,每次选取未确定最短路径的节点中距离起点最近的节点,然后根据该节点更新与该节点相邻的节点的距离。具体实现可以采用邻接表或邻接矩阵来表示图,同时利用优先队列STL来维护节点距离的更新。 算法步骤如下: 1.初始化:将起点的距离设置为0,其余节点的距离设置为无穷大,将所有节点标记为未确定最短路径。 2.选择当前距离起点最近的未确定最短路径节点,将其标记为确定最短路径,并更新其相邻节点的距离。 3.重复步骤2直到终点被标记为确定最短路径或者所有节点均被标记为确定最短路径。 4.输出最短路径。 使用邻接表可以较为简便地实现Dijkstra算法,具体实现如下: ```c++ #include<bits/stdc++.h> using namespace std; const int MAXN=100010; const int INF=0x3f3f3f3f; struct Edge{ int to,w; }; vector<Edge> G[MAXN]; int dis[MAXN]; bool vis[MAXN]; void dijkstra(int s){ priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>> q; memset(dis,INF,sizeof(dis)); memset(vis,false,sizeof(vis)); dis[s]=0; q.push(make_pair(0,s)); while(!q.empty()){ int u=q.top().second; q.pop(); if(vis[u]) continue; vis[u]=true; for(int i=0;i<G[u].size();i++){ int v=G[u][i].to; int w=G[u][i].w; if(dis[v]>dis[u]+w){ dis[v]=dis[u]+w; q.push(make_pair(dis[v],v)); } } } } int main(){ int n,m,s,t; scanf("%d%d%d%d",&n,&m,&s,&t); for(int i=1;i<=m;i++){ int u,v,w; scanf("%d%d%d",&u,&v,&w); G[u].push_back((Edge){v,w}); G[v].push_back((Edge){u,w}); } dijkstra(s); printf("%d\n",dis[t]); return 0; } ``` 其中,邻接表G[u]表示节点u的相邻节点,Edge结构体表示边的信息,dis[u]表示起点到节点u的最短路径长度,vis[u]表示节点u是否被标记为确定最短路径。使用优先队列STL来维护节点距离的更新,pair<int,int>表示节点距离和节点编号,greater<pair<int,int>>表示节点距离的比较器,使得距离小的节点在队列前面。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值