3.1.1 单源最短路的建图方式

最新推荐文章于 2022-12-27 21:33:11 发布
最新推荐文章于 2022-12-27 21:33:11 发布
阅读量235 收藏
点赞数
分类专栏： AcWing算法提高课 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/esjiang/article/details/114164206
版权

总览

在这里插入图片描述

单源最短路的一些算法

{ 边 权 非 负 { 朴 素 D i j k s t r a 堆 优 化 D i j k s t r a 有 负 权 边 { B e l l m a n − F o r d （ 用 的 情 况 少 ） s p f a （ 99 % 情 况 用 这 种 算 法 ） \left\{ \begin{matrix}边权非负\left\{\begin{matrix} 朴素Dijkstra \\ 堆优化Dijkstra \end{matrix}\right.\\ 有负权边\left\{\begin{matrix} Bellman-Ford （用的情况少）\\ spfa （99\%情况用这种算法） \end{matrix}\right.\\ \end{matrix} \right. ⎩⎪⎪⎨⎪⎪⎧​边权非负{朴素Dijkstra堆优化Dijkstra​有负权边{Bellman−Ford（用的情况少）spfa（99%情况用这种算法）​​
图论问题，最重要的在于问题的转化与抽象
在这里插入图片描述

AcWing 1129. 热浪

分析

无向图，求起点到终点的最短路径（裸题）
最简单的单源最短路模型

朴素版dijkstra 时间复杂度 O ( n 2 ) O(n^2) O(n2) 250 0 2 2500^2 25002可以过
堆优化版dijkstra 时间复杂度 O ( m l o g n ) O(mlogn) O(mlogn), 6200 ∗ l o g 2500 6200 * log {2500} 6200∗log2500 可以过
spfa 平均时间复杂度 O ( m ) O(m) O(m)， 也可以过
随便选择一个。
其中,
spfa可以采用循环队列, 来节省队列长度

while (hh != tt){
	if (hh == N) hh = 0;
	...
	if (tt == N) tt = 0;
}

代码

#include <iostream>
#include <cstring>
using namespace std;
const int N = 2510, M = 6210 * 2;
int n, m, S, E;
int h[N], e[M], w[M], ne[M], idx;
int dist[N], q[N];
bool st[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[S] = 0;
    int hh = 0, tt = 1; // tt表示当前位置, 还没放数字, 因此后面是tt ++, 而不是 ++ tt
    q[0] = S, st[S] = true;
    
    while (hh != tt){
        int t = q[hh ++];
        if (hh == N) hh = 0;
    
        st[t] = false;
        
        for (int i = h[t]; ~i; i = ne[i]){
            int j = e[i];
            if (dist[j] > dist[t] + w[i]){
                dist[j] = dist[t] + w[i];
                if (!st[j]){
                    q[tt ++ ] = j;
                    if (tt == N) tt = 0;
                    st[j] = true;
                }
            }
        }
    }
    return dist[E];
}

int main(){
    cin >> n >> m >> S >> E;
    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), add(b, a, c);
    }
    
    int t = spfa();
    
    cout << t << endl;
    
    return 0;
}

AcWing 1128. 信使

分析

题目问整个图中, 所有点被广播到需要多少时间,转化一下,就是求最短距离中最长的距离.
这有点意思啊…

dijkstra代码

#include <iostream>
#include <cstring>
#include <queue>
using namespace std;
const int N = 110, M = 210 * 2, INF = 0x3f3f3f3f;
typedef pair<int, int> PII;

int n, m;
int dist[N];
bool st[N];
int g[N][N];

int dijkstra(){
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0, 1});
    
    while (heap.size()){
        auto t = heap.top(); heap.pop();
        int ver = t.second, distance = t.first;
        if (st[ver]) continue;
        
        st[ver] = true;
        
        for (int j = 1; j <= n; j ++ ){
            if (dist[j] > dist[ver] + g[ver][j]){
                dist[j] = dist[ver] + g[ver][j];
                heap.push({dist[j], j});
            }
                
        }
    }
}
int main(){
    cin >> n >> m;
    for (int i = 1; i <= n; i ++ )  
        for (int j = 1; j <= n; j ++ )  
            if (i != j) g[i][j] = g[j][i] = INF;
            else g[i][j] = g[j][i] = 0;
            
    for (int i = 0; i < m; i ++ ){
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        g[a][b] = g[b][a] = min(g[a][b], c);
    }
    
    int t = dijkstra();
    
    int res = 0;
    for (int i = 2; i <= n; i ++ ) res = max(res, dist[i]);
    
    if (res == 0x3f3f3f3f) cout << -1 << endl;
    else cout << res << endl;
    
    return 0;
        
}

floyd 代码

#include <iostream>
#include <cstring>
#include <queue>
using namespace std;
const int N = 110, M = 210 * 2, INF = 0x3f3f3f3f;
typedef pair<int, int> PII;

int n, m;
int dist[N][N];
bool st[N];
int g[N][N];

void floyd(){
    for (int k = 1; k <= n; k ++ )
        for (int i = 1; i <= n; i ++ )
            for (int j = 1; j <= n; j ++ )
                dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}

int main(){
    cin >> n >> m;
    for (int i = 1; i <= n; i ++ )  
        for (int j = 1; j <= n; j ++ )  
            if (i != j) dist[i][j] = dist[j][i] = INF;
            else dist[i][j] = dist[j][i] = 0;
            
    for (int i = 0; i < m; i ++ ){
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        dist[a][b] = dist[b][a] = min(dist[a][b], c);
    }
    
    floyd();
    
    int res = 0;
    for (int i = 2; i <= n; i ++ ) res = max(res, dist[1][i]);
    
    if (res == 0x3f3f3f3f) cout << -1 << endl;
    else cout << res << endl;
    
    return 0;
        
}

AcWing 1127. 香甜的黄油

分析

就是求图中一个点 到 给出的所有奶牛位置的最短距离之和的最小值
在求最短路的时候, 外层还要套一层n次起点.
在这里插入图片描述

floyed(TLE)

#include <iostream>
#include <cstring>
using namespace std;
const int N = 810, M = 1460 * 2, INF = 0x3f3f3f3f;
int d[N][N];
int n, P, m;
int a[N];

void floyd(){
    for (int k = 1; k <= n; k ++ )
        for (int i = 1; i <= n; i ++ )
            for (int j = 1; j <= n; j ++ )
                d[i][j] = d[j][i] = min(d[i][j], d[i][k] + d[k][j]);
}

int main(){
    cin >> P >> n >> m;
    for (int i = 0; i < P; i ++ ){
        cin >> a[i];
    }
    
    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= n; j ++ )
            if (i != j) d[i][j] = d[j][i] = INF;
            else d[i][i] = 0;
            
    for (int i = 1; i <= m; i ++ ){
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        d[a][b] = d[b][a] = min(d[a][b], c);
    }
    
    // cout << d[2][4] << d[3][4] << endl;
            
    floyd();
    
    int res = INF;
    for (int i = 1; i <= n; i ++ ) {
        int t = 0;
        for (int j = 0; j < P; j ++ )
            t += d[a[j]][i];
        res = min(t, res);
    }
            
    cout << res << endl;
    
    return 0;
    
}

spfa

#include <iostream>
#include <cstring>
using namespace std;
const int N = 810, M = 1460 * 2, INF = 0x3f3f3f3f;
int h[N], e[M], w[M], ne[M], idx;
bool st[N];
int q[N];
int n, p, m;
int id[N];
int dist[N];

void add(int a, int b, int c){
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}

int spfa(int start){
    memset(dist, 0x3f, sizeof dist);
    dist[start] = 0;
    int hh = 0, tt = 1;
    q[0] = start, st[start] = true;
    
    while (hh != tt){
        int t = q[hh ++];
        if (hh == N) hh = 0;
        st[t] = false;
        
        for (int i = h[t]; ~i; i = ne[i]){
            int j = e[i];
            if (dist[j] > dist[t] + w[i]){
                dist[j] = dist[t] + w[i];
                if (!st[j]){
                    q[tt ++] = j;
                    if (tt == N) tt =  0;
                    st[j] = true; 
                }
            }
        }
    }
    
    int res = 0; // 计算所有奶牛到起点的距离
    for (int i = 0; i < n; i ++ ){
        int j = id[i];
        int t = dist[j];
        if (t == INF) return INF;
        else res += t;
    }
    return res;
}
int main(){
    cin >> n >> p >> m;
    memset(h, -1, sizeof h);
    
    for (int i = 0; i < n; i ++ ) cin >> id[i];
    
    for (int i = 0; i < m; i ++ ){
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c), add(b, a, c);
    }
    
    int res = INF;
    for (int i = 1; i <= p; i ++ ) res = min(res, spfa(i)); // 计算所有起点开始到奶牛的最小距离
    
    cout << res << endl;
    
    return 0;
}

堆优化dijkstra

#include <iostream>
#include <cstring>
#include <queue>
using namespace std;
const int N = 810, M = 1460 * 2, INF = 0x3f3f3f3f;
int h[N], e[M], w[M], ne[M], idx;
bool st[N];
int q[N];
int n, p, m;
int id[N];
int dist[N];
typedef pair<int, int> PII;
void add(int a, int b, int c){
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}

int dijkstra(int start){
    memset(st, 0, sizeof st); // st数组每次需要重制. 别忘了
    memset(dist, 0x3f, sizeof dist);
    dist[start] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0, start});
    
    while (heap.size()){
        auto t = heap.top(); heap.pop();
        int ver = t.second, distance = t.first;
        if (st[ver]) continue;
        
        st[ver] = true;
        for (int i = h[ver]; ~i; i = ne[i]){
            int j = e[i];
            if (dist[j] > dist[ver] + w[i]){
                dist[j] = dist[ver] + w[i];
                heap.push({dist[j], j});
            }
        }
    }
    int res = 0;
    for (int i = 0; i < n; i ++ ){
        int j = id[i];
        if (dist[j] == INF) return INF;
        res += dist[j];
    }
    return res;
}
int main(){
    cin >> n >> p >> m;
    memset(h, -1, sizeof h);
    
    for (int i = 0; i < n; i ++ ) cin >> id[i];
    
    for (int i = 0; i < m; i ++ ){
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c), add(b, a, c);
    }
    
    int res = INF;
    for (int i = 1; i <= p; i ++ ) res = min(res, dijkstra(i)); // 计算所有起点开始到奶牛的最小距离
    
    cout << res << endl;
    
    return 0;
}

