最短路算法

最新推荐文章于 2024-04-30 22:25:35 发布
最新推荐文章于 2024-04-30 22:25:35 发布
阅读量194 收藏
点赞数
分类专栏： 算法竞赛 文章标签： 图论 广度搜索 dijkstra bellman–ford algorithm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CesareBorgia/article/details/114369281
版权

目录

算法选择

在这里插入图片描述

存图

邻接表
const int N = 1e6;
int n, m, h[N], e[N], ne[N], idx, w[N], dist[N];
bool vis[N];
void add(int a, int b, int c)
{
	e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}
int main()
{
	cin >> n >> m;
	memset(h, -1, sizeof h);
	for (int i = 0; i < m; i ++)
	{
		int a, b, c;
		cin >> a >> b >> c;
		add(a, b, c);
	}
	return 0;
}
邻接矩阵
const int N = 1e4;
int n, m, mp[N][N], dist[N];
反向建图

用反向图找到一条从A到B的道路后，若翻回原图，则路线会变成B到A。
因此，反向建图之后，跑一遍最短路(Dijkstra | SPFA)，得到的就是任意点到源点的最短路。

求最短路有几条

当访问到这个节点时，如果是第一次访问，将这个节点的答案+=他父节点的答案，并将这个节点推到队尾（push）。
如果是第二次访问且当前的距离等于之前记录的距离，说明这是第二条最短路，同样，将这个节点的答案+=他父节点的答案，但不需要（push）了。

if(dist[j] > dist[t] + w[i])
{
    cnt[j] = cnt[t];
}
else if (dist[j] == dist[t] + w[i])
{
	cnt[j] += cnt[t];
	cnt[j] %= mod;
}
判负环

在找最短路的时候当经过的路径中有负环的时候，没经过该负环一次距离减小，重复经过这几个形成负环的点。根据鸽巢原理，n个点的最短路中最多经过n - 1个点，当经过的点数大于等于n的时候说明该路径中存在负环。因此，只需要在spfa中每次更新dist的时候统计经过的点数。

cnt[j] = cnt[t] + 1;
if (cnt[j] >= n) return true;

朴素Dijkstra

模板：

// 稠密图
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int INF = 0x3f3f3f3f;
typedef long long ll;
const int N = 510;
int n, m, g[N][N], dist[N]; // g数组存边，dist数组表示从1到i点的最短距离
bool vis[N]; // 表示每个点的最短路是否已经确定
int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    for (int i = 1; i < n; i ++)
    {
        int t = -1; // 在未确定最短路的点中找到距离起点最短的点
        for (int j = 1; j <= n; j ++)
            if (!vis[j] && (t == -1 || dist[t] > dist[j])) 
                t = j;
        // 用t更新其他点的距离
        for (int j = 1; j <= n; j ++)
            dist[j] = min(dist[j], dist[t] + g[t][j]);
        vis[t] = true;
    }
    if (dist[n] == INF) return -1;
    return dist[n];
}
int main()
{
    cin >> n >> m;
    memset(g, 0x3f, sizeof g);
    for (int i = 0; i < m; i ++)
    {
        int x, y, z;
        cin >> x >> y >> z;
        g[x][y] = min(g[x][y], z);
    }
    cout << dijkstra() << endl;
    return 0;
}

// 稀疏图
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
using namespace std;
const int INF = 0x3f3f3f3f;
typedef long long ll;
const int N = 1e6 + 10;
int n, m, s, dist[N], e[N], ne[N], idx, h[N], w[N];
bool vis[N];
void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}
void dijkstra()
{
    for (int i = 1; i <= n; i ++) dist[i] = 2147483647;
    dist[s] = 0;
    for (int i = 1; i < n; i ++)
    {
        int t = -1;
        for (int j = 1; j <= n; j ++)
            if (!vis[j] && (t == -1 || dist[t] > dist[j]))
                t = j;
        for (int j = h[t]; j != -1; j = ne[j])
            dist[e[j]] = min(dist[e[j]], dist[t] + w[j]);
        vis[t] = true;
    }
}
int main()
{
    cin >> n >> m >> s;
    memset(h, -1, sizeof h);
    for (int i = 0; i < m; i ++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
    }    
    dijkstra();
    for (int i = 1; i <= n; i ++) printf("%d ", dist[i]);
    return 0;
}

