图论问题的算法 (C++)

最新推荐文章于 2023-10-09 11:58:12 发布

ghost_him

最新推荐文章于 2023-10-09 11:58:12 发布

阅读量1.6k

点赞数 2

分类专栏：算法学习文章标签： c++ 算法图论蓝桥杯

本文链接：https://blog.csdn.net/ghost_him/article/details/124024682

版权

算法学习专栏收录该内容

16 篇文章 6 订阅

订阅专栏

以下题目和算法思路均来自AcWing
这个文章当作我的笔记了,方便以后的复习
在这里再次感谢y总

图论问题的算法

有向图的拓扑排序
单源最短路径算法
多源最短路径算法
最小生成树算法
染色法判定二分图

有向图的拓扑排序

AcWing 848.有向图的拓扑序列

给定一个 $n$ 个点 $m$ 条边的有向图，点的编号是 $1$ 到 $n$ ，图中可能存在重边和自环。

请输出任意一个该有向图的拓扑序列，如果拓扑序列不存在，则输出 $- 1$ 。

若一个由图中所有点构成的序列 $A$ 满足：对于图中的每条边 $(x, y)$ ， $x$ 在 $A$ 中都出现在 $y$ 之前，则称 $A$ 是该图的一个拓扑序列。

输入格式
第一行包含两个整数 $n$ 和 $m$ 。

接下来 $m$ 行，每行包含两个整数 $x$ 和 $y$ ，表示存在一条从点 $x$ 到点 $y$ 的有向边 $(x, y)$ 。

输出格式
共一行，如果存在拓扑序列，则输出任意一个合法的拓扑序列即可。

否则输出 $- 1$ 。

数据范围
$1 \leq n, m \leq 105$
输入样例：

输出样例：

1 2 3

通过入度的数量来判断当前的点是否是该输出

C++ 代码

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
#include<vector>

using namespace std;

const int N = 100010;

int n, m;
int h[N], e[N], ne[N], idx;
int din[N];                     // 入度的大小
vector<int> ans;

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

void topsort() {
    queue<int> store;
    for (int i = 1; i <= n; i++)
        if (din[i] == 0)
            store.push(i);

    while (store.size()) {
        auto t = store.front();
        store.pop();
        
        ans.push_back(t);

        for (int i = h[t]; ~i; i = ne[i]) {
            int j = e[i];
            if (--din[j] == 0)
                store.push(j);
        }
    }
}

int main() {
    memset(h, -1, sizeof h);
    cin >> n >> m;
    for (int i = 0; i < m; i++) {
        int x, y;
        scanf("%d%d", &x, &y);
        add(x, y);
        din[y]++;
    }

    topsort();

    if (ans.size() != n) cout << "-1" << endl;
    else {
        for (int i = 0, len = ans.size(); i < len; i++)
            printf("%d ", ans[i]);
    }
    return 0;
}

dijkstra

AcWing 849. Dijkstra求最短路 I

给定一个 $n$ 个点 $m$ 条边的有向图，图中可能存在重边和自环，所有边权均为正值。

请你求出 $1$ 号点到 $n$ 号点的最短距离，如果无法从 $1$ 号点走到 $n$ 号点，则输出 $- 1$ 。

输入格式
第一行包含整数 $n$ 和 $m$ 。

接下来 $m$ 行每行包含三个整数 $x, y, z$ ，表示存在一条从点 $x$ 到点 $y$ 的有向边，边长为 $z$ 。

输出格式
输出一个整数，表示 $1$ 号点到 $n$ 号点的最短距离。

如果路径不存在，则输出 $- 1$ 。

数据范围
$1 \leq n \leq 500$ ,
$1 \leq m \leq 105$ ,
图中涉及边长均不超过 $10000$ 。

输入样例：

输出样例：

算法的步骤:

寻找路径最小的点
用这个点更新他的周围的点
将点添加到路径中

C++ 代码

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;

const int N = 510;

int n, m;
int g[N][N];	// 从i到j的距离
int dist[N];	// 到起点的距离
bool st[N];		// 是否已经被遍历过

