最小生成树---Priml算法

1 、Prim算法思想

思想：首先找到权值最小的一条边，由这两个顶点出发，分别去找权值最小的(不能有环的出现)；由各个顶点，每次都找权值最小的。

连贯的做法：从顶点的连续角度出发，每次从相应顶点出发，到权值最小的边进行连接。

模型如下：

2、Prim算法实现

lowCost[i]：表示以i为终点的边的最小权值，当lowCost[i] = 0；说明以i为终点的边的最小权值=0；也就是表示i点加入了mst数组；

    mst[i]：表示对应lowCost[i]的起点，即说明边<mst[i], i>是mst的一条边；

    每次进行一次比较，都要随之更改其lowCost和mst数组；

    每并入一个顶点，都更改为0，并且修改相应的记录；都会从内部挑选最小的权值，直到最后所有的lowCost[i] = 0;

均由C++实现(邻接矩阵实现)：

template<typename Type, typename E>
void GraphMtx<Type, E>::MinSpanTree_Prim(const Type &v){
    int n = Graph<Type, E>::getCurVertex();
    int *lowCost = new int[n];  //这两个数组是至关重要的 
    int *mst = new int[n];

    int k = getVertexIndex(v);
    for(int i = 0; i < n; i++){
        if(i != k){
            lowCost[i] = edge[k][i];  //i:表示最终顶点，lowCost[i]:表示起始到最终顶点的权值；
            mst[i] = k;  //起始顶点
        }else{
            lowCost[i] = 0;
        }
    }

    int min;
    int minIndex;
    int begin;
    int end;

    for(i = 0; i < n-1; i++){
        min = MAX_COST;
        minIndex = -1;

        for(int j = 0; j < n; j++){
            if(lowCost[j] != 0 && lowCost[j] < min){
                min = lowCost[j];  //最小权值
                minIndex = j;  //终点
            }
        }
        begin = mst[minIndex];  //起点
        end = minIndex;  //终点
        printf("%c-->%c : %d\n", getValue(begin), getValue(end), min);

        lowCost[minIndex] = 0; //赋为0并入mst集合

        int cost;
        for(j = 0; j < n; j++){  //每次都重新更改lowCost和mst数组；
            cost = edge[minIndex][j];
            if(cost < lowCost[j]){
                lowCost[j] = cost;
                mst[j] = minIndex;
            }
        }
        
    }
}

3、完整代码、测试代码、测试结果

(1)、完整代码

#ifndef _GRAPH_H_
#define _GRAPH_H_

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

#define VERTEX_DEFAULT_SIZE        10
#define MAX_COST                0x7FFFFFFF

template<typename Type, typename E>    
class Graph{
public:
    bool isEmpty()const{
        return curVertices == 0;
    }
    bool isFull()const{
        if(curVertices >= maxVertices || curEdges >= curVertices*(curVertices-1)/2)
            return true;  //图满有2种情况：(1)、当前顶点数超过了最大顶点数，存放顶点的空间已满
        return false;     //(2)、当前顶点数并没有满，但是当前顶点所能达到的边数已满
    }
    int getCurVertex()const{
        return curVertices;
    }
    int getCurEdge()const{
        return curEdges;
    }
public:
    virtual bool insertVertex(const Type &v) = 0;  //插入顶点
    virtual bool insertEdge(const Type &v1, const Type &v2, E cost) = 0; //插入边
    virtual bool removeVertex(const Type &v) = 0;  //删除顶点
    virtual bool removeEdge(const Type &v1, const Type &v2) = 0; //删除边
    virtual int getFirstNeighbor(const Type &v) = 0; //得到第一个相邻顶点
    virtual int getNextNeighbor(const Type &v, const Type &w) = 0; //得到下一个相邻顶点
public:
    virtual int getVertexIndex(const Type &v)const = 0; //得到顶点下标
    virtual void showGraph()const = 0;  //显示图
    virtual Type getValue(int index)const = 0; 
public:
    virtual void DFS(const Type &v) = 0;
    virtual void BFS(const Type &v) = 0;
protected:
    int maxVertices;  //最大顶点数
    int curVertices;  //当前顶点数
    int curEdges;  //当前边数
};