堆优化Dijkstra

模板

#include <iostream>
#include <algorithm>
#include <queue>
#include <cstring>
using namespace std;
const int INF = 0x3f3f3f3f;
typedef long long ll;
typedef pair<int, int> pii;
const int N = 2e5 + 10;
int n, m, h[N], e[N], ne[N], w[N], idx, dist[N];
bool vis[N];
void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}
int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    priority_queue<pii, vector<pii>, greater<pii>> q;
    q.push({0, 1}); // first表示距离， second表示编号
    while (q.size())
    {
        auto t = q.top();
        q.pop();
        int ver = t.second, distance = t.first;
        if (vis[ver]) continue;
        vis[ver] = true;
        for (int i = h[ver]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > distance + w[i])
            {
                dist[j] = distance + w[i];
                q.push({dist[j], j});
            }
        }
    }
    if (dist[n] == INF) return -1;
    return dist[n];
}
int main()
{
    cin >> n >> m;
    memset(h, -1, sizeof h);
    for (int i = 0; i < m; i ++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
    }
    cout << dijkstra() << endl;
    return 0;
}

Bellman-Ford

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int INF = 0x3f3f3f3f;
typedef long long ll;
const int N = 1e5 + 10;
struct Edge
{
    int a, b, w;
}edges[N];
int n, m, k, dist[N], backup[N];
int Bellman_ford()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    for (int i = 0; i < k; i ++)
    {
        memcpy(backup, dist, sizeof dist);
        for (int j = 0; j < m; j ++)
        {
            int a = edges[j].a, b = edges[j].b, w = edges[j].w;
            dist[b] = min(dist[b], backup[a] + w);
        }
    }
    if (dist[n] > INF / 2) return -1;
    return dist[n];
}
int main()
{
    cin >> n >> m >> k;
    for (int i = 0; i < m; i ++)
    {
        cin >> edges[i].a >> edges[i].b >> edges[i].w;
    }
    int t = Bellman_ford();
    if (t == -1) cout << "impossible" << endl;
    else cout << t << endl;

    return 0;
}

SPFA

求最短路
#include <iostream>
#include <algorithm>
#include <cstring>
#include <queue>
using namespace std;
const int INF = 0x3f3f3f3f;
typedef long long ll;
const int N = 1e5 + 10;
int n, m, e[N], ne[N], idx, h[N], dist[N], w[N];
bool vis[N];
void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}
int SPFA()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    vis[1] = true;
    queue<int> q;
    q.push(1);
    while (q.size())
    {
        int t = q.front();
        q.pop();
        vis[t] = false;
        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                if (!vis[j])
                {
                    vis[j] = true;
                    q.push(j);
                }
            }
        }
    }
    if (dist[n] == INF) return -1;
    return dist[n];
}
int main()
{
    cin >> n >> m;
    memset(h, -1, sizeof h);
    for (int i = 0; i < m; i ++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
    }
    int t = SPFA();
    if (t == -1) puts("impossible");
    else cout << t << endl;
    return 0;
}
判负环
#include <iostream>
#include <algorithm>
#include <queue>
#include <cstring>
#include <cstdio>
using namespace std;
const int INF = 0x3f3f3f3f;
typedef long long ll;
const int N = 1e6;
int n, m, h[N], e[N], ne[N], idx, dist[N], w[N], cnt[N];
bool vis[N];
void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}
bool SPFA()
{
    queue<int> q;
    for (int i = 1; i <= n; i ++) 
    {
        q.push(i);
        vis[i] = true;
    }
    while (q.size())
    {
        int t = q.front();
        q.pop();
        vis[t] = false;
        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                cnt[j] = cnt[t] + 1;
                if (cnt[j] >= n) return true;
                if (!vis[j])
                {
                    vis[j] = true;
                    q.push(j);
                }
            }
        }
    }
    return false;
}
int main()
{
    cin >> n >> m;
    memset(h, -1, sizeof h);
    for (int i = 0; i < m; i ++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
    }
    if (SPFA()) cout << "Yes" << endl;
    else cout << "No" << endl;
    return 0;
}

练习

