四种求图的最短路径模板

一：Dijkstra算法(图中可能存在重边和自环，所有边权均为正值)

#include 
#include 
#include 
#include 
using namespace std;

typedef pair pii;

vector Dijkstr(vector>& graph, int start, int n){
    priority_queue, greater> q;
    vector dist(n + 1, INT_MAX);
    vector visited(n + 1, false);

    dist[start] = 0;
    q.push({0,start});

    while(!q.empty()){
        int u = q.top().second;
        q.pop();

        if(visited[u]){
            continue;
        }
        visited[u] = true;

        for(auto& i : graph[u]){
            int v = i.first, weight = i.second;
            if(dist[u] + weight < dist[v]){
                dist[v] = dist[u] + weight;
                q.push({dist[v],v});
            }
        }
    }
    return dist;
}

int main(){
    int n = 0, m = 0;
    cin >> n >> m;

    vector> graph(n + 1);
    while(m--){
        int x = 0, y = 0, z = 0;
        cin >> x >> y >> z;
        graph[x].push_back({y,z});
    }

    vector dist = Dijkstr(graph, 1, n);

    if(dist[n] == INT_MAX){
        cout << "-1" << endl;
    }else{
        cout << dist[n] << endl;
    }

    return 0;    
}

二：Bellman-Ford算法（有边数限制的最短路）
       图中可能存在重边和自环， 边权可能为负数

#include 
#include 
#include 
using namespace std;

const int N = 510, M = 10010;

struct edge {
    int from, to, weight;
} edges[M];

int n, m, k;
int dist[N], last[N];

void Bellman_ford() {
    memset(dist, 0x3f, sizeof(dist));
    dist[1] = 0;

    for (int i = 0; i < k; i++) {
        memcpy(last, dist, sizeof(dist));
        for (int j = 0; j < m; j++) {
            auto e = edges[j];
            dist[e.to] = min(last[e.from] + e.weight, dist[e.to]);
        }
    }
}

int main()
{
    scanf("%d%d%d", &n, &m, &k);

    for (int i = 0; i < m; i ++ )
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        edges[i] = {a, b, c};
    }

    Bellman_ford();

    if (dist[n] > 0x3f3f3f3f / 2) puts("impossible");
    else printf("%d\n", dist[n]);

    return 0;
}

三：SPFA算法(图中可能存在重边和自环， 边权可能为负数)
        存在负环，则死循环，因此也可用来判断是否存在负环

#include 
#include 
#include 
#include 

using namespace std;

const int INF = INT_MAX;

struct Edge {
    int to;
    int weight;
};

vector> graph;

vector SPFA(int n, int m) {
    vector dist(n + 1, INF);
    vector inQueue(n + 1, 0);
    vector count(n + 1, 0);

    queue q;
    q.push(1);
    dist[1] = 0;
    inQueue[1] = 1;
    count[1] = 1;

    while (!q.empty()) {
        int u = q.front();
        q.pop();
        inQueue[u] = 0;

        for (const auto& edge : graph[u]) {
            int v = edge.to;
            int weight = edge.weight;

            if (dist[u] + weight < dist[v]) {
                dist[v] = dist[u] + weight;

                if (!inQueue[v]) {
                    q.push(v);
                    inQueue[v] = 1;
                    count[v]++;

                    if (count[v] > n) {
                        return vector();
                    }
                }
            }
        }
    }

    return dist;
}

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

    graph.resize(n + 1);

    for (int i = 0; i < m; i++) {
        int x, y, z;
        cin >> x >> y >> z;
        graph[x].push_back({y, z});
    }

    vector dist = SPFA(n, m);

    if (dist[n] == INF) {
        cout << "impossible" << endl;
    } else {
        cout << dist[n] << endl;
    }

    return 0;
}

四：Floyd算法(图中可能存在重边和自环，边权可能为负数)

#include 
#include 
#include 
using namespace std;

const int INF = INT_MAX / 2;
const int N = 210;
vector> dist(N, vector(N, INF));
int n, m, k;

void floyd(){
    for (int k = 1; k <= n; k++) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                if (dist[i][k] != INF && dist[k][j] != INF && dist[i][k] + dist[k][j] < dist[i][j]) {
                    dist[i][j] = dist[i][k] + dist[k][j];
                }
            }
        }
    }
}

int main(){
    cin >> n >> m >> k;
    for(int i = 1; i <= m; i++){
        int x, y, z;
        cin >> x >> y >> z;
        dist[x][y] = min(dist[x][y], z);
    }

    for(int i = 1; i <= n; i++){
        dist[i][i] = 0;
    }

    floyd();

    while(k--){
        int f, t;
        cin >> f >> t;
        if(dist[f][t] == INF){
            cout << "impossible" << endl;
        }else{
            cout << dist[f][t] << endl;
        }
    }

    return 0;
}