《算法4》最小生成树讲解笔记（Prim的延时和即使实现，Kruskal算法）

最新推荐文章于 2022-11-22 18:53:54 发布
最新推荐文章于 2022-11-22 18:53:54 发布
阅读量397 收藏 2
点赞数
分类专栏： 数据结构和算法 文章标签： 算法 数据结构 java kruskal prim
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43696529/article/details/104744242
版权

生成树： 图的生成树就是一颗含有其所有顶点的无环连通子图。
最小生成树： 即给定一个加权无向图，找到它的一颗最小生成树（权值最小）。

因此最小生成树的研究范围是：
带权无向图，且是连通图。

如下给出加权无向图的数据结构：
带权重的边：

/**
 * 带权重的边
 * @author MaoLin Wang
 * @date 2020/2/239:49
 */
public class Edge implements Comparable<Edge>{
    private final int v;
    private final int w;
    private final double weight;

    public Edge(int v, int w, double weight) {
        if (v < 0) throw new IllegalArgumentException("vertex index must be a nonnegative integer");
        if (w < 0) throw new IllegalArgumentException("vertex index must be a nonnegative integer");
        if (Double.isNaN(weight)) throw new IllegalArgumentException("权重必须为数值");
        this.v = v;
        this.w = w;
        this.weight = weight;
    }

    /**
     * 返回权重
     * @return
     */
    public double weight() {
        return weight;
    }

    /**
     * 返回边两端的顶点之一
     * @return
     */
    public int either() {
        return v;
    }

    /**
     * 返回另一个顶点
     * @param vertex
     * @return
     */
    public int other(int vertex) {
        if      (vertex == v) return w;
        else if (vertex == w) return v;
        else throw new IllegalArgumentException("Illegal endpoint");
    }
    @Override
    public int compareTo(Edge edge) {
        return Double.compare(this.weight, edge.weight);
    }
    public String toString() {
        return String.format("%d-%d %.5f", v, w, weight);
    }
}

加权无向图：
同之前将的几个图基本一样，只是这是添加边是通过Edge对象
还要注意的是，在返回所有的边时，要考虑自环的情况。

/**
 * 加权无向图
 * @author MaoLin Wang
 * @date 2020/2/239:54
 */
public class EdgeWeightedGraph {
    private static final String NEWLINE = System.getProperty("line.separator");

    private final int V;
    private int E;
    private Bag<Edge>[] adj;
    public EdgeWeightedGraph(int V) {
        if (V < 0) throw new IllegalArgumentException("Number of vertices must be nonnegative");
        this.V = V;
        this.E = 0;
        adj = (Bag<Edge>[]) new Bag[V];
        for (int v = 0; v < V; v++) {
            adj[v] = new Bag<Edge>();
        }
    }
	//添加一条边
    private void addEdge(Edge e) {
            int v = e.either();
            int w = e.other(v);
            validateVertex(v);
            validateVertex(w);
            adj[v].add(e);
            adj[w].add(e);
            E++;
    }
    //返回顶点v的邻边
    public Iterable<Edge> adj(int v) {
        validateVertex(v);
        return adj[v];
    }
    //顶点v的度
    public int degree(int v) {
        validateVertex(v);
        return adj[v].size();
    }
    //返回所有边
    public Iterable<Edge> edges() {
        Bag<Edge> list = new Bag<Edge>();
        for (int v = 0; v < V; v++) {
            int selfLoops = 0;
            for (Edge e : adj(v)) {
                if (e.other(v) > v) {
                    list.add(e);
                }
                else if (e.other(v) == v) { //是自环 如 1-1
                    if (selfLoops % 2 == 0) list.add(e);//对于自环，只需要添加一个副本即可，因为我们在addEdge时，添加了两条一样的边
                    selfLoops++;
                }
            }
        }
        return list;
    }
    private void validateVertex(int v) {
        if (v < 0 || v >= V)
            throw new IllegalArgumentException("vertex " + v + " is not between 0 and " + (V-1));
    }
    public int V() {
        return V;
    }

    public int E() {
        return E;
    }
    @Override
    public String toString() {
        return "顶点：" + V +
                ", 边=" + E +
                "\n" + Arrays.toString(adj);
    }



}

一、Prim算法

