单源最短路径问题(dijkstra算法 及其 优化算法(优先队列实现))

#define _CRT_SECURE_NO_WARNINGS
/*
7 10
0 1 5
0 2 2
1 2 4
1 3 2
2 3 6
2 4 10
3 5 1
4 5 3
4 6 5
5 6 9
6
*/
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdio>
using namespace std;

const int maxn = 1010 + 20;
const int INF = 99999999;
int cost[maxn][maxn];      //表示边e=(u,v)的权值 (不存在这条边时设为INF)
int d[maxn];               //顶点出发的最短距离
bool used[maxn];           //已经使用过的图
int V, E;
void init();
void dijkstra(int s);
void input();

void init()
{
    for (int i = 0; i < V; i++) {
        for (int j = 0; j < V; j++) {
            if (i == j) {
                cost[i][j] = 0;
            }
            else {
                cost[i][j] = INF;
            }
        }
    }
}

void dijkstra(int s)
{
    fill(d, d + V, INF);
    fill(used, used + V, false);
    d[s] = 0;

    while (true) {
        int v = -1;
        //从尚未使用过的顶点中选择一个距离最小的顶点
        for (int u = 0; u < V; u++) {
            if (!used[u] && (v == -1 || d[u] < d[v])) {
                v = u;
            }
        }
        if (v == -1) break;        //已经没有尚未使用的点了
        used[v] = true;            //标志v已访问

        for (int u = 0; u < V; u++) {
            d[u] = min(d[u], d[v] + cost[u][v]);
        }
    }
}

void input()
{
    int s, t, ct;
    for (int i = 0; i < E; i++)
    {
        cin >> s >> t >> ct;
        cost[s][t] = cost[t][s] = ct;
    }
}

int main()
{
    cin >> V >> E;           //输入顶点数和边数
    init();                  //必须要初始化
    input();                 //输入临接的边和权值
    dijkstra(0);             //设置起点
    int ov;
    cin >> ov;               //输入终点
    cout << d[ov] << endl;
    return 0;
}

//解法二:

需要优化的是数值的插入（更新）和取出最小值两个操作，因此使用堆就可以了。把每个顶点当前的最短距离用堆维护，在更新最短距离时，把对应的元素往根的方向移动以满足堆的性质。而每次从堆中取出的最小值就是下一次要使用的顶点。这样堆中元素共有O(|V|)个。更新和取出数值的操作有O(|E|)次，因此整个算法复杂度是O(|E|log|V|)。

下面是使用STL的priority_queue的实现。在每次更新时往堆里插入当前最短距离和顶点的值对。插入的次数是O(|E|)次，因此元素也是O(|E|)个。当取的最小值不是最短距离的话，就丢弃这个值。

#define _CRT_SECURE_NO_WARNINGS
/*
7 10
0 1 5
0 2 2
1 2 4
1 3 2
2 3 6
2 4 10
3 5 1
4 5 3
4 6 5
5 6 9
6
*/
#include <iostream>
#include <vector>
#include <utility>
#include <queue>
#include <functional>
#include <algorithm>
#include <cstdio>
using namespace std;

const int maxn = 1010 + 20;
const int INF = 99999999;
struct edge
{
    int to, cost;
};
typedef pair<int, int> P;      //first是最短距离，second是顶点的编号
int V, E;
vector<edge> G[maxn];
int d[maxn];
//void init();
void input();

void dijkstra(int s)
{
    //通过指定greater<P>参数,堆按照first从小到大的顺序取出值
    priority_queue<P, vector<P>, greater<P> > que;
    fill(d, d + V, INF);
    d[s] = 0;
    que.push(P(0, s));

    while (!que.empty()) {
        P p = que.top(); que.pop();
        int v = p.second;
        if (d[v] < p.first) continue;
        for (int i = 0; i < G[v].size(); i++) {
            edge e = G[v][i];
            if (d[e.to] > d[v] + e.cost) {
                d[e.to] = d[v] + e.cost;
                que.push(P(d[e.to], e.to));
            }
        }
    }
}

//void init()
//{    
//}

void input()
{
    int s, t, ct;
    edge tmp;
    for (int i = 0; i < E; i++) {
        cin >> s >> t >> ct;
        tmp.to = t; tmp.cost = ct;
        G[s].push_back(tmp);
        //无向图，反向也需要连接
        tmp.to = s; tmp.cost = ct;
        G[t].push_back(tmp);
    }
}

int main()
{
    cin >> V >> E;
    //init();
    input();
    dijkstra(0);
    int ov;
    cin >> ov;
    cout << d[ov] << endl;
    return 0;
}