图的最小生成树之Kruskal算法

图的最小生成树之Prim算法及Kruskal算法 最小生成树 定义:无向图连通图G中,由所有顶点构成且总价值(连接权值和)最低的一棵树(拓扑结构)称为一个最小生成树。 最小生成树顶点为|V|个,边数为|V|-1,没有圈。 对任一生成树T,如果将图中一条不属于T的边添加至T,则会产生一个圈,从该圈中除去任意一条边,则会又恢复成生成树。 下图为一示例: 对于上面的无向有权连通图,其最小生成树为: 解决最小生成树问题有两种算法Prim算法和... 阅读详情

参考:https://wangkuiwu.github.io/2013/04/12/kruskal-cplus

Kruskal算法介绍

克鲁斯卡尔(Kruskal)算法,和普利姆(Prim)算法类似,也是用来求加权连通图的最小生成树的算法。关于最小生成树的概念,已经在之前的图的最小生成树之Prim算法篇首介绍过。

Kruskal 与 Prim 算法思想出发点不同,Prim 算法是以顶点出发的,而 Kruskal 算法是以边出发的。

其算法思想是:按照权值从小到大的顺序选择 n-1 条边,并保证这 n-1 条边不构成回路。

其具体做法是:首先构造一个只含 n 个顶点的森林,然后依权值从小到大从连通网中选择边加入到森林中,并使森林中不产生回路,直至森林变成一棵树为止。

Kruskal算法图解

还是以 Prim 中的图 G4 为例:

Kruskal算法-图1

图 G4

来对 Kruskal 进行演示如下(假设用数组 R 保存最小生成树结果)。

Kruskal算法-图2

第 1 步:将边 <E, F> 加入到 R 中。边 <E, F> 的权值最小,因此将他们加入到最小生成树结果中。

第 2 步:将边 <C, D> 加入到 R 中,上一步操作之后,边 <C, D> 的权值最小,因此将它加入到最小生成树结果 R 中。

第 3 步:将边 <D, E> 加入到 R 中,上一步操作之后,边 <D, E> 的权值最小,因此将它加入到最小生成树结果 R 中。

第 4 步:将边 <B, F> 加入到 R 中,上一步操作之后,边 <C, E> 的权值最小,但 <C, E> 会和已有的边构成回路,因此,跳过边 <C, E>。同理,跳过边 <C, F>。

第 5 步:将边 <E, G> 加入到 R 中,上一步操作之后,边 <E, G> 的权值最小,因此将它加入到最小生成树结果 R 中。

第 6 步:将边 <A, B> 加入到 R 中,上一步操作之后,边 <F, G> 的权值最小,但 <F, G> 会和已有的边构成回路,因此,跳过边 <F, G>。同理,跳过边 <B, C>。最后将边 <A, B> 加入到最小生成树结果 R 中。

Kruskal算法分析

根据前面介绍的克鲁斯卡尔算法的基本思想和做法,就能够了解到,克鲁斯卡尔算法重点需要解决的以下两个问题:

问题 1:对图的所有边按照权值大小进行排序。

问题 2:将边添加到最小生成树中时,怎么判断是否形成了回路。

问题一很好解决,直接采用排序算法进行排序即可。

问题二处理方式是:记录顶点在“最小生成树”中的终点,顶点的终点是“在最小生成树中与它连通的最大顶点”(关于这一点,后面会通过图片给出说明)。然后每次需要将一条边添加到最小生成树时,判断该边的两个顶点的终点是否重合,重合的话则会构成回路。 以下图来进行说明:

Kruskal算法-图3

在将 <E, F>、<C, D>、<D, E> 加入到最小生成树 R 中之后,这几条边的顶点都有了终点:

C 的终点是 F。

D 的终点是 F。

E 的终点是 F。

F 的终点是 F。

关于终点,就是将所有的顶点按照从小到大的顺序排序好之后,某个顶点的终点就是“与它连通的最大顶点”。因此,接下来,虽然 <C, E> 是权值最小的边。但是 C 和 E 的终点都是 F,即它们的终点相同,因此,将 <C, E> 加入到最小生成树的话,会形成回路,这就是判断回路的方式。

注:这里有些文章对获得顶点的终点的描述是使用并查集,如果 arr 为并查集数组,将边 <E, F> 加入时,arr[E] = F,即把并查集中 E 下标的值改为 F,如果 arr[C] = D,arr[D] = E ,那么查询 arr[C] 和 arr[D] 的终点就是 F(注意:需要按照顶点的顺序将其插入,比如边 <E, F>,因为 E < F,所以必须 E 作为起点,F 作为终点)。其步骤如下:

比如原来的并查集中都是初始值:
A -> A
B -> B
C -> C
D -> D
E -> E
F -> F
G -> G
最小生成树结果中加入:<E, F>
将并查集中E对应的值改为F
A -> A
B -> B
C -> C
D -> D
E -> F
F -> F
G -> G
最小生成树结果中加入:<C, D>
将并查集中C对应的值改为D
A -> A
B -> B
C -> D
D -> D
E -> F
F -> F
G -> G
最小生成树结果中加入:<D, E>
将并查集中D对应的值改为E
A -> A     A -> A
B -> B     B -> B
C -> D     C -> D
D -> D     D -> E
E -> F     E -> F
F -> F     F -> F
G -> G     G -> G
查询C和D的终点就是F

Kruskal算法实现

图的邻接矩阵实现Kruskal算法

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

#define MAX 100
#define INF (~(0x1 << 31)) //无穷大(0x7FFFFFFF)

const int VEXNUM = 7;

struct EData
{
    char start; //边的起点
    char end;   //边的终点
    int weight; //边的权重

    EData() {}
    EData(char s, char e, int w) : start(s), end(e), weight(w) {}
};

class MatrixUDG
{
private:
    char mVexs[MAX];       //顶点集合,如:{'A', 'B', 'C', 'D', 'E', 'F', 'G'};
    int mVexNum;           //顶点数,如:7
    int mEdgNum;           //边数
    int mMatrix[MAX][MAX]; //邻接矩阵
public:
    //创建图(手动输入)
    MatrixUDG();
    //创建图(用提供的矩阵)
    MatrixUDG(char *vexs, int vNum, int matrix[][VEXNUM]);
    ~MatrixUDG();
    //打印邻接表
    void print();
    //Kruskal最小生成树
    void Kruskal();

private:
    //输入一个合法字母
    char readChar();
    //获得一个字母在顶点数组的下标
    int getPosition(char ch);
    //返回顶点v的第一个邻接顶点的索引,失败返回-1
    int firstVertex(int v);
    //范围顶点v相对于w的下一个邻接顶点的索引,失败返回-1
    //比如: A和C, D, E有连接,则A相对于C的下一个结点为D,即返回D的索引
    int nextVertex(int v, int w);
    //获取图中的边
    EData *getEdge();
    //对边按照权值从小到大进行排序
    void sortEdges(EData *edges, int eNum);
    //获取i的终点
    int getEnd(int *vEnds, int i);
};

MatrixUDG::MatrixUDG()
{
    char c1, c2;
    int p1, p2;
    int i, j;
    int weight;

    cout << "输入顶点数:";
    cin >> mVexNum;
    cout << "输入边数:";
    cin >> mEdgNum;
    if (mVexNum < 1 || mEdgNum < 1 || (mEdgNum > (mVexNum * (mVexNum - 1))))
    {
        cout << "输入有误!" << endl;
        return;
    }
    //初始化顶点
    for (i = 0; i < mVexNum; ++i)
    {
        cout << "vertex(" << i << "):";
        mVexs[i] = readChar();
    }
    //初始化边的权值
    for (i = 0; i < mVexNum; ++i)
    {
        for (j = 0; j < mVexNum; ++j)
        {
            if (i == j)
                mMatrix[i][j] = 0;
            else
                mMatrix[i][j] = INF;
        }
    }
    //初始化边的权值,根据用户输入进行初始化
    for (i = 0; i < mEdgNum; ++i)
    {
        cout << "edge(" << i << "):";
        c1 = readChar();
        c2 = readChar();
        cin >> weight;

        p1 = getPosition(c1);
        p2 = getPosition(c2);
        if (p1 == -1 || p2 == -1)
        {
            cout << "输入的边错误!" << endl;
            return;
        }
        mMatrix[p1][p2] = weight;
        mMatrix[p2][p1] = weight;
    }
}

MatrixUDG::MatrixUDG(char *vexs, int vNum, int matrix[][VEXNUM])
{
    if (!vexs || !*matrix)
        return;
    int i, j;
    mVexNum = vNum;
    //初始化顶点
    for (i = 0; i < mVexNum; ++i)
        mVexs[i] = vexs[i];

    //初始化边
    for (i = 0; i < mVexNum; ++i)
    {
        for (j = 0; j < mVexNum; ++j)
        {
            mMatrix[i][j] = matrix[i][j];
        }
    }

    //统计边的数目
    for (i = 0; i < mVexNum; ++i)
    {
        for (j = 0; j < mVexNum; ++j)
        {
            if (i != j && mMatrix[i][j] != INF)
            {
                ++mEdgNum;
            }
        }
    }
    mEdgNum /= 2;
}

MatrixUDG::~MatrixUDG()
{
}

int MatrixUDG::getPosition(char ch)
{
    for (int i = 0; i < mVexNum; ++i)
    {
        if (mVexs[i] == ch)
            return i;
    }
    return -1;
}