Prim算法的每一步都会为一颗正在生长的树添加一条边。树是从一个顶点开始的，然后每次添加一条边，该边是下一条 连接树中的顶点和不在树中的顶点且权重最小的边。

该算法能够得到任意加权连通图的最小生成树。

在这之前要讲一下切分定理：

图的一种切分就是将图的所有顶点分为两个非空的且不重叠的集合。
横切边是一条连接两个属于不同集合的顶点的边（一边连接这个集合，一边接连另一个集合）。
切分定理就是给定任意切分，横切边中权值最小的边必然属于最小生成树；

Prim的延时实现

1.1数据结构

我们需要如下的数据结构来实现Prim算法，其中BinaryHeap是前面讲过的优先队列（小顶堆实现），需要的可以看这篇文章：优先队列（堆）以及堆排序-------java实现

  /**
     * 最小生成树的顶点
     */
    private boolean[] marked;

    /**
     * 最小生成树的边
     */
    private Queue<Edge> mst;

    /**
     * 横切边（包括失效的边）
     */
    private BinaryHeap<Edge> pq;
1.2 实现思路

1.选择一个顶点标记它，然后将连接这个顶点和其他所有不再树中的顶点的边加入优先队列中（优先队列按边的权重从小到大排列）；
2.从优先队列中取出权重最小的边，如果边的两个顶点都被访问过了，则代表该边失效了，继续取下一个最小的边；
3.如果权重最小的边（即横切边）没有失效，则将其加入最小生成树队列，将对该边未被访问的点再次进行 步骤1的操作，直到优先队列为空，此时最小生成树的边都在mst队列中了。
如下图：
选取0作为开始的顶点，然后将与0相连的且其他不在树中的边加入优先队列（后边直接展示优先队列状态）：
*表示新加入的边，△表示失效的边，图中红色的边为加入最小生成树中的边，蓝色的边未优先队列中的边；橙色的节点表示最小生成树，绿色的表示未加入

  边    权重
* 0-7  0.16
* 0-2  0.26
* 0-4  0.38
* 6-0  0.58

在这里插入图片描述
将权重最小的边0-7从优先队列取出，并加入最小生成树，继续对未被访问的顶点7进行上述操作：

* 1-7  0.19
  0-2  0.26
* 5-7  0.28
* 2-7  0.34
* 4-7  0.37
  0-4  0.38
  6-0  0.58

在这里插入图片描述
将边 1-7取出加入生成树：

  0-2  0.26
  5-7  0.28
* 1-3  0.29
* 1-5  0.32 
  2-7  0.34
* 1-2  0.36
  4-7  0.37
  0-4  0.38
  6-0  0.58

在这里插入图片描述
将边0-2取出加入生成树：

* 2-3  0.17
  5-7  0.28
  1-3  0.29
  1-5  0.32 
△ 2-7  0.34
△ 1-2  0.36
  4-7  0.37
  0-4  0.38
* 6-2  0.40
  6-0  0.58

在这里插入图片描述将2-3取出加入生成树：


  5-7  0.28
△ 1-3  0.29
  1-5  0.32 
△ 2-7  0.34
△ 1-2  0.36
  4-7  0.37
  0-4  0.38
  6-2  0.40
* 3-6  0.52
  6-0  0.58

在这里插入图片描述
取出5-7加入生成树：

△ 1-3  0.29
△ 1-5  0.32 
△ 2-7  0.34
* 5-4  0.35
△ 1-2  0.36
  4-7  0.37
  0-4  0.38
  6-2  0.40
  3-6  0.52
  6-0  0.58

在这里插入图片描述
此时前面三个边已经失效了，全部移除，将边5-4加入生成树：

△ 1-2  0.36
△ 4-7  0.37
△ 0-4  0.38
  6-2  0.40
  3-6  0.52
  6-0  0.58
  6-4  0.93

在这里插入图片描述
将未失效的6-2加入生成树：
在这里插入图片描述
此时优先队列剩余边全部失效，mst队列已经得到了该图从0开始的最小生成树。

1.3 Prim的延时实现
public class LazyPrimMST {
    /**
     * 最小生成树的顶点
     */
    private boolean[] marked;

    /**
     * 最小生成树的边
     */
    private Queue<Edge> mst;

