图的最小生成树之Prim算法

prim算法基础详解(无向赋权图的最小生成树MST) 带权图分为有向和无向,无向图的最短路径又叫做最小生成树,有prime算法和kruskal算法 阅读详情

参考: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
Prim(普里姆)算法求最小生成树(邻接矩阵) 一、项目功能、方案选择及性能描述: 功能: 1.列出目标系统具有的各个功能,并简述其作用 建立无向图: 输入点的数目和标识、边的数目及其权值,使用二维数组的方式建立无向图并用邻接矩阵的方式进行存储。 找出最小生成树: 从输入的起始点开始,使用Prim算法来寻找最小生成树,并输出树的结点和边。 构造辅助数组: 设置一个一维数组每寻找一个顶点,清空一次,得到最小权值的顶点下标。 画出连通图: 使用EasyX画出之前输入的无向图及标记边的权值。 演示Prim算法: 逐步演示Prim算法的寻找过程,并把得到的最小. 阅读详情

相关推荐

图的邻接矩阵存储方式之普里姆prim算法(最小生成树问题)

假设在n个城市间建立通信网络,则联通n个城市只需要n-1条线路,这就存在n!种联通网络即生成树,那么这就要考虑怎么建立网络能使路径最短,成本最低或是权重和最小,这个问题就是最小生成树问题(minimum cost spanning tree)。而prim算法是构造最小生成树的方法之一。 为了实现这个算法,需要设置一个辅助数组closedg[i],其中有两个分量,一个存储顶点元素(边的起始点),一...

东南之风的博客 7945

图论——最小生成树 kurskal算法、prim算法

基本概念 树(Tree) 如果一个无向连通图中不存在回路,则这种图称为树。 生成树 (Spanning Tree) 无向连通图 G\mathrm GG 的一个子图如果是一颗包含 G\mathrm GG 的所有顶点的树,则该子图称为 G\mathrm GG 的生成树。 生成树是连通图的极小连通子图。 这里所谓极小是指:若在树中任意增加一条边,则将出现一条回路;若去掉一条边,将会使之变成非连通图。 最小生成树 一个带权值的连通图,用 n−1n-1n−1 条边把 nnn 个顶点连接起来,使得连接起来的权值最小。

https://github.com/ZichengCao 1117

图的最小生成树之Prim算法及Kruskal算法

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

SanFancsgo的博客 5238

C++数据结构之图的连通性——最小生成树(Kruskal & Prim算法实现 带有图示与gif演示)

本文有对最小生成树以及相关的概念有较详细的介绍和图示,以及gif帮助读者加深理解,并且有对Kruskal和Prim算法进行讲解分析并利用了两这种算法得到最小生成树。

m0_56398315的博客 5288

Prim算法求图的最小生成树

算法之-----使用prim算法求得最小生成树的权值 代码实现: 1.输入:n,m(n代表无向图顶点数,m代表边数)    输入:m行(每行输入内容为(i,j,c)分别代表每条边的起点、终点和权值) 2. 输出:最小生成树的权值 /*---prim算法时间复杂度O(n^2),n为顶点数, 时间复杂度与边的数目无关,因此适用于求边稠密的图的最小生成树---*/ #include&lt;s...

qq_39800695的博客 5562

图邻接矩阵存储 最小生成树 prim普里姆算法 C语言实现

MGraph.h#pragma once #include "Queue.h" #define MaxVertexNum 100 typedef char VertexType; typedef int EdgeType; typedef int VRType; typedef struct ArcCell { VRType adj; //对于无向图 用1、0填充 有向图以权值填充 }ArcCell, AdjMatrix[MaxVertexNum][MaxVertexNum]; ty

6150

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

知识点: 1、图的邻接矩阵表示法; 2、Prim算法实现 // MiniCostSpanTree_Prim.cpp //基于图的邻接矩阵表示法 //图的最小生成树Prim算法 //逐个顶点的找出最小生成树 #include <iostream> using namespace std; #define max_vertex_num 20 int vex_num;//顶点个数 char v[max_vertex_num];//存储顶点 int arcs[max_vertex_nu.

一匹刚学打乒乓球的老马 404

图的最小生成树-Prim算法

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

AIGC 1616

图的最小生成树(Prim算法)

最小生成树 定义:生成树中边的权值(代价)之和最小的树 Prim Prim算法:普里姆算法,图论中的一种算法,可在加权连通图里搜索最小生成树。 Ps:该算法于1930年由捷克数学家沃伊捷赫·亚尔尼克(Vojtěch Jarník)发现;并在1957年由美国计算机科学家罗伯特·普里姆(Robert C. Prim)独立发现;1959年,艾兹格·迪科斯彻再次发现了该算法。因此,在某些场合,普里姆算法又...

qq_41891805的博客 4732

寻迹Arduino智能小车

Arduino巡线寻迹智能小车

Rachael_Wang的博客 1万+

微信小程序使用TCP通信

最终目的:在微信小程序内实现对局域网发起TCP通信实现步骤:建立TCP服务 + 小程序发起通信。

Big_YiFeng的博客 5613

图的最小生成树-prim算法

记录顶点与最小生成树的边的权值。记录顶点是否已经在最小生成树中。记录最小生成树的父节点。

2302_76919629的博客 1809

华为Atlas 300I推理卡驱动安装避坑指南:不同安装方式的选择与优化

