NO.95十六届蓝桥杯备战|图论基础-单源最短路|负环|BF判断负环|SPFA判断负环|邮递员送信|采购特价产品|拉近距离|最短路计数(C++)

P3385 【模板】负环 - 洛谷

如果图中存在负环，那么有可能不存在最短路。

BF算法判断负环

执⾏n轮松弛操作，如果第n轮还存在松弛操作，那么就有负环。

#include <bits/stdc++.h>
using namespace std;

const int N = 2e3 + 10, M = 3e3 + 10;

int n, m;
int pos;
struct node
{
    int u, v, w;
}e[M * 2];

int dist[N];

bool bf()
{
    //初始化
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    bool flg;
    for (int i = 1; i <= n; i++)
    {
        flg = false;
        for (int j = 1; j <= pos; j++)
        {
            int u = e[j].u, v = e[j].v, w = e[j].w;
            if (dist[u] == 0x3f3f3f3f) continue;

            if (dist[u] + w < dist[v])
            {
                flg = true;
                dist[v] = dist[u] + w;
            }
        }
        if (flg == false) return flg;
    }
    return flg;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);

    int T; cin >> T;
    while (T--)
    {
        cin >> n >> m;
        pos = 0;
        for (int i = 1; i <= m; i++)
        {
            int u, v, w; cin >> u >> v >> w;
            pos++;
            e[pos].u = u, e[pos].v = v, e[pos].w = w;
            if (w >= 0)
            {
                pos++;
                e[pos].u = v, e[pos].v = u, e[pos].w = w;
            }
        }

        if (bf()) cout << "YES" << endl;
        else cout << "NO" << endl;
    }
    
    return 0;
}

spfa算法判断负环

维护⼀个 cnt 数组记录从起点到该点所经过的边数，如果 cnt[i] >= n ，说明有负环

#include <bits/stdc++.h>
using namespace std;

typedef pair<int, int> PII;

const int N = 2e3 + 10, M = 3e3 + 10;

int n, m;
vector<PII> edges[N];

int dist[N];
bool st[N]; //标记在队列中
int cnt[N];

bool spfa()
{
    //初始化
    memset(dist, 0x3f, sizeof dist);
    memset(st, 0, sizeof st);
    memset(cnt, 0, sizeof cnt);
    
    queue<int> q;
    q.push(1);
    dist[1] = 0;
    st[1] = true;

    while (q.size())
    {
        auto u = q.front(); q.pop();
        st[u] = false;

        for (auto& t : edges[u])
        {
            int v = t.first, w = t.second;
            if (dist[u] + w < dist[v])
            {
                dist[v] = dist[u] + w;
                cnt[v] = cnt[u] + 1;
                if (cnt[v] >= n) return true;

                if (!st[v])
                {
                    q.push(v);
                    st[v] = true;
                }
            }
        }
    }
    return false;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);

    int T; cin >> T;
    while (T--)
    {
        cin >> n >> m;
        for (int i = 1; i <= n; i++) edges[i].clear();
        
        for (int i = 1; i <= m; i++)
        {
            int u, v, w; cin >> u >> v >> w;
            edges[u].push_back({v, w});
            if (w >= 0) edges[v].push_back({u, w});
        }

        if (spfa()) cout << "YES" << endl;
        else cout << "NO" << endl;
    }
    
    return 0;
}


	常规版-dijkstra	堆优化-dijkstra	bellman‒ford算法	spfa算法
算法思想	贪⼼ • 每次拿出还未确定最短路的点中，距离起点最近的点； • 打上标记之后，更新出边所连点的最短路。	使⽤堆优化找点操作： • 把还未确定最短路的点扔到堆中，⽤堆快速找出距离起点最近的点。	暴⼒松弛： • 执⾏n-1轮松弛操作； • 每次都扫描所有的边，看看能否松弛。	使⽤队列优化bf算法： • 只有上⼀轮被松弛的点，下⼀轮才有可能松弛。
负边权	失效	失效	可⾏	可⾏
负环	失效	失效	可以判断负环： • 执⾏n轮操作，判断是否松弛	可以判断负环： • 创建cnt数组，标记从起点到该点的边数
时间复杂度	O(n2)	O(mlog m)	O(nm)	O(km) ~O(nm)

