算法基础课：图论

最新推荐文章于 2024-07-08 22:12:26 发布
最新推荐文章于 2024-07-08 22:12:26 发布
阅读量120 收藏
点赞数
分类专栏： Acwing 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41699013/article/details/119841731
版权

DFS

BFS

走迷宫

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

using namespace std;
const int N = 110;
typedef pair<int, int> PII;
int d[N][N];
int n, m;
int g[N][N];

int bfs(){
    int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
    queue<PII> q;
    q.push({0, 0});
    d[0][0] = 0;
    while (!q.empty())
    {
        auto t = q.front();
        q.pop();
        
        for (int i = 0; i < 4; i ++)
        {
            int x = t.first + dx[i], y = t.second + dy[i];
            if (x >= 0 && x < n && y >= 0 && y < m 
                && g[x][y] == 0 && d[x][y] == -1){
                d[x][y] = d[t.first][t.second] + 1;
                q.push({x, y});
            }    
        }
    }
    return d[n - 1][m - 1];
}

int main()
{
    memset(d, -1, sizeof d);
    cin >> n >> m;
    for (int i = 0; i < n; i ++ )
    {
        for (int j = 0; j < m; j ++ )
            cin >> g[i][j];
    }   
    int res = bfs();

    cout << res;
    return 0;
}

逃离大森林
bfs的“简单”应用



#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
const int N = 1010;
typedef pair<int, int> PII;
int n, m;
int d[N][N];
char g[N][N];

void bfs(PII start, PII end)
{
    queue <PII> q;
    int dx[4] = { -1, 0, 1, 0 }, dy[4] = { 0, 1, 0, -1 };
    memset(d, 0x3f, sizeof d);
    d[start.first][start.second] = 0;
    q.push(start);
    while (!q.empty())
    {
        PII t = q.front();
        q.pop();
        for (int i = 0; i < 4; i++)
        {
            int x = dx[i] + t.first, y = dy[i] + t.second;
            if (x >= 0 && x < n && y >= 0 && y < m && g[x][y] != 'T' && d[x][y] > d[t.first][t.second] + 1)
            {
                d[x][y] = d[t.first][t.second] + 1;
                q.push({ x, y });
            }
        }
    }
}
int main(void)
{
    PII start, end;
    cin >> n >> m;
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            cin >> g[i][j];
            if (g[i][j] == 'S')
                start = { i, j };
            if (g[i][j] == 'E')
                end = { i, j };
        }
    }
    bfs(end, start);//这里倒过来，目的是查找某个点到终点的距离
    int res = 0;
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            if (g[i][j] >= '0' && g[i][j] <= '9'
                && d[i][j] <= d[start.first][start.second]) {//挑战者到终点的距离小于本人，必定战斗
                res += g[i][j] - '0';
            }
        }
    }
    // for (int i = 0; i < n; i++)
    // {
    //     for (int j = 0; j < m; j++)
    //     {
    //         cout << g[i][j] << " ";
    //     }
    //     cout << endl;
    // }
    // for (int i = 0; i < n; i++)
    // {
    //     for (int j = 0; j < m; j++)
    //     {
    //         if (d[i][j] == 1061109567) d[i][j] = 2;
    //         cout << d[i][j] << " ";
    //     }
    //     cout << endl;
    // }
    cout << res;
}

最短路：单源最短路：从1号点到n号点
①所有边权都是正数：朴素Dijkstra（O(n^2)）、堆优化Dijkstra（O(mlogn)）
②存在负权边
Bellman-Ford O(nm)
SPFA O(m) 最坏O(nm)
多源汇（起点、终点）最短路Floyd O(n^3)
m和n^2一个级别 稠密图
m和n一个级别 稀疏图
结构图如下：
在这里插入图片描述

难点：建图

朴素Dijkstra

集合s：已经确定了最短距离的点

① dis[1] = 0, dis[i] = +inf；
②for i : 0 ~ n
t ←不在s中的距离最近的点
s←t
用t更新其他点的距离

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

