图__最小生成树

最新推荐文章于 2023-02-03 14:59:56 发布
最新推荐文章于 2023-02-03 14:59:56 发布
阅读量385 收藏
点赞数 1
分类专栏： 我的转载文章
图__最小生成树
标签： primkruskal数据结构算法c++
2016-09-12 09:52 80人阅读 评论(0) 收藏 举报
本文章已收录于：
分类：
作者同类文章 X

    版权声明：本文为博主原创文章，未经博主允许不得转载。

    图---最小生成树

    学习总结：


    //---------------------------------------
    //-----根据下图----------------------------------------
    //--实现普里姆算法(Prim)--及--克鲁斯卡尔算法(kruskal)---------------
    /*
                 A
             /    |    \
           B -- F -- E
             \   / \    /
              C -- D
                  A B C D E F
    索引：    0 1 2 3 4 5

    权值：A-B 6        A-F 1     A-E 5
               B-C 3        B-F 2
               C-F 8        C-D 7
               D-F 4        D-E 2
               E-F 9

            //无向图
              A    B    C    D    E
        A    0    1    1    0    0
        
        B    1    0    0    1    1
        
        C    1    0    0    0    0
        
        D    0    1    0    0    0
        
        E    0    1    0    0    0


    */

    Node.h 
    #ifndef NODE_H
#define NODE_H
//-----------------
//-----顶点----------
class Node{

public:
    Node(char data = 0);
    char m_cData;
    bool m_bIsVisited;
    
};

#endif

    Node.cpp 
    #include"Node.h"
#include<iostream>
#include<stdio.h>
using namespace std;

Node::Node(char data){
    
    m_cData = data;
    m_bIsVisited = false;
}


    Edge.h 
    #ifndef EDGE_H
#define EDGE_H
//-------------------
//----边-------------

class Edge{

public:
    Edge(int nodeIndexA = 0, int nodeIndexB = 0, int weightValue = 0);

public:
    int m_iNodeIndexA;//A索引
    int m_iNodeIndexB;//B索引
    int m_iWeightValue;//权值
    bool m_bSelected;
    
};

#endif


    Edge.cpp 
    #include"Edge.h"

Edge::Edge(int nodeIndexA, int nodeIndexB, int weightValue){
    
        m_iNodeIndexA = nodeIndexA;
        m_iNodeIndexB = nodeIndexB;
        m_iWeightValue = weightValue;
        m_bSelected = false;
}


    CMap.h 
    #ifndef CMAP_H
#define CMAP_H
#include"Node.h"
#include"Edge.h"
#include<iostream>
#include<vector>
using namespace std;
//---------------------------
//--------图--------------------

class CMap{
    
public:
    CMap(int capacity);
    ~CMap();
    bool addNode(Node *pNode);//添加顶点(节点)
    void resetNode(); //重置顶点
    bool setValueToMatrixForDirectedGraph(int row, int col, int val = 1);//为有向图设置邻接矩阵
    bool setValueToMatrixForUndriectedGraph(int row, int col, int val = 1);//为无向图设置邻接矩阵
    void printMatrix();//打印邻接矩阵
    
    void depthFirstTraverse(int nodeIndex);//深度优先遍历
    void breadthFirstTraverse(int nodeIndex);//广度优先遍历
    
    void primTree(int nodeIndex);//普里姆算法最小生成树
    void kruskalTree();            //克鲁斯卡尔算法最小生成树
    
private:
    bool getValueFromMatrix(int row, int col, int &val);//从矩阵中获取权值
    void breadthFirstTraverseImpl(vector<int> preVec);//广度优先遍历实现函数
    
    int getMinEdge(vector<Edge> edgeVec);//获得最小边
    bool isInSet(vector<int> nodeSet, int target);//判断顶点(节点)是否在集合中
    void mergeNodeSet(vector<int> &nodeSetA, vector<int> nodeSetB);//合并两个点的集合,B合并到A中

private:
    int m_iCapacity;//容量
    int m_iNodeCount;//节点个数
    Node *m_pNodeArray;//顶点数组
    int *m_pMatrix;//存放邻接矩阵,弧
    
    Edge *m_pEdge;//边的集合
};