    /**
     * 横切边（包括失效的边）
     */
    private BinaryHeap<Edge> pq;

    public LazyPrimMST(EdgeWeightedGraph G){
        pq=new BinaryHeap<>();
        marked=new boolean[G.V()];
        mst=new Queue<>();

        //假设G是连通的
        visit(G,0);
        while (!pq.isEmpty()){
            //从pq中得到权重最小的边
            Edge edge = pq.deleteMin();
            int v=edge.either(),w=edge.other(v);
            if (marked[v]&&marked[w]){//已失效，忽略
                continue;
            }
            //当前边加入最小生成树
            mst.enqueue(edge);
            //访问当前横切边未被访问的那个顶点v或w
            if (!marked[v]){
                visit(G,v);
            }
            if (!marked[w]){
                visit(G,w);
            }
        }
    }

    /**
     * 将所有与v连接且未被标记的顶点的边加入横切边
     * @param G
     * @param v
     */
    private void visit(EdgeWeightedGraph G, int v) {
        marked[v]=true;
        for (Edge edge:G.adj(v)){
            if (!marked[edge.other(v)]){
                pq.insert(edge);
            }
        }
    }

    /**
     * 返回最小生成树的所有边
     * @return
     */
    public Iterable<Edge> edges(){
        return mst;
    }

    /**
     * 最小生成树的权重和
     * @return
     */
    public double weight(){
        double weight=0;
        for (Edge edge:mst){
            weight+=edge.weight();
        }
        return weight;
    }


}

Prim算法的延时实现（V个顶点E条边）所需空间与E成正比，所需时间与ElogE成正比（最坏情况）

1.4 Prim算法的即时实现

对于上面的延时实现，我们发现优先队列中存在大量失效的边，如果我们可以将失效的边从中删除就好了。
对于每个非树顶点w，我们不需要保存所有从w到树顶点的边，而只要保存权重最小的那个边就可以了，添加顶点v到树中后，就需要更新权重最小的边，因为可能 v-w 的权重比之前w到另外一个树顶点的边更小。而对于最小权重之外的边，其早晚会失效。

在即时实现中，我们使用edgeTo[v]保存v和树最近的边，用distTo[v]保存该边的权重，distTo[v]应始终保持v到树顶点的最小权重值。
另外使用索引优先队列将顶点v作为索引，顶点v到树顶点最小的边权重distTo[v]作为索引关联的值（索引优先队列即按该权重进行排序）
（索引优先队列参考 算法4》索引优先队列笔记-----java实现一文）

如下：

public class PrimMST {
    /**
     * edgeTo[v] 顶点v距离树最近的边
     */
    private Edge[] edgeTo;

    /**
     * distTo[v] 保存顶点v到树顶点最小边的权重
     */
    private double[] distTo;

    private boolean[] marked;

    private double weight=0.0;

    /**
     * 有效的横切边：索引优先队列，顶点v作为索引，disTo[v]作为索引关联的值
     */
    private IndexMinPQ<Double>pq;

    public PrimMST(EdgeWeightedGraph G){
        edgeTo=new Edge[G.V()];
        distTo=new double[G.V()];
        marked=new boolean[G.V()];

        for (int v = 0; v < G.V(); v++) {
        	//初始化为无穷大
            distTo[v]=Double.POSITIVE_INFINITY;
        }
        pq=new IndexMinPQ<>(G.V());

        //如果是连通的，则直接走prim()，这个循环不需要加
        for (int v = 0; v < G.V(); v++) {
            if (!marked[v]){
                prim(G,v);
            }
        }
    }
}

举例说明（仍使用上面的图）：
如下图，以0为起点，此时我们将连接0和非树节点的边加入索引优先队列，edgeTo和distTo的状态为：

	edgeTo[]  distTo[]
2  	 0-2 		0.26
4  	 0-4	    0.38
6 	 0-6		0.58
7	 0-7		0.16

索引优先队列为：

 	index    Key
 	 7		0.16
 	 2		0.26
 	 4		0.38
 	 6		0.58

在这里插入图片描述
接着从索引优先队列取出第一个索引7，然后更新edgeTo和distTo：

	edgeTo[]  distTo[]