void dijkstra(int start) {
    memset(dist, 0x3f, sizeof dist);												// 初始化距离
    dist[start] = 0;

    for (int i = 0; i < n - 1; i ++) {
        int minv = -1;
        for (int j = 1; j <= n; j++)                        // 寻找路径最小的点
            if (!st[j] && (minv == -1 || dist[minv] > dist[j]))
                minv = j;

        for (int j = 1; j <= n; j++)                        // 用这个点更新周围的点
            dist[j] = min(dist[j], dist[minv] + g[minv][j]);

        st[minv] = true;                                    // 将点添加到路径中
    }
}

int main() {
    memset(g, 0x3f,sizeof g);   //初始化地图

    cin >> n >> m;
    while (m--) {
        int x, y, z;
        scanf("%d%d%d", &x, &y, &z);
        g[x][y] = min(g[x][y], z);
    }

    dijkstra(1);

    if (dist[n] == 0x3f3f3f3f)
        cout << -1 << endl;
    else
        cout << dist[n] << endl;

    return 0;
}

dijkstra堆优化版

AcWing 850. Dijkstra求最短路 II

给定一个 $n$ 个点 $m$ 条边的有向图，图中可能存在重边和自环，所有边权均为非负值。

请你求出 $1$ 号点到 $n$ 号点的最短距离，如果无法从 $1$ 号点走到 $n$ 号点，则输出 $- 1$ 。

输入格式
第一行包含整数 $n$ 和 $m$ 。

接下来 $m$ 行每行包含三个整数 $x, y, z$ ，表示存在一条从点 $x$ 到点 $y$ 的有向边，边长为 $z$ 。

输出格式
输出一个整数，表示 $1$ 号点到 $n$ 号点的最短距离。

如果路径不存在，则输出 $- 1$ 。

数据范围
$1≤n,m≤1.5×10^{5}$ ,
图中涉及边长均不小于 $0$ ，且不超过 $10000$ 。
数据保证：如果最短路存在，则最短路的长度不超过 $10^{9}$ 。

输入样例：

输出样例：

用堆可以优化查找最小路径的这个过程

C++代码

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>

#define x first
#define y second

using namespace std;

typedef pair<int, int> PII;

const int N = 150010;

int n, m;
int h[N], e[N], ne[N], w[N], idx;
int dist[N];
bool st[N];

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

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

    while (store.size()) {
        auto temp = store.top();								// 获取最短路径的点
        store.pop();

        int distance = temp.x, ver = temp.y;

        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];
                store.push({dist[j], j});
            }
        }
    }
}

int main() {
    memset(h, -1, sizeof h);   //初始化地图

    cin >> n >> m;
    while (m--) {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c);
    }

    dijkstra(1);

    if (dist[n] == 0x3f3f3f3f)
        cout << -1 << endl;
    else
        cout << dist[n] << endl;

    return 0;
}

Bellman-Ford

AcWing 853. 有边数限制的最短路

给定一个 $n$ 个点 $m$ 条边的有向图，图中可能存在重边和自环，边权可能为负数。

请你求出从 $1$ 号点到 $n$ 号点的最多经过 $k$ 条边的最短距离，如果无法从 $1$ 号点走到 $n$ 号点，输出 $i m p o s s i b l e$ 。

注意：图中可能存在负权回路。

输入格式
第一行包含三个整数 $n, m, k$ 。

接下来 $m$ 行，每行包含三个整数 $x, y, z$ ，表示存在一条从点 $x$ 到点 $y$ 的有向边，边长为 $z$ 。

输出格式
输出一个整数，表示从 $1$ 号点到 $n$ 号点的最多经过 $k$ 条边的最短距离。

如果不存在满足条件的路径，则输出 $i m p o s s i b l e$ 。

数据范围
$1 \leq n, k \leq 500$ ,
$1 \leq m \leq 10000$ ,
任意边长的绝对值不超过 $10000$ 。

输入样例：

输出样例：

bellman-ford比dijkstra更有广泛性, 他处理的图可以有负权边,dijkstra则不可以

核心思想:

