算法与数据结构之带权图与图最小生成树

最新推荐文章于 2024-04-01 11:40:29 发布
最新推荐文章于 2024-04-01 11:40:29 发布
阅读量614 收藏 1
点赞数
文章标签： 数据结构与算法
原文链接：https://juejin.im/post/5b23759ee51d4558d726da8a
版权

主要介绍有权图、最小生成树问题和切分定理、Prim算法、Krusk算法等

带权图 Weighted Graph

边上都有自己的权值的带权图。

邻接矩阵表示有权图

  • 把原来的1/0变成权值。

邻接表的改造

  • 邻接表的点变成键值对。节点的索引：权值。封装成Edge类
  • 为了让邻接表和邻接矩阵有一个统一的接口：Edge。i到j的。
  • 没有边的地方用空。edge中存储一个指针。

edge类代码实现

// 边
template<typename Weight>
class Edge{
private:
    int a,b;    // 边的两个端点
    Weight weight;  // 边的权值

public:
    // 构造函数
    Edge(int a, int b, Weight weight){
        this->a = a;
        this->b = b;
        this->weight = weight;
    }
    // 空的构造函数, 所有的成员变量都取默认值
    Edge(){}

    ~Edge(){}

    int v(){ return a;} // 返回第一个顶点
    int w(){ return b;} // 返回第二个顶点
    Weight wt(){ return weight;}    // 返回权值

    // 给定一个顶点, 返回另一个顶点
    int other(int x){
        assert( x == a || x == b );
        return x == a ? b : a;
    }

    // 输出边的信息
    friend ostream& operator<<(ostream &os, const Edge &e){
        os<<e.a<<"-"<<e.b<<": "<<e.weight;
        return os;
    }

    // 边的大小比较, 是对边的权值的大小比较
    bool operator<(Edge<Weight>& e){
        return weight < e.wt();
    }
    bool operator<=(Edge<Weight>& e){
        return weight <= e.wt();
    }
    bool operator>(Edge<Weight>& e){
        return weight > e.wt();
    }
    bool operator>=(Edge<Weight>& e){
        return weight >= e.wt();
    }
    bool operator==(Edge<Weight>& e){
        return weight == e.wt();
    }
};
复制代码

稠密有权图代码实现

// 稠密图 - 邻接矩阵
template <typename Weight>
class DenseGraph{

private:
    int n, m;       // 节点数和边数
    bool directed;  // 是否为有向图
    vector<vector<Edge<Weight> *>> g;   // 图的具体数据

public:
    // 构造函数
    DenseGraph( int n , bool directed){
        assert( n >= 0 );
        this->n = n;
        this->m = 0;
        this->directed = directed;
        // g初始化为n*n的矩阵, 每一个g[i][j]指向一个边的信息, 初始化为NULL
        g = vector<vector<Edge<Weight> *>>(n, vector<Edge<Weight> *>(n, NULL));
    }

    // 析构函数
    ~DenseGraph(){

        for( int i = 0 ; i < n ; i ++ )
            for( int j = 0 ; j < n ; j ++ )
                if( g[i][j] != NULL )
                    delete g[i][j];
    }

    int V(){ return n;} // 返回节点个数
    int E(){ return m;} // 返回边的个数

    // 向图中添加一个边, 权值为weight
    void addEdge( int v, int w , Weight weight ){
        assert( v >= 0 && v < n );
        assert( w >= 0 && w < n );

        // 如果从v到w已经有边, 删除这条边
        if( hasEdge( v , w  ) ){
            delete  g[v][w];
            if( v != w && !directed )
                delete g[w][v];
            m --;
        }

        g[v][w] = new Edge<Weight>(v, w, weight);
        if( v != w && !directed )
            g[w][v] = new Edge<Weight>(w, v, weight);
        m ++;
    }

    // 验证图中是否有从v到w的边
    bool hasEdge( int v , int w ){
        assert( v >= 0 && v < n );
        assert( w >= 0 && w < n );
        return g[v][w] != NULL;
    }