using namespace std;
const int N = 510;
int n, m;
int g[N][N];
int dist[N];
bool st[N];//某个点的距离是否已经确定
//typedef pair<int, int> PII;
int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    for (int i = 0; i < n; i++)//进行n次迭代
    {
        int t = -1;//当前访问的点
        for (int j = 1; j <= n; j++)//j从1号点开始，到n号点结束
            if (!st[j] && (t == -1 || dist[t] > dist[j]))//寻找不在st中的最近的点
                t = j;
        st[t] = true;
        for (int j = 1; j <= n; j++)
            dist[j] = min(dist[j], dist[t] + g[t][j]);//用找到的这个点更新与其他点的距离
    }
    if (dist[n] == 0x3f3f3f3f)//四个3f是因为字节填充，int类型有4个字节
        return -1;
    else return dist[n];
}
int main()
{
    cin >> n >> m;
    memset(g, 0x3f, sizeof g);
    while (m -- )
    {
        int a, b, c;
        cin >> a >> b >> c;
        g[a][b] = min(g[a][b], c);
    }
    int t = dijkstra();
    cout << t << endl;
}

堆优化版Dijkstra
用优先队列写，每次从后面插进去，堆里有m个数
一个题解

Bellman-Ford算法

for i:1~n
for 所有边a, b, w a→b
dist[b] = min(dist[b], dist[a] + w);
循环n次后，对于所有的边都满足dist[b] ≤dist[a] + w
在这里插入图片描述
最短路题解
出现负权回路（循环一次后权值变小）时，不一定存在最短距离

SPFA算法：对bellman-ford算法的优化

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

using namespace std;
const int N = 100010;

int m, n, idx;
int e[N], w[N], ne[N], h[N];
int dist[N];
bool st[N];
typedef pair<int, int> PII;

void add(int a, int b, int c)  // 添加一条边a->b，边权为c
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}

int spfa()
{
    queue<PII> q;
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    q.push({0, 1});
    st[1] = true;
    while (q.size())
    {
        PII p = q.front();
        q.pop();
        int t = p.second;
        st[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 (!st[j])
                {
                    q.push({dist[j], j});
                    st[j] = true;
                }
            }
        }
    }
    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];    
}

int main()
{
    memset(h, -1, sizeof h);
    cin >> n >> m;
    for (int i = 1; i <= m; i ++ )
    {
        int x, y, z;
        cin >> x >> y >> z;
        add(x, y, z);
    }
    spfa();
    if (dist[n] == 0x3f3f3f3f) puts("impossible");
    else cout << dist[n] << endl;
}

多源汇最短路

	for (k = 1; k <= n; k++)
		for (i = 1; i <= n; i++)
			for (j = 1; j <= n; j++)
				d(i, j) = min(d(i, j), d(i, k) + d(k, j));

d[k, i, j] 从i只经过1~k这些点到达j的最短距离

作者：小呆呆
链接：https://www.acwing.com/solution/content/6337/
f[i, j, k]表示从i走到j的路径上除i和j点外只经过1到k的点的所有路径的最短距离。那么f[i, j, k] = min(f[i, j, k - 1), f[i, k, k - 1] + f[k, j, k - 1]。
因此在计算第k层的f[i, j]的时候必须先将第k - 1层的所有状态计算出来，所以需要把k放在最外层。
读入邻接矩阵，将次通过动态规划装换成从i到j的最短距离矩阵
在下面代码中，判断从a到b是否是无穷大距离时，需要进行if(t > INF/2)判断，而并非是if(t == INF)判断，原因是INF是一个确定的值，并非真正的无穷大，会随着其他数值而受到影响，t大于某个与INF相同数量级的数即可

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 20010, INF = 1e9;
int n, m, k;
int d[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 ++)
            {
                d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
            }
        }
}
int main()
{
    cin >> n >> m >> k;
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            if (i == j) d[i][j] = 0;
            else d[i][j] = INF; 
        }
    }
    for (int i = 1; i <= m; i++)
    {
        int x, y, z;
        cin >> x >> y >> z;
        d[x][y] = min(d[x][y], z);
    }
    floyd();
    for (int i = 1; i <= k; i++)
    {
        int a, b;
        cin >> a >> b;
        if (d[a][b] > INF / 2) puts("impossible");
        else cout << d[a][b] << endl;
    }
}

朴素prim