1	 7-1  		0.19	
2  	 0-2 		0.26   因为边7-2的权重大于边0-2的0.26 因此不需要更新索引优先队列中索引为2的关联的对象
4  	 7-4	    0.37   因为边7-4的权重小于边0-4的0.38 因此需要更新索引优先队列中索引为4的关联的对象
5    7-5    	0.28
6 	 0-6		0.58
7	 0-7		0.16

队列中的状态：

	index    Key
 	 1		0.19
 	 2		0.26    //新的权重()比0.26大，所以不做更新
 	 4		0.37    //由原来的0.38更新为较小的0.37
 	 5		0.28
 	 6		0.58

到此就可以看到，索引优先队列中保存的永远是顶点v距离树最近的边（每加入一个顶点到树中就做更新），而不像上面延时版本一样保存了所有的边，这样直到队列为空，便可以得到一颗最小生成树。

实现如下：

public class PrimMST {
    /**
     * edgeTo[v] 顶点v距离树最近的边
     */
    private Edge[] edgeTo;

    /**
     * distTo[v] 保存顶点v到树顶点最小边的权重
     */
    private double[] distTo;

    private boolean[] marked;

    /**
     * 最小生成树的权重
     */
    private double weight=0.0;

    /**
     * 有效的横切边：索引优先队列，顶点v作为索引，disTo[v]作为索引关联的值
     */
    private IndexMinPQ<Double>pq;

    public PrimMST(EdgeWeightedGraph G){
        edgeTo=new Edge[G.V()];
        distTo=new double[G.V()];
        marked=new boolean[G.V()];

        for (int v = 0; v < G.V(); v++) {
            //初始化为无穷大
            distTo[v]=Double.POSITIVE_INFINITY;
        }
        pq=new IndexMinPQ<>(G.V());

        //如果是连通的，则直接走prim()，这个循环不需要加
        for (int v = 0; v < G.V(); v++) {
            if (!marked[v]){
                prim(G,v);
            }
        }
         check(G);
    }

    private void prim(EdgeWeightedGraph G,int v) {
        distTo[v]=0.0;
        //将当前顶点作为索引，当前顶点距离树权重最小的边的权重作为关联的key加入索引优先队列
        pq.insert(v,distTo[v]);

        while (!pq.isEmpty()){
            //取出权重最小的索引（顶点）
            int w = pq.delMin();
            visit(G,w);
        }
    }

    private void visit(EdgeWeightedGraph G, int v) {
        marked[v]=true;
        weight+=distTo[v];
        for (Edge e:G.adj(v)){
            int w=e.other(v);

            if (marked[w]){
                continue;
            }
            if (e.weight()<distTo[w]){//只有当新的边的权重小于之前的distTo[w]值的时候，才更新值
                edgeTo[w]=e;
                distTo[w]=e.weight();
                if (pq.contains(w)){ //索引优先队列有这个索引，更新对应的权重值
                    pq.changeKey(w,distTo[w]);
                }else {//否则插入新的
                    pq.insert(w,distTo[w]);
                }
            }
        }
    }
 
    public Iterable<Edge> edges(){
        Queue<Edge> mst = new Queue<Edge>();
        for (int v = 0; v < edgeTo.length; v++) {
            Edge e = edgeTo[v];
            if (e != null) {
                mst.enqueue(e);
            }
        }
        return mst;
    }
    public double weight(){
        return weight;
    }

 
}

二、Kruskal法

Kruskal算法的思想是：按照边的权重从小到大的顺序处理它们，每次将权重最小的边加入树中，新加入的边不会与已经加入的边构成环，直到树中有V-1条边为止。是从边出发。

该算法的实现有两个关键：
1. 需要将所有边按权重大小排序，这样每次才能取出权重最小的一条边，实现此需要用到前面的优先队列（小顶堆）
2. 为了避免形成环，我们需要借助前面讲过的并查集判断树加入新取出的边后是否有环，即如果该边的两个顶点属于同一个属性集，则会形成环；否则将该边加入生成树，并将边的两个顶点连接

依然以上面的图为例：

一开始每个顶点都属于单独的分量