P3371 【模板】单源最短路径（弱化版）
解法1(朴素Dijkstra)：
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
using namespace std;
const int INF = 0x3f3f3f3f;
typedef long long ll;
const int N = 1e6 + 10;
int n, m, s, dist[N], e[N], ne[N], idx, h[N], w[N];
bool vis[N];
void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}
void dijkstra()
{
    for (int i = 1; i <= n; i ++) dist[i] = 2147483647;
    dist[s] = 0;
    for (int i = 1; i < n; i ++)
    {
        int t = -1;
        for (int j = 1; j <= n; j ++)
            if (!vis[j] && (t == -1 || dist[t] > dist[j]))
                t = j;

        for (int j = h[t]; j != -1; j = ne[j])
        {
            int k = e[j];
            dist[k] = min(dist[k], dist[t] + w[j]);
        }
        vis[t] = true;
    }
}
int main()
{
    cin >> n >> m >> s;
    memset(h, -1, sizeof h);
    for (int i = 0; i < m; i ++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
    }    
    dijkstra();
    for (int i = 1; i <= n; i ++) printf("%d ", dist[i]);
    return 0;
}
解法2(堆优化Dijkstra)：
#include <iostream>
#include <cstring>
#include <queue>
#include <cstdio>
#include <algorithm>
using namespace std;
const int INF = 0x3f3f3f3f;
typedef long long ll;
typedef pair<int, int> pii;
const int N = 1e6 + 10;
int m, n, s, e[N], ne[N], idx, w[N], h[N], dist[N];
bool vis[N];
void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}
void dijkstra()
{
    for (int i = 1; i <= n; i ++) dist[i] = 2147483647;
    dist[s] = 0;
    priority_queue<pii, vector<pii>, greater<pii> > heap;
    heap.push({0, s});
    while (heap.size())
    {
        pii t = heap.top();
        heap.pop();
        int ver = t.second, d = t.first;
        if (vis[ver]) continue;
        vis[ver] = true;
        for (int i = h[ver]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > w[i] + d)
            {
                dist[j] = w[i] + d;
                heap.push({dist[j], j});
            }
        }
    }
}
int main()
{
    scanf("%d%d%d", &n, &m, &s);
    memset(h, -1, sizeof h);
    for (int i = 0; i < m; i ++)
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c);
    }
    dijkstra();
    for (int i = 1; i <= n; i ++) printf("%d ", dist[i]);
    return 0;
}
解法3(SPFA):
#include <iostream>
#include <algorithm>
#include <cstring>
#include <queue>
#include <cstdio>
using namespace std;
const int INF = 0x3f3f3f3f;
typedef long long ll;
const int N = 1e6;
int n, m, s, e[N], ne[N], idx, w[N], h[N], dist[N];
bool vis[N];
void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}
void SPFA()
{
    for (int i = 1; i <= n; i ++) dist[i] = 2147483647;
    dist[s] = 0;
    queue<int> q;
    q.push(s);
    vis[s] = true;
    while (q.size())
    {
        int t = q.front();
        q.pop();
        vis[t] = false;
        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                if (!vis[j])
                {
                    vis[j] = true;
                    q.push(j);
                }
            }
        }
    }
}
int main()
{
    cin >> n >> m >> s;
    memset(h, -1, sizeof h);
    for (int i = 0; i < m; i ++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
    }
    SPFA();
    for (int i = 1; i <= n; i ++) printf("%d ", dist[i]);
    
    return 0;
}
P1629 邮递员送信

反向建图，将多源一汇最短路变为单源最短路。