其实还有两个单源最短路算法，那就是普通bfs以及01bfs：

普通bfs只能处理边权全部相同且⾮负的最短路；
01bfs只能解决边权要么为0，要么为1的情况

P1629 邮递员送信 - 洛谷

从起点找别的点的最短距离很简单，直接跑各种最短路算法均可。
但是从别的点回到起点的最短路，如果直接求时间复杂度巨⾼。思考⼀件事：

假设从某⼀点z，到达起点的最短路径为：z->y->x->s；
那么反过来就是s->x->y->z的最短路径。
因此，仅需对原图的所有图建⽴⼀个"反图"，然后跑⼀遍最短路即可。这就是建"反图"的技巧

#include <bits/stdc++.h>
using namespace std;

const int N = 1e3 + 10;

int n, m;
int e[N][N];

int dist[N];
bool st[N];

void dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    memset(st, 0, sizeof st);

    dist[1] = 0;

    for (int i = 1; i <= n; i++)
    {
        int a = 0;
        for (int j = 1; j <= n; j++)
            if (!st[j] && dist[j] < dist[a])
                a = j;

        st[a] = true;

        for (int b = 1; b <= n; b++)
        {
            int c = e[a][b];
            if (dist[a] + c < dist[b])
            {
                dist[b] = dist[a] + c;
            }
        }
    }
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);

    cin >> n >> m;
    memset(e, 0x3f, sizeof e);
    for (int i = 1; i <= m; i++)
    {
        int a, b, c; cin >> a >> b >> c;
        e[a][b] = min(e[a][b], c);
    }

    dijkstra();
    int ret = 0;
    for (int i = 1; i <= n; i++) ret += dist[i];

    //反图
    for (int i = 1; i <= n; i++)
        for (int j = i+1; j <= n; j++)
            swap(e[i][j], e[j][i]);

    dijkstra();
    for (int i = 1; i <= n; i++) ret += dist[i];

    cout << ret << endl;
    
    return 0;
}

P1744 采购特价商品 - 洛谷

看数据范围，所有的最短路算法均可解决，这⾥使⽤BF算法。
⽆需建图，只⽤把所有的边存下来。注意是⽆向边，所以要存两次，空间也要开两倍。
在所有边上做⼀次bf算法，输出结果即可

#include <bits/stdc++.h>
using namespace std;

const int N = 110, M = 1010;

int n, m, s, t;
double x[N], y[N];

struct node
{
    int a, b;
    double c;
}e[M];

double calc(int i, int j)
{
    double dx = x[i] - x[j];
    double dy = y[i] - y[j];
    return sqrt(dx * dx + dy * dy);
}

double dist[N];

void bf()
{
    for (int i = 1; i <= n; i++) dist[i] = 1e10;

    dist[s] = 0;

    for (int i = 1; i < n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            int a = e[j].a, b = e[j].b;
            double c = e[j].c;
            
            if (dist[a] + c < dist[b])
            {
                dist[b] = dist[a] + c;
            }

            if (dist[b] + c < dist[a])
            {
                dist[a] = dist[b] + c;
            }
        }
    }
}

int main()
{
    cin >> n;
    for (int i = 1; i <= n; i++) cin >> x[i] >> y[i];
    cin >> m;
    for (int i = 1; i <= m; i++)
    {
        int a, b; cin >> a >> b;
        e[i].a = a; e[i].b = b; e[i].c = calc(a, b);
    }
    cin >> s >> t;

    bf();

    printf("%.2lf\n", dist[t]);
    
    return 0;
}

P2136 拉近距离 - 洛谷

bf算法判断负环即可。但要注意⼀下细节：

题⽬中给的是距离w是能缩⼩的数，因此存边的时候，应该存成相反数；
爱情是双向奔赴的，我们要在1->n和n->1两种情况⾥⾯选择最⼩值

#include <bits/stdc++.h>
using namespace std;

const int N = 1e3 + 10, M = 1e4 + 10;