    // 显示图的信息
    void show(){

        for( int i = 0 ; i < n ; i ++ ){
            for( int j = 0 ; j < n ; j ++ )
                if( g[i][j] )
                    cout<<g[i][j]->wt()<<"\t";
                else
                    cout<<"NULL\t";
            cout<<endl;
        }
    }

    // 邻边迭代器, 传入一个图和一个顶点,
    // 迭代在这个图中和这个顶点向连的所有边
    class adjIterator{
    private:
        DenseGraph &G;  // 图G的引用
        int v;
        int index;

    public:
        // 构造函数
        adjIterator(DenseGraph &graph, int v): G(graph){
            this->v = v;
            this->index = -1;   // 索引从-1开始, 因为每次遍历都需要调用一次next()
        }

        ~adjIterator(){}

        // 返回图G中与顶点v相连接的第一个边
        Edge<Weight>* begin(){
            // 索引从-1开始, 因为每次遍历都需要调用一次next()
            index = -1;
            return next();
        }

        // 返回图G中与顶点v相连接的下一个边
        Edge<Weight>* next(){
            // 从当前index开始向后搜索, 直到找到一个g[v][index]为true
            for( index += 1 ; index < G.V() ; index ++ )
                if( G.g[v][index] )
                    return G.g[v][index];
            // 若没有顶点和v相连接, 则返回NULL
            return NULL;
        }

        // 查看是否已经迭代完了图G中与顶点v相连接的所有边
        bool end(){
            return index >= G.V();
        }
    };
};
复制代码

main.cpp:

// 测试有权图和有权图的读取
int main() {

    string filename = "testG1.txt";
    int V = 8;
    cout<<fixed<<setprecision(2);

    // Test Weighted Dense Graph
    DenseGraph<double> g1 = DenseGraph<double>(V, false);
    ReadGraph<DenseGraph<double>,double> readGraph1(g1, filename);
    g1.show();
    cout<<endl;

    // Test Weighted Sparse Graph
    SparseGraph<double> g2 = SparseGraph<double>(V, false);
    ReadGraph<SparseGraph<double>,double> readGraph2(g2, filename);
    g2.show();
    cout<<endl;

    return 0;
}
复制代码

稀疏有权图代码实现

// 稀疏图 - 邻接表
template<typename Weight>
class SparseGraph{

private:
    int n, m;       // 节点数和边数
    bool directed;  // 是否为有向图
    vector<vector<Edge<Weight> *> > g;   // 图的具体数据

public:
    // 构造函数
    SparseGraph( int n , bool directed){
        assert(n >= 0);
        this->n = n;
        this->m = 0;    // 初始化没有任何边
        this->directed = directed;
        // g初始化为n个空的vector, 表示每一个g[i]都为空, 即没有任和边
        g = vector<vector<Edge<Weight> *> >(n, vector<Edge<Weight> *>());
    }

    // 析构函数
    ~SparseGraph(){
        for( int i = 0 ; i < n ; i ++ )
            for( int j = 0 ; j < g[i].size() ; j ++ )
                delete g[i][j];
    }

    int V(){ return n;} // 返回节点个数
    int E(){ return m;} // 返回边的个数

    // 向图中添加一个边, 权值为weight
    void addEdge( int v, int w , Weight weight){
        assert( v >= 0 && v < n );
        assert( w >= 0 && w < n );

        // 注意, 由于在邻接表的情况, 查找是否有重边需要遍历整个链表
        // 我们的程序允许重边的出现

        g[v].push_back(new Edge<Weight>(v, w, weight));
        if( v != w && !directed )
            g[w].push_back(new Edge<Weight>(w, v, weight));
        m ++;
    }

    // 验证图中是否有从v到w的边
    bool hasEdge( int v , int w ){
        assert( v >= 0 && v < n );
        assert( w >= 0 && w < n );
        for( int i = 0 ; i < g[v].size() ; i ++ )
            if( g[v][i]->other(v) == w )
                return true;
        return false;
    }

    // 显示图的信息
    void show(){

        for( int i = 0 ; i < n ; i ++ ){
            cout<<"vertex "<<i<<":\t";
            for( int j = 0 ; j < g[i].size() ; j ++ )
                cout<<"( to:"<<g[i][j]->w()<<",wt:"<<g[i][j]->wt()<<")\t";
            cout<<endl;
        }
    }

