算法基础课：图论

最新推荐文章于 2024-07-01 22:56:08 发布
最新推荐文章于 2024-07-01 22:56:08 发布
阅读量109 收藏
点赞数
分类专栏： 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
    评论
专栏目录
算法学习：图论
曹老师
10-20 421
1
算法基础课
weixin_44920293的博客
06-13 158
List item acwing算法基础 1.2 前缀和差分 大整数之和模板 #include<iostream> #include<vector> using namespace std; const int N=1e6+10; //c=A+B vector<int> add(vector<int> &A,vector<int> &B) { vector <int> C; int t =.
算法基础课：第三讲——搜索与图论
m0_52806260的博客
07-17 251
包括DFS、BFS、树与图的深度优先遍历、树与图的广度优先遍历、拓扑排序、Dijkstra、Bellman-ford、SPFA、Floyd、Prim、Kruskal、染色法判定二分图、匈牙利算法
Acwing-算法基础课——图论篇 代码模板大全
m0_64177548的博客
07-29 438
Acwing-算法基础课——图论篇 代码模板大全
AcWing算法基础课模板大全
07-14
基础算法 —— 代码模板链接 常用代码模板1——基础算法 排序 二分 高精度 前缀和与差分 双指针算法 位运算 离散化 区间合并 数据结构 —— 代码模板链接 常用代码模板2——数据结构 链表与邻接表：树与图的存储 ...
建议收藏算法基础课模板大全
08-12
基础算法 —— 代码模板链接 常用代码模板1——基础算法 排序 二分 高精度 前缀和与差分 双指针算法 位运算 离散化 区间合并 数据结构 —— 代码模板链接 常用代码模板2——数据结构 链表与邻接表：树与图的存储 ...
acwing基础算法模板整理
02-27
算法整理，包括但不限于基础算法，数据结构，搜索图论以及数学知识
图论基础 acm 算法
05-24
在“图论基础 ACM 算法”课程中，我们首先会接触到图的基本概念。图是由顶点（或节点）和边组成的结构，用于表示对象之间的关系。边可以是有向的（箭头指向一个方向）或无向的（没有箭头，两边对称）。在图论中，...
算法的力量 李开复
08-28
图论里有不少算法可以解决这个问题。这么做也许是最直观的，但绝对不是最迅速的。如果一个城市只有为数不多的咖啡馆，那么这么做应该没什么问题，反正计算量不大。但如果一个城市里有很多咖啡馆，又有很多用户都需要...
leetcode 403周赛 包含所有1的最小矩形面积||「暴力」
Suryxin's blogs
07-01 583
leetcode 403周赛 包含所有1的最小矩形面积||「暴力」
69. x 的平方根（简单）
最新发布
用魔法打败魔法，走楼梯啊！
07-01 746
对于此题，是计算算术平方根的整数部分，因此等价于寻找首次平方之和大于x的数，该数减1即为x的算术平方根（假定x的算术平方根为y.z,其中y为整数部分，z为小数部分，y*y的结果是小于x，而(y+1）*(y+1)是大于x的）。不能使用系统内置的函数，寻找某个数（假定为x）的算术平方根，并返回算术平方根的整数部分，最直观的方法是从0依次开始尝试所有小于等于x的数（假定为y），当y*y的积小于等于x时，继续遍历下一个数，直至y*y的积首次大于x时，此时y-1即为x的算术平方根的整数部分，如。
【算法——快慢指针&链表】
2301_76758064的博客
06-30 153
2—针对19这道力扣例题：会有一些变故：就是长度为1的情况；这时next->next就会报错，所以要设置一个新的链表，即在题目给我们的前面加一个节点（new）1—p2指针先走k步，然后p1和p2都1/s；直到p2走完时（p2->next==NULL），p1->next即为所删。快指针2/s，慢指针1/s；快指针前进要求：当前的下一个都是非空；快指针不满足时，慢指针所指就是中点。快慢指针一开始都在开头，快指针2/s，慢指针1/s；3—这道题很多解法，看力扣历史题解（画个图就通透了）
day54--面试专题（基础篇）
ZHUSHANGLIN的博客
06-28 1061
有一个有序表为 1,5,8,11,19,22,31,35,40,45,48,49,50 当二分查找值为 48 的结点时，查找成功需要比较的次数。使用二分法在序列 1,4,6,7,15,33,39,50,64,78,75,81,89,96 中查找元素 81 时，需要经过（ ）次比较。② A[M] > T，中间值右侧的其它元素都大于 T，无需比较，中间索引左边去找，M - 1 设置为右边界，重新查找。将数组分为两个子集，排序的和未排序的，每一轮从未排序的子集中选出最小的元素，放入排序子集。
【408考点之数据结构】顺序查找和折半查找
gygkhd的博客
07-01 344
顺序查找（Sequential Search），也称线性查找，是一种最简单、最直接的查找方法。它从数据集的第一个元素开始，逐个检查每个元素，直到找到目标元素或检查完整个数据集。
【代码随想录算法训练营第五十五天|742.接雨水、84.柱状图中最大的矩形】
weixin_46281930的博客
07-01 113
用单调栈来保存遍历过的木板，保持栈底到栈头从大到小的顺序，如果新的木板大于栈头的木板，则出栈，该木板决定了现在这个木桶的桶底的高度，然后还需要再判断一次栈是否为空，只有不为空的时候才能再取到左木板，使用这三块木板算出当前桶的存水量。其实感觉和双指针关系不大（如果是优化前的版本确实是双指针），因为每一个木块位置能存放的水的数量取决于他所处位置的水平线，水平线则是由它的向左找到的最大值和向右找到的最大值中的短板，拿水平线减去木板高度就是这个位置能找到的最大储水。
【算法题解】部分洛谷题解(下)
m0_72845244的博客
07-01 617
本篇为我做过的洛谷题的部分题解，大多是我认为比较具有代表性的或者比较有意思的题目，包含我自己的思考过程和想法。
JAVA期末速成库（7）第七、八章
m0_73399576的博客
06-27 860
JAVA期末复习宝典（7）第七、八章
《Unity3D高级编程之进阶主程》第一章 C#要点技术(五) 排序算法
仁希的博客
06-25 617
基础能力决定你到底能走多远。我们不是写一两年程序就完事了，从毕业算起，我们可能要写20-30年的程序，这段漫长的长跑路程中，最终比的不是谁熟悉API比较多，也不是谁用插件用的有多熟练，更不是比谁更熟悉某软件，而是。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值