int n, m;
struct node
{
    int a, b, c;
}e[M];

int dist[N];

bool bf(int s)
{
    memset(dist, 0x3f, sizeof dist);
    dist[s] = 0;

    bool flg;
    for (int i = 1; i <= n; i++)
    {
        flg = false;

        for (int j = 1; j <= m; j++)
        {
            int a = e[j].a, b = e[j].b, c = e[j].c;
            if (dist[a] + c < dist[b])
            {
                flg = true;
                dist[b] = dist[a] + c;
            }
        }
        if (flg == false) return flg;
    }
    return flg;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);

    cin >> n >> m;
    for (int i = 1; i <= m; i++)
    {
        cin >> e[i].a >> e[i].b >> e[i].c;
        e[i].c = -e[i].c;
    }

    int ret;
    bool st = bf(1);
    if (st)
    {
        cout << "Forever love" << endl;
        return 0;
    }
    ret = dist[n];

    st = bf(n);
    if (st)
    {
        cout << "Forever love" << endl;
        return 0;
    }

    cout << min(ret, dist[1]) << endl;
    
    return 0;
}

P1144 最短路计数 - 洛谷

解法⼀：bfs+动态规划

因为边权全都相等，所以可以⽤bfs找出最短路；
在bfs找最短路的过程中，更新最短路的条数。
动态规划：

状态表⽰：设 f[i] 表⽰从起点⾛到 i 点的最短路的条数。
状态转移⽅程： f[i] += f[prev] 。
其中 prev 表⽰ i 点的所有前驱，但是要注意是通过最短路过来的前驱。
填表顺序：按照bfs的顺序填表。
解法⼆：dijkstra算法+动态规划
这种解法更通⽤，因为即使边权不相等，也可以⽤dj算法

#include <bits/stdc++.h>
using namespace std;

typedef pair<int, int> PII;
const int N = 1e6 + 10, M = 2e6 + 10, MOD = 100003;

int n, m;
vector<int> edges[N];

int dist[N];
bool st[N];
int f[N];

void bfs()
{
    memset(dist, 0x3f, sizeof dist);
    queue<int> q;
    q.push(1);

    dist[1] = 0;
    f[1] = 1;
    
    while (q.size())
    {
        auto a = q.front(); q.pop();

        for (auto b : edges[a])
        {
            if (dist[a] + 1 < dist[b])
            {
                dist[b] = dist[a] + 1;
                f[b] = f[a];
                q.push(b);
            }
            else if (dist[a] + 1 == dist[b])
            {
                f[b] = (f[b] + f[a]) % MOD;
            }
        }
    }
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);

    cin >> n >> m;
    for (int i = 1; i <= m; i++)
    {
        int a, b; cin >> a >> b;
        edges[a].push_back(b);
        edges[b].push_back(a);
    }

    bfs();

    for (int i = 1; i <= n; i++) cout << f[i] << endl;

    return 0;
}

#include <bits/stdc++.h>
using namespace std;

typedef pair<int, int> PII;
const int N = 1e6 + 10, M = 2e6 + 10, MOD = 100003;

int n, m;
vector<int> edges[N];

int dist[N];
bool st[N];
int f[N];

void dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0, 1});
    
    dist[1] = 0;
    f[1] = 1;

    while (heap.size())
    {
        auto t = heap.top(); heap.pop();
        int a = t.second;

        if (st[a]) continue;
        st[a] = true;

        for (auto b : edges[a])
        {
            if (dist[a] + 1 < dist[b])
            {
                dist[b] = dist[a] + 1;
                f[b] = f[a];
                heap.push({dist[b], b});
            }
            else if (dist[a] + 1 == dist[b])
            {
                f[b] = (f[a] + f[b]) % MOD;
            }
        }
    }
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);

    cin >> n >> m;
    for (int i = 1; i <= m; i++)
    {
        int a, b; cin >> a >> b;
        edges[a].push_back(b);
        edges[b].push_back(a);
    }

    dijkstra();

    for (int i = 1; i <= n; i++) cout << f[i] << endl;

    return 0;
}