template<typename Type, typename E>
class GraphMtx : public Graph<Type, E>{ //邻接矩阵继承父类矩阵
#define maxVertices  Graph<Type, E>::maxVertices  //因为是模板，所以用父类的数据或方法都得加上作用域限定符
#define curVertices  Graph<Type, E>::curVertices
#define curEdges     Graph<Type, E>::curEdges
public:
    GraphMtx(int vertexSize = VERTEX_DEFAULT_SIZE){  //初始化邻接矩阵
        maxVertices = vertexSize > VERTEX_DEFAULT_SIZE ? vertexSize : VERTEX_DEFAULT_SIZE;
        vertexList = new Type[maxVertices]; //申请顶点空间
        for(int i = 0; i < maxVertices; i++){  //都初始化为0
            vertexList[i] = 0;
        }
        edge = new int*[maxVertices];  //申请边的行
        for(i = 0; i < maxVertices; i++){ //申请列空间
            edge[i] = new int[maxVertices];
        }
        for(i = 0; i < maxVertices; i++){ //赋初值为0 
            for(int j = 0; j < maxVertices; j++){
                if(i != j){
                    edge[i][j] = MAX_COST; //初始化时都赋为到其它边要花的代价为无穷大。
                }else{
                    edge[i][j] = 0;  //初始化时自己到自己认为花费为0
                }
            }
        }
        curVertices = curEdges = 0; //当前顶点和当前边数
    }
    GraphMtx(Type (*mt)[4], int sz){  //通过已有矩阵的初始化
        int e = 0; //统计边数
        maxVertices = sz > VERTEX_DEFAULT_SIZE ? sz : VERTEX_DEFAULT_SIZE;
        vertexList = new Type[maxVertices]; //申请顶点空间
        for(int i = 0; i < maxVertices; i++){  //都初始化为0
            vertexList[i] = 0;
        }
        edge = new int*[maxVertices];  //申请边的行
        for(i = 0; i < maxVertices; i++){ //申请列空间
            edge[i] = new Type[maxVertices];
        }
        for(i = 0; i < maxVertices; i++){ //赋初值为矩阵当中的值
            for(int j = 0; j < maxVertices; j++){
                edge[i][j] = mt[i][j];
                if(edge[i][j] != 0){
                    e++; //统计列的边数
                }
            }
        }
        curVertices = sz;
        curEdges = e/2;
    }
    ~GraphMtx(){}
public:
    bool insertVertex(const Type &v){
        if(curVertices >= maxVertices){
            return false;
        }
        vertexList[curVertices++] = v;
        return true;
    }
    bool insertEdge(const Type &v1, const Type &v2, E cost){
        int maxEdges = curVertices*(curVertices-1)/2;
        if(curEdges >= maxEdges){
            return false;
        }

        int v = getVertexIndex(v1);
        int w = getVertexIndex(v2);

        if(v==-1 || w==-1){
            cout<<"edge no exit"<<endl; //要插入的顶点不存在，无法插入
            return false;
        }
        if(edge[v][w] != MAX_COST){  //当前边已经存在，不能进行插入
            return false;
        }

        edge[v][w] = edge[w][v] = cost; //因为是无向图，对称, 权值赋为cost；
        return true; 
    }  //删除顶点的高效方法
    bool removeVertex(const Type &v){
        int i = getVertexIndex(v);
        if(i == -1){
            return false;
        }
        vertexList[i] = vertexList[curVertices-1];
        int edgeCount = 0;
        for(int k = 0; k < curVertices; k++){
            if(edge[i][k] != 0){  //统计删除那行的边数
                edgeCount++;
            }
        }
        //删除行
        for(int j = 0; j < curVertices; j++){
            edge[i][j] = edge[curVertices-1][j];
        }
        //删除列
        for(j = 0; j < curVertices; j++){
            edge[j][i] = edge[j][curVertices-1];
        }
        curVertices--;
        curEdges -= edgeCount;
        return true;
    }
/*  //删除顶点用的是数组一个一个移动的方法，效率太低。
    bool removeVertex(const Type &v){
        int i = getVertexIndex(v);
        if(i == -1){
            return false;
        }
        for(int k = i; k < curVertices-1; ++k){
            vertexList[k] = vertexList[k+1];
        }

        int edgeCount = 0;
        for(int j = 0; j < curVertices; ++j){
            if(edge[i][j] != 0)
                edgeCount++;
        }

        for(int k = i; k < curVertices-1; ++k)
        {
            for(int j = 0; j < curVertices; ++j)
            {
                edge[k][j] = edge[k+1][j];
            }
        }

        for(int k = i; k < curVertices-1; ++k)
        {
            for(int j = 0; j < curVertices; ++j)
            {
                edge[j][k] = edge[j][k+1];
            }
        }

        curVertices--;
        curEdges -= edgeCount;

        return true;
    }        
*/
    bool removeEdge(const Type &v1, const Type &v2){
        int v = getVertexIndex(v1);
        int w = getVertexIndex(v2);

        if(v==-1 || w==-1){  //判断要删除的边是否在当前顶点内
            return false;  //顶点不存在
        }
        if(edge[v][w] == 0){ //这个边根本不存在，没有必要删
            return false;
        }
        edge[v][w] = edge[w][v] = 0; //删除这个边赋值为0，代表不存在；
        curEdges--;

        return true;
    }
    int getFirstNeighbor(const Type &v){
        int i = getVertexIndex(v);
        if(i == -1){
            return -1;
        }
        for(int col = 0; col < curVertices; col++){
            if(edge[i][col] != 0){
                return col;
            }
        }
        return -1;
    }
    int getNextNeighbor(const Type &v, const Type &w){
        int i = getVertexIndex(v);
        int j = getVertexIndex(w);

        if(i==-1 || j==-1){
            return -1;
        }
        for(int col = j+1; col < curVertices; col++){
            if(edge[i][col] != 0){
                return col;
            }
        }

        return -1;
    }
public:
    void showGraph()const{
        if(curVertices == 0){
            cout<<"Nul Graph"<<endl;
            return;
        }

        for(int i = 0; i < curVertices; i++){
            cout<<vertexList[i]<<"  "; 
        }
        cout<<endl;
        for(i = 0; i < curVertices; i++){
            for(int j = 0; j < curVertices; j++){
                if(edge[i][j] != MAX_COST){
                    cout<<edge[i][j]<<"  ";
                }else{
                    cout<<"@  ";
                }
            }
            cout<<vertexList[i]<<endl;
        }
    }
    int getVertexIndex(const Type &v)const{
        for(int i = 0; i < curVertices; i++){
            if(vertexList[i] == v){
                return i;
            }
        }

        return -1;
    }
public:
    Type getValue(int index)const{
        return vertexList[index];
    }
    void DFS(const Type &v){
        int n = Graph<Type, E>::getCurVertex();
        bool *visit = new bool[n];

        for(int i = 0; i < n; i++){
            visit[i] = false;
        }
        DFS(v, visit);
        delete []visit;
    }
    void BFS(const Type &v){
        int n = Graph<Type, E>::getCurVertex();
        bool *visit = new bool[n];
        for(int i = 0; i < n; i++){
            visit[i] = false;
        }
        cout<<v<<"-->";
        int index = getVertexIndex(v);
        visit[index] = true;

        queue<int> q;  //队列中存放的是顶点下标;
        q.push(index);
        int w;
        while(!q.empty()){
            index = q.front();
            q.pop();
            w = getFirstNeighbor(getValue(index));
            while(w != -1){
                if(!visit[w]){
                    cout<<getValue(w)<<"-->";
                    visit[w] = true; 
                    q.push(w);
                }
                
                w = getNextNeighbor(getValue(index), getValue(w));
                
            }
        }

        delete []visit;
    }
public:
    void MinSpanTree_Kruskal();
    void MinSpanTree_Prim(const Type &v);
protected:
    void DFS(const Type &v, bool *visit){
        cout<<v<<"-->";
        int index = getVertexIndex(v);
        visit[index] = true;
        int w = getFirstNeighbor(v);
        while(w != -1){
            if(!visit[w]){
                DFS(getValue(w), visit);
            }
            w = getNextNeighbor(v, getValue(w)); 
        }
    }
private:
    Type *vertexList;  //存放顶点的数组
    int **edge;  //存放边关系的矩阵
};
//////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct MstEdge{
    int x;  //row
    int y;  //col
    int cost;
}MstEdge;