    // 邻边迭代器, 传入一个图和一个顶点,
    // 迭代在这个图中和这个顶点向连的所有边
    class adjIterator{
    private:
        SparseGraph &G; // 图G的引用
        int v;
        int index;

    public:
        // 构造函数
        adjIterator(SparseGraph &graph, int v): G(graph){
            this->v = v;
            this->index = 0;
        }

        ~adjIterator(){}

        // 返回图G中与顶点v相连接的第一个边
        Edge<Weight>* begin(){
            index = 0;
            if( G.g[v].size() )
                return G.g[v][index];
            // 若没有顶点和v相连接, 则返回NULL
            return NULL;
        }

        // 返回图G中与顶点v相连接的下一个边
        Edge<Weight>* next(){
            index += 1;
            if( index < G.g[v].size() )
                return G.g[v][index];
            return NULL;
        }

        // 查看是否已经迭代完了图G中与顶点v相连接的所有顶点
        bool end(){
            return index >= G.g[v].size();
        }
    };
};
复制代码

运行结果：

NULL	NULL	0.26	NULL	0.38	NULL	0.58	0.16	
NULL	NULL	0.36	0.29	NULL	0.32	NULL	0.19	
0.26	0.36	NULL	0.17	NULL	NULL	0.40	0.34	
NULL	0.29	0.17	NULL	NULL	NULL	0.52	NULL	
0.38	NULL	NULL	NULL	NULL	0.35	0.93	0.37	
NULL	0.32	NULL	NULL	0.35	NULL	NULL	0.28	
0.58	NULL	0.40	0.52	0.93	NULL	NULL	NULL	
0.16	0.19	0.34	NULL	0.37	0.28	NULL	NULL	

vertex 0:	( to:7,wt:0.16)	( to:4,wt:0.38)	( to:2,wt:0.26)	( to:6,wt:0.58)	
vertex 1:	( to:5,wt:0.32)	( to:7,wt:0.19)	( to:2,wt:0.36)	( to:3,wt:0.29)	
vertex 2:	( to:3,wt:0.17)	( to:0,wt:0.26)	( to:1,wt:0.36)	( to:7,wt:0.34)	( to:6,wt:0.40)	
vertex 3:	( to:2,wt:0.17)	( to:1,wt:0.29)	( to:6,wt:0.52)	
vertex 4:	( to:5,wt:0.35)	( to:7,wt:0.37)	( to:0,wt:0.38)	( to:6,wt:0.93)	
vertex 5:	( to:4,wt:0.35)	( to:7,wt:0.28)	( to:1,wt:0.32)	
vertex 6:	( to:2,wt:0.40)	( to:3,wt:0.52)	( to:0,wt:0.58)	( to:4,wt:0.93)	
vertex 7:	( to:4,wt:0.37)	( to:5,wt:0.28)	( to:0,wt:0.16)	( to:1,wt:0.19)	( to:2,wt:0.34)	

复制代码

最小生成树

最小生成树是一副连通加权无向图中一棵权值最小的生成树。 各个节点之间连通，连通总费用最小。

相关应用

  • 电缆布线设计
  • 网络设计
  • 电路设计

最小生成树主要针对：

  • 针对带权无向图
  • 针对连通图
  • 对于不连通的图，可以求所有是连通分量的最小生成树形成最小森林。

步骤

  • 找 V-1 条边
  • 连接V个顶点
  • 总权值最小

切分定理：Cut Property

切分的定义

把图中的节点分成两部分，成为一个切分（cut）

蓝色和红色的部分形成了一个切分。

横切边的定义

如果一个边的两个端点，属于切分(Cut)不同的两边，这个边称为横切边(Crossing Edge)。

切分定理：

给定任意切分，横切边中权值最小的边必然属于最小生成树。

Lazy Prim

  • 所有边中选取出v-1条。
  • 找出四条横切边中最小的
    • 最小堆进行实现
  • 把最小边加入后。进行新的切分
  • 不断加入最小横切边的点，直到所有顶点都进入（直到最后所有节点被访问过）。
  • 懒惰：虽然不是横切边，但是没有被扔掉。