对所有的边进行n-1轮松弛操作，因为在一个含有n个顶点的图中，任意两点之间的最短路径最多包含n-1边。换句话说，第1轮在对所有的边进行松弛后，得到的是源点最多经过一条边到达其他顶点的最短距离；第2轮在对所有的边进行松弛后，得到的是源点最多经过两条边到达其他顶点的最短距离；第3轮在对所有的边进行松弛后，得到的是源点最多经过一条边到达其他顶点的最短距离…

https://zhuanlan.zhihu.com/p/72185593

C++ 代码

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;

const int N = 510, M = 10010, INF = 0x3f3f3f3f;

int n, m, k;
int h[N], e[M], ne[M], w[M], idx;
int dist[N], backup[N];

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

void bellman_ford(int start) {
    memset(dist, 0x3f,sizeof dist);
    dist[start] = 0;
    for (int v = 0; v < k; v++){
        memcpy(backup, dist, sizeof dist);
        for (int i = 1; i <= n; i++)
            for (int j = h[i]; ~j; j = ne[j]) {
                int t = e[j];
                dist[t] = min(dist[t], backup[i] + w[j]);   // 松弛操作
            }
    }
}

int main() {
    memset(h, -1, sizeof h);

    cin >> n >> m >> k;
    while (m --) {
        int x, y, z;
        scanf("%d%d%d", &x, &y, &z);
        add(x, y, z);
    }

    bellman_ford(1);

    if (dist[n] > INF / 2) cout << "impossible" << endl;
    else cout << dist[n] << endl;

    return 0;
}

SPFA

AcWing 851. spfa求最短路

给定一个 $n$ 个点 $m$ 条边的有向图，图中可能存在重边和自环，边权可能为负数。

请你求出 $1$ 号点到 $n$ 号点的最短距离，如果无法从 $1$ 号点走到 $n$ 号点，则输出 $i m p o s s i b l e$ 。

数据保证不存在负权回路。

输入格式
第一行包含整数 $n$ 和 $m$ 。

接下来 $m$ 行每行包含三个整数 $x, y, z$ ，表示存在一条从点 $x$ 到点 $y$ 的有向边，边长为 $z$ 。

输出格式
输出一个整数，表示 $1$ 号点到 $n$ 号点的最短距离。

如果路径不存在，则输出 $i m p o s s i b l e$ 。

数据范围
$1≤n,m≤10^{5}$ ,
图中涉及边长绝对值均不超过 $10000$ 。

输入样例：

输出样例：

堆优化版的bellman-ford算法, 在最坏的情况下和bellman-ford算法是一个复杂度

C++ 代码

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>

using namespace std;

const int N = 100010, INF = 0x3f3f3f3f;

int n, m;
int h[N], e[N], ne[N], w[N], idx;
int dist[N];
bool st[N];

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

void spfa(int start) {
    memset(dist, 0x3f,sizeof dist);
    dist[start] = 0;
    queue<int> store;
    store.push(start);
    st[start] = true;

    while (store.size()) {
        int temp = store.front();
        store.pop();

        st[temp] = false;
        for (int i = h[temp]; ~i; i = ne[i]) {
            int j = e[i];
            if (dist[j] > dist[temp] + w[i]) {  // 松弛操作
                dist[j] = dist[temp] + w[i];
                if (!st[j]) {                   // 当队列中没有当前的点的时候才会添加
                    store.push(j);
                    st[j] = true;
                }
            }
        }
    }
}

int main() {
    memset(h, -1, sizeof h);

    cin >> n >> m;
    while (m--) {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c);
    }

    spfa(1);

    if (dist[n] > INF / 2) cout << "impossible" << endl;
    else cout << dist[n] << endl;

    return 0;
}

多源最短路算法

Floyed

Floyed

AcWing 854. Floyd求最短路

给定一个 $n$ 个点 $m$ 条边的有向图，图中可能存在重边和自环，边权可能为负数。

再给定 $k$ 个询问，每个询问包含两个整数 $x$ 和 $y$ ，表示查询从点 $x$ 到点 $y$ 的最短距离，如果路径不存在，则输出 $i m p o s s i b l e$ 。