int cmp(const void *a, const void *b){
    return (*(MstEdge*)a).cost - (*(MstEdge*)b).cost;
}

bool isSame(int *father, int i, int j){
    while(father[i] != i){
        i = father[i];
    }
    while(father[j] != j){
        j = father[j];
    }

    return i == j;
}
void markSame(int *father, int i, int j){
    while(father[i] != i){
        i = father[i];
    }
    while(father[j] != j){
        j = father[j];
    }

    father[j] = i;
}

template<typename Type, typename E>
void GraphMtx<Type, E>::MinSpanTree_Kruskal(){ 
    int n = Graph<Type, E>::getCurVertex();  //由于要用到父类的保护数据或方法，有模板的存在，必须加上作用域限定符;
    MstEdge *edge1 = new MstEdge[n*(n-1)/2];
    int k = 0;

    for(int i = 0; i < n; i++){
        for(int j = i+1; j < n; j++){
            if(edge[i][j] != MAX_COST){
                edge1[k].x = i;
                edge1[k].y = j;
                edge1[k].cost = edge[i][j];
                k++;
            }
        }
    }
    qsort(edge1, k, sizeof(MstEdge), cmp);

    int *father = new int[n];
    Type v1, v2;
    for(i = 0; i < n; i++){
        father[i] = i;
    }
    for(i = 0; i < n; i++){
        if(!isSame(father, edge1[i].x, edge1[i].y)){
            v1 = getValue(edge1[i].x);
            v2 = getValue(edge1[i].y);
            printf("%c-->%c : %d\n", v1, v2, edge1[i].cost);
            markSame(father, edge1[i].x, edge1[i].y);
        }
    }
}
template<typename Type, typename E>
void GraphMtx<Type, E>::MinSpanTree_Prim(const Type &v){
    int n = Graph<Type, E>::getCurVertex();
    int *lowCost = new int[n];
    int *mst = new int[n];

    int k = getVertexIndex(v);
    for(int i = 0; i < n; i++){
        if(i != k){
            lowCost[i] = edge[k][i];
            mst[i] = k;
        }else{
            lowCost[i] = 0;
        }
    }

    int min;
    int minIndex;
    int begin;
    int end;

    for(i = 0; i < n-1; i++){
        min = MAX_COST;
        minIndex = -1;

        for(int j = 0; j < n; j++){
            if(lowCost[j] != 0 && lowCost[j] < min){
                min = lowCost[j];
                minIndex = j;
            }
        }
        begin = mst[minIndex];
        end = minIndex;
        printf("%c-->%c : %d\n", getValue(begin), getValue(end), min);

        lowCost[minIndex] = 0;

        int cost;
        for(j = 0; j < n; j++){
            cost = edge[minIndex][j];
            if(cost < lowCost[j]){
                lowCost[j] = cost;
                mst[j] = minIndex;
            }
        }
        
    }
}