1.先选择权重最小的边 0-7，将0和7两个顶点使用union(0,7)连接，此时0和7在一个分量中
在这里插入图片描述
2.选取下一个最小边2-3，将2-3加入生成树，并用union连接，此时2和3在一个分量中
在这里插入图片描述
3.选取1-7加入生成树，连接1和7，此时1加入7所在的分量
在这里插入图片描述
3.选取0-2加入生成树，连接0和2，此时2和3加入0所在分量
在这里插入图片描述
4.这时边 1-3 ， 1-2 和 7-2 失效，因为这任意一条边连接都构成了环（任意一条边两个顶点都在同一个分量中），只能选取下一个权重最小边5-7
在这里插入图片描述
然后是5-4和2-6，最终得到一个最小生成树：
在这里插入图片描述
在这里插入图片描述

实现如下：
关于并查集的实现可以看前面的文章：《算法第四版》—union-find并查集笔记

public class KruskalMST {
    /**
     * 最小生成树权重
     */
    private double weight=0.0;
    /**
     * 最小生成树所有边
     */
    private Queue<Edge> mst;

    public KruskalMST(EdgeWeightedGraph G){
        mst=new Queue<>();
        //创建一个优先队列
        BinaryHeap<Edge> pq= new BinaryHeap<>();
        for (Edge e: G.edges()){
            //将所有边加入队列中，按权重大小从小到大排序
            pq.insert(e);
        }
        //创建一个并查集
        ComPathWeightedQuickUnionFind uf=new ComPathWeightedQuickUnionFind(G.V());
        //队列非空且边的个数小于顶点数-1时循环
        while (!pq.isEmpty() && mst.size()<G.V()-1){
            //得到权重最小的边
            Edge edge = pq.deleteMin();
            int v=edge.either(),w=edge.other(v);

            if (uf.connected(v,w)){
                //忽略失效的边
                continue;
            }
            uf.union(v,w);//合并分量
            mst.enqueue(edge);//加入生成树
            weight+=edge.weight();


        }

    }
    public Iterable<Edge> edges(){
        return mst;
    }
    public double weight(){
        return weight;
    }

}
一颗小陨石
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最小生成树 Prim以及Kruskal算法及效率解析
colorfulshark
02-01 6460
生成树：       一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，并且有保持图连通的最少的边。 最小生成树：    在一给定的无向图G = (V, E) 中，(u, v) 代表连接顶点 u 与顶点 v 的边（即），而 w(u, v) 代表此边的权重，若存在 T 为 E 的子集（即）且为无循环图，使得 的 w(T) 最小
最小生成树的Prim算法的延时实现和即时实现
Code & Data & Finance
12-16 1100
Prim算法，每次总是将下一条连接树中的顶点与不在树中的顶点且权重最小的边加入树中。 Prim算法能够得到任意加权连通图的最小生成树。 数据结构： 顶点：使用一个布尔数组marked来表示顶点是否在最小生成树中 边：一条队列mst来保存最小生成树的边 横切边：用优先队列pq来根据权重比较所有的边 重点：每当我们向最小生成树中添加了一条边之后，也向树中添加了一个顶点。要维护一个包含所有横
C++使用Kruskal和Prim算法实现最小生成树
12-31
很久以前就学过最小生成树之Kruskal和Prim算法，这两个算法很容易理解，但实现起来并不那么容易。最近学习了并查集算法，得知并查集可以用于实现上述两个算法后，我自己动手实现了最小生成树算法。 宏观上讲，Kruskal算法就是一个合并的过程，而Prim算法是一个吞并的过程，另外在Prim算法中还用到了一种数据结构——优先级队列，用于动态排序。由于这两个算法很容易理解，在此不再赘述。接下来给出我的源代码。 输入 第一行包含两个整数n和m，n表示图中结点个数，m表示图中边的条数；接下来m行，每一行包含三个整数u,v,w，表示途中存在一条边(u,v)，并且其权重为w；为了便于调试，我的程序是从文件
cpp-图论算法最小生成树Prim算法和Kruskal算法C实现
08-16
图论算法：最小生成树——Prim算法和Kruskal算法C 实现
JS使用Prim算法和Kruskal算法实现最小生成树
12-02
之前都是看书，大部分也是c++的实现，但是搞前端不能忘了JS啊，所以JS实现一遍这两个经典的最小生成树算法。 一、权重图和最小生成树 权重图：图的边带权重 最小生成树：在连通图的所有生成树中，所有边的权重和最小的生成树 本文使用的图如下： 它的最小生成树如下： 二、邻接矩阵 邻接矩阵：用来表示图的矩阵就是邻接矩阵，其中下标表示顶点，矩阵中的值表示边的权重（或者有无边，方向等）。 本文在构建邻接矩阵时，默认Number.MAX_SAFE_INTEGER表示两个节点之间没有边，Number.MIN_SAFE_INTEGER表示当前节点没有自环。 代码如下： /** * 邻接矩阵 *
算法（第4版） Chapter 4.3 最小生成树
weixin_34364135的博客
01-19 183
Algorithms Fourth EditionWritten By Robert Sedgewick & Kevin WayneTranslated By 谢路云Chapter 4 Section 3 最小生成树 定义 树是特殊的图 图的生成树： 含有图全部顶点的无环连通子图 加权无向图的最小生成树（MST）：权重最小的生...
《算法4》最小生成树之Prim与Kruskal算法
leonliu1995的博客
11-26 782
最小生成树 贪心算法 基本数据结构 Prim 算法 Kruskal算法 总结 最小生成树在前面我们了解到了无向图和加权有向图，类似的我们给无向图的每一条边加上权重，就得到了加权无向图，加权无向图在现实中也有许多应用，在这一篇，我们讨论对它的一个重要的处理，就是找出图中（本篇中默认为加权无向图）的最小生成树。最小生成树：图的生成树是它的一棵含有所有顶点的无环连通子图。加权图的最小生成树（MST）是它的
数据结构-图的笔记(4)（图的最小生成树和最短路径）
m0_71069189的博客
11-22 744
这是我个人做的数据结构-图的笔记。
图——最小生成树的两种算法
weixin_62917800的博客
07-15 2438
还不理解普里姆算法和克鲁斯卡尔算法？赶快来看这篇文章！
数据结构——Prim算法
一个巨大的博客
11-29 3984
Prim算法（加点法） Prim为求图最小生成树的算法 本文章采用邻接矩阵的存储方式 具体思路如下 1.首先以邻接矩阵方式输入图 2.进入算法函数 3.设置closedge数组辅助 typedef struct{ int adjvex; /记录该顶点和顶点集合中相连权值最小的顶点序号/ int lowcost; /记录最小的权值/ }Closedge; //数组元素的下标对应图G...
常用算法——克鲁斯卡尔(Kruskal)算法（公交站问题，最小生成树问题 ）
笔记别偷看
11-10 3435
克鲁斯卡尔算法介绍 克鲁斯卡尔(Kruskal)算法，是用来求加权连通图的最小生成树的算法。 基本思想：按照权值从小到大的顺序选择n-1 条边，并保证这n-1 条边不构成回路 具体做法：首先构造一个只含n 个顶点的森林，然后依权值从小到大从连通网中选择边加入到森林中，并使森 林中不产生回路，直至森林变成一棵树为止 克鲁斯卡尔算法图解说明 以城市公交站问题来图解说明克鲁斯卡尔算法的原理和步骤： 代码实现 import java.util.Arrays; public class KruskalCase
Prim与Kruskal算法的最小生成树matlab实现
05-26
Prim与Kruskal算法的最小生成树matlab实现
一步一步写算法（之prim算法 下）
嵌入式-老费，一个分享专业嵌入式知识的blog
11-06 5426
【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】     前两篇博客我们讨论了prim最小生成树的算法，熟悉了基本的流程。基本上来说，我们是按照自上而下的顺序来编写代码的。首先我们搭建一个架构，然后一步一步完成其中的每一个子功能，这样最后构成一个完成prim算法计算过程。     f）将DIR_LINE队列中不符合的数据删
数据结构学习笔记——图的应用1（最小生成树、最短路径）
小宇y的博客
08-29 2939
V1→V3：有三条路径，分别是V1→V2→V4→V3，路径长度为4+2+8=14、V1→V2→V4→V6→V3，路径长度为4+2+3+3=12、V1→V2→V5→V6→V3，路径长度为4+7+6+3=20，故最短路径为V1→V2→V4→V6→V3，即12；}，即{V1，V2}，{V1，V3}，{V1，V2}，{V2，V1}，{V2，V3}，{V2，V4}，{V3，V1}，{V3，V2}，{V3，V4}，{V4，V1}，{V4，V2}，{V4，V3}，设当前访问的顶点对为{v。...
求最小生成树两种算法
ancientear的博客
02-10 1452
求最小生成树，两种算法，求输出权值的和。第一行n,m，n为顶点数，小于等于20，m边数，后面m行，每行一个边的信息，每行三个数，i j c，起点i，终点j，权值c，i，j大于等于1，无向图。 /*求最小生成树，两种算法，求输出权值的和。 第一行n,m，n为顶点数，小于等于20，m边数，后面m行，每行一个边的信息，每行三个数 i j c，起点i，终点j，权值c，i，j大于等于1，无向图。*/ #...
算法4.3 最小生成树
LYZ
05-05 566
最小生成树4.3.1 定义
最小生成树的两种算法实现
Theseus_sky的博客
03-15 9994
1.问题 如何求一个包含有原图所有n个结点的且所有边的代价和最小的极小连通子图。 2.解析 构造最小生成树有两种算法模式。 第一种是Kruskal算法。它的要点就是选边。即从最短的边开始生成森林，最后连成树。简单的步骤： 1.图中的所有边按权重从小到大排序； 2.图中的n个顶点看成独立的n棵树组成的森林； 3.按权重从小到大选择边，所选的边连接的两个顶点应属于两颗不同的树，则成为最小生成树的一条边，并将这两颗树合并作为一颗树。 4.重复3,直到所有顶点都在一颗树内或者有n-1条边为止。 以下面为例。所有
最小生成树问题
weixin_30657541的博客
07-06 377
--------------------siwuxie095 最小生成树问题 这里介绍最小生成树（Minimum Spanning Tree）问题 所谓生成树，就是对于一个完全连通的带权无向图，用 V-1 条边连接 V 个顶点而...
最小生成树算法（引自《算法导论》）
CNV_2305
11-09 1372
http://rock3.info/blog/2013/10/21/%E6%9C%80%E5%B0%8F%E7%94%9F%E6%88%90%E6%A0%91%E7%AE%97%E6%B3%95%EF%BC%88%E5%BC%95%E8%87%AA%E3%80%8A%E7%AE%97%E6%B3%95%E5%AF%BC%E8%AE%BA%E3%80%8B%EF%BC%89/ 一、概念
实现最小生成树计算的Prim算法和Kruskal算法python
最新发布
05-13
Prim算法实现： ```Python from heapq import heappush, heappop # 堆优化 from collections import defaultdict def prim(graph, start): mst = defaultdict(set) # 存储最小生成树的结果 visited = set([start]) # 已经访问过的节点 edges = [ (cost, start, to) for to, cost in graph[start].items() ] # 从起始节点开始的所有边 # 将边按照权值排序 edges.sort() # 遍历每一条边 while edges: cost, frm, to = heappop(edges) # 取出当前最小的边 if to not in visited: # 如果该节点未访问过，加入最小生成树 visited.add(to) mst[frm].add(to) for to_next, cost in graph[to].items(): # 将新加入的节点的边加入边集中 if to_next not in visited: heappush(edges, (cost, to, to_next)) return mst ``` Kruskal算法实现： ```Python def kruskal(graph): mst = defaultdict(set) # 存储最小生成树的结果 vertices = set(graph.keys()) # 所有节点 edges = [ (graph[v1][v2], v1, v2) for v1 in vertices for v2 in graph[v1] ] # 所有边 # 将边按照权值排序 edges.sort() # 遍历每一条边 for cost, frm, to in edges: if to not in vertices: # 如果该边的终点不在当前最小生成树中，加入该边 continue vertices.remove(to) mst[frm].add(to) mst[to].add(frm) return mst ``` 其中，图的数据结构可以使用字典来表示，例如： ```Python graph = { 'A': {'B': 2, 'D': 6}, 'B': {'A': 2, 'C': 3, 'D': 8}, 'C': {'B': 3}, 'D': {'A': 6, 'B': 8}, } ``` 其中，每个键（例如'A'）表示一个节点，对应的值（例如{'B': 2, 'D': 6}）表示与该节点相连的边及其权值。例如，图中节点'A'与节点'B'之间的边权为2，节点'A'与节点'D'之间的边权为6。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值