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

最新推荐文章于 2024-04-01 11:40:29 发布
最新推荐文章于 2024-04-01 11:40:29 发布
阅读量613 收藏 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
    评论
图的计算（2）：带权图的最短路径
scienceknight的博客
01-13 2913
带权图(weighted digraph) 设G=(V,E)是一简单图。称一元函数 w:E®R+ 为图G 的权函数，使得　对于每一条边eÎE，均有一正实数w(e)ÎR+与之对应，称图G 为带有权w的图，简称为带权图。并记为G=(V,E, w)。 最短路(shortest path) 设G=(V,E,w)是一带权图。 (1)设P=(ei1, ei2,¼, eik)是G中的一条路。则路P的路长 定义为： w(P)=； 　(2)从结点u到结点v的最短路P0是满足下述条件的...
最小树形图（有向图的最小生成树）
辰巳X4
08-09 1万+
我们知道，无向图的最小生成树的求法有Krusal和prime算法，一个是归点一个是归边，在具体实现上Krusal可以用并查集实现，难度不大。 这里稍微区别一下最短路径和最小生成树（因为我又搞混了23333） 最小生成树能够保证首先是树（对于n个顶点的图只有n-1条边），其次保证任意两个顶点之间都可达，再次保证这棵树的边权值之和为最小，但不能保证任意两点之间是最短路径； 最短路径保证从源点S到目地...
数据结构(9)之带权图
star时光的博客
05-14 6589
1.        带权图中，边带有一个数字，叫做权，它可能代表距离、耗费、时间或其他意义。 2.        带权图用来最常解决的问题是最短路径问题（pps）。 3.        带权图的最小生成树中有所有的顶点和连接它们的必要的边，且这些边的权值最小。 4.        优先级队列的算法可用于寻找带权图的最小生成树。 5.        解决无向带权图的最小生成树的方法 1) 
带权图 Weighted Graph
底层码农
11-10 1万+
带权图 Weighted Graph
二、图的表示和带权图
dragon Fly的博客
04-01 1000
上述使用图的邻接矩阵表示图的时候，当图时一个稀疏图时(图中的边数量较少)，在图的存储时会浪费大量的存储空间，所以需要将图进行压缩存储。邻接表中表的头结点表示图中每一个顶点，邻接表中的每一个节点中有值域和指针域，值域存储图中节点的编号，指针域存储一个指针，指向和当前结点相邻接的其他结点。可以用无向加权图来对TSP建模，则城市是图的顶点，道路是图的边，道路的距离就是该边的长度。将图的所有顶点和所有的边分别构成一个二维矩阵的行列，将顶点之间和边之间的关系表示在构成的矩阵之中，则称这个二维矩阵为图的关联矩阵。
贝叶斯网络
SunChao3555的博客
04-09 1319
条件概率： 全概率公式： 贝叶斯（Bayes）公式： 朴素贝叶斯的假设 1.一个特征出现的概率，与其他特征（条件）独立（特征独立性）-------对于给定分类的条件下，特征独立 2.每个特征同等重要（特征均衡性） ---------------七月在线机器学习笔记 以文本分类为例： 样本：1000封邮件，每个邮件...
头歌数据结构图的最小生成树算法
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)，访问并加入...
带权无向图
09-17
关于c 的数据结构 图方面得东西 可以对图有好的了解
3367 Pseudoforest 伪森林 最小生成树
u010690055的专栏
06-05 859
这题做的我吐血，wang了n次了。 刚开始题意理解错了，后来思路弄错。 最后还是看了disscuss过得，引用下: 【copy】 这题题意理解了好一阵子才明白, 给出一个图，要求出最大的pseudoforest， 所谓pseudoforest就是指这个图的一个子图，这个子图的每个连通分量中最多只能有一个环， 而且这个子图的所有权值之和最大。这个就是所谓的伪森林。 过程类似与krusk
数据结构：最小生成树--Prim算法
CCPP Blog
08-05 1万+
最小生成树 给定一无向带权图，顶点数是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中。
带权图的最小生成树问题
Stevenson的博客
04-21 7604
带权图的最小生成树问题假设共有六个定点，分别为命名为０-５，如下图所示： 根据图构建出邻接矩阵adjMat[][]如下（其中权值为-1表示该两点之间没有路径）： adjMat[][] 0 1 2 3 4 5 0 -1 6 -1 4 -1 -1 1 6 -1 10 7 7 -1 2 -1 10
最大生成树
DK
07-31 3490
POJ 2377 一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，并且有保持图连通的最少的边。[1]  最小生成树可以用kruskal（克鲁斯卡尔）算法或prim（普里姆）算法求出。 Time Limit:1000MS     Memory Limit:65536KB     64bit IO Form
6.1图的定义、无向图、有向图、连通图、强连通图、带权图
qq_26553393的博客
01-19 1万+
1. 知识总览 2. 图的定义 3. 图逻辑结构的应用 4. 无向图、有向图 5. 简单图、多重图 6. 顶点的度、入度、出度 7. 连通图、强连通图 8. 研究图的局部–子图 9. 连通分量 10. 强连通分量 11. 生成树 12. 生成森林 13 边的权、带权图/网 14. 几种特殊形态的图 15. 知识回顾 1. 知识总览 2. 图的定义 3. 图逻辑结构的应用 4. 无向图、有向图 5. 简单图、多重图 6. 顶点的度、入度、出度 7. 连通图、强连通图 8. 研究图...
(带权有向图)邻接矩阵表示图代码实现
热门推荐
叫个锤子哟
11-26 2万+
package dn1124; /**    * @author sj  E-mail: 961784535@qq.com    * @version 创建时间: 2017-11-26 下午10:16:38    * 类说明:  (带权有向图)邻接矩阵表示图代码实现  */ public class Graph { public static final int MAX_WEIG
带权图的最小生成树
DouDouLee_blog的博客
08-26 1991
数据结构实验图的最小生成树
最新发布
06-07
数据结构实验中的最小生成树问题，是指在一个无向连通带权图中，找到一棵生成树，使得所有边的权值之和最小。 求解最小生成树的算法有很多种，其中比较常见的是Prim算法和Kruskal算法。这两个算法都是贪心算法，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值