#endif

(2)、测试代码

#include"Graph1.h"

int main(void){
    GraphMtx<char,int> gm;
    gm.insertVertex(‘A‘); //0
    gm.insertVertex(‘B‘); //1
    gm.insertVertex(‘C‘); //2
    gm.insertVertex(‘D‘); //3
    gm.insertVertex(‘E‘); //4
    gm.insertVertex(‘F‘); //5

    gm.insertEdge(‘A‘,‘B‘,6);
    gm.insertEdge(‘A‘,‘C‘,1);
    gm.insertEdge(‘A‘,‘D‘,5);
    gm.insertEdge(‘B‘,‘C‘,5);
    gm.insertEdge(‘B‘,‘E‘,3);
    gm.insertEdge(‘C‘,‘E‘,6);
    gm.insertEdge(‘C‘,‘D‘,5);
    gm.insertEdge(‘C‘,‘F‘,4);
    gm.insertEdge(‘D‘,‘F‘,2);
    gm.insertEdge(‘E‘,‘F‘,6);

    gm.showGraph();
    gm.MinSpanTree_Kruskal();
    cout<<"---------------------------------------------------------"<<endl;
    gm.MinSpanTree_Prim(‘A‘);

    return 0;
 
}

(3)、测试结果

测试图模型：

时间： 2024-10-04 16:31:37