AcWing 1126. 最小花费

分析

在这里插入图片描述

A 最少需要多少钱使得转账后 B 收到 100 元
100 = d(A) * W1 * W2 * … Wn

要让 A的值最小 则(W1 * W2 * … Wn)最大

证明最短路模型对于 乘法也成立

100 = d(A) * W1 * W2 * … Wn
对W1 * W2 * … Wn 取log, 那么每条边权重会变成 l o g ( w i ) log(w_i) log(wi​),题目转化为求A到B的和最大的路径(因为 W i W_i Wi​乘法变成加法了, 可以用最短路模型了) , 对每条边* (-1), 使得权重变成正的, 就会转化成权重为 − l o g ( w i ) > 0 -log(w_i) > 0 −log(wi​)>0的最短路问题.
0 < w i ≤ 1 0 < w_i \leq 1 0<wi​≤1, l o g ( w i ) < 0 log(w_i) < 0 log(wi​)<0.

注意

w i ≤ 1 w_i \leq 1 wi​≤1, 使得取完log * (-1), 权重都为正的, 所以才可以dijkstra. 如果没有这个条件, 只能spfa
在这里插入图片描述

spfa代码

#include <iostream>
#include <cstring>
using namespace std;
const int N = 2010, M = 100010 * 2;

int h[N], e[M], w[M], ne[M], idx;