#endif


    CMap.cpp 
    #include"CMap.h"


CMap::CMap(int capacity){
    
    m_iCapacity = capacity;
    m_iNodeCount = 0;
    m_pNodeArray = new Node[m_iCapacity];
    m_pMatrix = new int[m_iCapacity*m_iCapacity];
    //memset(m_pMatrix, 0, m_iCapacity*m_iCapacity*sizeof(int));//内存的设定
    //或
    for(int i = 0; i < m_iCapacity*m_iCapacity; i++){
        m_pMatrix[i] = 0;
    }
    
    m_pEdge = new Edge[m_iCapacity-1];//边的集合
    
}
CMap::~CMap(){
    
    delete []m_pNodeArray;
    delete []m_pMatrix;
    delete []m_pEdge;
}

bool CMap::addNode(Node *pNode){
    
    if(pNode == NULL){
        return false;
    }
    m_pNodeArray[m_iNodeCount].m_cData = pNode->m_cData;
    m_iNodeCount++;
    return true;
}
void CMap::resetNode(){
    
    for(int i = 0; i < m_iNodeCount; i++){
        
        m_pNodeArray[i].m_bIsVisited = false;
    }
}

bool CMap::setValueToMatrixForDirectedGraph(int row, int col, int val){
    
    if(row < 0 || row >= m_iCapacity){
        return false;
    }
    if(col < 0 || col >= m_iCapacity){
        return false;
    }
    m_pMatrix[row*m_iCapacity + col] = val;
    return true;
}

bool CMap::setValueToMatrixForUndriectedGraph(int row, int col, int val){
    
    if(row < 0 || row >= m_iCapacity){
        return false;
    }
    if(col < 0 || col >= m_iCapacity){
        return false;
    }
    m_pMatrix[row*m_iCapacity + col] = val;
    m_pMatrix[col*m_iCapacity + row] = val;
    return true;
}

void CMap::printMatrix(){
    
    for(int i = 0; i < m_iCapacity; i++){
        for(int j = 0; j < m_iCapacity; j++){
            cout << m_pMatrix[i*m_iCapacity + j] << " ";
        }
        cout << endl;
    }
}


void CMap::depthFirstTraverse(int nodeIndex){//深度优先搜索
    
    int value = 0;
    
    cout << m_pNodeArray[nodeIndex].m_cData << " ";
    m_pNodeArray[nodeIndex].m_bIsVisited = true;
    
    //通过邻接矩阵判断是否与其他的顶点有连接,看是否存在一条连通的弧
    for(int i = 0; i < m_iCapacity; i++){
        
        getValueFromMatrix(nodeIndex, i, value);//取出相应的弧
        //判断有弧连接其他顶点
        if(value != 0){//有这样的弧
            //判断  连接的顶点  是否被访问过
            if(m_pNodeArray[i].m_bIsVisited){
                continue;
            }
            else{//没有访问过，则递归访问
                depthFirstTraverse(i);
            }
        }
        else{
            continue;
        }
    }
}

void CMap::breadthFirstTraverse(int nodeIndex){//广度优先遍历
    
    cout << m_pNodeArray[nodeIndex].m_cData << " ";
    m_pNodeArray[nodeIndex].m_bIsVisited = true;
    
    vector<int> cur;
    cur.push_back(nodeIndex);//保存顶点的索引
    
    breadthFirstTraverseImpl(cur);//实现广度优先遍历的函数
}

