图的最小生成树之Prim算法

最新推荐文章于 2023-07-25 20:08:11 发布
最新推荐文章于 2023-07-25 20:08:11 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： 数据结构
原文链接：https://wangkuiwu.github.io/2013/04/13/prim-cplus
版权

参考：https://wangkuiwu.github.io/2013/04/13/prim-cplus

Prim算法介绍

在介绍普里姆 Prim 算法前，首先需要知道 Prim 算法的作用。Prim 算法是用来求加权连通图的最小生成树的算法。下面先介绍最小生成树。

最小生成树概念

在含有 n 个顶点的连通图中选择 n -1 条边，构成一棵极小连通子图，并使该连通子图中 n -1 条边上权值之和达到最小，则称其为连通图的最小生成树。

Prim算法-图1

图 G4

如上连通图 G4 所示，可以有多棵权值总和不相同的生成树。

情况 1：权值总和为 43。

Prim算法-图2

情况 2：权值总和为 36。

Prim算法-图3

情况 3：权值总和为 64。

Prim算法-图4

Prim算法思想

普利姆 算法思想如下：

对于连通图 G 而言，V 是其所有的顶点的集合。现在，设置两个新的集合 U 和 T，其中 U 用于存放 G 的最小生成树中的顶点，T 存放 G 的最小生成树中的边。从所有 uЄU，vЄ(V-U)（V-U 表示除去 U 的所有顶点）的边中选取权值最小的边 (u, v)，将顶点 v 加入集合 U 中，将边 (u, v) 加入集合 T 中，如此不断重复，直到 U = V 为止，最小生成树构造完毕，这时集合 T 中包含了最小生成树中的所有边。

Prim算法图解

以上面的加权连通图 G4 为例，对 Prim 算法进行演示（从第一个顶点 A 开始通过 Prim 算法生成最小生成树）。

Prim算法-图5

步骤说明：

  • 初始状态：V 是所有顶点的集合，即V = {A, B, C, D, E, F, G}，U 和 T 都是空。
  • 第1步：将顶点 A 加入到 U 中。
    此时，U = {A}。
  • 第2步：将顶点 B 加入到 U 中。
    上一步操作之后， U = {A}，V - U = {B, C, D, E, F, G}。因此，边 (A, B) 的权值最小。将顶点 B 添加到 U 中。此时，U = {A, B}。
  • 第3步：将顶点 F 加入到 U 中。
    上一步操作之后，U = {A, B}，V - U = {C, D, E, F, G}。因此，边 (B, F) 的权值最小。将顶点 F 添加到 U 中。此时，U = {A, B, F}。
  • 第4步：将顶点 E 加入到 U 中。
    上一步操作之后，U = {A, B, F}，V - U = {C, D, E, G}。因此，边 (F, E) 的权值最小。将顶点 E 添加到 U 中。此时，U = {A, B, F, E}。
  • 第5步：将顶点 D 加入到 U 中。
    上一步操作之后，U = {A, B, F, E}，V - U = {C, D, G}。因此，边 (E, D) 的权值最小。将顶点 D 添加到 U 中。此时，U = {A, B, F, E, D}。
  • 第6步：将顶点 C 加入到 U 中。
    上一步操作之后，U = {A, B, F, E, D}，V - U = {C, G}。因此，边 (D, C) 的权值最小。将顶点 C 添加到 U 中。此时，U = {A, B, F, E, D, C}。
  • 第7步：将顶点 G 加入到 U 中。
    上一步操作之后，U = {A, B, F, E, D, C}，V - U = {G}。因此，边 (F, G) 的权值最小。将顶点 G 添加到 U 中。此时，U = V。

此时，最小生成树构造完成，它包括的顶点依次是：A, B, F, E, D, C, G。

Prim算法的实现

图的邻接矩阵实现Prim算法

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

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

const int VEXNUM = 7;

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();
    //prim最小生成树算法
    void Prim(int start);

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);
};

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;
}