int n, m;
int S, T;
double dist[N];
int q[N];
bool st[N];

void add(int a, int b, int c){
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}

void spfa(){
    dist[T] = 1;
    
    int hh = 0, tt = 1;
    q[0] = T, st[T] = true;
    
    while (hh != tt){
        int t = q[hh ++];
        if (hh == N) hh = 0;
        st[t] = false;
        
        for (int i = h[t]; ~i; i = ne[i]){
            int j = e[i];
            if (dist[j] < (double)dist[t] * (double)(100 - w[i]) / 100.0){
                dist[j] = (double)dist[t] * (double)(100 - w[i]) / 100.0;
                if (!st[j]){
                    q[tt ++] = j;
                    if (tt == N) tt = 0;
                    st[j] = true;
                }
            }
        }
    }
}

int main(){
    cin >> n >> m;
    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), add(b, a, c);
    }
    cin >> S >> T;
    spfa();
    
    printf("%.8lf\n", 100.0 / dist[S]);
    
    return 0;
}

朴素dijkstra代码

#include <iostream>
#include <cstring>
using namespace std;
const int N = 2010, M = 100010 * 2;

int h[N], e[M], w[M], ne[M], idx;

int n, m;
int S, T;
double dist[N];
bool st[N];
double g[N][N];

void dijkstra(){
    // 因为求最大, 所以dist = 0, 表示此路不通
    dist[S] = 1;
    for (int i = 0; i < n; i ++ ){
        int t = -1;
        for (int j = 1; j <= n; j ++ )
            if (!st[j] && (t == -1 || dist[t] < dist[j])) t = j; // 找出s中距离原点最大的
            

        st[t] = true;
        for (int j = 1; j <= n; j ++)
            dist[j] = max(dist[j], dist[t] * g[t][j]);
    }
}