dist[i] ← inf
for (i = 0; i < n; i ++)
	t←找到集合外距离最近的点
	用t更新其他点到集合的距离
	st[t] = true

最小生成树是所有最短距离组成的边
在这里插入图片描述
与Dijkstra算法的区别：
dist[j] = min(dist[j], dist[t] + g[t][j]);表示到1号点的最短距离

kruskal算法
①所有边按权重从小到大排序 O(mlogm)
②枚举每条边a——b，权重c O(m)
if a,b不连通
将这条边加入集合中

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 200010;
int n, m, u, v, w;
int p[N];//并查集
struct Edge{
    int u, v, w;
    bool operator < (Edge &W){
        return w < W.w;
    }
}edges[N];

int find(int x)  // 并查集
{
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}

int main()
{
    cin >> n >> m;
    for (int i = 0; i < m; i ++)
    {
        cin >> u >> v >> w;
        edges[i] = {u, v, 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 ++)
    {
        u = edges[i].u, v = edges[i].v, w = edges[i].w;
        u = find(u), v = find(v);
        if (u != v)
        {
            p[u] = v;//合并
            res += w;
            cnt ++;
        }
    }
    if (cnt < n - 1) puts("impossible");
    else cout << res << endl;
    return 0;
}

关于并查集的讲解

qq_41699013
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AcWing算法基础课模板大全
07-14
【AcWing算法基础课模板大全】是一门涵盖了基础算法、数据结构以及相关代码模板的课程，旨在帮助学习者熟练掌握编程中常见的算法和数据结构的实现。以下将详细阐述这些知识点： ### 1. 基础算法 **快速排序算法...
建议收藏算法基础课模板大全
08-12
基础算法 —— 代码模板链接 常用代码模板1——基础算法 排序 二分 高精度 前缀和与差分 双指针算法 位运算 离散化 区间合并 数据结构 —— 代码模板链接 常用代码模板2——数据结构 链表与邻接表：树与图的存储 ...
算法基础课：第三讲——搜索与图论
m0_52806260的博客
07-17 259
包括DFS、BFS、树与图的深度优先遍历、树与图的广度优先遍历、拓扑排序、Dijkstra、Bellman-ford、SPFA、Floyd、Prim、Kruskal、染色法判定二分图、匈牙利算法
Acwing-算法基础课——图论篇 代码模板大全
m0_64177548的博客
07-29 442
Acwing-算法基础课——图论篇 代码模板大全
acwing算法基础课：最小生成树和二分图算法分类
qq_42216575的博客
10-26 131
最小生成树和二分图算法
acwing算法基础课：二分图算法（匈牙利算法）
qq_42216575的博客
10-29 163
匈牙利算法模板 时间复杂度是 O(nm), n 表示点数，m表示边数 int n1, n2; // n1表示第一个集合中的点数，n2表示第二个集合中的点数 int h[N], e[M], ne[M], idx; // 邻接表存储所有边，匈牙利算法中只会用到从第一个集合指向第二个集合的边，所以这里只用存一个方向的边 int match[N]; // 存储第二个集合中的每个点当前匹配的第一个集合中的点是哪个 bool st[N]; // 表示第二个集合中的每个点是否已经被遍
acwing算法基础课：最短路算法（floyd算法）
qq_42216575的博客
10-25 282
floyd算法模版 时间复杂度是 O(n3), n表示点数 初始化： for (int i = 1; i <= n; i ++ ) for (int j = 1; j <= n; j ++ ) if (i == j) d[i][j] = 0; else d[i][j] = INF; // 算法结束后，d[a][b]表示a到b的最短距离 void floyd() { for (int k = 1; k <=
acwing算法基础课：最短路算法（spfa算法）
qq_42216575的博客
10-24 223
spfa算法模版 时间复杂度 平均情况下 O(m)，最坏情况下 O(nm), n 表示点数，m 表示边数 int n; // 总点数 int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边 int dist[N]; // 存储每个点到1号点的最短距离 bool st[N]; // 存储每个点是否在队列中 // 求1号点到n号点的最短路距离，如果从1号点无法走到n号点则返回-1 int spfa() { memset(
acwing算法基础课：最小生成树算法（Kruskal算法）
qq_42216575的博客
10-27 310
Kruskal算法模版 时间复杂度是 O(mlogm), n 表示点数，m 表示边数 int n, m; // n是点数，m是边数 int p[N]; // 并查集的父节点数组 struct Edge // 存储边 { int a, b, w; bool operator< (const Edge &W)const { return w < W.w; } }edges[M]; int find(int
acwing算法基础课：区间DP（石子合并）
qq_42216575的博客
11-11 211
区间DP:石子合并 设有N堆石子排成—排，其编号为1，2，3,…，N。 每堆石子有一定的质量，可以用一个整数来描述，现在要将这N堆石子合并成为一堆。 每次只能合并相邻的两堆，合并的代价为这两堆石子的质量之和，合并后与这两堆石子相邻的石子将和新堆相邻，合并时由于选择的顺序不同，合并的总代价也不相同。 例如有4堆石子分别为1352，我们可以先合并1、2堆，代价为4，得到452，又合并1，2堆，代价为9，得到92，再合并得到11，总代价为4+9+11=24; 如果第二步是先合并2，3堆，则代价为7，得到47，最后
acwing算法基础课：线性DP(数字三角形)
qq_42216575的博客
11-06 99
线性dp：数字三角形 给定一个如下图所示的数字三角形，从顶部出发，在每一结点可以选择移动至其左下方的结点或移动至其右下方的结点，一直走到底层，要求找出一条路径，使路径上的数字的和最大。 7 3 8 8 1 0 2 7 4 4 4 5 2 6 5 #include <iostream> using namespace std; const int N = 1010, INF = 1e9; int n; int a[N][N]; int f[N][N]; int main() { cin
class1_算法基础课_左神_
09-29
《算法基础课——左神解析》 在编程领域，算法是解决问题的核心，它如同一把精巧的钥匙，能够高效地解锁复杂的问题。本课程“class1_算法基础课_左神_”由知名的编程导师“左神”主讲，旨在为初学者提供坚实的算法...
acwing基础算法模板整理
02-27
"acwing基础算法模板整理"是一个集合，包含了各种基础算法、数据结构、图论和数学知识的详细讲解和实例，旨在帮助学习者巩固和提升这些核心技能。 首先，我们来深入探讨一下**基础算法**。基础算法通常涵盖排序、...
图论基础 acm 算法
05-24
在“图论基础 ACM 算法”课程中，我们首先会接触到图的基本概念。图是由顶点（或节点）和边组成的结构，用于表示对象之间的关系。边可以是有向的（箭头指向一个方向）或无向的（没有箭头，两边对称）。在图论中，...
【代码随想录_Day27】509 斐波那契数 70 爬楼梯 746 使用最小花费爬楼梯
最新发布
qq_43671872的博客
07-08 853
509 斐波那契数70 爬楼梯746 使用最小花费爬楼梯今天的题目难度不低，尽量还是写一些简洁代码 ^ _ ^
【排序算法】插入排序（希尔排序）
2301_80555259的博客
07-07 684
直接插入排序是一种简单的插入排序法，其核心思想是对一个已经有序的序列插入一个数据，该数据依次比较有序序列中的值，直到插入到合适的位置。在我们玩扑克牌整理牌序的时候，用到的就是直接插入排序的思想。
十一、作业
weixin_58543820的博客
07-07 492
计算1/1-1/2+1/3-1/4+1/5 ……+ 1/99 - 1/100 的值，打印出结果。编写程序数一下 1到 100 的所有整数中出现多少个数字9。要求：找到了就打印数字所在的下标，找不到则输出：找不到。写一个代码打印1-100之间所有3的倍数的数字。编写代码在一个整形有序数组中查找具体的某个数。打印1000年到2000年之间的闰年。写代码将三个整数数按从大到小输出。给定两个数，求这两个数的最大公约数。最小公倍数=a*b/最大公约数。在屏幕上输出9*9乘法口诀表。%-2d - 左对齐。
每周算法：无向图的双连通分量
少儿编程乔老师
07-06 1237
通过Tarjan算法求无向连通图的双连通分量，计算至少添加多少条边可以将原图变为一个双连通分量。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值