【讲解 + 模板】Dijkstra迪杰斯特拉+堆优化

Dijkstra迪杰斯特拉+堆优化

众所周知,朴素的迪杰斯特拉的时间复杂度为O(n^2),这在某些题目当中是会超时的。但如果在迪杰斯特拉中枚举每个最短边时加入堆优化,则迪杰斯特拉的效率则会大大提高。

朴素版迪杰斯特拉

void dijkstra(int x)  //x为起点,使用迪杰斯特拉查找起点到其他任意点的最短路径
{
    for(int i = 1; i <= n; i++) dis[i] = w[x][i];  //dis[i]数组存储从x到i的最短路(迪杰斯特拉跑完之前不一定是最终解)
    //w[i][j]数组存储从i到j的路径长度(这里用的邻接矩阵存储,也可以换成前向星等)
    b[x] = 1; //b[i]数组存储此点是否被访问过
    dis[x] = 0;
    for(int i = 1; i <= n - 1; i++)
      {
        minl = maxx;
        k = 0;
        for(int j = 1; j <= n; j++)  //查找可以更新的点
          if((!b[j]) && (dis[j] < minl))
            {
                minl = dis[j];
                k = j;
            }
        if(k == 0) break;  //这一句也可以换成if(k == y) break;表示已经更新完从x到y的最短路
        b[k] = true;  //更新k点,把k标记为已确定最短路径
        for(int j = 1; j <= n; j++)  //更新与k相连的每个未确定最短路径的顶点j
          if(dis[k] + w[k][j] < dis[j])
            dis[j] = dis[k] + w[k][j]; //可以加上pre[j] = k用来记录前驱节点
      }
}

加入堆优化

笔者在oj上找到了几个较好的不同类型的模板,大家可以灵活选择记忆理解。

题目

题目描述

如题,给出一个有向图,请输出从某一点出发到所有点的最短路径长度。

输入输出格式

输入格式:
第一行包含三个整数N、M、S,分别表示点的个数、有向边的个数、出发点的编号。

接下来M行每行包含三个整数Fi、Gi、Wi,分别表示第i条有向边的出发点、目标点和长度。

输出格式:
一行,包含N个用空格分隔的整数,其中第i个整数表示从点S出发到点i的最短路径长度(若S=i则最短路径长度为0,若从点S无法到达点i,则最短路径长度为2147483647)
输入输出样例
输入样例#1:

4 6 1
1 2 2
2 3 2
2 4 1
1 3 5
3 4 3
1 4 4

输出样例#1:

0 2 4 3

版本一(邻接矩阵存图)

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
using namespace std;
struct ha//小根堆
{
    int x; 
    int d;//节点编号 
    bool operator < (const ha &a) const 
    {
        return x > a.x;
    }
}; 
struct haha//小根堆
{
    int x; 
    int d;//节点编号
}; 
ha e;
haha ee;
int d[1000010];
priority_queue  q;
int n, m, s, xx, yy, zz, i;
vector a[1000000];
int main()
{
    scanf("%d%d%d",&n ,&m ,&s);
    for(i = 1; i <= m; i++)
    {
        scanf("%d%d%d",&xx ,&yy ,&zz);
        ee.d = yy;
        ee.x = zz;
        a[xx].push_back(ee);
    }
    for(i = 1; i <= n; i++) d[i] = 2000003647;
    e.d = s;
    e.x = 0; 
    d[s] = 0;
    q.push(e);//入队 
    while (!q.empty())//队列非空 
    {
        e = q.top(); q.pop();//出队
        int v = e.d;//取出节点编号
        int d1 = e.x;
        if (d[v] < d1) continue;//说明在这个点再此之后又入队了
        //此次出队的并不是s到这个点的最短路,
        //所以在这次更新前点v所连的点已经更过一次了 
        //所以后面也不会进行松弛操作 
        int len = a[v].size(); 
        for(i = 0; i < len; i++)
        {
            haha g = a[v][i];
            if ((d[v] + g.x < d[g.d]) || (d[g.d] == -233))//松弛操作 
            {
                d[g.d] = d[v] + g.x;
                e.d = g.d;
                e.x = d[g.d];
                q.push(e);
            }
        }
    }
    for (i=1; i <= n; i++) //输出 
    if (d[i] == 2000003647) cout << 2147483647 << " "; else cout << d[i] << " ";
    return 0;
}

版本二(前向星存图)

#include
#include
#include
#include
using namespace std;
const int INF = 2147483647;
const int maxn = 10000 + 10;
const int maxm = 500000 + 10;
int n, m, s;
int fir[maxn], nxt[maxm], to[maxm], val[maxm], cnt;
void add_edge(int u, int v, int w) //前向星加边
{
    nxt[++cnt] = fir[u];
    fir[u] = cnt;
    to[cnt] = v;
    val[cnt] = w;
}
struct Node 
{
    int d, id;
    Node(){}
    Node(int d, int id) : d(d), id(id){}
    bool operator < (const Node& rhs) const
      {
        return d > rhs.d;//重载 < 方便堆
      }
};
int dis[maxn], vis[maxn];
void Dijkstra(int s)
{
    for(int i = 1; i <= n; i++) dis[i] = INF;
    dis[s]=0;
    priority_queue Q;
    Q.push(Node(0,s));
    while(!Q.empty()) 
      {
        Node u = Q.top(); Q.pop();
        if(vis[u.id]) continue;  //若某个点已经被更新到最优,就不用再次更新其他点
        vis[u.id] = 1;
        for(int e = fir[u.id]; e; e = nxt[e]) 
          {
            int v = to[e], w = val[e];
            if(u.d + w < dis[v]) 
              {
                dis[v] = u.d + w;
                Q.push(Node(dis[v],v));
              }
          }
      }
}
int main()
{
    scanf("%d%d%d",&n ,&m ,&s);
    for(int u, v, w, i=0; i < m; i++)
      {
        scanf("%d%d%d",&u ,&v ,&w);
        add_edge(u, v, w);
      }
    Dijkstra(s);
    for(int i = 1; i <= n; i++) printf("%d ", dis[i]);
    return 0;
}

版本三(运用pair存储)

#include
#include
#include
#include
#include
#include
#define MAXN 20000
#define INF 2147483647
using namespace std;
typedef pair<int,int> pii;
priority_queuevector, greater > pq;
struct edge
{
    int to;
    int cost;
};
vector G[MAXN];//g[i]--i to g[i].to cost cost
int n, m, s;
int dis[MAXN];
void dijk(int s)
{
    for(int i = 1; i <= n; i++)
        dis[i] = INF;
    dis[s] = 0;
    pq.push(make_pair(0,s));
   // cout<
    while(!pq.empty())
    {
        pii u = pq.top();
        pq.pop();
        int x = u.second; // bian hao
        //cout<
        for(int i = 0; i < G[x].size(); i++)
        {
            edge e = G[x][i];
            if(dis[e.to] > dis[x] + e.cost)
            {
                dis[e.to] = dis[x] + e.cost;
                pq.push(make_pair(dis[e.to], e.to));
               // cout<
            }
        }
    }
}
int main()
{
    cin >> n >> m >> s;
    int from, to, cost;
    edge in;
    for(int i = 0; i < m; i++)
    {
        scanf("%d%d%d",&from ,&to ,&cost);
        in.to = to; in.cost = cost;
        G[from].push_back(in);
    }
   // cout<
    dijk(s);
    for(int i = 1; i <= n; i++)
        printf("%d ", dis[i]);
    return 0;
}

【讲解 + 模板】Dijkstra迪杰斯特拉+堆优化_第1张图片

你可能感兴趣的:(最短路)