Til the Cows Come Home(最短路, Dijkstra算法, spfa(bellman ford)算法, Floyd算法, 深搜DFS)

本篇博客以POJ2387为例介绍了最短路径算法比如单源最短路径(dijikstra算法和bellman ford算法)

递归dfs版本

//TLE 版本
#include <vector>
#include <algorithm>
#include <cstdio>
#include <cstring>
//#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
int graph[maxn][maxn];  //用数组来保存图的信息
bool vis[maxn];  //记录顶点是否被访问过
vector<vector<int> > ve(maxn); //保存邻接的顶点
int ans, n, prv;

void dfs(int v) {
    if (1 == v) {
        ans = min(ans, prv); //更新最短路径的值
        return ;
    }
    if (prv >= ans)  //剪枝
        return ;
    vis[v] = true;
    for (int i = 0; i < ve[v].size(); ++i) {
        if (vis[ve[v][i]]) continue;  //表示已经访问过该顶点
        vis[ve[v][i]] = true;
        prv += graph[v][ve[v][i]];
        dfs(ve[v][i]);
        prv -= graph[v][ve[v][i]];
        vis[ve[v][i]] = false;
    }
    vis[v] = false;
}


int main() {
    int t;
    while (~scanf("%d%d", &t, &n)) {
        ve.clear();
        memset(vis, false, sizeof vis);
        memset(graph, -1, sizeof graph);
        ans = INT_MAX, prv = 0;
        for (int i = 0; i < t; ++i) {
            int from, to, edge;
            scanf("%d%d%d", &from, &to, &edge);
            if (-1 == graph[from][to] || edge < graph[from][to])
                graph[from][to] = graph[to][from] = edge;
            // 去掉重边
            ve[from].push_back(to), ve[to].push_back(from);
        }
        dfs(n);
        printf("%d\n", ans);
    }
    return 0;
}

dijkstra算法

//至于堆优化后的dijkstra等以后学习之后补在这篇博客当中
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int maxx = 1005;
int adj[maxx][maxx]; // 邻接表来存储图的信息
bool found[maxx];  //标记是否访问过该结点
int t, n;
const int inf = 1 << 29;  //记住不要将最大值设成101等，虽然说题目给的边的大小是1 ~ 100 但是输入数据有坑

void init() { // 初始化
    for (int i = 1; i <= n ; ++i) {
        for (int j = 1; j <= n; ++j) {
            adj[i][j] = inf;
        }
    }
    memset(found, false, n + 1);
}

void dijkstra() {
    int dis[n + 1];
    for (int i = 1; i <= n; ++i) {
        dis[i] = adj[n][i]; // 首先对distance数组进行初始化  我选择的是从结点n到结点1
        // 也可以选择从结点1到结点n
    }
    found[n] = true;
    for (int i = 1; i <= n; ++i) {
        int minv = 0, mind = inf;  //找到在未被访问的结点之中的最小的结点
        for (int j = 1; j <= n; ++j) {
            if (found[j]) continue;
            if (dis[j] < mind) {
                minv = j;
                mind = dis[j];
            }
        }
        for (int j = 1; j <= n; ++j) {
            if (adj[minv][j] != inf) {
                dis[j] = min(dis[j], adj[minv][j] + dis[minv]);  // 对dis进行更新
            }
        }
        found[minv] = true;
    }
    printf("%d\n", dis[1]);
}

int main() {
    scanf("%d%d", &t, &n);
    init();
    for (int i = 0; i < t; ++i) {
        int from, to, edge;
        scanf("%d%d%d", &from, &to, &edge);
        adj[from][to] = adj[to][from] = min(adj[from][to], edge); // 去重边
    }
    dijkstra();
    return 0;
}

floyd算法

floyd视频讲解链接(非本人)

#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdio>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
int t, n;
const int maxx = 1005;
int gra[maxx][maxx], path[maxx][maxx];
const int inf = 1 << 29;

void floyd() {
    vector<vector<int> > A(n + 1, vector<int>(n + 1));
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= n; ++j) {
            A[i][j] = gra[i][j];
            path[i][j] = -1;
        }
    }
    for (int v = 1; v <= n; ++v) {
        for (int i = 1; i <= n; ++i) {
            for (int j = 1; j <= n; ++j) {
                if (A[i][j] > A[i][v] + A[v][j]) {
                    A[i][j] = A[i][v] + A[v][j];
                    path[i][j] = v;
                }
            }
        }
    }
}

int printPath(int v, int w) {
    if (-1 == path[v][w]) {
        return gra[v][w];
    }
    int mid = path[v][w];
    return printPath(v, mid) + printPath(mid, w);
}

int main() {
    scanf("%d%d", &t, &n);
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= n; ++j) {
            if (i != j)
                gra[i][j] = inf;
        }
    }

    for (int i = 0; i < t; ++i) {
        int from, to, edge;
        scanf("%d%d%d", &from, &to, &edge);
        gra[from][to] = gra[to][from] = min(gra[from][to], edge);
    }
    floyd();
    printf("%d\n", printPath(n, 1));
    return 0;
}

Bellman ford算法

Bellmanford视频讲解(包含怎么判断负环)

#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdio>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;

const int N = 1005, T = 4005;
int n, t;
int dis[N];
vector<vector<int> > gra(T, vector<int> (3)); //邻接表存储图
const int inf = 1 << 29;

void bellmanford() {
    for (int i = 1; i <= n; ++i) {
        dis[i] = inf;
    }
    dis[1] = 0;
    for (int i = 1; i < n; ++i) {
        for (int j = 1; j <= t * 2; ++j) {
            dis[gra[j][1]] = min(dis[gra[j][1]], dis[gra[j][0]] + gra[j][2]);
        }
    }
}


int main() {
    scanf("%d%d", &t, &n);
    for (int i = 0, index = 1; i < t; ++i) {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        gra[index][0] = a, gra[index][1] = b, gra[index][2] = c; ++index;
        gra[index][1] = a, gra[index][0] = b, gra[index][2] = c; ++index;
    }
    bellmanford();
    printf("%d\n", dis[n]);
    return 0;
}

spfa队列优化(bfs)

//spfa
#include <vector>
#include <algorithm>
#include <cstdio>
#include <queue>
using namespace std;
const int N = 1005, T = 4005;
int n, t;
int dis[N], vis[N];  //dis数组存单元源点到其他各个点的距离
//vis存顶点v是否已经在队列当中以减少不必要的操作
vector<int> to[N], edge[N]; //邻接表分别存以i为下标的邻接的顶点和权值
const int inf = 1 << 29;

void spfa() {
    queue<int> q;
    for (int i = 1; i <= n; ++i) {
        dis[i] = inf;
    }
    dis[1] = 0;
    q.push(1);
    while (!q.empty()) {
        int u = q.front(); q.pop();
        vis[u] = false;
        for (int i = 0; i < to[u].size(); ++i) { //遍历邻接的顶点
            int v = to[u][i], w = edge[u][i];
            if (dis[v] > dis[u] + w) {
                dis[v] = dis[u] + w;
                if (!vis[v]) {
                    vis[v] = true;
                    q.push(v);
                }
            }
        }
    }
}


int main() {
    scanf("%d%d", &t, &n);
    for (int i = 0; i < t; ++i) {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        //无向图
        to[a].push_back(b); edge[a].push_back(c);
        to[b].push_back(a); edge[b].push_back(c);
    }
    spfa();
    printf("%d\n", dis[n]);
    return 0;
}

不同算法之间的优劣

图片来自以下博客：
图片来源