最短路模板 HDU1874

O(n2)的dijkstra。点少的时候用。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 550;
const int inf = 0x3f3f3f3f;
int mp[maxn][maxn]; //图
int d[maxn]; //s到其余点的距离
bool vis[maxn]; //标记访问
int n, m;  // 点和边的个数
void dijkstra(int s) {
    memset(vis, false, sizeof(vis));
    for(int i = 0; i < n; ++ i) d[i] = (i == s ? 0 : inf);
    for(int i = 0; i < n; ++ i) {
        int x, m = inf;
        for(int y = 0; y < n; ++ y) if(!vis[y] && d[y] <= m) m = d[x = y];
        vis[x] = true;
        for(int y = 0; y < n; ++ y) d[y] = min(d[y], d[x] + mp[x][y]);
    }
}
int main() {
    int u, v, x;
    while(~scanf("%d%d", &n, &m)) {
        memset(mp, inf, sizeof(mp));
        for(int i = 0; i < m; ++ i) {
            scanf("%d%d%d", &u, &v, &x);
            mp[u][v] = min(mp[u][v], x);
            mp[v][u] = mp[u][v];
        }
        int s, t;
        scanf("%d%d", &s, &t);
        dijkstra(s);
        printf("%d\n", d[t] == inf ? -1 : d[t]);
    }
}

O(mlogn)的dijkstra

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5; //最大点数量
const int INF = 0x3f3f3f3f;
struct Edge {
    int from, to, dist;
    Edge(int u, int v, int d) : from(u), to(v), dist(d) {}
};
struct Node {
    int d, u;
    Node(int dd, int uu) : d(dd), u(uu) {}
    bool operator < (const Node &o) const {
        return d > o.d;
    }
};
int n, m; //n个点m条边,从0开始编号
vector<Edge> edges;
vector<int> G[maxn];
bool vis[maxn]; //是否已永久标号
int d[maxn]; //s到各个点的距离
int p[maxn]; //最短路中的上一条弧
void init(int n) {
    for(int i = 0; i < n; ++ i)
        G[i].clear();
    edges.clear();
}
void AddEdge(int from, int to, int dist) {
    edges.push_back(Edge(from, to, dist));
    int m = edges.size();
    G[from].push_back(m - 1);
}
priority_queue<Node>q; //dijkstra用到的，防止爆，开成全局
void dijkstra(int s) {
    while(!q.empty()) q.pop();
    for(int i = 0; i < n; ++ i) d[i] = INF;
    d[s] = 0;
    memset(vis, false, sizeof(vis));
    q.push(Node(0, s));
    while(!q.empty()) {
        Node x = q.top(); q.pop();
        int u = x.u;
        if(vis[u]) continue;
        vis[u] = true;
        for(int i = 0; i < G[u].size(); ++ i) {
            Edge& e = edges[G[u][i]];
            if(d[e.to] > d[u] + e.dist) {
                d[e.to] = d[u] + e.dist;
                p[e.to] = G[u][i];
                q.push(Node(d[e.to], e.to));
            }
        }
    }
}
int main() {
    int u, v, x;
    while(~scanf("%d%d", &n, &m)) {
        init(n);
        for(int i = 0; i < m; ++ i) {
            scanf("%d%d%d", &u, &v, &x);
            AddEdge(u, v, x);
            AddEdge(v, u, x);
        }
        int s, t;
        scanf("%d%d", &s, &t);
        dijkstra(s);
        printf("%d\n", d[t] == INF ? -1 : d[t]);
    }
}

O(n3)的floyd

#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 200 + 10;
int mp[maxn][maxn]; //图
int n, m; //点和边的个数
void floyd(int s, int t) //起点、终点
{
    for(int i = 0; i < n; ++ i) mp[i][i] = 0; //否则s=t时，floyd总会到最近的点再回来
    for(int k=0;k<n;k++)
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
                mp[i][j]=mp[j][i]=min(mp[i][j],mp[i][k]+mp[k][j]);
}
int main() {
    while(~scanf("%d%d", &n, &m)) {
        int s, t, u, v, w;
        memset(mp, INF, sizeof(mp));
        for(int i = 0; i < m; i++) {
            scanf("%d%d%d", &u, &v, &w);
            mp[u][v] = min(mp[u][v], w);
            mp[v][u] = mp[u][v];
        }
        scanf("%d%d", &s, &t);
        floyd(s, t);
        printf("%d\n", mp[s][t] == INF ? -1 : mp[s][t]);
    }
}

SPFA 适合有负边的情况，也很快

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000; //点的最大
int n, m, src; //点、边，起点
vector<pair<int,int> > g[maxn + 10];
int dist[maxn + 10];
bool vis[maxn + 10];
queue<int>q;
void spfa() {
    memset(dist, 63, sizeof(dist));
    memset(vis, false, sizeof(vis));
    dist[src] = 0;
    while(!q.empty())q.pop();
    q.push(src);
    vis[src] = true;
    while(!q.empty()) {
        int u = q.front();
        q.pop();
        for(int i = 0; i < g[u].size(); i++) {
            if(dist[u] + g[u][i].second < dist[g[u][i].first]) {
                dist[g[u][i].first] = dist[u] + g[u][i].second;
                if(!vis[g[u][i].first]) {
                    vis[g[u][i].first] = true;
                    q.push(g[u][i].first);
                }
            }
        }
        vis[u] = false;
    }
}
int main() {
    int n, m;
    while(~scanf("%d%d", &n, &m)) {
        int from, to, val;
        for(int i = 0; i <= n; i++) g[i].clear();
        for(int i = 0; i < m; i++) {
            scanf("%d%d%d", &from, &to, &val);
            g[from].push_back(make_pair(to, val));
            g[to].push_back(make_pair(from, val));
        }
        scanf("%d%d", &from, &to);
        src = from;
        spfa();
        printf("%d\n", dist[to] == 0x3f3f3f3f ? -1 : dist[to]);
    }
}