//普里姆算法最小生成树
void CMap::primTree(int nodeIndex){
    
    int value = 0;//保存权值
    int edgeCount = 0;//边的计数器
    vector<int> nodeVec;//存储点的集合，用索引代替
    vector<Edge> edgeVec;//边的集合
    
    cout << m_pNodeArray[nodeIndex].m_cData << endl;
    
    nodeVec.push_back(nodeIndex);
    m_pNodeArray[nodeIndex].m_bIsVisited = true;
    
    while(edgeCount < m_iCapacity - 1){
        
        int temp = nodeVec.back();
        
        //放入待选边的集合
        for(int i = 0; i < m_iCapacity; i++){
            //寻找待选边的集合
            getValueFromMatrix(temp, i, value);//从邻接矩阵中获取权值
            if(value != 0){
                if(m_pNodeArray[i].m_bIsVisited){
                    continue;
                }
                else{
                    Edge edge(temp, i, value);//确定了nodeIndexA，nodeIndexB等索引
                    edgeVec.push_back(edge);//不会放重复的边
                }
            }
        }
        
        //从待选边中选出最小的边
        int edgeIndex = getMinEdge(edgeVec);//返回最小边的索引
        edgeVec[edgeIndex].m_bSelected = true;
        
        cout << edgeVec[edgeIndex].m_iNodeIndexA << "-->" << edgeVec[edgeIndex].m_iNodeIndexB << "  ";
        cout << edgeVec[edgeIndex].m_iWeightValue << endl;
        
        //放入最小生成树边的集合中
        m_pEdge[edgeCount] = edgeVec[edgeIndex];
        edgeCount++;
        
        //最小边连接的点
        int nextNodeIndex = edgeVec[edgeIndex].m_iNodeIndexB;
        
        //将下一个点放入点的集合
        nodeVec.push_back(nextNodeIndex);
        m_pNodeArray[nextNodeIndex].m_bIsVisited = true;
        
        cout << m_pNodeArray[nextNodeIndex].m_cData << endl;
    }
    
    
}

//克鲁斯卡尔算法最小生成树
void CMap::kruskalTree(){
    
    int value = 0;//存放权值
    int edgeCount = 0;//边计数器
    //定义存放节点 集合 的数组,可能不止一个点的集合，demo.cpp运行结果就是如此
    vector<vector<int> > nodeSets;
    
    //<1>取出所有边
    vector<Edge> edgeVec;
    for(int i = 0; i < m_iCapacity; i++){
        
        for(int j = i + 1; j < m_iCapacity; j++){//上三角，不包含主对角线，例如A-A,B-B..没意义
            
            getValueFromMatrix(i, j, value);//从邻接矩阵中获取权值
            if(value != 0){
                
                Edge edge(i, j, value);//确定了nodeIndexA，nodeIndexB等索引
                edgeVec.push_back(edge);//放入边集合中
            }
        }
    }
    
    
    //<2>从所有边中取出组成最小生成树的边
    //1.算法结束条件
     while(edgeCount < m_iCapacity - 1){
         
    //2.从边集合中找到最小边
        int minEdgeIndex = getMinEdge(edgeVec);
        edgeVec[minEdgeIndex].m_bSelected = true;
        
    //3.找出最小边连接的点
        int nodeIndexA = edgeVec[minEdgeIndex].m_iNodeIndexA;
        int nodeIndexB = edgeVec[minEdgeIndex].m_iNodeIndexB;
    //4.找出点所在的集合
        bool nodeAIsInSet = false;
        bool nodeBIsInSet = false;
        int nodeAInSetLabel = -1;
        int nodeBInSetLabel = -1;
        
        for(int i = 0; i < nodeSets.size(); i++){//A点集合所在的索引
             
             nodeAIsInSet = isInSet(nodeSets[i], nodeIndexA);
             if(nodeAIsInSet){
                 
                 nodeAInSetLabel = i;
            }
        }
        
        for(int i = 0; i < nodeSets.size(); i++){//B点集合所在的索引
             
             nodeBIsInSet = isInSet(nodeSets[i], nodeIndexB);
             if(nodeAIsInSet){
                 
                 nodeBInSetLabel = i;
            }
        }
        //5.根据点所在集合的不同做不同的处理
        if(nodeAInSetLabel == -1 && nodeBInSetLabel == -1){
            
            vector<int> vec;
            vec.push_back(nodeAInSetLabel);
            vec.push_back(nodeBInSetLabel);
            nodeSets.push_back(vec);
            
        }
        else if(nodeAInSetLabel == -1 && nodeBInSetLabel != -1){
            
            nodeSets[nodeBInSetLabel].push_back(nodeIndexA);//nodeIndexA到B集合
        }
        
        else if(nodeAInSetLabel != -1 && nodeBInSetLabel == -1){
            
            nodeSets[nodeAInSetLabel].push_back(nodeIndexB);//nodeIndexB到A集合
        }
        //合并两个集合
        else if(nodeAInSetLabel != -1 && nodeBInSetLabel != -1 && nodeAInSetLabel != nodeBInSetLabel){
            
            mergeNodeSet(nodeSets[nodeAInSetLabel], nodeSets[nodeBInSetLabel]);//合并到A集合
            for(int k = nodeBInSetLabel; k < (int)nodeSets.size(); k++){
                
                nodeSets[k] = nodeSets[k+1];//清除B集合所占空间
            }
        }
        //两个点在一个集合中形成了回路，舍弃
        else if(nodeAInSetLabel != -1 && nodeBInSetLabel != -1 && nodeAInSetLabel == nodeBInSetLabel){
            
            continue;
        }
        
        m_pEdge[edgeCount] = edgeVec[minEdgeIndex];//放入边的集合中
        edgeCount++;//边数增加
        
        cout << edgeVec[minEdgeIndex].m_iNodeIndexA << "-->" << edgeVec[minEdgeIndex].m_iNodeIndexB << "  ";
        cout << edgeVec[minEdgeIndex].m_iWeightValue << endl;
    }
    
}