Prim算法代码实现

// 使用Prim算法求图的最小生成树
template<typename Graph, typename Weight>
class LazyPrimMST{

private:
    Graph &G;                   // 图的引用
    MinHeap<Edge<Weight>> pq;   // 最小堆, 算法辅助数据结构
    bool *marked;               // 标记数组, 在算法运行过程中标记节点i是否被访问
    vector<Edge<Weight>> mst;   // 最小生成树所包含的所有边
    Weight mstWeight;           // 最小生成树的权值

    // 访问节点v
    void visit(int v){

        assert( !marked[v] );
        marked[v] = true;

        // 将和节点v相连接的所有未访问的边放入最小堆中
        typename Graph::adjIterator adj(G,v);
        for( Edge<Weight>* e = adj.begin() ; !adj.end() ; e = adj.next() )
            if( !marked[e->other(v)] )
                pq.insert(*e);
    }

public:
    // 构造函数, 使用Prim算法求图的最小生成树
    LazyPrimMST(Graph &graph):G(graph), pq(MinHeap<Edge<Weight>>(graph.E())){

        // 算法初始化
        marked = new bool[G.V()];
        for( int i = 0 ; i < G.V() ; i ++ )
            marked[i] = false;
        mst.clear();

        // Lazy Prim
        visit(0);
        while( !pq.isEmpty() ){
            // 使用最小堆找出已经访问的边中权值最小的边
            Edge<Weight> e = pq.extractMin();
            // 如果这条边的两端都已经访问过了, 则扔掉这条边
            if( marked[e.v()] == marked[e.w()] )
                continue;
            // 否则, 这条边则应该存在在最小生成树中
            mst.push_back( e );

            // 访问和这条边连接的还没有被访问过的节点
            if( !marked[e.v()] )
                visit( e.v() );
            else
                visit( e.w() );
        }

        // 计算最小生成树的权值
        mstWeight = mst[0].wt();
        for( int i = 1 ; i < mst.size() ; i ++ )
            mstWeight += mst[i].wt();
    }

    // 析构函数
    ~LazyPrimMST(){
        delete[] marked;
    }

    // 返回最小生成树的所有边
    vector<Edge<Weight>> mstEdges(){
        return mst;
    };

    // 返回最小生成树的权值
    Weight result(){
        return mstWeight;
    };
};
复制代码

main函数

int main() {

    string filename = "testG1.txt";
    int V = 8;

    SparseGraph<double> g = SparseGraph<double>(V, false);
    ReadGraph<SparseGraph<double>, double> readGraph(g, filename);

    // Test Lazy Prim MST
    cout<<"Test Lazy Prim MST:"<<endl;
    LazyPrimMST<SparseGraph<double>, double> lazyPrimMST(g);
    vector<Edge<double>> mst = lazyPrimMST.mstEdges();
    for( int i = 0 ; i < mst.size() ; i ++ )
        cout<<mst[i]<<endl;
    cout<<"The MST weight is: "<<lazyPrimMST.result()<<endl;

    cout<<endl;


    // Test Prim MST
    cout<<"Test Prim MST:"<<endl;
    PrimMST<SparseGraph<double>, double> primMST(g);
    mst = primMST.mstEdges();
    for( int i = 0 ; i < mst.size() ; i ++ )
        cout<<mst[i]<<endl;
    cout<<"The MST weight is: "<<primMST.result()<<endl;

    cout<<endl;

    return 0;
}
复制代码

结果

Test Lazy Prim MST:
0-7: 0.16
7-1: 0.19
0-2: 0.26
2-3: 0.17
7-5: 0.28
5-4: 0.35
2-6: 0.4
The MST weight is: 1.81
复制代码

时间复杂度

O(ElogE)
复制代码

###Prim算法优化

Lazy Prim存在的问题

  • 所有的边都进入最小堆，而已经访问的节点之间的边其实是可以忽略的（在最小堆中的边已经不是横切边了）。
  • 只需考虑和节点连接的最小横切边。

维护数据结构：

和每个节点相连的最短横切边。

Prim算法优化