数据保证图中不存在负权回路。

输入格式
第一行包含三个整数 $n, m, k$ 。

接下来 $m$ 行，每行包含三个整数 $x, y, z$ ，表示存在一条从点 $x$ 到点 $y$ 的有向边，边长为 $z$ 。

接下来 $k$ 行，每行包含两个整数 $x, y$ ，表示询问点 $x$ 到点 $y$ 的最短距离。

输出格式
共 $k$ 行，每行输出一个整数，表示询问的结果，若询问两点间不存在路径，则输出 $i m p o s s i b l e$ 。

数据范围
$1 \leq n \leq 200$ ,
$1 \leq k \leq n 2$
$1 \leq m \leq 20000$ ,
图中涉及边长绝对值均不超过 $10000$ 。

输入样例：

输出样例：

impossible
1

C++ 代码

#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

const int N = 210, INF = 0x3f3f3f3f;

int n, m, k;
int g[N][N];

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

int main() {
    memset(g, 0x3f,sizeof g);
    cin >> n >> m >> k;
    for (int i = 1; i <= n; i++)
        g[i][i] = 0;
        
    for (int i = 1; i <= m; i++) {
        int x, y, z;
        scanf("%d%d%d", &x, &y, &z);
        g[x][y] = min(g[x][y], z);
    }

    floyed();

    while (k--) {
        int x, y;
        scanf("%d%d", &x, &y);
        if (g[x][y] > INF / 2) printf("impossible\n");
        else printf("%d\n", g[x][y]);
    }

    return 0;
}

最小生成树算法

prim
Kruskal

prim

AcWing 858. Prim算法求最小生成树

给定一个 $n$ 个点 $m$ 条边的无向图，图中可能存在重边和自环，边权可能为负数。

求最小生成树的树边权重之和，如果最小生成树不存在则输出 $i m p o s s i b l e$ 。

给定一张边带权的无向图 $G = (V, E)$ ，其中 V 表示图中点的集合， $E$ 表示图中边的集合， $n = ∣ V ∣$ ， $m = ∣ E ∣$ 。

由 $V$ 中的全部 $n$ 个顶点和 $E$ 中 $n - 1$ 条边构成的无向连通子图被称为 $G$ 的一棵生成树，其中边的权值之和最小的生成树被称为无向图 $G$ 的最小生成树。

输入格式
第一行包含两个整数 $n$ 和 $m$ 。

接下来 $m$ 行，每行包含三个整数 $u, v, w$ ，表示点 $u$ 和点 $v$ 之间存在一条权值为 $w$ 的边。

输出格式
共一行，若存在最小生成树，则输出一个整数，表示最小生成树的树边权重之和，如果最小生成树不存在则输出 $i m p o s s i b l e$ 。

数据范围
$1 \leq n \leq 500$ ,
$1≤m≤10^{5}$ ,
图中涉及边的边权的绝对值均不超过 $10000$ 。

输入样例：

输出样例：

普里姆算法查找最小生成树的过程，采用了贪心算法的思想。对于包含 N 个顶点的连通网，普里姆算法每次从连通网中找出一个权值最小的边，这样的操作重复 N-1 次，由 N-1 条权值最小的边组成的生成树就是最小生成树。

http://c.biancheng.net/algorithm/prim.html

算法步骤

初始化距离,将他初始化为正无穷
n次迭代
1. 找到不在集合中的距离最小的点 $t$
2. 用 $t$ 来更新其他点到集合的距离
3. 把 $t$ 加到集合中

C++ 代码

#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

const int N = 510, INF = 0x3f3f3f3f;

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

int prim() {
    memset(dist, 0x3f,sizeof dist);

    int res = 0;
    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;
        }

        if (i && dist[t] == INF) return INF;

        if (i) res += dist[t];
        st[t] = true;

        for (int j = 1; j <= n; j++) dist[j] = min(dist[j], g[t][j]);
    }

    return res;
}