bool CMap::getValueFromMatrix(int row, int col, int &val){
    
    if(row < 0 || row >= m_iCapacity){
        return false;
    }
    if(col < 0 || col >= m_iCapacity){
        return false;
    }
    val = m_pMatrix[row*m_iCapacity + col];
    return true;
}


void CMap::breadthFirstTraverseImpl(vector<int> preVec){
    
    int value = 0;
    vector<int> cur;
    
    for(int i = 0; i < preVec.size();i++){//上一层的节点数
        
        for(int j = 0; j < m_iCapacity; j++){
            //判断当前点与其他点是否有连接
            getValueFromMatrix(preVec[i], j, value);//上一个点判断是否有连接j的弧
            if(value != 0){
                if(m_pNodeArray[j].m_bIsVisited){//看是否被访问过
                    continue;
                }
                else{//若没有访问过的话
                    cout << m_pNodeArray[j].m_cData << " ";//现有的顶点
                    m_pNodeArray[j].m_bIsVisited = true;
                    
                    cur.push_back(j);//当前的点保存到数组中
                }
            }
            
        }
    }
    
    if(cur.size() == 0){//下一层节点数的判断
        return ;
    }
    else{//下一层节点数的开始，递归进行深度优先遍历
        breadthFirstTraverseImpl(cur);
    }
}

int CMap::getMinEdge(vector<Edge> edgeVec){//获得最小边
    
    int minWeight = 0;
    int edgeIndex = 0;
    int i = 0;
    for(; i < edgeVec.size(); i++){//找出第一条没有被访问过的边
        
        if(!edgeVec[i].m_bSelected){
            
            minWeight = edgeVec[i].m_iWeightValue;//权值
            edgeIndex = i;//边的索引
            break;//找到，则跳出循环
        }
    }
    
    if(0 == minWeight){//若都被访问过的话
        return -1;
    }
    
    //接着i后面继续找
    for(; i < (int)edgeVec.size(); i++){//找出最小权值的边
        
        if(edgeVec[i].m_bSelected){
            continue;
        }
        else{
            if(minWeight > edgeVec[i].m_iWeightValue){
                
                minWeight = edgeVec[i].m_iWeightValue;
                edgeIndex = i;
            }
        }
    }
    
    return edgeIndex;
}

bool CMap::isInSet(vector<int> nodeSet, int target){
    
    for(int i = 0; i < nodeSet.size(); i++){
        
        if(nodeSet[i] == target){
            
            return true;
        }
    }
    
    return false;
}

void CMap::mergeNodeSet(vector<int> &nodeSetA, vector<int> nodeSetB){
    
    for(int i = 0; i < nodeSetB.size(); i++){
        
        nodeSetA.push_back(nodeSetB[i]);
    }
}


    demo.cpp 
    #include"CMap.h"