代码实现 (O(ElogV)

//
// Created by liuyubobobo on 9/26/16.
//

#ifndef INC_05_IMPLEMENTATION_OF_OPTIMIZED_PRIM_ALGORITHM_PRIMMST_H
#define INC_05_IMPLEMENTATION_OF_OPTIMIZED_PRIM_ALGORITHM_PRIMMST_H

#include <iostream>
#include <vector>
#include <cassert>
#include "Edge.h"
#include "IndexMinHeap.h"

using namespace std;


template<typename Graph, typename Weight>
class PrimMST{

private:
    Graph &G;
    vector<Edge<Weight>> mst;

    bool* marked;
    IndexMinHeap<Weight> ipq;
    vector<Edge<Weight>*> edgeTo; //存储节点的最短横切边。
    Weight mstWeight;


    void visit(int v){
        assert( !marked[v] );
        marked[v] = true;

        typename Graph::adjIterator adj(G,v);
        for( Edge<Weight>* e = adj.begin() ; !adj.end() ; e = adj.next() ){
            int w = e->other(v);
            if( !marked[w] ){
                if( !edgeTo[w] ){
                    edgeTo[w] = e;
                    ipq.insert(w, e->wt());
                }
                else if( e->wt() < edgeTo[w]->wt() ){
                    edgeTo[w] = e;
                    ipq.change(w, e->wt());//最小索引堆才有change操作
                }
            }
        }

    }
public:
    // assume graph is connected
    PrimMST(Graph &graph):G(graph), ipq(IndexMinHeap<double>(graph.V())){

        assert( graph.E() >= 1 );

        marked = new bool[G.V()];
        for( int i = 0 ; i < G.V() ; i ++ ){
            marked[i] = false;
            edgeTo.push_back(NULL);
        }
        mst.clear();

        visit(0);
        while( !ipq.isEmpty() ){
            int v = ipq.extractMinIndex();
            assert( edgeTo[v] );
            mst.push_back( *edgeTo[v] );
            visit( v );
        }

        mstWeight = mst[0].wt();
        for( int i = 1 ; i < mst.size() ; i ++ )
            mstWeight += mst[i].wt();
    }

    ~PrimMST(){
        delete[] marked;
    }

    vector<Edge<Weight>> mstEdges(){
        return mst;
    };

    Weight result(){
        return mstWeight;
    };
};

#endif //INC_05_IMPLEMENTATION_OF_OPTIMIZED_PRIM_ALGORITHM_PRIMMST_H

复制代码

Kruskal算法

定义

Kruskal算法是一种用来查找最小生成树的算法，由Joseph Kruskal在1956年发表。用来解决同样问题的还有Prim算法和Boruvka算法等。三种算法都是贪心算法的应用。和Boruvka算法不同的地方是，Kruskal算法在图中存在相同权值的边时也有效。

步骤

  • 新建图G，G中拥有原图中相同的节点，但没有边
  • 将原图中所有的边按权值从小到大排序
  • 从权值最小的边开始，如果这条边连接的两个节点于图G中不在同一个连通分量中，则添加这条边到图G中
  • 重复3，直至图G中所有的节点都在同一个连通分量中

判断节点是否构成环

  • 使用Union Find快速判断环
    • 只需要判断已经找到的边的两个节点的根是否相同，如果相同的话说明已经是连通图了。

代码实现

// Kruskal算法
template <typename Graph, typename Weight>
class KruskalMST{

private:
    vector<Edge<Weight>> mst;   // 最小生成树所包含的所有边
    Weight mstWeight;           // 最小生成树的权值

public:
    // 构造函数, 使用Kruskal算法计算graph的最小生成树
    KruskalMST(Graph &graph){

        // 将图中的所有边存放到一个最小堆中
        MinHeap<Edge<Weight>> pq( graph.E() );
        for( int i = 0 ; i < graph.V() ; i ++ ){
            typename Graph::adjIterator adj(graph,i);
            for( Edge<Weight> *e = adj.begin() ; !adj.end() ; e = adj.next() )
                //只存一条边中的一个节点
                if( e->v() < e->w() )
                    pq.insert(*e);
        }

        // 创建一个并查集, 来查看已经访问的节点的联通情况
        UnionFind uf = UnionFind(graph.V());
        while( !pq.isEmpty() && mst.size() < graph.V() - 1 ){

            // 从最小堆中依次从小到大取出所有的边
            Edge<Weight> e = pq.extractMin();
            // 如果该边的两个端点是联通的, 说明加入这条边将产生环, 扔掉这条边
            if( uf.isConnected( e.v() , e.w() ) )
                continue;

            // 否则, 将这条边添加进最小生成树, 同时标记边的两个端点联通
            mst.push_back( e );
            uf.unionElements( e.v() , e.w() );
        }

        mstWeight = mst[0].wt();
        for( int i = 1 ; i < mst.size() ; i ++ )
            mstWeight += mst[i].wt();
    }

    ~KruskalMST(){ }

    // 返回最小生成树的所有边
    vector<Edge<Weight>> mstEdges(){
        return mst;
    };

    // 返回最小生成树的权值
    Weight result(){
        return mstWeight;
    };
};


// 测试Kruskal算法
int main() {

    string filename = "testG1.txt";
    int V = 8;

    SparseGraph<double> g = SparseGraph<double>(V, false);
    ReadGraph<SparseGraph<double>, double> readGraph(g, filename);

    // Test Lazy Prim MST
    cout<<"Test Lazy Prim MST:"<<endl;
    LazyPrimMST<SparseGraph<double>, double> lazyPrimMST(g);
    vector<Edge<double>> mst = lazyPrimMST.mstEdges();
    for( int i = 0 ; i < mst.size() ; i ++ )
        cout<<mst[i]<<endl;
    cout<<"The MST weight is: "<<lazyPrimMST.result()<<endl;

    cout<<endl;


    // Test Prim MST
    cout<<"Test Prim MST:"<<endl;
    PrimMST<SparseGraph<double>, double> primMST(g);
    mst = primMST.mstEdges();
    for( int i = 0 ; i < mst.size() ; i ++ )
        cout<<mst[i]<<endl;
    cout<<"The MST weight is: "<<primMST.result()<<endl;

    cout<<endl;


    // Test Kruskal MST
    cout<<"Test Kruskal MST:"<<endl;
    KruskalMST<SparseGraph<double>, double> kruskalMST(g);
    mst = kruskalMST.mstEdges();
    for( int i = 0 ; i < mst.size() ; i ++ )
        cout<<mst[i]<<endl;
    cout<<"The MST weight is: "<<kruskalMST.result()<<endl;


    return 0;
}
复制代码
算法的更多思考
  • Lazy Prim O( ElogE )
  • Prim O( ElogV )
  • Kruskal O( ElogE )
Vyssotsky’s Algorithm：
  • 根据算法的具体实现，每次选择一个边
  • 此时，图存在多个最小生成树
  • 将边逐渐地添加到生成树中
  • 一旦形成环，删除环中权值最大的边.

-------------------------华丽的分割线--------------------

看完的朋友可以点个喜欢/关注，您的支持是对我最大的鼓励。

个人博客番茄技术小栈和掘金主页

想了解更多，欢迎关注我的微信公众号：番茄技术小栈

weixin_33749131
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
图
qq_45030497的博客
04-23 319
图是一种较为复杂的非线性结构。 为啥说其较为复杂呢？ 根据前面的内容，我们知道： 线性数据结构的元素满足唯一的线性关系，每个元素(除第一个和最后一个外)只有一个直接前趋和一个直接后继。 树形数据结构的元素之间有着明显的层次关系。 但是，树形结构的元素之间的关系是任意的。 何为图呢？ 简单来说，图就是由顶点的有穷非空集合和顶点之间的边组成的集合。通常表示为：G(V,E)，其中，G表示一个图，V表示顶点的集合，E表示边的集合。 下图所展示的就是图这种数据结构，并且还是一张有向图。 图的基本概念 顶点 图中
数据结构与算法 -- 图的应用之最小生成树问题
LiangliangSpeak的博客
05-07 505
数据结构与算法 -- 图的应用之最小生成树问题前言1.最小生成树问题2.最小生成树求解（普里姆(Prim)算法）2.最小生成树求解（克鲁斯卡尔算法） 前言   前面对 图的存储 和 **图的遍历（广度优先/深度优先）**做了简单的学习和了解，本篇文章，学习一下最小生成树的问题，以及对应解决这个问题的两种算法 普里姆算法 和 克鲁斯卡尔算法 1.最小生成树问题 首先看下面一道面试题： 假设目前有N...
C++算法：加权连通图的最小生成树(Kruskal)
攻城狮的博客
06-14 1288
最小生成树算法就是在众多可行的方案中选择代价最小的方法。生活中我们经常会遇到类似可以抽象成最小生成树的例子：比如你要给家中布电线，我们将每个用电器看作是顶点，那你可以从总闸布设到每一电器的电线，也可以从就近点接线。假设我们用从就近点接线，那就存在如何布线更节约的问题。这就是最小生成树可以解决的问题。用数学话来说，存在一个有n个顶点的带权连通图G。如果存在一个包含了G中所有顶点以及部分边的子图G，且子图G的各边权值和最小，并且还不形成回路。那么我们就可以称子图G是图G的最小生成树。
二、图的表示和带权图
dragon Fly的博客
04-01 1009
上述使用图的邻接矩阵表示图的时候，当图时一个稀疏图时(图中的边数量较少)，在图的存储时会浪费大量的存储空间，所以需要将图进行压缩存储。邻接表中表的头结点表示图中每一个顶点，邻接表中的每一个节点中有值域和指针域，值域存储图中节点的编号，指针域存储一个指针，指向和当前结点相邻接的其他结点。可以用无向加权图来对TSP建模，则城市是图的顶点，道路是图的边，道路的距离就是该边的长度。将图的所有顶点和所有的边分别构成一个二维矩阵的行列，将顶点之间和边之间的关系表示在构成的矩阵之中，则称这个二维矩阵为图的关联矩阵。
数据结构(9)之带权图
star时光的博客
05-14 6602
1.        带权图中，边带有一个数字，叫做权，它可能代表距离、耗费、时间或其他意义。 2.        带权图用来最常解决的问题是最短路径问题（pps）。 3.        带权图的最小生成树中有所有的顶点和连接它们的必要的边，且这些边的权值最小。 4.        优先级队列的算法可用于寻找带权图的最小生成树。 5.        解决无向带权图的最小生成树的方法 1) 
数据结构之图笔记：图论基础术语以及基础知识略
被一个OIER遗弃的一堆烂代码
05-07 6847
基本概念： 一、顶点（vertex） 上图中黑色的带数字的点就是顶点，表示某个事物或对象。由于图的术语没有标准化，因此，称顶点为点、节点、结点、端点等都是可以的。叫什么无所谓，理解是什么才是关键。 二、边（edge） 上图中顶点之间蓝色的线条就是边，表示事物与事物之间的关系。需要注意的是边表示的是顶点之间的逻辑关系，粗细长短都无所谓的。包括上面的顶点也一样，表示逻辑事物或对象，画的时候大小形状都无所谓。 三、路径/最短路径（path/shortest path） 在图上任取两顶点，分别作为起点（start
图和带权图（数据结构13-14章——读书笔记）
m0_47447562的博客
05-13 3145
一. 图 在计算机程序设计中，图是最常用的结构之一。一般来说，用图来帮助解决的问题类型与本书中已经讨论过的问题类型有很大差别。如果处理一般的数据存储问题，可能用不到图，但对某些问题，图是必不可少的。 1.1 图简介 图是一种与树有些相像的数据结构。实际上，从数学意义上说，树是图的一种。然而，在计算机程序设计中，图的应用方式与树不同。 图通常有一个固定的形状，这是由物理或抽象的问题所决定的。例如，图中节点表示城市，而边可能表示城市间的班级航线。另一个更抽象的例子是一个代表了几个单独任务的图，这些任务是完成一个
数据结构_图的最小生成树（prim和kruskal算法）
qq_2210007943的博客
08-09 308
数据结构_图的应用一级目录二级目录三级目录 一级目录 二级目录 三级目录
头歌数据结构图的最小生成树算法
05-26
头歌数据结构图的最小生成树算法 第1关求图（邻接矩阵存储）最小生成树的普里姆（Prim）算法 第2关求图（邻接表存储）最小生成树的普里姆（Prim）算法 第3关求图（邻接矩阵存储）最小生成树的克鲁斯卡尔（Kruskal）...
数据结构实验报告9-图-Prim算法求最小生成树-实验内容与要求.docx
07-06
用字符文件提供数据建立连通带权网络邻接矩阵存储¬¬结构。编写程序，用Prim算法求一棵最小生成树。要求输出最小生成树的各条边（用顶点无序偶表示）、各条边上的权值、最小生成树所有边上的权值之和。
数据结构实验:用邻接表存储，并按Kruskal算法求最小生成树
10-10
根据书P262习题3给定的无向带权图，用邻接表作为存储结构，用kruskal算法构造其最小生成树。 克鲁斯卡尔算法的基本思想是:设一个有n个顶点的连通网络G={V，E}，先构造一个包括全部n个顶点和0条边的森林F={T0，T1，…...
数据结构实验-构造图的最小生成树
10-26
运用Prim算法或Kruskal算法构造图的最小生成树。 输入格式（无向图的邻接矩阵）： 8 10, 0 5, 6, 0 0, 3, 13, 0 二、实验目的 掌握图的存储方法、Prim算法或Kruskal算法。 三、实验内容及要求 1、构造图的存储结构。...
数据结构实验：用邻接矩阵存储，并按Prim算法求最小生成树
10-10
根据书P262习题3给定的无向带权图，用邻接矩阵作为存储结构，用prim算法构造其最小生成树。 对图G(V,E)设置集合S，存放已访问的顶点，然后每次从集合V-S中选择与集合S的最短距离最小的一个顶点(记为u)，访问并加入...
数据结构[4] -- 带权图
01-11 3997
带权图 GraphW 最小生成树（MSTW） 有权图的最小生成树是用优先级队列来实现的，优先级队列 可以基于堆来实现，也可以基于数组实现。 方法 从一个顶点开始，放到树的集合中，循环执行下面步骤 找到从最新的顶点到其他顶点的的所有边，这些顶点不在树的集合中，将这些边放到优先级队列 找到权值最小的边，把它和它所到达的顶点都放到树的集合中 顶点分类 已经被连接的顶点，...
【离散数学】带权图中权的意义和概念
Sky*殇的博客
03-30 5870
1. 带权图中，边带有一个数字，叫做权， 它可能代表距离、耗费、时间或其他意义。 2. 在实际问题中： 在处理有关图的实际问题时，往往有值的存在， 比如公里数，运费，城市，人口数以及电话部数等。 一般这个值成为权值，带权值的图称为带权图或赋权图。也称为网。 ...
带权图 Weighted Graph
热门推荐
底层码农
11-10 1万+
带权图 Weighted Graph
带权图最小生成树
执妄
12-22 2086
一、节点 package weightGraph; public class Vertex { public char label; public boolean isInTree; //Tree,该顶点在最小生成树里,反之就不在 public Vertex(char label) { this.label = label; this.isInTree = false; } } 二、边 package weightGraph; pu
图 —— 最小生成树
中都
06-23 1644
目录无权图的最小生成树带权图的最小生成树1、无向带权图的最小生成树2、有向带权图的最小生成树说明和总结 注意： 最小生成树和最短路径不一样的，实际应用中就是：最小生成树求的是经过所有城市的最短的那条路，最短路径只是求两个城市之间最短的那条路，它并不经过所有城市！ 无权图的最小生成树 无权的实现很简单： 随便从一个顶点开始找一个经过所有节点的路径即可； 下面的代码也是基于深度优先搜索实现的： /**...
数据结构实验图的最小生成树
最新发布
06-07
数据结构实验中的最小生成树问题，是指在一个无向连通带权图中，找到一棵生成树，使得所有边的权值之和最小。 求解最小生成树的算法有很多种，其中比较常见的是Prim算法和Kruskal算法。这两个算法都是贪心算法，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值