最小生成树---Priml算法的相关文章

SOJ4339 Driving Range 最小生成树 kruskal算法

典型的最小生成树 然后求最大的一条边 附上链接 http://cstest.scu.edu.cn/soj/problem.action?id=4339 需要注意的是有可能有 "IMPOSSIBLE" 的情况 这里用一个flag标记 记录所并的节点 只有flag = n时才能成功 负责就 "IMPOSSIBLE" 1 #include <iostream> 2 #include <cstdio> 3 #include <cstring&g

最小生成树--prim算法

一个无向图G的最小生成树就是由该图的那些连接G的所有顶点的边构成的树,且其总价值最低,因此,最小生成树存在的充分必要条件为图G是连通的,简单点说如下: 1.树的定义:有n个顶点和n-1条边,没有回路的称为树 生成树的定义:生成树就是包含全部顶点,n-1(n为顶点数)条边都在图里就是生成树 最小:指的是这些边加起来的权重之和最小 2.判定条件:向生成树中任加一条边都一定构成回路 充分必要条件:最小生成树存在那么图一定是连通的,反过来,图是连通的则最小生成树一定存在 上图的红色的边加上顶点就是原图的

hdu 3371 最小生成树prim算法

Connect the Cities Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 8992    Accepted Submission(s): 2519 Problem Description In 2100, since the sea level rise, most of the cities disappear. Thoug

最小生成树 kruskal算法简介

生成树--在一个图中的一个联通子图  使得所有的节点都被(访问) 最小生成树 (MST) 即联通子图的总代价(路程)最小 已知的一个图 有n个点 m条边 kruskal的算法如下 先对边从小到大排序 从最小的边起,不停的合并这条边的两个节点到一个集合,如果这条边的两个节点已经在一个集合里,则无视,否则形成回路(显然错误)直到所有的节点并到一个集合里 这里需要用到并查集来合并节点 1 int cmp(const int i,const int j) { 2 return w[i] < w[j];

最小生成树 Kruskal算法

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

最小生成树 Prim算法 Kruskal算法

最小生成树 给定一个无向图,如果它的某个子图中任意两个顶点都互相连通并且是一棵树,那么这棵树就叫做生成树,如果边上有权值,那么使得边权和最小的生成树叫做最小生成树. 常见的求解最小生成树的算法有Kruskal算法和Prim算法,生成树是否存在和图是否连通是等价的,所以假定图是连通的. Prim算法 假设有一棵只包含一个顶点v的数T,然后贪心地选取T和其他顶点之间相连的最小权值的边,并把它加到T中.不断进行这个操作,就可以得到最小生成树了(可用反证法证明) 不使用Heap优化的代码 int eg[

POJ1258最小生成树(prim算法)

POJ1258 思路:首先把第一个结点加入树中,每次往树中加入一个结点,加入的结点必须是与当前树中的结点距离最小那个点,这样每次把结点加入树中选取的都是最小权值,循环n-1次后把所有结点都加入树中. #include<iostream> #include<cstdio> #include<cstring> using namespace std; const int MAXN = 1e9; //创建map二维数组储存图表,low数组记录每2个点间最小权值,vis数组标记

poj1789Truck History（最小生成树prim算法）

题目链接: 啊哈哈,点我点我 思路:根据字符串中不同的长度建图,然后求图的最小生成树.. 题目: Truck History Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 18272   Accepted: 7070 Description Advanced Cargo Movement, Ltd. uses trucks of different types. Some trucks are used for vege

数据结构：最小生成树--Prim算法

最小生成树:Prim算法 最小生成树 给定一无向带权图,顶点数是n,要使图连通只需n-1条边,若这n-1条边的权值和最小,则称有这n个顶点和n-1条边构成了图的最小生成树(minimum-cost spanning tree). Prim算法 Prim算法是解决最小生成树的常用算法.它采取贪心策略,从指定的顶点开始寻找最小权值的邻接点.图G=<V,E>,初始时S={V0},把与V0相邻接,且边的权值最小的顶点加入到S.不断地把S中的顶点与V-S中顶点的最小权值边加入,直到所有顶点都已加入到S中