本文详细解析华为Atlas 300I推理卡驱动安装的三种主流方式(.run、.rpm和源码编译),提供关键环境检查步骤、安装流程优化建议及常见问题解决方案,帮助开发者高效完成芯片推理卡部署并规避典型安装陷阱。

q9w8e7r6t5的博客 434

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

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

m0_70980326的博客 2万+

多模态情感识别(MER)数据集实战指南:从IEMOCAP到应用落地

本文提供了多模态情感识别(MER)从数据集到应用落地的完整实战指南。以经典IEMOCAP数据集为例,详细讲解了音频、视觉、文本等多模态数据的预处理、特征提取与融合技术,并分享了模型训练调优心得及面向智能客服、在线教育等场景的部署考量,帮助开发者快速构建高效可用的MER系统。

h3i4j的博客 1072

AltiumDesigner相同模块复用操作

AltiumDesigner相同模块复用操作框选已布局好的A电路,作为复用模块创建Room同样的操作,框选C电路,然后也创建Room查看A电路的Chanel Offset显示设置复制Channel Offset查看B电路的Channel Offset复制A电路的Channel Offset到C电路Room格式的复制 框选已布局好的A电路,作为复用模块 创建Room 同样的操作,框选C电路,然后也创建Room 查看A电路的Chanel Offset 框选A模块的,然后点右下角的菜单——PCB——PCB

weixin_41947101的博客 5964

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

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

2302_80023639的博客 869

TX 的 LOL(Local Oscillator Leakage,本振泄露)

项目内容LOL 是什么本振残留在 TX 输出中心频率上的杂散主要原因IQ 失衡、硬件不完美、零中频架构影响杂散、干扰、性能劣化、安全问题解决方法初始化校准 + 跟踪校准(AD9371 支持)检测手段频谱仪、回环检测、ADC ILA 抓取。

weixin_41230430的博客 2052

图的最小生成树prim算法总结

昨天刚刚把prim算法复习了一遍,现在把将自己的理解与总结写出来分享下,prim算法的思想通俗的讲就是:将连通网N={V,E}的顶点分为最小生成树集合U与非最小生成树集合V-U,然后从U中的顶点到V-U中的顶点的边中选出一条权值最小的边,然后把这条边对应的另一个顶点也加入最小生成树集合U中,反复的循环下去。。。 下面就一起看看prim算法的代码 1.用邻接矩阵存储图 public c

Tseng 1969

DRV8311HRRWR直流无刷(BLDC)电机驱动原理图设计

DRV8311HRRWR集成三个MOSFET 半H桥,用于驱动三相无刷直流电机(BLDC),适用于5V、9V、12V或18V直流电源轨或1S至4S电池供电应用。内部集成三个具有集成电流感测功能的电流感测放大器(CSA),可感测BLDC电机的三相电流,从而实现FOC和电流控制系统设计方案。集成保护特性:VM 欠压锁定 (UVLO)、 电荷泵欠压 (CPUV)、过流保护 (OCP)、热警告和热关断 (OTW/OTSD)、故障条件指示引脚 (nFAULT)支持 1.8V、3.3V 和 5V 逻辑输入。

zhusl6688的博客 1230

YOLOv13多分支融合机制+SE注意机制 RepVGGBlock_OREPA架构 map提升4.89,召回率提升8.66

本文提出了一种改进的YOLOv13目标检测模型,通过引入RepVGGOREPA模块和重参数化技术,显著提升了模型性能。实验结果表明,采用RepVGGBlock后,mAP提升4.89,召回率提升8.66%。文章详细介绍了模型移植过程,包括创建YOLOv13-REPVGGOREPA配置文件、修改任务处理代码和模块初始化文件,并提供了完整的OREPA模块实现代码。该模块通过多尺度特征融合和SE注意力机制,实现了训练时的丰富表征能力和推理时的高效计算,为YOLO系列模型提供了新的优化思路。

FJN110的博客 2650

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

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

jinzhao1993的博客 1万+

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

C语言图的最小生成树prim算法(超详细版)

最近刚刚学习了图的最小生成树算法,也看了很多作者写的文章,在加上自己的钻研终于明白了其中的奥妙。 最小生成树算法的原理,大神们已经给了很详细的解释,有的还用图像说明。但美中不足的是,对代码的解释较少,这些代码让初学者阅读起来比较费力,也不利于初学者将彻底理解原理并将其转化成代码。 于是我写了一个关于代码的解释,希望对初学者有所帮助。我力求精确不误人子弟。 代码的 #include<stdio...

春季觉醒的博客 7740

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

pscad IEEE标准系统搭建说明

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

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

普里姆算法(Prim算法)获取最小生成树

qq_44075108的博客 9480

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

图的最小生成树(二)—Prim算法

上一篇中写了图的最小生成树求法一——Kruskal算法 http://blog.youkuaiyun.com/wtyvhreal/article/details/43526695 这一篇中用另外一种方法来求解图的最小生成树,Prim算法。 图中随便选一个顶点开始,看看这个顶点有哪些边,在它的边中找一条最短的。1号有1-2,1-3,其中1-2短,选择1-2.通过它把1和2连接在一起。接下来开始枚举1

小地盘的诺克萨斯 2966
上一篇: 图的拓扑排序
下一篇: 图的最小生成树之Kruskal算法
code_peak
博客等级 码龄5年 403粉丝 67原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值