#include<iostream>
using namespace std;
//---------------------------------------
//-----根据下图----------------------------------------
//--实现普里姆算法(Prim)--及--克鲁斯卡尔算法(kruskal)---------------
/*
            A
         /  |  \
       B -- F -- E
         \  / \ /
          C -- D
          A B C D E F
索引：    0 1 2 3 4 5

权值：     A-B 6        A-F 1     A-E 5
           B-C 3        B-F 2
           C-F 8        C-D 7
           D-F 4        D-E 2
           E-F 9

        //无向图
         A    B    C    D    E
    A    0    1    1    0    0
    
    B    1    0    0    1    1
    
    C    1    0    0    0    0
    
    D    0    1    0    0    0
    
    E    0    1    0    0    0


*/

int main(){
    
    Node *node = new Node[6]; 
    node[0].m_cData = 'A';
    node[1].m_cData = 'B';
    node[2].m_cData = 'C';
    node[3].m_cData = 'D';
    node[4].m_cData = 'E';
    node[5].m_cData = 'F';
    
    CMap *cmap = new CMap(6);
    
    cmap->addNode(&node[0]);
    cmap->addNode(&node[1]);
    cmap->addNode(&node[2]);
    cmap->addNode(&node[3]);
    cmap->addNode(&node[4]);
    cmap->addNode(&node[5]);
    
    //为无向图设置邻接矩阵
    cmap->setValueToMatrixForUndriectedGraph(0, 1, 6);
    cmap->setValueToMatrixForUndriectedGraph(0, 4, 5);
    cmap->setValueToMatrixForUndriectedGraph(0, 5, 1);
    cmap->setValueToMatrixForUndriectedGraph(1, 2, 3);
    cmap->setValueToMatrixForUndriectedGraph(1, 5, 2);
    cmap->setValueToMatrixForUndriectedGraph(2, 5, 8);
    cmap->setValueToMatrixForUndriectedGraph(2, 3, 7);
    cmap->setValueToMatrixForUndriectedGraph(3, 5, 4);
    cmap->setValueToMatrixForUndriectedGraph(3, 4, 2);
    cmap->setValueToMatrixForUndriectedGraph(4, 5, 9);
    
    cmap->primTree(0);
    cout << endl << endl;
    cmap->kruskalTree();
    
    
    
    /*cmap->printMatrix();
    
    cout << endl;
    cmap->depthFirstTraverse(0);
    cmap->resetNode();
    cout << endl;
    cmap->breadthFirstTraverse(0);*/
    
    delete cmap;
    cmap = NULL;

}


    //控制台运行得：
    A
    0-->5  1
    F
    5-->1  2
    B
    1-->2  3
    C
    5-->3  4
    D
    3-->4  2
    E


    0-->5  1
    1-->5  2
    3-->4  2
    1-->2  3
    3-->5  4

    //--------------------------------------------------------------------------

    //-----------------------------------------------------------------------------------------

    C51ArmConWinceLinux
    关注
    • 1
      点赞
    • 踩
    • 0
      收藏
      觉得还不错? 一键收藏
    • 0
      评论
    专栏目录
    python_prim最小生成树算法
    都凉儿的博客
    08-24 650
    假设要在n个城市之间建立通信网络，则连通n个城市至少需要n-1条线路。n个城市之间，最多可能设置n(n-1)/2条线路。如何在这些可能的线路中选择n-1条，以便在最节省费用的前提下建立该通信网络？ ...
    普里姆算法最小生成树_普里姆的最小生成树
    cumtb2009的博客
    07-19 1895
    普里姆算法最小生成树What to Learn? 学什么？ How to construct minimum spanning tree using Prim's Minimum Spanning Tree algorithm and its C++ implementation? 如何使用Prim的最小生成树算法及其C ++实现构造最小生成树？ Minimum Spanning Tree...
    最小生成树详解(模板 + 例题)
    热门推荐
    潘小蓝的博客
    10-15 12万+
    作为一个伪ACMer,先来首广为人知的打油诗: 模拟只会猜题意，贪心只能过样例，数学上来先打表，规律一般是DP，组合数学碰运气，计算几何瞎暴力，图论一顿套模板，数论只会GCD,递归递推伤不起，搜索茫然TLE，分治做得像枚举，暴力枚举数第一，数据结构干瞪眼，怒刷水题找信心。 文章目录1、什么是树2、最小生成树3、最小生成树的应用4、实现最小生成树的两种算法4.1 prim (普里姆算法)4.2 kruskal (克鲁斯卡尔算法)5、总结 1、什么是树 如果一个无向连通图不包含回路(连通图中不存在环),.
    最小生成树
    Tom的博客
    05-08 5981
    简单介绍两大算法——Prim算法 和 Kruskal 算法.
    最小生成树的性质及证明
    qq_23096319的博客
    02-03 1673
    是MST，所以新加上的边一定是环上最大的，环上的其他边只能来自。是任意一棵生成树，将所有边以非递减的次序排列，即。，这些边会形成多个连通分支，而每个。性质二可以应用两次性质三推出。数某个最小生成树边的子集，且。中边权重值构成的有序列表，中边权重值构成的有序列表。中，形成一个环，所有边均在。的两端点均在同一个分支中，是其他的最小生成树，则有。任意一个最小生成树，且。是另一个MST，且包含。属于一棵最小生成树。是环上的另一条边，则。不失一般性，假设存在。是树中的边，至多形成。
    python最小生成树算法_最小生成树：Kruskal算法及python实现
    weixin_42337065的博客
    02-21 2744
    本人数学专业本科，研究生读的计算机，方向是深度学习相关的，在平时上课和自己自学，看论文都是深度学习和机器学习相关的。打算毕业之后从事机器学习相关工作，但是不知道学完Dl，ML的相关算法之后，还需不需要学习传统的数据结构，比如二叉树，图，队列，栈什么的，还有必要学习算法导论里的算法吗？如果都学的话，那感觉时间不够，而且这些难度都挺大的。有没有前辈来指点一二呢？这是今天逛知乎时看到的一个提问“学习机器...
    判断最小生成树的唯一性
    Mr_dimple的博客
    04-06 5282
    先来看一个例题：Forsaken喜欢独一无二的树 题意： 现在给定一个 nnn 个点，mmm 条边的图，每条边 eie_{i}ei​ 都有一个权值 wiw_{i}wi​ 。 刚开始最小生成树可能不唯一，现在可以删除一些边，使得剩下的边的最小生成树大小不变并且唯一。 求删除的边的权值和最小是多少? 分析： 什么样的边会影响到最小生成树的唯一性呢？ kruskal 求最小生成树 是将所有边权从小到大排序，然后判断当前边的两个端点所在连通块是否连通。如果没有连通，那么这条边就需要拿。 而此时如果有另外一条边，虽然
    7.3 图-最小生成树
    michael_linux的博客，一个小小小学生。滴水穿石，步步为营，只为那刹那芳华。
    08-13 2546
    图-最小生成树1 普里姆算法2 克鲁斯卡尔算法3 重(双)连通图和关节点4 两点之间的最短路径问题4.1 源点到其余各点的最短路径4.2 每一对顶点之间的最短路径5 拓扑排序6 关键路径待处理 问题：如图假设要在 n 个城市之间建立通讯联络网，则连通 n 个城市只需要修建 n-1 条线路，如何在最节省经费的前提下建立这个通讯网？ 该问题等价于：构造网的一棵最小生成树，即：在 e 条带权的边中选取 n-1条 (不构成回路)，使 “权值之和” 为最小。 1 普里姆算法 可取图中任意一个顶点v作为生成树的根，之
    图Graph--最小生成树
    Michael是个半路程序员
    06-14 1247
    文章目录1.概念 1.概念 对图运用不同的遍历方法就可能得到图的不同遍历顺序，每一种遍历顺序对应于一棵生成树 对于无向连通图，所有的生成树中必有一棵树的所有边的权的总和最小的，称之为最小生成树（Minimum cost spanning tree） ...
    C++实现图 - 03 最小生成树
    Newin2020的博客
    06-05 4982
    数据结构与算法专栏 —— C++实现一个连通图的生成树是一个极小的连通子图，它包含图中全部的 n 个顶点，但只有构成一棵树的 n-1 条边。说人话就是我要用最少的边将所有结点连接起来，直接上图： 而这个原图的生成树就有一下三个：由此可以知道对于包含 n 个顶点的无向完全图最多包含 n 的 n-2 次方颗生成树。最小生成树是带权图当中所有边权之和最小的生成树，对于一个无权图它只有生成树而没有最小生成树。我们还是直接看图理解，假设有这样一个带权无向图：那么我们可以得到它的最小生成树：通过计算可以知道，其所有边权
    最小生成树_prim_数据结构_课设_最小生成树_
    10-04
    问题描述：给定一个地区的n个城市间的距离网，用Prim算法或Kruskal算法建立最小生成树，并计算得到的最小生成树的代价。基本要求：1、城市间的距离网采用邻接矩阵表示，邻接矩阵的存储结构定义采用课本中给出的定义...
    图的最小生成树（Kruskal算法）_图的最小生成树_
    10-04
    图的最小生成树是图论中的一个重要概念，它在计算机科学和网络设计中有着广泛的应用。这个概念主要是解决如何在连接n个顶点的无向图中找到一棵包含所有顶点且边权重之和尽可能小的树。在实际问题中，这可以用于规划...
    最小生成树_matlab图论_最小生成树_
    10-03
    最小生成树问题就是在加权图中寻找一棵包括所有顶点的树，使得树中所有边的权重之和最小。 Kruskal算法是一种解决最小生成树问题的有效方法，其基本步骤如下： 1. **按边的权重排序**：首先，将图中的所有边按照...
    smallest_tree.rar_最小生成树_最小生成树 C++
    09-19
    4. **实践应用**：尝试用给定的算法解决不同类型的最小生成树问题，比如带权连通图、非连通图等。 5. **优化技巧**：研究如何优化这两种算法，比如使用 Fibonacci heap 优化Prim算法，或者采用 disjoint-set with ...
    MST-.rar_MST prim_mst_最小生成树
    09-24
    最小生成树（Minimum Spanning Tree, MST）是图论中的一个重要概念，特别是在计算机科学和网络设计中具有广泛...用户可以通过这个程序，输入自己的图数据，快速得到最小生成树的解决方案，简化了计算过程，提高了效率。
    ubuntu20.04安装教程.docx
    07-09
    安装 Ubuntu 20.04（Focal Fossa）的步骤如下所示。确保在开始安装之前备份重要数据，以防万一。 1. 下载 Ubuntu 20.04 镜像文件 访问 Ubuntu 官网（https://ubuntu.com/download/desktop）下载 Ubuntu 20.04 的镜像文件。根据你的计算机架构选择合适的版本（通常是 64 位的）。 2. 制作启动盘 你可以使用以下两种方法制作 Ubuntu 的启动盘： 使用 Rufus 制作启动盘（适用于 Windows）： 下载并安装 Rufus。 插入空白 USB 驱动器。 打开 Rufus，选择你下载的 Ubuntu 镜像文件。 点击 "开始" 制作启动盘。 使用 Etcher 制作启动盘（跨平台）： 下载并安装 Etcher。 打开 Etcher，选择 Ubuntu 镜像文件和你的 USB 驱动器。 点击 "Flash!" 制作启动盘。 3. 安装 Ubuntu 20.04 制作完成后，将 USB 启动盘插入到需要安装 Ubuntu 的计算机上，然后按照以下步骤进行安装： 启动计算机：在 BIOS 设置
    贵阳市建筑物矢量数据（Shp格式+带高度）.txt
    最新发布
    07-09
    因文件较多，数据存放网盘，txt文件内包含下载链接及提取码，永久有效。失效会第一时间进行补充。
    学校安全责任追究制度.docx
    07-09
    学校安全责任追究制度
    述职报告（08）PPT模板.pptx
    07-09
    述职报告（08）PPT模板.pptx
    prim＿mst构造最小生成树的思想
    12-28
    6. 最终得到的MST就是原图的最小生成树。 以下是使用prim_mst构造最小生成树的示例代码： ```python import numpy as np def prim_mst(graph): num_vertices = len(graph) MST = [] visited = set() # 选择...

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

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

    请填写红包祝福语或标题

    个

    红包个数最小为10个

    元

    红包金额最低5元

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

    抵扣说明：

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

    余额充值