int main() {
    memset(g, 0x3f,sizeof g);

    cin >> n >> m;
    
    for (int i = 1; i <= n; i++) g[i][i] = 0;
    
    while (m--) {
        int u, v, w;
        scanf("%d%d%d", &u, &v, &w);
        g[u][v] = min(g[u][v], w);
        g[v][u] = min(g[v][u], w);
    }

    int sum = prim();
    if (sum == INF) cout << "impossible" << endl;
    else cout << sum << endl;
    return 0;
}

Kruskal

AcWing 859. Kruskal算法求最小生成树

给定一个 $n$ 个点 $m$ 条边的无向图，图中可能存在重边和自环，边权可能为负数。

求最小生成树的树边权重之和，如果最小生成树不存在则输出 $i m p o s s i b l e$ 。

给定一张边带权的无向图 $G = (V, E)$ ，其中 V 表示图中点的集合， $E$ 表示图中边的集合， $n = ∣ V ∣$ ， $m = ∣ E ∣$ 。

输入格式
第一行包含两个整数 $n$ 和 $m$ 。

接下来 $m$ 行，每行包含三个整数 $u, v, w$ ，表示点 $u$ 和点 $v$ 之间存在一条权值为 $w$ 的边。

输出格式
共一行，若存在最小生成树，则输出一个整数，表示最小生成树的树边权重之和，如果最小生成树不存在则输出 $i m p o s s i b l e$ 。

数据范围
$1≤n≤10^{5}$ ,
$1≤m≤2∗10^{5}$ ,
图中涉及边的边权的绝对值均不超过 $1000$ 。

输入样例：

输出样例：

适合稀疏图

算法思路:

先将所有的边按权重从小到大的进行排序
枚举每条边 $(a, b)$ 权重是 $c$ 若 $a, b$ 不连通,则将这条边加入到集合中

C++ 代码

#include<iostream>
#include<algorithm>

using namespace std;

const int N = 200010;

int n, m;
int p[N];

struct Edge {
    int a, b, w;

    bool operator< (const Edge &W) const {
        return w < W.w;
    }
}edges[N];

int find(int x) {
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}

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

    sort(edges, edges + m);

    for (int i = 1; i <= n; i++) p[i] = i;

    int res = 0, cnt = 0;   // 最小生成树的所有数边的权重之和, 加入的边数
    for (int i = 0; i < m; i++) {
        int a = edges[i].a, b = edges[i].b, w = edges[i].w;

        a = find(a), b = find(b);
        if (a != b) {
            p[a] = b;   // 将两个点合并
            res += w;
            cnt++;
        }
    }
    if (cnt < n - 1) cout << "impossible" << endl;
    else cout << res << endl;
}

染色法判定二分图

AcWing 860. 染色法判定二分图

给定一个 $n$ 个点 $m$ 条边的无向图，图中可能存在重边和自环。

请你判断这个图是否是二分图。

输入格式
第一行包含两个整数 $n$ 和 $m$ 。

接下来 $m$ 行，每行包含两个整数 $u$ 和 $v$ ，表示点 $u$ 和点 $v$ 之间存在一条边。

输出格式
如果给定图是二分图，则输出 $Y e s$ ，否则输出 $N o$ 。

数据范围
$1≤n,m≤10^{5}$
输入样例：

输出样例：

Yes

C++ 代码

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;

const int N = 100010;

int n, m;
int h[N], e[N * 2], ne[N * 2], idx;
int g[N];

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

bool dfs(int u, int a) {
    g[u] = a;
    for (int i = h[u]; ~i; i = ne[i]) {
        int j = e[i];
        if (!g[j]) {
            if(!dfs(j, 3 - a)) return false;
        }
        else if (g[j] == a) return false;
    }
    return true;
}

int main() {
    memset(h, -1, sizeof h);
    cin >> n >> m;
    while (m--) {
        int u, v;
        scanf("%d%d", &u, &v);
        add(u, v);
        add(v, u);
    }

    bool flag = true;
    for (int i = 1; i <= n; i++) {
        if (!g[i]) {
            if(!dfs(i, 1)){
                flag = false;
                break;
            }
        }
    }

    if (flag) cout << "Yes" << endl;
    else cout << "No" << endl;
}