//Prim最小生成树算法
void MatrixUDG::Prim(int start)
{
    int min;
    int i, j;
    int n, m;
    int min_index = 0;
    int prim_index = 0; //prim最小生成树的索引，即prims数组的索引
    char prims[MAX];    //prim最小生成树的结果数组
    int weights[MAX];   //存储顶点间边的权值
    //prim最小生成树中第一个数是图中第start个顶点，因为是从start开始的
    prims[prim_index++] = mVexs[start];
    //初始化顶点的权值数组
    //将每个顶点的权值初始化为第start个顶点到该顶点的权值
    for (i = 0; i < mVexNum; ++i)
    {
        weights[i] = mMatrix[start][i];
    }
    //将第start个顶点到它自身的距离为0
    weights[start] = 0;
    for (i = 0; i < mVexNum; ++i)
    {
        //由于从start开始的，因此不需要再对第start个顶点进行处理
        if (i == start)
            continue;
        j = 0;
        min_index = 0; //标记最小权值下标
        min = INF;
        //在未被加入到最小生成树中的顶点中，找出权值最小的顶点
        while (j < mVexNum)
        {
            //若weights[j] = 0,说明第j个节点已经加入了最小生成树
            if (weights[j] != 0 && weights[j] < min)
            {
                min = weights[j];
                min_index = j; //找到最小权值的顶点下标
            }
            ++j;
        }
        //经过上面的处理后，在未被加入到最小生成树的顶点中,权值最小的顶点是第min_index个顶点
        //将第min_index个顶点加入到最下生成树的结果数组中
        prims[prim_index++] = mVexs[min_index];
        weights[min_index] = 0;
        //当第min_index个顶点被加入最小生成树的结果数组中，更新其他顶点的权值
        //比如从点A开始,B是权值最端的路径，
        //此时weight[0, 0, INF, INF, INF, 16, 14]
        //现在需要遍历B(第min_index个顶点)的邻接点，找到与B连接的最短路径，
        //此时weight[0, 0, 10, INF, INF, 7, INF],
        //下次循环再得出F是权值最短的路径，此时weight[0, 0, 10, INF, INF, 0, INF]
        //现在需要遍历F(第min_index个顶点)的邻接点，找到F连接的最端路径，
        //此时weight[0, 0, 6, INF, 2, 0, 9]
        //下次循环再得出E是权值最短的路径,...
        for (j = 0; j < mVexNum; ++j)
        {
            //当第j个节点没有被处理，并且需要更新时才被处理
            if (weights[j] != 0 && mMatrix[min_index][j] < weights[j])
            {
                weights[j] = mMatrix[min_index][j];
            }
        }
    }
    //计算最小生成树的权值
    int sum = 0;
    for (i = 1; i < prim_index; ++i)
    {
        min = INF;
        //获取prims[i]在顶点中的下标位置
        n = getPosition(prims[i]);
        //在vexs[0...i]中,找出到j的权值最小的顶点
        //比如[A, B, F, E, D, C, G]
        //n=1 B时, j=0; prims[0]=A=12; min = 12
        //n=2 F时, j=0, 1; prims[0]=A=INF, prims[1]=B=7; min=7
        //n=3 E时, j=0, 1, 2; prims[0]=A=INF, prims[1]=B=INF, prims[2]=F=2; min=2
        //...
        for (j = 0; j < i; ++j)
        {
            m = getPosition(prims[j]);
            if (mMatrix[m][n] < min)
            {
                min = mMatrix[m][n];
            }
        }
        sum += min;
    }
    //打印最小生成树
    cout << "Prim:(" << mVexs[start] << ")=" << sum << ":";
    for (i = 0; i < prim_index; ++i)
    {
        cout << prims[i] << " ";
    }
    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.Prim(0);
    //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
Prim:(A)=36:A B F E D C G

图的邻接表实现Prim算法

#include <iostream>
using namespace std;

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

//边的权重结构体，用来初始化构建邻接表(演示)
struct EData
{
    EData() {}
    EData(char s, char e, int w) : start(s), end(e), weight(w) {}

    char start; //边的起点
    char end;   //边的终点
    int weight; //边的权重
};

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();
    //Prim最小生成树
    void Prim(int start);

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);
};

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;
}