int main(){
    cin >> n >> m;
    // g = 0表示路不通
    for (int i = 0; i < m; i ++ ){
        int a, b, c;
        cin >> a >> b >> c;
        g[a][b] = g[b][a] = max(g[a][b], (100 - c) / 100.0);
    }
    cin >> S >> T;
    
    dijkstra();
    
    
    printf("%.8lf\n", 100.0 / dist[T]);
    
    return 0;
}

总结

对于乘法的最短路问题.
如果权重 > 1, 那么可以dijkstra
如果权重 >= 0, 那么只能spfa
在这里插入图片描述

AcWing 920. 最优乘车

分析

在这里插入图片描述
可以先求坐车的最小次数, 然后 - 1, 就是换车的最小次数
然后再每段车的起点,往后面的终点连一条边权重为1的边, 然后求1-n的最短路径, 再-1,就是换车次数了
特判下 1 == n, 会减成-1, 输出0.
边权为1的话,用bfs就可以了
在这里插入图片描述

代码

#include <iostream>
#include <cstring>
#include <sstream>
using namespace std;
const int N = 510;
int dist[N];
int g[N][N];
int n, m;
int q[N];
int stop[N];

void bfs(){
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    int hh = 0, tt = 0;
    q[0] = 1;
    
    while (hh <= tt){
        int t = q[hh ++];
        // bfs不用判重, 每次出队就是最小值
        for (int i = 1; i <= n; i ++ )
            if (g[t][i] && dist[i] > dist[t] + 1){
                dist[i] = dist[t] + 1;
                q[++ tt] = i;
            }

    }
}

int main(){
    cin >> m >> n;
    string line;
    getline(cin, line);
    while (m -- ){
        getline(cin, line);
        stringstream ssin(line);
        int cnt = 0, p;
        while (ssin >> p) stop[cnt ++] = p;
        for (int j = 0; j < cnt; j ++ )
            for (int k = j + 1; k < cnt; k ++ )
                g[stop[j]][stop[k]] = true;
    }
    
            
    bfs();
    
    if (dist[n] == 0x3f3f3f3f) puts("NO");
    else cout << max(0, dist[n] - 1) << endl;
    
    return 0;
}

AcWing 903. 昂贵的聘礼

分析

读题, 发现一个物品, 有多条路径, 其中一种方式是某个点直接可以和这个点相连, 在其他物品中也发现都存在这个点, 可以将这个点建立为虚拟源点
然后对于等级限制, 暴力枚举从最低范围内的等级为起点, 最高范围为酋长, 求最短路
在这里插入图片描述

代码

#include <iostream>
#include <cstring>
using namespace std;
const int N = 110, INF = 0x3f3f3f3f;
int w[N][N], dist[N];
bool st[N];
int n, m;
int level[N];