char MatrixUDG::readChar()
{
    char ch;
    do
    {
        cin >> ch;
    } while (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')));
    return ch;
}

/*
返回顶点v的第一个邻接顶点的索引,失败返回-1
*/
int MatrixUDG::firstVertex(int v)
{
    if (v < 0 || v > (mVexNum - 1))
        return -1;
    for (int i = 0; i < mVexNum; ++i)
    {
        if (mMatrix[v][i] != 0 && mMatrix[v][i] != INF)
            return i;
    }
    return -1;
}
/*
返回顶点v相对于w的下一个邻接顶点的索引,失败则返回-1
比如:A和C,D,E有连接,则A相对于C的下一个结点为D,即返回D的索引
*/
int MatrixUDG::nextVertex(int v, int w)
{
    if (v < 0 || v > (mVexNum - 1) || w < 0 || w > (mVexNum - 1))
        return -1;
    for (int i = w + 1; i < mVexNum; ++i)
    {
        if (mMatrix[v][i] != 0 && mMatrix[v][i] != INF)
            return i;
    }
    return -1;
}

//获取图中的边
EData *MatrixUDG::getEdge()
{
    int i, j;
    int index = 0;
    EData *edges = new EData[mEdgNum];
    for (i = 0; i < mVexNum; ++i)
    {
        for (j = i + 1; j < mVexNum; ++j)
        {
            if (mMatrix[i][j] != INF)
            {
                edges[index].start = mVexs[i];
                edges[index].end = mVexs[j];
                edges[index].weight = mMatrix[i][j];
                ++index;
            }
        }
    }
    return edges;
}

//对边按照权值大小进行排序(由小到大)
void MatrixUDG::sortEdges(EData *edges, int eNum)
{
    //直接调用STL排序
    std::sort(edges, edges + eNum, [](EData &edge1, EData &edge2) -> bool
              { return edge1.weight < edge2.weight; });
}

int MatrixUDG::getEnd(int *vEnds, int i)
{
    //相当于并查集的操作
    while (vEnds[i] != 0)
    {
        i = vEnds[i];
    }
    return i;
}

//Kruskal最小生成树算法
void MatrixUDG::Kruskal()
{
    int i;
    int m, n;
    int p1, p2;

    int index = 0;            //rets数组的索引
    int vEnds[MAX] = {0};     //用于保存"已有最小生成树"中每个顶点在该最小生成树中的终点(并查集数组)
    EData rets[MAX];          //结果数组,保存kruskal最小生成树的边
    EData *edges = getEdge(); //图对应的所有边
    //将边按照从小到大的顺序进行排序
    sortEdges(edges, mEdgNum);
    for (i = 0; i < mEdgNum; ++i)
    {
        p1 = getPosition(edges[i].start);
        p2 = getPosition(edges[i].end);
        //并查集操作
        m = getEnd(vEnds, p1); // 获取p1在"已有的最小生成树"中的终点
        n = getEnd(vEnds, p2); // 获取p2在"已有的最小生成树"中的终点
        // 如果m!=n,意味着边i与已经添加到最小生成树中的顶点没有形成环路
        if (m != n)
        {
            vEnds[m] = n;             //设置m在"已有的最小生成树"中的终点为n
            rets[index++] = edges[i]; //保存结果
        }
    }
    delete[] edges;
    //统计并打印"kruskal最小生成树"的信息
    int length = 0;
    for (i = 0; i < index; ++i)
    {
        length += rets[i].weight;
    }
    cout << "Kruskal=" << length << ":";
    for (i = 0; i < index; ++i)
    {
        cout << "(" << rets[i].start << "," << rets[i].end << ")";
    }
    cout << endl;
}

void MatrixUDG::print()
{
    for (int i = 0; i < mVexNum; ++i)
    {
        for (int j = 0; j < mVexNum; ++j)
        {
            if (mMatrix[i][j] == INF)
            {
                cout << "INF"
                     << "\t";
            }
            else
            {
                cout << mMatrix[i][j] << "\t";
            }
        }
        cout << endl;
    }
}

int main()
{
    char vexs[VEXNUM] = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
    int vNum = sizeof(vexs) / sizeof(vexs[0]);
    int matrix[][VEXNUM] = {
        {0, 12, INF, INF, INF, 16, 14},
        {12, 0, 10, INF, INF, 7, INF},
        {INF, 10, 0, 3, 5, 6, INF},
        {INF, INF, 3, 0, 4, INF, INF},
        {INF, INF, 5, 4, 0, 2, 8},
        {16, 7, 6, INF, 2, 0, 9},
        {14, INF, INF, INF, 8, 9, 0}};

    // 1. 根据提供的数据生成
    MatrixUDG mudg(vexs, vNum, matrix);
    mudg.print(); //打印图
    mudg.Kruskal();
    //2. 手动生成
    // MatrixUDG mudg1;
    // mudg1.print();
}

运行结果如下:

$ ./test
0       12      INF     INF     INF     16      14
12      0       10      INF     INF     7       INF
INF     10      0       3       5       6       INF
INF     INF     3       0       4       INF     INF
INF     INF     5       4       0       2       8
16      7       6       INF     2       0       9
14      INF     INF     INF     8       9       0
Kruskal=36:(E,F)(C,D)(D,E)(B,F)(E,G)(A,B)

图的邻接表实现Kruskal算法

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

#define MAX 100
#define INF (~(0x1 << 31)) //无穷大(0x7FFFFFFF)

const int VEXNUM = 7;

#define MAX 100
#define INF (~(0x1 << 31)) //最大值

struct EData
{
    char start; //边的起点
    char end;   //边的终点
    int weight; //边的权重

    EData() {}
    EData(char s, char e, int w) : start(s), end(e), weight(w) {}
};

class ListUDG
{
private:
    //每一条边
    struct ENode
    {
        int iVex = 0;           //指向的顶点的位置
        int weight = 0;         //该边的权
        ENode *nextEdge = NULL; //指向顶点的下一条边的指针
    };
    //数组中存储的顶点
    struct VNode
    {
        char data;
        ENode *firstEdge = NULL; //指向第一条该顶点的边
    };

private:
    int mVexNum;      //图的顶点数目
    int mEdgeNum;     //图的边的数目
    VNode mVexs[MAX]; //存储顶点
public:
    //创建邻接表对应的图(自己收入)
    ListUDG();
    //创建邻接表对应的图(用已提供的数据)
    ListUDG(char *vexs, int vNum, EData *edges[], int eNum);
    ~ListUDG();
    //打印邻接表
    void print();
    //Kruskal最小生成树
    void Kruskal();

private:
    //读取一个合法的输入字符
    char readChar();
    //返回字符ch在的位置
    int getPosition(char ch);
    //将node结点链接到list的最后
    void linkLast(ENode *list, ENode *node);
    //获取边<start, end>的权值,若start和end不是连通的,则返回无穷大
    int getWeight(int start, int end);
    //获取图中的边
    EData *getEdges();
    //对边按照权值从小到大进行排序
    void sortEdges(EData *edges, int eNum);
    //获取i的终点
    int getEnd(int *vEnds, int i);
};

ListUDG::ListUDG()
{
    char c1, c2;
    int p1, p2;
    ENode *node1, *node2;
    int weight;

    cout << "输入顶点数:";
    cin >> mVexNum;
    cout << "输入边数:";
    cin >> mEdgeNum;
    if (mVexNum > MAX || mEdgeNum > MAX || mVexNum < 1 || mEdgeNum < 1 || (mEdgeNum > (mVexNum * (mVexNum - 1))))
    {
        cout << "输入有误!" << endl;
        return;
    }
    //初始化邻接表的顶点
    for (int i = 0; i < mVexNum; ++i)
    {
        cout << "vertex(" << i << "):";
        mVexs[i].data = readChar();
        mVexs[i].firstEdge = NULL;
    }
    //初始化邻接表的边
    for (int j = 0; j < mEdgeNum; ++j)
    {
        cout << "edge(" << j << "):";
        c1 = readChar();
        c2 = readChar();
        cin >> weight;

        p1 = getPosition(c1);
        p2 = getPosition(c2);

        if (p1 == -1 || p2 == -1)
        {
            cout << "输入的边有错误!" << endl;
            return;
        }
        //初始化node1
        node1 = new ENode();
        node1->iVex = p2;
        node1->weight = weight;
        //将node1链接到p1所在链表的末尾
        if (mVexs[p1].firstEdge == NULL)
            mVexs[p1].firstEdge = node1;
        else
            linkLast(mVexs[p1].firstEdge, node1);
        //初始化node2
        node2 = new ENode();
        node2->iVex = p1;
        node2->weight = weight;
        //将node2链接到p2所在链表的末尾
        if (mVexs[p2].firstEdge == NULL)
            mVexs[p2].firstEdge = node2;
        else
            linkLast(mVexs[p2].firstEdge, node2);
    }
}

ListUDG::ListUDG(char *vexs, int vNum, EData *edges[], int eNum)
{
    if (vNum > MAX || eNum > MAX)
        return;
    char c1, c2;
    int p1, p2;
    ENode *node1, *node2;
    int weight;
    //初始化顶点数和边数
    mVexNum = vNum;
    mEdgeNum = eNum;
    //初始化邻接表的顶点
    for (int i = 0; i < mVexNum; ++i)
    {
        mVexs[i].data = vexs[i];
        mVexs[i].firstEdge = NULL;
    }
    //初始化邻接表的边
    for (int j = 0; j < mEdgeNum; ++j)
    {
        //读取边的起始顶点和结束顶点
        c1 = edges[j]->start;
        c2 = edges[j]->end;
        weight = edges[j]->weight;

        p1 = getPosition(c1);
        p2 = getPosition(c2);
        if (p1 == -1 || p2 == -1)
        {
            cout << "输入的边有错误!" << endl;
            return;
        }
        //初始化node1
        node1 = new ENode();
        node1->iVex = p2;
        node1->weight = weight;
        //将node1链接到p1所在的链表末尾
        if (mVexs[p1].firstEdge == NULL)
            mVexs[p1].firstEdge = node1;
        else
            linkLast(mVexs[p1].firstEdge, node1);
        //初始化node2
        node2 = new ENode();
        node2->iVex = p1;
        node2->weight = weight;
        //将node2链接到p2所在链表末尾
        if (mVexs[p2].firstEdge == NULL)
            mVexs[p2].firstEdge = node2;
        else
            linkLast(mVexs[p2].firstEdge, node2);
    }
}

ListUDG::~ListUDG()
{
}

void ListUDG::linkLast(ENode *list, ENode *node)
{
    ENode *p = list;
    while (p->nextEdge)
        p = p->nextEdge;
    p->nextEdge = node;
}

int ListUDG::getPosition(char ch)
{
    for (int i = 0; i < mVexNum; ++i)
    {
        if (mVexs[i].data == ch)
            return i;
    }
    return -1;
}

char ListUDG::readChar()
{
    char ch;
    do
    {
        cin >> ch;
    } while (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')));
    return ch;
}

int ListUDG::getWeight(int start, int end)
{
    if (start == end)
        return 0;
    ENode *node = mVexs[start].firstEdge;
    while (node != NULL)
    {
        if (end == node->iVex)
        {
            return node->weight;
        }
        node = node->nextEdge;
    }
    return INF;
}

//获得图中的边
EData *ListUDG::getEdges()
{
    int i;
    int index = 0;
    ENode *node = NULL;
    EData *edges = new EData[mEdgeNum];
    for (i = 0; i < mVexNum; ++i)
    {
        node = mVexs[i].firstEdge;
        while (node != NULL)
        {
            if (node->iVex > i)
            {
                edges[index].start = mVexs[i].data;
                edges[index].end = mVexs[node->iVex].data;
                edges[index].weight = node->weight;
                ++index;
            }
            node = node->nextEdge;
        }
    }
    return edges;
}

//对边按照权值大小进行排序(由小到大)
void ListUDG::sortEdges(EData *edges, int eNum)
{
    if (!edges)
        return;
    //直接调用STL排序
    std::sort(edges, edges + eNum, [](EData &edge1, EData &edge2) -> bool
              { return edge1.weight < edge2.weight; });
}

int ListUDG::getEnd(int *vEnds, int i)
{
    //相当于并查集的操作
    while (vEnds[i] != 0)
    {
        i = vEnds[i];
    }
    return i;
}

//Kruskal最小生成树算法
void ListUDG::Kruskal()
{
    int i;
    int m, n;
    int p1, p2;

    int index = 0;             //rets数组的索引
    int vEnds[MAX] = {0};      //用于保存"已有最小生成树"中每个顶点在该最小生成树中的终点(并查集数组)
    EData rets[MAX];           //结果数组,保存kruskal最小生成树的边
    EData *edges = getEdges(); //图对应的所有边
    //将边按照从小到大的顺序进行排序
    sortEdges(edges, mEdgeNum);
    for (i = 0; i < mEdgeNum; ++i)
    {
        p1 = getPosition(edges[i].start);
        p2 = getPosition(edges[i].end);
        //并查集操作
        m = getEnd(vEnds, p1); // 获取p1在"已有的最小生成树"中的终点
        n = getEnd(vEnds, p2); // 获取p2在"已有的最小生成树"中的终点
        // 如果m!=n,意味着边i与已经添加到最小生成树中的顶点没有形成环路
        if (m != n)
        {
            vEnds[m] = n;             //设置m在"已有的最小生成树"中的终点为n
            rets[index++] = edges[i]; //保存结果
        }
    }
    delete[] edges;
    //统计并打印"kruskal最小生成树"的信息
    int length = 0;
    for (i = 0; i < index; ++i)
    {
        length += rets[i].weight;
    }
    cout << "Kruskal=" << length << ":";
    for (i = 0; i < index; ++i)
    {
        cout << "(" << rets[i].start << "," << rets[i].end << ")";
    }
    cout << endl;
}

void ListUDG::print()
{
    ENode *node;
    for (int i = 0; i < mVexNum; ++i)
    {
        cout << i << "(" << mVexs[i].data << "):";
        node = mVexs[i].firstEdge;
        while (node != NULL)
        {
            cout << node->iVex << "(" << mVexs[node->iVex].data << ")";
            node = node->nextEdge;
        }
        cout << endl;
    }
}

int main(int argc, char **argv)
{
    char vexs[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
    EData *edges[] = {
        new EData('A', 'B', 12),
        new EData('A', 'F', 16),
        new EData('A', 'G', 14),
        new EData('B', 'C', 10),
        new EData('B', 'F', 7),
        new EData('C', 'D', 3),
        new EData('C', 'E', 5),
        new EData('C', 'F', 6),
        new EData('D', 'E', 4),
        new EData('E', 'F', 2),
        new EData('E', 'G', 8),
        new EData('F', 'G', 9),
    };
    int vNum = sizeof(vexs) / sizeof(vexs[0]);
    int eNum = sizeof(edges) / sizeof(edges[0]);
    //1. 根据提供的数据生成
    ListUDG ludg(vexs, vNum, edges, eNum);
    ludg.print();
    ludg.Kruskal();
    //2. 手动输入
    // ListUDG ludg;
    // ludg.print();
    return 0;
}

运行结果如下:

$ ./test
0(A):1(B)5(F)6(G)
1(B):0(A)2(C)5(F)
2(C):1(B)3(D)4(E)5(F)
3(D):2(C)4(E)
4(E):2(C)3(D)5(F)6(G)
5(F):0(A)1(B)2(C)4(E)6(G)
6(G):0(A)4(E)5(F)
Kruskal=36:(E,F)(C,D)(D,E)(B,F)(E,G)(A,B)
Kruskal算法构造图的最小生成树 Kruskal算法的思想是: 假设联通网T=(V,{E}),则最小生成树的初始状态为只有n个顶点而无边的非连通图T=(V,{}),图中每个顶点自成一个连通分量。在E中选择代价最小的边,若该边依附的顶点位于不同的连通分量中,则将该边加入T中,否则舍去该边而选择下一条代价最小的边。一次类推,直到T中所有的顶点都在同一个连通分量为止。 以下给出代码: 1、用数组实现,指定图的结点数和弧数 #in 阅读详情

相关推荐

图的最小生成树-Kruskal算法

【问题描述】 编写程序,利用带权无向图的邻接矩阵存储,实现图的最小生成树Kruskal算法。 【输入形式】 输入图的顶点序列及图的边的情况。如样例所示。边的输入以输入-1,-1,-1作为结束。 0,1,6表示对应的顶点及边是:A到B的边权值为6. 【输出形式】 输出图的最小生成树

AIGC 1245

图的最小生成树——Kruskal算法

Kruskal算法的思想如下 假设有n个顶点的连通图。首先先构造有顶点构成的集合0,每个顶点都是一个集合,不含有任何边。 在边找一个最小权值的边 判断这个边的俩个顶点是否来自于两个不同的集合,若是就将它俩归并为一个集合,然后将这个边添加到要构成的图的集合中。 直到上述的边的个数为顶点个数-1;否则,重复2-3;算法构成树的过程如下: 如a图所示的图,...

weixin_33989058的博客 815

图的最小生成树算法: Prim算法和Kruskal算法(C++)

本文介绍图论中最小生成树算法, 包含Prim算法和Kruskal算法. 通过代码和图解希望能帮助读者理解.

一些C++相关的技术笔记或者教程. 1307

Acwing 858-Prim算法求最小生成树

给定一个n个点m条边的无向图,图中可能存在重边和自环,边权可能为负数。 求最小生成树的树边权重之和,如果最小生成树不存在则输出impossible。 给定一张边带权的无向图G=(V,E),其中VV表示图中点的集合,EE表示图中边的集合,n=|V|,m=|E|。 由V中的全部n个顶点和E中n−1条边构成的无向连通子图被称为G的一棵生成树,其中边的权值之和最小的生成树被称为无向图G的最小生成树。 输入格式 第一行包含两个整数n和m。 接下来m行,每...

她与伞皆过客的博客 1975

CentOS7下NFS共享报错RPC问题的3种解决方案(含防火墙配置详解)

本文详细解析了CentOS7下NFS共享报错RPC问题的3种解决方案,包括防火墙配置详解。从基础连通性检查到RPC服务状态验证,再到精准开放必要端口和SELinux集成,提供全面的排查与解决指南,帮助用户快速解决'No route to host'等常见问题。

weixin_29274969的博客 455

高速窄脉冲峰值保持设计

一、目的 在激光探测领域,探测器发出的高速窄脉冲,单片机AD进行采样,很难捕捉到窄脉冲的幅值,即使使用高速AD进行采样,也存在一定的难度。因此,本方案设计了一种高速窄脉冲峰值保持电路,有助于单片机AD采样能很好的捕捉到脉冲幅值。 二、方案分析与比较 峰值保持器一般分为两种:电压型和跨导型。 方案一:电压型峰值保持器,由电压型运放、二极管、保持电容、缓冲器组成,优点是元件成本低,缺点是峰值保持存在过...

weixin_43184208的博客 9299

图解最小生成树 --- 克鲁斯卡尔算法(Kruskal)与普里姆算法(Prim)

所以选择B和F相连。第八步B-A-H-G-F-C-I-D组成集合M,剩下的点到这个集合的距离的最小值是9,也就是E到M的距离,也就是E到D的距离。第七步B-A-H-G-F-C-I组成集合M,剩下的点到这个集合的距离的最小值是7,也就是D到M的距离,也就是D到C的距离。第六步B-A-H-G-F-C组成集合M,剩下的点到这个集合的距离的最小值是2,也就是I到M的距离,也就是I到C的距离。第五步B-A-H-G-F组成集合M,剩下的点到这个集合的距离的最小值是4,也就是C到M的距离,也就是C到F的距离。......

weixin_60569662的博客 4039

四足机器人如何用对抗运动先验(AMP)实现复杂地形行走?Unitree Go1实战解析

本文深入解析了四足机器人Unitree Go1如何通过对抗运动先验(AMP)算法实现复杂地形行走。AMP结合模仿学习与对抗训练,使机器人仅凭本体感知就能适应未知地形。文章详细介绍了AMP的核心架构、仿真训练工程实践以及在Unitree Go1上的部署优化方案,展示了其在极端地形下的卓越性能表现。

weixin_29050513的博客 330

最小生成树构建算法 —— Kruskal算法(克鲁斯卡尔算法)、Prim算法(普里姆算法)

分成两个集合,分别为集合X和集合Y,集合X初始化为图G中的任意一个顶点,剩余的顶点全部放入集合Y中,每次选取集合X到集合Y中的权值最小的边用于构建最小生成树,直到所有的点都被添加进来之后,如果边的条数为 n-1,则构建出来的就是最小生成树。假设原连通图有n个顶点,而极大无环子图要保证连通性,肯定要包含n个顶点,又要保证无环,最多只能包含n-1条边。示例代码设置为类的成员函数,由于篇幅原因并没有在此给出图这个类的全部代码,任给一个有n个顶点的连通图G{V, E},其中V是点集,E是边集。

知其然 知其所以然 1655

Microsemi Libero使用技巧11——CoreUARTAPB RX管脚分配时不显示

调用串口IP核CoreUARTAPB,并例化到顶层设计,发现UART_RX管脚在进行管脚分配时没有显示出来,最后发现是CoreAPB3总线IP核配置不对导致,改为如下配置后正常。

whik1194的博客 759

Vue3 - 详细实现流程图编辑器可视化平台示例代码,打造前端web网页流程图在线编辑绘制操作展示,vue3自定义绘制流程图在页面上画流程图功能(提供各种操作按钮及节点控件,界面美观交互式流程图插件)

vue3,绘制流程图,在线流程图制作,在vue3中实现流程图,vue3做一个制作流程图的功能,vue3流程图组件,vue3流程图,流程图绘制展示,vue3流程图可视化在线编辑源码,基于VUE3的在线绘制流程图工具,vue3+logicflow流程图,绘制动态流程图并自定义节点和线,vue使用logicFlow绘制流程图,生成各种流程图图形可连接点移除,基于Vue的流程图组件,工作流程图,流程编辑器,vue3流程组件,vue-flow绘制流程图,绘制流程图示例demo,vue3 logicflow流程图使用教

🏆 前端领域优质创作者 9971

最小生成树算法--Kruskal精讲(图文并茂)

Kruskal算法 1.概览 Kruskal算法是一种用来寻找最小生成树的算法,由Joseph Kruskal在1956年发表。用来解决同样问题的还有Prim算法和Boruvka算法等。三种算法都是贪婪算法的应用。和Boruvka算法不同的地方是,Kruskal算法在图中存在相同权值的边时也有效。 2.算法简单描述 1).记Graph中有v个顶点,e个边 2).新建图Graphnew,Graphn...

BigData_Mining的博客 2497

手把手教你 Ubuntu 24.04 离线安装 Ollama

本文介绍 Ubuntu 下离线安装 Ollama 并使用 Ollama 部署 llama3.1-70b 大模型

举世誉之而不加劝,举世非之而不加沮,定乎内外之分,辩乎荣辱之境,斯已矣。 1021

图详解第三篇:最小生成树(Kruskal算法+Prim算法)

最小生成树:Kruskal算法+Prim算法

m0_70980326的博客 2万+

【WRF安装(2025)】服务器移植 WRF 安装环境

【WRF安装(2025)】服务器移植 WRF 安装环境

WW、forever的博客 108

智元机器人开源具身仿真框架 Genie Sim 入门教程

GenieSim是AgiBot推出的具身智能仿真框架,提供完整闭环开发管道,包括轨迹生成、模型训练和基准测试。框架支持Docker容器化部署,要求Ubuntu 22.04和NVIDIA硬件环境。主要功能涵盖: 支持12种基准测试任务 提供ADER评估框架 集成UniVLA/RDT等基线模型 支持PICO/键盘遥操作 具备轨迹记录回放功能 提供完整API控制接口 开发者可通过Hugging Face获取场景资产,使用标准化ROS主题与仿真环境交互。框架特别优化了碰撞检测和抓取物理模拟,适用于从简单抓取到复杂操

2506_90492529的博客 2544

数据结构——图及其C++实现(2)最小生成树Kruskal算法和Prim算法

在上一篇文章中,我们对图的基本概念和图的存储结构及两种遍历方式做了了解,既然已经认识了图,那么对于图中的顶点来说,我们思考当面临“用最小代价把所有点连起来”这类问题时,我们该如何做?接下来我们我们引出关于图的另一个很重要的概念——最小生成树。

学习日记 749

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

图的最小生成树:Prim算法和Kruskal算法

1. 图的最小生成树 生成树的定义:如果连通图G的一个子图是一棵包含G的所有顶点的树,则该子图称为G的生成树。 生成树是连通图的包含图中的所有顶点的极小连通子图。它并不唯一,从不同的顶点出发进行遍历,可以得到不同的生成树。 其中,权值最小的树就是最小生成树。 关于最小生成树最经典的应用模型就是城市通信线路网最小造价的问题:网络G表示n个城市之间的通信线路(其中顶点表示城市,边表示两个城市之

jinzhao1993的博客 1万+

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

【算法】图的最小生成树(Kruskal算法)

前面介绍了图的最小生成树的Prim算法,这个算法是从顶点的角度来刻画生成树的。今天要说的Kruskal(克鲁斯卡尔)算法,是从边的角度来进行刻画的。 Kruskal算法用到的数据结构有: 1、边顶点与权值存储结构(即图是由连接某一条边的两个顶点,以及这条边的权值来进行存储,具体看后面的例子) 2、并查集(具体是什么以及作用在后面的例子中解释) Kruskal算法步骤 – 我们今天要实现的目标依然与...

qq_44134712的博客 1275

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

图 - 最小生成树算法 - Kruskal - Prim

图 - 最小生成树算法 - Kruskal(克鲁斯卡尔) - Prim(普利姆)

2302_80023639的博客 869

图之最小生成树Kruskal算法详解(C语言版)

Kruskal算法(克鲁斯卡尔算法)查找最小生成树的方法是:将连通网中所有的边按照权值大小做升序排序,从权值最小的边开始选择,只要此边不和已选择的边一起构成环路,就可以选择它组成最小生成树。对于 N 个顶点的连通网,挑选出 N-1 条符合条件的边,这些边组成的生成树就是最小生成树。

qq_44075108的博客 8048

图的最小生成树Kruskal算法

/ 存储图中的所有节点,键为节点值,值为节点对象。// 存储每个节点的父节点。// 邻接表,存储与该节点相连的其他节点。// 存储从该节点出发的边。// 获取起始节点和终止节点的对象。

2401_83010439的博客 536

C++ 图 Kruskal最小生成树算法

权值排序,依次取出,判断闭环 #define _CRT_SECURE_NO_WARNINGS #include <iostream> #include <string> #include <fstream> #include <sstream> #include <cassert> #include <vector> #in...

牛~ 295

prim算法_图的最小生成树Kruskal算法

昨天说了图的最小生成树的其中一种算法,Prim算法,今天就再来说一下平时用的比较多的另一种最小生成树算法,Kruskal(克鲁斯卡尔)算法。然后再来比较一下这两个算法之间的差异。首先回顾一下最小生成树到底是个什么东西。简单说就是在有权连通图中,找到一组边,把所有的点连接在一起,并且这组边的权值加和最小,就是这个图的最小生成树。效果大概如下图,图1,图2就是生成树,而图3因为边的权值加起来...

weixin_39878716的博客 101

kruskal算法求图的最小生成树c语言,利用Kruskal算法求图的最小生成树.doc

利用Kruskal算法求图的最小生成树利用Kruskal算法求图的最小生成树程序设计 2007-10-09 22:23 阅读160 评论1 字号: 大大 中中 小小 /*利用Kruskal算法求图的最小生成树(2007.8.7)*/#include#include#define MaxVertexNum 12#define MaxEdgeNum 20#define MaxVal...

weixin_39610964的博客 465
上一篇: 图的最小生成树之Prim算法
下一篇: 图的最短路径之Dijkstra算法
code_peak
博客等级 码龄5年 403粉丝 67原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值