//Prim最小生成树
void ListUDG::Prim(int start)
{
    int i, j;
    int m, n;
    int min = 0;
    int min_index = 0;
    int prim_index = 0; //prim最小生成树的索引，即prims数组的索引
    char prims[MAX];    //prim最小生成树的结果数组
    int weights[MAX];   //顶点间边的权值

    //prim最小生成树中第一个数是图中第start个顶点，因为从start开始
    prims[prim_index++] = mVexs[start].data;
    //初始化顶点权值数组，将每个顶点的权值初始化为第start个顶点，因为是从start开始的
    for (i = 0; i < mVexNum; ++i)
    {
        weights[i] = getWeight(start, i);
    }
    for (i = 0; i < mVexNum; ++i)
    {
        //由于从start开始的,因此不需要再对第start个顶点进行处理
        if (start == i)
            continue;
        j = 0;
        min_index = 0;
        min = INF;
        //在未被加入到最小生成树的顶点中,找出权值最小的顶点
        while (j < mVexNum)
        {
            //若weights[j] = 0,说明第j个节点已经加入了最小生成树
            if (weights[j] != 0 && weights[j] < min)
            {
                min = weights[j];
                min_index = j;
            }
            ++j;
        }
        //经过上面的处理后，在未被加入到最小生成树的顶点中,权值最小的顶点是第min_index个顶点
        //将第min_index个顶点加入到最小生成树的结果数组中
        prims[prim_index++] = mVexs[min_index].data;
        //将第min_index个顶点的权值标记为0，意味着第min_index个节点已经加入到最小生成树的结果数组中
        weights[min_index] = 0;
        //当第min_index个顶点被加入最小生成树的结果数组中，更新其他顶点的权值
        //比如从点A开始,B是权值最端的路径，
        //此时weights[0, 0, INF, INF, INF, 16, 14]
        //现在需要遍历B(第min_index个顶点)的邻接点，找到与B连接的最短路径，
        //此时weights[0, 0, 10, INF, INF, 7, INF],
        //下次循环再得出F是权值最短的路径，此时weights[0, 0, 10, INF, INF, 0, INF]
        //现在需要遍历F(第min_index个顶点)的邻接点，找到F连接的最端路径，
        //此时weights[0, 0, 6, INF, 2, 0, 9]
        //下次循环再得出E是权值最短的路径,...
        int tmp = 0;
        for (j = 0; j < mVexNum; ++j)
        {
            tmp = getWeight(min_index, j);
            //当第j个节点没有被处理，并且需要更新时才被处理
            if (weights[j] != 0 && tmp < weights[j])
            {
                weights[j] = tmp;
            }
        }
    }
    //计算最小生成树的权值
    int sum = 0;
    int tmp = 0;
    for (i = 1; i < prim_index; ++i)
    {
        min = INF;
        //获取prims[i]在矩阵中的位置
        n = getPosition(prims[i]);
        //在vexs[0...i]中,找出到j的权值最小的顶点
        //比如[A, B, F, E, D, C, G]
        //n=1 B时, j=0; prims[0]=A=12; min = 12
        //n=2 F时, j=0, 1; prims[0]=A=INF, prims[1]=B=7; min=7
        //n=3 E时, j=0, 1, 2; prims[0]=A=INF, prims[1]=B=INF, prims[2]=F=2; min=2
        //...
        for (j = 0; j < i; ++j)
        {
            m = getPosition(prims[j]);
            tmp = getWeight(m, n);
            if (tmp < min)
            {
                min = tmp;
            }
        }
        sum += min;
    }
    //打印最小生成树
    cout << "Prim(" << mVexs[start].data << ")=" << sum << ":";
    for (i = 0; i < prim_index; ++i)
    {
        cout << prims[i] << " ";
    }
    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.Prim(0);
    //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)
Prim(A)=36:A B F E D C G
code_peak
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最小生成树算法之Prim算法
09-03
主要讲解了普里姆算法（Prim算法），图论中的一种算法，可在加权连通图里搜索最小生成树,需要的朋友可以参考下
最小生成树(Prim算法）
06-13
使用Prim算法编写的最小生成树（C语言），为更好地学习数据结构
可视化最小生成树Prim、Kruskal
weixin_51187996的博客
11-02 1580
摘 要：最小生成树问题在生活应用中存在诸多实例，多用于光纤铺设，管道铺设等。本次项目以为东校区铺设管线系统为实例，设计一个辅助程序。将地图抽象为无向图，用邻接矩阵的形式存储在文本中，将铺设最小成本管线抽象为求最小生成树的问题，通过C语言使用Prim和Kuaskal算法实现，求得最小生成树后，绘制简单的示意图并将结果格式化输出最小生成树的各个边及边权。关键词：Prim；Kruskal；文本1 项目分析项目要求开发一个管线铺设辅助系统，使其成本达到最小，是一个在现实中非常重要的问题。这一类的问题
【数学与算法】Prim算法 - 寻找无向图中最小生成树
u011754972的博客
10-11 571
Prim's 算法的基本想法是： 种一棵树，让树从一个节点增长到n个节点。 初始时，树只有一个节点，可以是n个节点中的任意一个，没有边(这是肯定的，两个节点才会有边)； 每一轮循环会找出一个节点和一条边，把他们接到树上，这样树会变大一点。 整个过程都要保证树的两个性质： 1.树是连通图； 2.树没有回路； 算法循环次数等于节点的数量；这是因为，每一轮循环就会往树里添加一个节点。 例子： 算法的输入是一张连通的无向图，如下： 使用集合U记录生成的树的节点。下面的介绍中，使用红色标出集合U中的节点，
Prim算法实现-求连通图的最小生成树（用孩子兄弟CSTree）表示-邻接表(ALGraph)-C语言实现
qq_45768871的博客
03-15 1510
[图] Prim算法实现-求连通图的最小生成树（用孩子兄弟CSTree）表示-邻接表(ALGraph)-C语言实现 普里姆算法（邻接表） 思想 从某个顶点开始（不要把它看成一个单独的顶点，把它看成只有一个结点的子生成树） 在第一步的生成树的相邻边中，选一条最小的边，将最小的边和边的另一个结点并入子生成树中（生成树就长大了一点） 继续，直到所有的顶点都被并入了生成树 步骤 1.取图中任意一个顶点 v...
图论——最小生成树 kurskal算法、prim算法
https://github.com/ChengziCao
11-20 866
基本概念 树（Tree） 如果一个无向连通图中不存在回路，则这种图称为树。 生成树 （Spanning Tree） 无向连通图 G\mathrm GG 的一个子图如果是一颗包含 G\mathrm GG 的所有顶点的树，则该子图称为 G\mathrm GG 的生成树。 生成树是连通图的极小连通子图。 这里所谓极小是指：若在树中任意增加一条边，则将出现一条回路；若去掉一条边，将会使之变成非连通图。 最小生成树 一个带权值的连通图，用 n−1n-1n−1 条边把 nnn 个顶点连接起来，使得连接起来的权值最小。
C++数据结构之图的连通性——最小生成树（Kruskal & Prim算法实现 带有图示与gif演示)
m0_56398315的博客
08-31 3958
本文有对最小生成树以及相关的概念有较详细的介绍和图示，以及gif帮助读者加深理解，并且有对Kruskal和Prim算法进行讲解分析并利用了两这种算法得到最小生成树。
2022-1-27 数据结构 图 最小生成树 prim kruskal
HITORANGE的博客
01-27 367
图的应用最小生成树生成树的概念最小生成树MST构造最小生成树：prim 算法构造最小生成树：kruskal 算法 最小生成树 生成树的概念 最小生成树 最小生成树（又名：最小权重生成树） 概念：将给出的所有点连接起来（即从一个点可到任意一个点），且连接路径之和最小的图叫最小生成树。最小生成树属于一种树形结构（树形结构是一种特殊的图），或者说是直链型结构，因为当n个点相连，且路径和最短，那么将它们相连的路一定是n-1条。 可以利用参考一个问题理解最小生成树，有n个村庄，每个村庄之间距离不同，要求村庄
数据结构 最小生成树 prim算法（普里姆算法）C语言实现
m0_62341092的博客
11-24 9488
我们可以将定义理解为：将图的所有顶点分为两类，A类（保存已经查找过的顶点），B类（保存未查找过的顶点），从任一顶点开始，并将其从B类移至A类，然后开始寻找B类中（的顶点）到A类顶点之间权值最小的顶点，将其从B类中移至A类，重复上述操作，直至B类中没有顶点。所走过的顶点和边就是该连通图的最小生成树。
最小生成树（邻接矩阵或邻接表）
qq_63306482的博客
05-19 1872
题目描述 最小生成树问题是实际生产生活中十分重要的一类问题。假设需要在n个城市之间建立通信联络网，则连通n个城市只需要n-1条线路。这时，自然需要考虑这样一个问题，即如何在最节省经费的前提下建立这个通信网。 可以用连通网来表示n个城市以及n个城市之间可能设置的通信线路，其中网的顶点表示城市，边表示两个城市之间的线路，赋于边的权值表示相应的代价。对于n个顶点的连通网可以建立许多不同的生成树，每一棵生成树都可以是一个通信网。现在，需要选择一棵生成树，使总的耗费最小。这个问题就是构造连通网的最小代价生成树，简
代码 最小生成树Prim算法代码
06-04
代码 最小生成树Prim算法代码代码 最小生成树Prim算法代码代码 最小生成树Prim算法代码代码 最小生成树Prim算法代码代码 最小生成树Prim算法代码代码 最小生成树Prim算法代码代码 最小生成树Prim算法代码代码 最小...
最小生成树 普列姆算法 prim matlab
06-30
最小生成树的经典算法。我在代码中加入了文字解释。并以算法导论第二版书中例子为例，得到了相同结果。代码很完整，也有结果显示环节。
最小生成树算法（Prim Kruskal）
咸鱼势力登场
07-25 1万+
最小生成树算法总览 最小生成树的定义及性质 Prim（普利姆）算法[朴素Prim算法 堆优化Prim算法] Prim算法求最小生成树[朴素Prim的代码实现 堆优化Prim的代码实现] Kruskal（克鲁斯卡尔）算法[Kruskal算法求最小生成树]
最小生成树——Prim算法
qq_54731568的博客
03-28 469
【代码】最小生成树——Prim算法。
【算法与数据结构】—— 最小生成树（Prim算法、Kruskal算法）
酱懵静的博客
05-05 9157
生成树是一个连通图G的一个极小连通子图。 包含G的所有n个顶点,但只有n-1条边,并且是连通的。 生成树可由遍历过程中所经过的边组成（有多个）。一个带权连通无向图的生成树中，边的权值之和最小的那棵树叫做此图的最小生成树（唯一）。
Prim算法实现、最小生成树(加权无向图)
一名小白的博客
08-27 2344
最小生成树 加权图，我们发现它的边关联了一个权重，那么我们就可以根据这个权重解决最小成本问题，但如何才能找到最小成本对应的顶点和边呢？最小生成树相关算法可以解决。 1. 最小生成树定义以及相关约定 定义： 图的生成树是它的一棵含有其所有顶点的无环连通子图，一副加权无向图的最小生成树它的一棵权值(树中所有边的权重之和)最小的生成树 约定： 只考虑连通图。最小生成树的定义说明它只能存在于连通图中，如果图不是连通的，那么分别计算每个连通图子图的最小生成树，合并到一起称为最小生成森林。 所有边的权重都各不相同。
用邻接矩阵+普里姆(Prim)算法构造最小生成树(最小支撑树)
Love_Irelia97的博客
09-12 6764
首先什么是最小生成树（我的教材称为最小支撑树）？它是一个图的极小连通子图。那什么是图？什么是极小连通子图？ 图是一种数据结构，由顶点集合V(非空)和边集合E构成，记为G=(V,E)。G即Graph图，V即Vertex顶点，E即Edge边。连通图可以理解为能够一笔画出来的图。而极小连通子图则是包含一个连通图的所有顶点（假设有n个），却只有(n-1)条边（这些边仍然属于E）的子图，并且这个子图仍然是...
最小生成树：Prim算法
热门推荐
大力海棠的博客
09-17 2万+
讲构建最小生成树的算法前，先来回顾一下什么是生成树，什么是最小生成树？生成树是指：在一个连通图Graph中，包含Graph中所有n个顶点的极小连通子图，一定包含Graph中的n-1条边（如果小于n-1条边，生成树会不连通。如果大于n-1条边，就一定会产生回路，那么就不是树了，树中不能产生回路）。且生成树不唯一。举个例子： 这个无向连通图的生成树分别有 什么是最小生成树？ ...
C#，数值计算，解微分方程的龙格-库塔二阶方法与源代码
最新发布
04-25
C#，数值计算，解微分方程的龙格-库塔二阶方法与源代码 微分方程 含有导数或微分的方程称为微分方程，未知函数为一元函数的微分方程称为常微分方程。 微分方程的阶数 微分方程中导数或微分的最高阶数称为微分方程的阶数。 微分方程的解 使得微分方程成立的函数称为微分方程的解。 微分方程的特解 微分方程的不含任意常数的解称为微分方程的特解。 微分方程的通解 所含相互独立的任意常数的个数与微分方程的阶数相等的微分方程的解称为微分方程的通解。
c++最小生成树的 Prim算法 Kruskal算法
04-30
Prim算法和Kruskal算法都是用来解决最小生成树问题的算法，它们的思路和实现都有所不同。 Prim算法的基本思路是从一个顶点开始，每次找到一个与当前生成树相连的权值最小的边所连接的顶点，并将该顶点加入到生成树中，直到所有的顶点都被加入到生成树中为止。 Kruskal算法则是按照边的权值从小到大的顺序来加入边，每次加入一条边之前，判断这条边所连接的两个顶点是否在同一个连通块中，如果不在，则将这条边加入到生成树中，直到生成树中有n-1条边为止。 两种算法都能够求出最小生成树，但是它们的实现方式和时间复杂度略有不同。Prim算法的时间复杂度为O(n^2)，适用于稠密图；而Kruskal算法的时间复杂度为O(m log m)，适用于稀疏图。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值