int dijkstra(int down, int up){
    memset(dist, 0x3f, sizeof dist);
    memset(st, 0, sizeof st);
    dist[0] = 0;
    
    for (int i = 1; i <= n + 1; i ++ ){
        int t = -1;
        for (int j = 0; j <= n; j ++ )
            if (!st[j] && (t == -1 || dist[t] > dist[j])) t = j;
            
        st[t] = true;
        for (int j = 1; j <= n; j ++ )
            if (level[j] >= down && level[j] <= up)
                dist[j] = min(dist[j], dist[t] + w[t][j]);
    }
    return dist[1];
}

int main(){
    cin >> m >> n;
    memset(w, 0x3f, sizeof w);
    for (int i = 1; i <= n; i ++ ) w[i][i] = 0;
    
    for (int i = 1; i <= n; i ++ ){
        int price, cnt;
        cin >> price >> level[i] >> cnt;
        w[0][i] = min(w[0][i], price);
        while (cnt --){
            int id, cost;
            cin >> id >> cost;
            w[id][i] = min(w[id][i], cost);
        }
    }
    
    int res = INF;
    for (int i = level[1] - m; i <= level[1]; i ++ )  res = min(res, dijkstra(i, i + m));
    
    cout << res << endl;
    
    return 0;
}
打雷要下雨，雷欧
关注
专栏目录
单源最短路的建图方式
m0_57193124的博客
05-31 126
题目1：热浪 分析： 由题目可知，求的是两个点之间的最短距离，边权为正数且点数和边数属于同一量级，使用堆优化版的dijkstra进行求解即可。 这道题是无向图，我们建有向图能求解吗？ 不能。 因为如果a 和 b有一条边， 我们只建一条有向边， 意味着 a能到b, b确不能到a， 如果输入时起点是b，终点是a，那么我们就到达不了a，答案出错。 关于能否只建有向图求解无向图的问题， 一定要证明，如果证明不出来，直接按题目要求建立无向图。 时间复杂度：O(m∗logm)O(m * log ^m)O(m∗logm)
图论：单源最短路的建图方式（二分 + dijkstra/spfa/双端队列bfs）
m0_66252872的博客
05-24 221
最近考试周，一周多没写题解了。最近两天题都刷不成~ε=(´ο｀*)))唉。 今天抽时间做了几道题，这道题我觉得学习价值很大，囊括了很多的知识点，并且本题的建图方式也值得学习。分享给大家~ 🎁题目:通信线路 在郊区有N座通信基站，P条双向电缆，第i条电缆连接基站 Ai和 Bi。 特别地，1号基站是通信公司的总站，N号基站位于一座农场中。 现在，农场主希望对通信线路进行升级，其中升级第i条电缆需要花费Li。 电话公司正在举行优惠活动。 农产主可以指定一条从1号基...
算法提高课：3.1.1 单源最短路的建图方式
Geek
10-21 327
1129. 热浪 1128. 信使 1127. 香甜的黄油 1126. 最小花费 920. 最优乘车 903. 昂贵的聘礼
图论（1）：单源最短路的建图方式
weixin_64197656的博客
12-27 756
最短路
MQTT 协议 3.1.1 中文版
07-07
MQTT 协议 3.1.1 中文版 MQTT（Message Queuing Telemetry Transport）是一种轻量级的、基于发布/订阅模式的消息传输协议。它的设计思想是轻巧、开放、简单、规范，因此易于实现。这些特点使得它对很多场景来说都是...
MQTT v3.1.1 & v5.0协议
01-17
MQTT v3.1.1是MQTT协议的第三个主要版本，于2014年发布，是目前最广泛使用的版本。该版本主要特性包括： 1. **发布/订阅模型**：MQTT采用发布者和订阅者模式，允许设备或应用作为发布者发送消息，而其他设备或应用...
LNMP方式安装ITop3.1.1
最新发布
07-15
1
MQTT-3.1.1-CN.zip_MQTT-3.1.1-CN_MQTT-3.1.1-CN.pdf_mqtt 3.1.1 文档
07-14
MQTT中文文档,帮助理解MQTT具体协议，用于创建服务器或者客户端
【算法题归纳合集】图论-单源最短路的建图方式
一只快乐的小蒟蒻~
11-02 344
前言 对于图论的题目，代码重复的现象尤为明显，即模板代码的部分占比特别大。因此很多图论的难点并不在算法代码实现本身，而在于对题目信息的抽象能力与建图能力（因为图论题的题目描述往往都是又臭又长的），因此如何根据题意建出相应的图的能力是十分重要的。 一、AcWing 1129. 热浪 【题目描述】 John已经研究过可以把牛奶从威斯康星运送到德克萨斯州的路线。 这些路线包括起始点和终点一共有TTT个城镇，为了方便标号为111到TTT。 除了起点和终点外的每个城镇都由双向道路连向至少两个其它的城镇。 每条道路有一
单源最短路的建图方式------热浪
qq_45772483的博客
03-30 186
德克萨斯纯朴的民众们这个夏天正在遭受巨大的热浪！！！他们的德克萨斯长角牛吃起来不错，可是它们并不是很擅长生产富含奶油的乳制品。农夫John此时身先士卒地承担起向德克萨斯运送大量的营养冰凉的牛奶的重任，以减轻德克萨斯人忍受酷暑的痛苦。John已经研究过可以把牛奶从威斯康星运送到德克萨斯州的路线。这些路线包括起始点和终点一共有 TT 个城镇，为了方便标号为 11 到 TT 。除了起点和终点外的每个城镇...
[Acwing提高]单源最短路的建图方式
鱼竿钓鱼干
04-12 192
[Acwing提高]单源最短路的建图方式 知识点 题目 扩展方式 类型 热浪 裸的单源最短路 SPFA/dijkstra 题目 热浪 SPFA代码 在这里插入代码片
acwing单源最短路的建图模式总结
weixin_45630722的博客
04-27 287
.根据边权的范围以及问题求解的需要，最短路问题可以分为以下 4 种情形，分别用不同的算法求解。 • 单源最短路径（固定一个顶点为原点，求源点到其他每个顶点 的最短路径） • 1. 边权非负：Dijkstra算法。 • 2. 边权允许为负：Bellman-Ford算法 • 3. Bellman-Ford算法的改进版本：SPFA算法 • 多源最短路径（计算每个点对之间的最短路） • 4. 求所有顶点之...
HDU1596 最短路 乘法
夷则九的博客
03-24 141
要注意的是 dis初始值的设定 以及dis【st】，q.push(P(1,st)); #include <cstdio> #include <cstdlib> #include <cstring> #include <cmath> #include <iostream> #include <algorithm> #includ...
3.3.1 最小生成树的典型应用
esjiang的博客
03-07 4878
命题: Kruskal算法的正确性 证明: 假设不选择“Prim选择的边”, 即选择了红色虚线的边, 那么我们再连接“Prim算法选择的边”, 可以构成环, 然后再删掉红色虚线边, 一定可以使树中权值之和减小, 与当前选择是权值和最小的方案, 矛盾.(因为prim算法计算加边的时候, 保证了选择的边权最小) ...
3.7 有向图的强连通分量
esjiang的博客
03-14 1012
连通分量 对于一个有向图, 连通分量: 对于分量中任意u, v, 必然可以从u走到v, 也可以从v走到u 强(极大)连通分量 极大连通分量. 如果连通分量加上任何一个点之后, 都不是连通分量了, 那么称这个连通分量为极大连通分量(强连通分量) 强连通分量的用途 可以把任意一个有向图, 转化称一个有向无环图. 有向图 —>缩点(将所有连通分量缩成一个点)–> 有向无环图(DAG)(拓扑图) 有向无环图/拓扑图的好处: 求最短路/最长路的时候, 可以按照顺序递推O(n + m) 一般先去求下这个图
3.4 SPFA找负环
esjiang的博客
03-08 542
负环 有向图或者无向图中, 存在环路, 使得一圈的权值之和 < 0, 称为负环 负环为什么要单独处理, 比如最短路中, 如果一个点能走到负环上, 那么就能在这个点上转无穷多次, 每转1次, 距离就会小一点, 因此图形中, 某些点的最短路就会变成−∞-\infty−∞, 会影响最短路算法的正确性 求负环的常用方法, 基于SPFA (1) : 统计每个点入队的次数, 如果某个点入队n次, 说明存在负环 实际上就是bellman-ford算法: bellman-ford算法说迭代n次, 还有点被更新的话,
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值