解法1(朴素Dijkstra + 反向建图)：
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 1e3 + 10;
int n, m, g[N][N], dist[N];
bool vis[N];
void Dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    memset(vis, 0, sizeof vis);
    dist[1] = 0;
    for (int i = 1; i < n; i ++)
    {
        int t = -1;
        for (int j = 1; j <= n; j ++)
            if (!vis[j] && (t == -1 || dist[t] > dist[j]))
                t = j;
        for (int j = 1; j <= n; j ++)
            dist[j] = min(dist[j], dist[t] + g[t][j]);
        vis[t] = true;
    }
}
int main()
{
    cin >> n >> m;
    memset(g, 0x3f, sizeof g);
    for (int i = 0; i < m; i ++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        g[a][b] = min(g[a][b], c);
    }
    Dijkstra();
    int ans = 0;
    for (int i = 1; i <= n; i ++) ans += dist[i];
    for (int i = 1; i <= n; i ++) 
    	for (int j = i; j <= n; j ++) 
    		swap(g[i][j], g[j][i]);
    Dijkstra();
    for (int i = 1; i <= n; i ++) ans += dist[i];
    cout << ans << endl;
    
    return 0;
}
解法2(堆优化DIjkstra + 反向建图)：
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <queue>
using namespace std;
typedef pair<int, int> pii;
const int INF = 0x3f3f3f3f;
const int N = 1e6 + 10;
int n, m, e[N], ne[N], h[N], w[N], idx, dist[N];
bool vis[N];
void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}
void Dijkstra(int start)
{
    memset(dist, 0x3f, sizeof dist);
    memset(vis, 0, sizeof vis);
    dist[start] = 0;
    priority_queue<pii, vector<pii>, greater<pii> > heap;
    heap.push({0, start}); // first distance seconde node
    while (heap.size())
    {
        pii t = heap.top();
        heap.pop();
        int distance = t.first, ver = t.second;
        if (vis[ver]) continue;
        vis[ver] = true;
        for (int i = h[ver]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > distance + w[i])
            {
                dist[j] = distance + w[i];
                heap.push({dist[j], j});
            }
        }
    }
}
int main()
{
    cin >> n >> m;
    memset(h, -1, sizeof h);
    for (int i = 0; i < m; i ++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
        add(b + n, a + n, c);
    }
    int ans = 0;
    Dijkstra(1);
    for (int i = 2; i <= n; i ++) ans += dist[i];
    Dijkstra(1 + n);
    for (int i = 2 + n; i <= 2 * n; i ++) ans += dist[i];
    cout << ans << endl;
    
    return 0;
}
解法3(SPFA + 反向建图)
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <queue>
using namespace std;
const int INF = 0x3f3f3f3f;
typedef long long ll;
const int N = 1e6;
int n, m, e[N], ne[N], h[N], w[N], idx, dist[N];
bool vis[N];
void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}
void SPFA(int start)
{
    memset(vis, 0, sizeof vis);
    memset(dist, 0x3f, sizeof dist);
    dist[start] = 0;
    queue<int> q;
    q.push(start);
    vis[start] = true;
    while (q.size())
    {
        int t = q.front();
        q.pop();
        vis[t] = false;
        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                if (!vis[j])
                {
                    vis[j] = true;
                    q.push(j);
                }
            }
        }
    }
}
int main()
{
    cin >> n >> m;
    memset(h, -1, sizeof h);
    for (int i = 0; i < m; i ++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
        add(b + n, a + n, c);
    }
    int ans = 0;
    SPFA(1);
    for (int i = 2; i <= n; i ++) ans += dist[i];
    SPFA(1 + n);
    for (int i = 2 + n; i <= n * 2; i ++) ans += dist[i];
    cout << ans << endl;
    
    return 0;
}
P4779 【模板】单源最短路径（标准版）
解法1(SPFA)：

被卡了

