【代码随想录训练营第42期 Day57打卡 - 图论Part7 - Prim算法与Kruskal算法

目录

一、Prim算法

二、题目与题解

[题目:卡码网 53. 寻宝](#题目:卡码网 53. 寻宝)

题目链接

题解1:Prim算法

题解2:Prim算法优化

题解3:Kruskal算法

三、小结

一、Prim算法与Kruskal算法

Prim算法 是一种贪心算法,用于求解加权无向图的最小生成树问题。其中,最小生成树是指一个边的子集,它连接图中的所有顶点,且边的总权重最小,并且没有形成环。

Kruskal算法是一种用于寻找加权无向图的最小生成树的贪心算法。所谓最小生成树,是指在保证图中的所有顶点都通过边相连的前提下,所有边的权重之和最小的树形结构。

对于Prim算法和Kruskal算法的简单了解,这里推荐看看:【图-最小生成树-Prim(普里姆)算法和Kruskal(克鲁斯卡尔)算法】

二、题目与题解

题目:卡码网 53. 寻宝

题目链接

53. 寻宝(第七期模拟笔试) (kamacoder.com)

题目描述

在世界的某个区域,有一些分散的神秘岛屿,每个岛屿上都有一种珍稀的资源或者宝藏。国王打算在这些岛屿上建公路,方便运输。

不同岛屿之间,路途距离不同,国王希望你可以规划建公路的方案,如何可以以最短的总公路距离将 所有岛屿联通起来(注意:这是一个无向图)。

给定一张地图,其中包括了所有的岛屿,以及它们之间的距离。以最小化公路建设长度,确保可以链接到所有岛屿。

输入描述

第一行包含两个整数V 和 E,V代表顶点数,E代表边数 。顶点编号是从1到V。例如:V=2,一个有两个顶点,分别是1和2。

接下来共有 E 行,每行三个整数 v1,v2 和 val,v1 和 v2 为边的起点和终点,val代表边的权值。

输出描述

输出联通所有岛屿的最小路径总距离

输入示例

7 11
1 2 1
1 3 1
1 5 2
2 6 1
2 4 2
2 3 2
3 4 1
4 5 1
5 6 2
5 7 1
6 7 1

输出示例

6

提示信息

数据范围:

2 <= V <= 10000;

1 <= E <= 100000;

0 <= val <= 10000;

如下图,可见将所有的顶点都访问一遍,总距离最低是6.

题解1:Prim算法

建议先看视频了解了Prim算法的实现步骤再看以下思路和步骤。

基本思路:

1.选择一个起始顶点,将其标记为已访问,并将其距离设置为0,其他顶点的距离设置为无穷大

2.创建一个循环,直到所有顶点都被访问:

初始化一个变量来记录当前最小边的权重,将其设置为无穷大。

初始化两个变量来记录最小边的两个顶点。

3.遍历所有已访问顶点,对于每个已访问顶点,遍历它的所有邻接顶点:

如果邻接顶点未被访问,并且连接这两个顶点的边的权重小于当前记录的最小边权重,则更新最小边权重和对应的两个顶点。

将找到的最小边加入到最小生成树中,并标记连接的非最小生成树顶点为已访问。 更新该顶点的所有邻接顶点到最小生成树的最短距离。

4.当所有顶点都被访问后,算法结束,此时最小生成树由记录的所有边组成。

cpp 复制代码
#include <bits/stdc++.h>
using namespace std;

int main()
{
    int v, e;
    int x, y, k;
    cin >> v >> e;                                              // 输入顶点数v(注意范围是:1 - v)和边数e
    vector<vector<int>> grid(v + 1, vector<int>(v + 1, 10001)); // 二维数组grid,用于存储图的邻接矩阵,初始值为10001(表示无穷大)
    while (e--)
    {
        cin >> x >> y >> k; // 输入边的两个顶点和权值
        // 因为是双向图,所以两个方向都要填上
        grid[x][y] = k;
        grid[y][x] = k;
    }
    // 用于存储每个顶点到最小生成树的最短距离 -- 由于顶点数为v,这里大小设置为v+1
    vector<int> minDist(v + 1, 10001);
    // 初始化第一个顶点到最小生成树的距离为0
    minDist[1] = 0;

    // 用于标记顶点是否已经在最小生成树中
    vector<bool> isInTree(v + 1, false);

    // 我们只需要循环 n-1次,因为最小生成树有v-1条边,这样就可以把n个节点的图连在一起
    for (int i = 1; i < v; i++)
    {
        // 选择距离最小生成树最近的顶点
        int cur = -1;                // 当前选中的顶点 -- 最终选中的cur节点即是加入最小生成树的最近节点
        int minVal = INT_MAX;        // 当前最小距离,初始化为无穷大
        for (int j = 1; j <= v; j++) // 顶点编号:1 - v
        {
            if (!isInTree[j] && minDist[j] < minVal) // 选择不在最小生成树中且距离最小的顶点
            {
                minVal = minDist[j];
                cur = j;
            }
        }
        // 最近节点(cur)加入生成树
        isInTree[cur] = true;

        // 更新非生成树节点到生成树的距离(即更新minDist数组):由于新加入了cur节点,这里只需要多考虑cur与不在最小生成树的节点的距离即可
        for (int j = 1; j <= v; j++)
        {
            if (!isInTree[j] && grid[cur][j] < minDist[j]) // 如果顶点j不在生成树中,并且通过cur到j的距离小于当前记录的最短距离,则更新
            {
                minDist[j] = grid[cur][j];
            }
        }
    }
    int ans = 0;                 // 统计结果
    for (int i = 2; i <= v; i++) // 累加每个顶点到生成树的最短距离,注意从第二个顶点开始累加,因为第一个顶点距离为0
    {
        ans += minDist[i];
    }
    cout << ans << endl;
}
题解2:Prim算法优化

这题还可以用优先队列(堆)进行优化,这也是Prim算法最经典的使用方法:

算法思路:

PRIM(G, w, s):

  1. for each u in G.V:

u.key = INFINITY

u.pi = NIL

  1. s.key = 0

  2. Q = G.V (创建一个顶点的优先队列,初始时包含所有顶点)

  3. while Q is not empty:

u = EXTRACT-MIN(Q) (从Q中取出具有最小key值的顶点)

for each v in G.Adj[u]: (遍历顶点u的所有邻接顶点v)

if v in Q and w(u, v) < v.key:

v.pi = u

v.key = w(u, v)

其中:G表示图,w表示边的权重函数,s是起始顶点。u.key表示顶点u到最小生成树的最短边权重,u.pi表示在最小生成树中顶点u的前驱顶点。

代码如下:

cpp 复制代码
#include <bits/stdc++.h>
using namespace std;

int main()
{
    int v, e;
    cin >> v >> e; // 输入顶点数v和边数e

    // 使用邻接矩阵存储图的边信息,初始化为无穷大
    vector<vector<int>> grid(v + 1, vector<int>(v + 1, INT_MAX));

    // 读取边的信息
    for (int i = 1; i <= e; ++i)
    {
        int x, y, k;
        cin >> x >> y >> k; // 输入边的两个顶点和权值
        grid[x][y] = k;
        grid[y][x] = k;
    }

    // 使用优先队列来存储顶点及其到最小生成树的最短距离
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;

    // 用于存储每个顶点到最小生成树的最短距离,初始化为无穷大
    vector<int> minDist(v + 1, INT_MAX);
    minDist[1] = 0; // 第一个顶点到最小生成树的距离为0

    // 标记顶点是否已经在最小生成树中
    vector<bool> isInTree(v + 1, false);

    // 将第一个顶点加入优先队列
    pq.push({0, 1});

    while (!pq.empty())
    {
        // 从优先队列中取出距离最小生成树最近的顶点
        int cur = pq.top().second;
        pq.pop();

        // 如果该顶点已经在最小生成树中,则跳过
        if (isInTree[cur])
            continue;

        // 将该顶点标记为已加入最小生成树
        isInTree[cur] = true;

        // 更新邻接顶点到最小生成树的最短距离
        for (int j = 1; j <= v; ++j)
        {
            if (!isInTree[j] && grid[cur][j] < minDist[j])
            {
                minDist[j] = grid[cur][j];
                pq.push({minDist[j], j}); // 将更新后的顶点和距离加入优先队列
            }
        }
    }

    // 计算最小生成树的总权重
    int ans = 0;
    for (int i = 2; i <= v; ++i)
    {
        ans += minDist[i];
    }

    cout << ans << endl; // 输出最小生成树的总权重
    return 0;
}
题解3:Kruskal算法

对应Kruskal算法,一般按照以下思路进行:

KRUSKAL(G)算法思路 :

  1. 将G中的所有边按权重从小到大排序。

  2. 初始化森林F,使得每个顶点都是一个独立的树。

  3. for each 边(u, v) in G的边列表,按权重从小到大:

a. 查找u所在的树的根节点。

b. 查找v所在的树的根节点。

c. if u和v的根节点不同(即不会形成环):

i. 将边(u, v)加入森林F。

ii. 合并u和v所在的树。

  1. 返回森林F,即为最小生成树。

其中某些步骤的实现即是前缀和的几个基本操作,之前有提到,这里不多做解释。

代码如下:

cpp 复制代码
#include <bits/stdc++.h>
using namespace std;

int n = 1001;
vector<int> father(n, 0); // 并查集数组:节点编号是从1开始的

// l,r为 边两边的节点,val为边的数值
struct Edge
{
    int l, r, val;
};

// 并查集初始化
void init()
{
    for (int i = 1; i <= n; i++)
        father[i] = i;
}

// 并查集里寻找该节点的根节点(带路径压缩)
int find(int u)
{
    if (u != father[u])
        father[u] = find(father[u]);
    return father[u];
}

// join 函数用于合并两个节点所在的集合:将v-u这条边加入并查集
void join(int u, int v)
{
    int rootu = find(u);
    int rootv = find(v);
    if (rootu != rootv)
        father[rootv] = rootu;
}

int main()
{

    int v, e;
    int v1, v2, val;
    vector<Edge> edges; // edges数组存放所有边 -- 每个元素都是Edge结构(l,r,val)
    int ans = 0;
    cin >> v >> e;
    while (e--)
    {
        cin >> v1 >> v2 >> val;
        edges.push_back({v1, v2, val});
    }

    // Kruskal算法
    // 1.按边的权值对边进行从小到大排序
    sort(edges.begin(), edges.end(), [](const Edge &a, const Edge &b)
         { return a.val < b.val; });
    // 2.并查集初始化
    init();

    for (Edge edge : edges) // 3.从头开始遍历边:按边的权重从小到大
    {
        // 4.并查集,搜出两个节点u和v所在树的根节点 -- 确保不会形成环
        int rootu = find(edge.l);
        int rootv = find(edge.r);

        // 5.如果u,v根节点不同 -- 即不会形成环(注意)
        if (rootu != rootv)
        {
            ans += edge.val;    // 6.这条边u-v加入生成树
            join(rootu, rootv); // 7.合并u,v所在的树:两个节点加入到同一个集合
        }
    }
    cout << ans << endl;
    return 0;
}

三、小结

至此完善了这天的打卡,后边会继续加油!

相关推荐
好奇龙猫4 分钟前
【学习AI-相关路程-mnist手写数字分类-win-硬件:windows-自我学习AI-实验步骤-全连接神经网络(BPnetwork)-操作流程(3) 】
人工智能·算法
sp_fyf_202440 分钟前
计算机前沿技术-人工智能算法-大语言模型-最新研究进展-2024-11-01
人工智能·深度学习·神经网络·算法·机器学习·语言模型·数据挖掘
香菜大丸1 小时前
链表的归并排序
数据结构·算法·链表
jrrz08281 小时前
LeetCode 热题100(七)【链表】(1)
数据结构·c++·算法·leetcode·链表
oliveira-time1 小时前
golang学习2
算法
南宫生2 小时前
贪心算法习题其四【力扣】【算法学习day.21】
学习·算法·leetcode·链表·贪心算法
懒惰才能让科技进步3 小时前
从零学习大模型(十二)-----基于梯度的重要性剪枝(Gradient-based Pruning)
人工智能·深度学习·学习·算法·chatgpt·transformer·剪枝
Ni-Guvara3 小时前
函数对象笔记
c++·算法
泉崎3 小时前
11.7比赛总结
数据结构·算法
你好helloworld3 小时前
滑动窗口最大值
数据结构·算法·leetcode