解法2(堆优化Dijkstra)：
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <queue>
using namespace std;
const int INF = 0x3f3f3f3f;
typedef long long ll;
typedef pair<int, int> pii;
const int N = 1e6;
int n, m, s, e[N], ne[N], h[N], w[N], idx, dist[N];
bool vis[N];
void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}
void Dijkstra(int start)
{
    memset(dist, 0x3f, sizeof dist);
    dist[start] = 0;
    priority_queue<pii, vector<pii>, greater<pii> > heap;
    heap.push({0, start});
    while (heap.size())
    {
        pii t = heap.top();
        heap.pop();
        int distance = t.first, ver = t.second;
        if (vis[ver]) continue;
        vis[ver] = true;
        for (int i = h[ver]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > distance + w[i])
            {
                dist[j] = distance + w[i];
                heap.push({dist[j], j});
            }
        }
    }
}
int main()
{
    cin >> n >> m >> s;
    memset(h, -1, sizeof h);
    for (int i = 0; i < m; i ++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
    }
    Dijkstra(s);
    for (int i = 1; i <= n; i ++) printf("%d ", dist[i]);
    return 0;
}
P1144 最短路计数
解法1(SPFA + 操作计数)
#include <iostream>
#include <algorithm>
#include <queue>
#include <cstring>
#include <cstdio>
using namespace std;
const int INF = 0x3f3f3f3f;
typedef long long ll;
const int mod = 100003;
const int N = 1e7;
int n, m, h[N], e[N], ne[N], idx, dist[N], cnt[N];
bool vis[N];
void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}
void SPFA()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    cnt[1] = 1;
    vis[1] = true;
    queue<int> q;
    q.push(1);
    while (q.size())
    {
        int t = q.front();
        q.pop();
        vis[t] = false;
        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + 1)
            {
                dist[j] = dist[t] + 1;
                cnt[j] = cnt[t];
                if (!vis[j])
                {
                    vis[j] = true;
                    q.push(j);
                }
            }
            else if (dist[j] == dist[t] + 1)
            {
                cnt[j] += cnt[t];
                cnt[j] %= mod;
            }
        }
    }
}
int main()
{
    cin >> n >> m;
    memset(h, -1, sizeof h);
    for (int i = 0; i < m; i ++)
    {
        int a, b;
        cin >> a >> b;
        add(a, b);
        add(b, a);
    }
    SPFA();
    for (int i = 1; i <= n; i ++) cout << cnt[i] << endl;
    
    return 0;
}
解法2(堆优化Dijkstra + 操作计数)
#include <iostream>
#include <algorithm>
#include <cstring>
#include <queue>
using namespace std;
const int INF = 0x3f3f3f3f;
typedef long long ll;
typedef pair<int, int> pii;
const int N = 1e7;
const int mod = 100003;
int n, m, e[N], ne[N], h[N], idx, dist[N], ans[N];
bool vis[N];
void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}
void Dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    ans[1] = 1;
    priority_queue<pii, vector<pii>, greater<pii> > heap;
    heap.push({0, 1});
    while(heap.size())
    {
        pii t = heap.top();
        heap.pop();
        int distance = t.first, ver = t.second;
        if (vis[ver]) continue;
        vis[ver] = true;
        for (int i = h[ver]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > distance + 1)
            {
                ans[j] = ans[ver];
                dist[j] = distance + 1;
                heap.push({dist[j], j});
            }
            else if (dist[j] == distance + 1)
            {
                ans[j] += ans[ver];
                ans[j] %= mod;
            }
        }
    }
}
int main()
{
    cin >> n >> m;
    memset(h, -1, sizeof h);
    for (int i = 0; i < m; i ++)
    {
        int a, b;
        cin >> a >> b;
        add(a, b), add(b, a);
    }
    Dijkstra();
    for (int i = 1; i <= n; i ++) cout << ans[i] << endl;
    return 0;
}
A-Egoist
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
次短路（第二最短路径）
WayToAccept的专栏
10-28 6644
第二最短路径 有句古话叫“不破不立”，这个思想跟次短路也就是第二最短路的思想一样。 算法思想：计算原图的最短路，并保存路径。一一破坏最短路中的每一条边，重新计算最短路，并排序。最小的那个就是第二最短路。 1.用dijkstra计算u->v的最短路径，保存路径上的每条边 2.依次删除最短路径上的每一条边（每次删一条），重新计算新的u->v最短路径（新的最短路>=原最短路） 3.把所有新
hdu 6181 Two Paths（最短路，spfa）
nhl19961226的博客
08-28 243
题目链接：传送门Two PathsTime Limit: 4000/2000 MS (Java/Others) Memory Limit: 153428/153428 K (Java/Others) Total Submission(s): 971 Accepted Submission(s): 450Problem Description You are given a undir
图论·最短路·题解【路障·次短路径·Roadblocks】（SPFA）
Chenyu_oi的博客
01-23 666
图论·最短路拓展【洛谷 P2865 [USACO06NOV]路障Roadblocks】题意思路代码 2019.1.22 记本蒟蒻的第一次博客，还请各位大佬多多指教！ 题目链接 题意 在一个无向、有权图中，求起点至终点的严格次短路长度。初拿到题后可能不太容易上手毕竟我太菜了 ，但总的说来，思路还是应该非常清晰的。 思路 首先，前向星建图，邻接表存图，应该没太大问题。然后，便容易产生以下三种思路： ...
第二短路
MILLOPE的博客
02-23 722
题目 描述 Description 贝茜把家搬到了一个小农场，但她常常回到FJ的农场去拜访她的朋友。贝茜很喜欢路边的风景，不想那么快地结束她的旅途，于是她每次回农场，都会选择第二短的路径，而不象我们所习惯的那样，选择最短路。 　　贝茜所在的乡村有R(1&amp;amp;lt;=R&amp;amp;lt;=100,000)条双向道路，每条路都联结了所有的N(1&amp;amp;lt;=N&amp;amp;lt;=5000)个农场中的某两个。贝茜居住在农场1，...
最短路算法详解
qq_59539549的博客
06-25 2460
图的最短路算法
【算法】最短路算法
白晨的博客
02-25 3441
这次为大家分享的是图论中的最短路算法。考虑到最短路算法的复杂性以及本文新手向的教程，本次算法讲解列举了大量例子并且配上了大量动图。篇文章所有的代码实现都是算法向的，以快速实现和效率为主，如果出现算法向的代码实在看不懂，可以参考白晨的工程向实现的代码
最短路算法总结（超详细~）
热门推荐
wmy0217_的博客
04-11 3万+
文章目录最短路算法框架朴素Dijkstra算法堆优化版Dijkstra算法 最短路算法框架 最短路有五种算法，分别适用不同的情况。 单源最短路： 求一个点到其他点的最短路 多源最短路： 求任意两个点的最短路 稠密图用邻接矩阵存，稀疏图用邻接表存储。 稠密图： m 和 n2 一个级别 稀疏图： m 和 n 一个级别 朴素Dijkstra算法 Dijkstra算法是通过 n 次循环来确定 n 个点...
最短路算法——Dijkstra
指北针_N的博客
04-22 3660
Dijkstra 在大多数最短路径问题中，Dijkstra 算法是最常用、效率最高的。它是一种“单源”最短路径算法，一次计算能得到从一个起点 s 到其他所有点的最短距离长度、最短路径的途径点。 一、Dijkstra的算法思想 Dijkstra 的模型例如多米诺骨牌，你可以想象下面的场景： 在图中所有的边上，排满多米诺骨牌，相当于把骨牌看成图的边。一条边上的多米诺骨牌数量，和边的权值（例如长度或费用）成正比。规定所有骨牌倒下的速度都是一样的。如果在一个结点上推倒骨牌，会导致这个结点上的所有骨牌都往后面
Dijkstra最短路算法
qq_19018277的博客
11-17 2292
迪杰斯特拉算法！
常用最短路算法详解
qq_52852138的博客
05-04 667
文章目录1.弗洛伊德 Floyd-Warshall2.迪杰斯塔拉 Dijkstra2.1.算法流程2.2.一些解释3.SPFA3.1.前面两种算法的局限性3.2.Bellman-Ford算法3.3.SPFA(Shortest Path Faster Algorithm)4.负权环路 1.弗洛伊德 Floyd-Warshall 主要想法是，通过逐渐增加允许经过的节点，来更新最短路，本质上是动态规划方法 求取图中任意两点之间的距离 f[k][x][y] ：只允许经过节点 1 到 k（不包括两个端点，两个
算法合集之《最短路算法及其应用》
02-26
算法合集之《最短路算法及其应用》
【老生谈算法】floyd最短路算法Dijkstra最短路算法Matlab程序.doc
07-02
【老生谈算法】floyd最短路算法Dijkstra最短路算法Matlab程序.doc
动态最短路_动态最短路算法程序_
10-03
利用线形规划实现最短路路径找到相对最优解
【图论】图论基础
OI博客
04-30 1493
讲解图的定义和存储方式
华为OD机试D卷 - 用连续自然数之和来表达整数 - 免费看解析和代码.html
05-10
私信博主免费获取真题解析以及代码
Screenshot_2024-05-10-20-21-01-857_com.chaoxing.mobile.jpg
05-10
Screenshot_2024-05-10-20-21-01-857_com.chaoxing.mobile.jpg
数字图像处理｜Matlab-频域增强实验-彩色图像的频域滤波.zip
最新发布
05-10
数字图像处理｜Matlab-频域增强实验-彩色图像的频域滤波.zip
2024-2030中国定向转向膜市场现状研究分析与发展前景预测报告.docx
05-10
2024-2030中国定向转向膜市场现状研究分析与发展前景预测报告
最短路算法matlab
08-28
在MATLAB中，可以使用图论工具箱中的函数来解决最短路问题其中，最短路算法主要涉及到的函数是shortestpath函数。该函数的语法如下： [P,d] = shortestpath(G,s,t) 其中，G表示输入的有向图，s和t分别表示起始节点和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值