算法第一部分（3）

最新推荐文章于 2021-08-06 20:35:38 发布
最新推荐文章于 2021-08-06 20:35:38 发布
阅读量139 收藏
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39100543/article/details/91049363
版权

并查集

定义：并查集是一种不一样的树形结构，可以使用并查集来解决连接问题
可以使用并查集来解决1.网络节点间的连接问题 2.数学中的集合类的实现
并查集的查找与连接：并查集某索引的值就是其父节点的值。向上查找到父节点指向自己的值就是根节点。可以通过查找两个元素之间的根节点是否相等得出他们是否连接。如果需要将两个点相连，只需要将其中一个节点的根节点指向另一个节点的根节点就可以使两节点相连

基于size的优化，基于rank的路径优化，路径压缩可以对并查集进行优化

// 我们的第三版Union-Find
public class UnionFind3 {

    private int[] parent; // parent[i]表示第一个元素所指向的父节点
    private int[] sz;     // sz[i]表示以i为根的集合中元素个数
    private int count;    // 数据个数

    // 构造函数
    public UnionFind3(int count){
        parent = new int[count];
        sz = new int[count];
        this.count = count;
        // 初始化, 每一个parent[i]指向自己, 表示每一个元素自己自成一个集合
        for( int i = 0 ; i < count ; i ++ ){
            parent[i] = i;
            sz[i] = 1;
        }
    }

    // 查找过程, 查找元素p所对应的集合编号
    // O(h)复杂度, h为树的高度
    private int find(int p){
        assert( p >= 0 && p < count );
        // 不断去查询自己的父亲节点, 直到到达根节点
        // 根节点的特点: parent[p] == p
        while( p != parent[p] )
            p = parent[p];
        return p;
    }

    // 查看元素p和元素q是否所属一个集合
    // O(h)复杂度, h为树的高度
    public boolean isConnected( int p , int q ){
        return find(p) == find(q);
    }

    // 合并元素p和元素q所属的集合
    // O(h)复杂度, h为树的高度
    public void unionElements(int p, int q){

        int pRoot = find(p);
        int qRoot = find(q);

        if( pRoot == qRoot )
            return;

        // 根据两个元素所在树的元素个数不同判断合并方向
        // 将元素个数少的集合合并到元素个数多的集合上
        if( sz[pRoot] < sz[qRoot] ){
            parent[pRoot] = qRoot;
            sz[qRoot] += sz[pRoot];
        }
        else{
            parent[qRoot] = pRoot;
            sz[pRoot] += sz[qRoot];
        }
    }
}

路径压缩所需要修改的地方：
在这里插入图片描述

图论

在这里插入图片描述
使用图要注意是有向图还是无向图，有权图还是无权图

对于图来说，其经常使用的表示方法为：
邻接矩阵 适合使用在稠密图
邻接表 适合使用在稀疏表

稀疏图的简要代码实现：

// 稀疏图 - 邻接表
public class SparseGraph {

    private int n;  // 节点数
    private int m;  // 边数
    private boolean directed;    // 是否为有向图
    private Vector<Integer>[] g; // 图的具体数据

    // 构造函数
    public SparseGraph( int n , boolean directed ){
        assert n >= 0;
        this.n = n;
        this.m = 0;    // 初始化没有任何边
        this.directed = directed;
        // g初始化为n个空的vector, 表示每一个g[i]都为空, 即没有任和边
        g = (Vector<Integer>[])new Vector[n];
        for(int i = 0 ; i < n ; i ++)
            g[i] = new Vector<Integer>();
    }

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

    // 向图中添加一个边
    public void addEdge( int v, int w ){

        assert v >= 0 && v < n ;
        assert w >= 0 && w < n ;

        g[v].add(w);
        if( v != w && !directed )
            g[w].add(v);

        m ++;
    }

    // 验证图中是否有从v到w的边
    boolean 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].elementAt(i) == w )
                return true;
        return false;
    }

    // 返回图中一个顶点的所有邻边
    // 由于java使用引用机制，返回一个Vector不会带来额外开销,
    public Iterable<Integer> adj(int v) {
        assert v >= 0 && v < n;
        return g[v];
    }
}

稠密图的简要代码实现：

// 稠密图 - 邻接矩阵
public class DenseGraph {

    private int n;  // 节点数
    private int m;  // 边数
    private boolean directed;   // 是否为有向图
    private boolean[][] g;      // 图的具体数据

    // 构造函数
    public DenseGraph( int n , boolean directed ){
        assert n >= 0;
        this.n = n;
        this.m = 0;    // 初始化没有任何边
        this.directed = directed;
        // g初始化为n*n的布尔矩阵, 每一个g[i][j]均为false, 表示没有任和边
        // false为boolean型变量的默认值
        g = new boolean[n][n];
    }

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

    // 向图中添加一个边
    public void addEdge( int v , int w ){

        assert v >= 0 && v < n ;
        assert w >= 0 && w < n ;

        if( hasEdge( v , w ) )
            return;

        g[v][w] = true;
        if( !directed )
            g[w][v] = true;

        m ++;
    }

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

    // 返回图中一个顶点的所有邻边
    // 由于java使用引用机制，返回一个Vector不会带来额外开销,
    public Iterable<Integer> adj(int v) {
        assert v >= 0 && v < n;
        Vector<Integer> adjV = new Vector<Integer>();
        for(int i = 0 ; i < n ; i ++ )
            if( g[v][i] )
                adjV.add(i);
        return adjV;
    }
}

图的遍历方式

深度优先遍历

定义：深度优先遍历先遍历一个节点0，寻找该节点的相邻节点，与1相邻，接下来来到1节点。直到节点遍历完，需要退回上一下遍历的节点重新遍历
可以通过深度优先遍历求出连通分量，无处可去，就换一个还没遍历的点求出
使用深度优先遍历求连通分量实例：

// 求无权图的联通分量
public class Components {

    Graph G;                    // 图的引用
    private boolean[] visited;  // 记录dfs的过程中节点是否被访问
    private int ccount;         // 记录联通分量个数
    private int[] id;           // 每个节点所对应的联通分量标记

    // 图的深度优先遍历
    void dfs( int v ){

        visited[v] = true;
        //设置ccount可以通过连通分量是否相等得出两个点是否相连接
        id[v] = ccount;

        for( int i: G.adj(v) ){
            if( !visited[i] )
                dfs(i);
        }
    }

    // 构造函数, 求出无权图的联通分量
    public Components(Graph graph){

        // 算法初始化
        G = graph;
        visited = new boolean[G.V()];
        id = new int[G.V()];
        ccount = 0;
        for( int i = 0 ; i < G.V() ; i ++ ){
            visited[i] = false;
            id[i] = -1;
        }

        // 求图的联通分量
        for( int i = 0 ; i < G.V() ; i ++ )
            if( !visited[i] ){
                dfs(i);
                //第二次求图的连通分量
                ccount ++;
            }
    }

    // 返回图的联通分量个数
    int count(){
        return ccount;
    }

    // 查询点v和点w是否联通
    boolean isConnected( int v , int w ){
        assert v >= 0 && v < G.V();
        assert w >= 0 && w < G.V();
        return id[v] == id[w];
    }
}

获取图的路径

public class Path {

    private Graph G;   // 图的引用
    private int s;     // 起始点
    private boolean[] visited;  // 记录dfs的过程中节点是否被访问
    private int[] from;         // 记录路径, from[i]表示查找的路径上i的上一个节点

    // 图的深度优先遍历
    private void dfs( int v ){
        visited[v] = true;
        for( int i : G.adj(v) )
            if( !visited[i] ){
                from[i] = v;
                dfs(i);
            }
    }

    // 构造函数, 寻路算法, 寻找图graph从s点到其他点的路径
    public Path(Graph graph, int s){

        // 算法初始化
        G = graph;
        assert s >= 0 && s < G.V();

        visited = new boolean[G.V()];
        from = new int[G.V()];
        for( int i = 0 ; i < G.V() ; i ++ ){
            visited[i] = false;
            from[i] = -1;
        }
        this.s = s;

        // 寻路算法
        dfs(s);
    }

    // 查询从s点到w点是否有路径
    boolean hasPath(int w){
        assert w >= 0 && w < G.V();
        return visited[w];
    }

    // 查询从s点到w点的路径, 存放在vec中
    Vector<Integer> path(int w){

        assert hasPath(w) ;

        Stack<Integer> s = new Stack<Integer>();
        // 通过from数组逆向查找到从s到w的路径, 存放到栈中
        int p = w;
        while( p != -1 ){
            s.push(p);
            p = from[p];
        }

        // 从栈中依次取出元素, 获得顺序的从s到w的路径
        Vector<Integer> res = new Vector<Integer>();
        while( !s.empty() )
            res.add( s.pop() );

        return res;
    }

    // 打印出从s点到w点的路径
    void showPath(int w){

        assert hasPath(w) ;

        Vector<Integer> vec = path(w);
        for( int i = 0 ; i < vec.size() ; i ++ ){
            System.out.print(vec.elementAt(i));
            if( i == vec.size() - 1 )
                System.out.println();
            else
                System.out.print(" -> ");
        }
    }
}

深度优先遍历稀疏图的复杂度是O(V+E) 稠密图的复杂度是O(V^2)

广度优先遍历

广度优先遍历优先将该节点的子结果全部添加进队列（从遍历的起始点开始，后加进队列应该在后一层）

public class ShortestPath {

    private Graph G;   // 图的引用
    private int s;     // 起始点
    private boolean[] visited;  // 记录dfs的过程中节点是否被访问
    private int[] from;         // 记录路径, from[i]表示查找的路径上i的上一个节点
    private int[] ord;          // 记录路径中节点的次序。ord[i]表示i节点在路径中的次序
                                //即从s到每一个节点的最短距离是多少

    // 构造函数, 寻路算法, 寻找图graph从s点到其他点的路径
    public ShortestPath(Graph graph, int s){

        // 算法初始化
        G = graph;
        assert s >= 0 && s < G.V();

        visited = new boolean[G.V()];
        from = new int[G.V()];
        ord = new int[G.V()];
        for( int i = 0 ; i < G.V() ; i ++ ){
            visited[i] = false;
            from[i] = -1;
            ord[i] = -1;
        }
        this.s = s;

        // 无向图最短路径算法, 从s开始广度优先遍历整张图
        Queue<Integer> q = new LinkedList<Integer>();

        q.add(s);
        visited[s] = true;
        ord[s] = 0;
        while( !q.isEmpty() ){
            int v = q.remove();
            for( int i : G.adj(v) )
                if( !visited[i] ){
                    q.add(i);
                    visited[i] = true;
                    from[i] = v;
                    ord[i] = ord[v] + 1;
                }
        }
    }

    // 查询从s点到w点是否有路径
    public boolean hasPath(int w){
        assert w >= 0 && w < G.V();
        return visited[w];
    }

    // 查询从s点到w点的路径, 存放在vec中
    public Vector<Integer> path(int w){

        assert hasPath(w) ;

        Stack<Integer> s = new Stack<Integer>();
        // 通过from数组逆向查找到从s到w的路径, 存放到栈中
        int p = w;
        while( p != -1 ){
            s.push(p);
            p = from[p];
        }

        // 从栈中依次取出元素, 获得顺序的从s到w的路径
        Vector<Integer> res = new Vector<Integer>();
        while( !s.empty() )
            res.add( s.pop() );

        return res;
    }

    // 打印出从s点到w点的路径
    public void showPath(int w){

        assert hasPath(w) ;

        Vector<Integer> vec = path(w);
        for( int i = 0 ; i < vec.size() ; i ++ ){
            System.out.print(vec.elementAt(i));
            if( i == vec.size() - 1 )
                System.out.println();
            else
                System.out.print(" -> ");
        }
    }

    // 查看从s点到w点的最短路径长度
    // 若从s到w不可达，返回-1
    public int length(int w){
        assert w >= 0 && w < G.V();
        return ord[w];
    }
}

有权图

邻接表的有权图
在这里插入图片描述
在这里插入图片描述
对于有权图来说，我们的每一个边都需要有一个权值

// 边
public class Edge<Weight extends Number & Comparable> implements Comparable<Edge>{

    private int a, b;    // 边的两个端点
    private Weight weight;  // 边的权值

    public Edge(int a, int b, Weight weight)
    {
        this.a = a;
        this.b = b;
        this.weight = weight;
    }

    public Edge(Edge<Weight> e)
    {
        this.a = e.a;
        this.b = e.b;
        this.weight = e.weight;
    }

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

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

    // 输出边的信息
    public String toString(){
        return "" + a + "-" + b + ": " + weight;
    }

    // 边之间的比较
    public int compareTo(Edge that)
    {
        if( weight.compareTo(that.wt()) < 0 )
            return -1;
        else if ( weight.compareTo(that.wt()) > 0 )
            return +1;
        else
            return  0;
    }
}

对于邻接矩阵来说，存的就不应该是true和false，而应该是权，对于邻接表来说，存的应该是边和值

// 稠密图 - 邻接矩阵
public class DenseWeightedGraph<Weight extends Number & Comparable>
        implements WeightedGraph{

    private int n;  // 节点数
    private int m;  // 边数
    private boolean directed;   // 是否为有向图
    private Edge<Weight>[][] g;         // 图的具体数据

    // 构造函数
    public DenseWeightedGraph( int n , boolean directed ){
        assert n >= 0;
        this.n = n;
        this.m = 0;    // 初始化没有任何边
        this.directed = directed;
        // g初始化为n*n的布尔矩阵, 每一个g[i][j]均为null, 表示没有任和边
        // false为boolean型变量的默认值
        g = new Edge[n][n];
        for(int i = 0 ; i < n ; i ++)
            for(int j = 0 ; j < n ; j ++)
                g[i][j] = null;
    }

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

    // 向图中添加一个边
    public void addEdge(Edge e){

        assert e.v() >= 0 && e.v() < n ;
        assert e.w() >= 0 && e.w() < n ;

        if( hasEdge( e.v() , e.w() ) )
            return;

        g[e.v()][e.w()] = new Edge(e);
        if( e.v() != e.w() && !directed )
            g[e.w()][e.v()] = new Edge(e.w(), e.v(), e.wt());

        m ++;
    }

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

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

        for( int i = 0 ; i < n ; i ++ ){
            for( int j = 0 ; j < n ; j ++ )
                if( g[i][j] != null )
                    System.out.print(g[i][j].wt()+"\t");
                else
                    System.out.print("NULL\t");
            System.out.println();
        }
    }

    // 返回图中一个顶点的所有邻边
    // 由于java使用引用机制，返回一个Vector不会带来额外开销,
    public Iterable<Edge<Weight>> adj(int v) {
        assert v >= 0 && v < n;
        Vector<Edge<Weight>> adjV = new Vector<Edge<Weight>>();
        for(int i = 0 ; i < n ; i ++ )
            if( g[v][i] != null )
                adjV.add( g[v][i] );
        return adjV;
    }
}

最小生成树问题

针对带权无向图
针对连通图
定义：最小生成树就是在一张有V个顶点的图上，找V - 1 条边，且使得最终的总权值最小
切分：把图中的节点分成两部分，形成一个切分。
横切边：如果一个边的两个端点，属于切分不同的两边，这个称为横切边
切分定理：给定任意切分，横切边中权值最小的边必然属于最小生成树

prim算法

在这里插入图片描述

// 使用Prim算法求图的最小生成树
public class LazyPrimMST<Weight extends Number & Comparable> {

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

    // 构造函数, 使用Prim算法求图的最小生成树
    public LazyPrimMST(WeightedGraph<Weight> graph){

        // 算法初始化
        G = graph;
        pq = new MinHeap<Edge<Weight>>(G.E());
        marked = new boolean[G.V()];
        mst = new Vector<Edge<Weight>>();

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

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

        // 计算最小生成树的权值

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

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

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

        // 将和节点v相连接的所有未访问的边放入最小堆中
        for( Edge<Weight> e : G.adj(v) )
            
            if( !marked[e.other(v)] )
               //表明找到了一条横切边
                pq.insert(e);
    }

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

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

lazy prim算法的时间复杂度是O(ElogE级别的)
prim算法可以优化成ElogV级别，满足能更新和每个节点相连的最短的横切边
索引堆要满足能取出最小值，还要更新。可以使用索引堆，堆中只要保存和每个节点相连接的最短的横切边。即把当前节点的所有边都存入索引堆相应索引中

// 使用优化的Prim算法求图的最小生成树
public class PrimMST<Weight extends Number & Comparable> {

    private WeightedGraph G;              // 图的引用
    private IndexMinHeap<Weight> ipq;     // 最小索引堆, 算法辅助数据结构
    private Edge<Weight>[] edgeTo;        // 访问的点所对应的边, 算法辅助数据结构
    private boolean[] marked;             // 标记数组, 在算法运行过程中标记节点i是否被访问
    private Vector<Edge<Weight>> mst;     // 最小生成树所包含的所有边
    private Number mstWeight;             // 最小生成树的权值

    // 构造函数, 使用Prim算法求图的最小生成树
    public PrimMST(WeightedGraph graph){

        G = graph;
        assert( graph.E() >= 1 );
        ipq = new IndexMinHeap<Weight>(graph.V());

        // 算法初始化
        marked = new boolean[G.V()];
        edgeTo = new Edge[G.V()];
        for( int i = 0 ; i < G.V() ; i ++ ){
            marked[i] = false;
            edgeTo[i] = null;
        }
        mst = new Vector<Edge<Weight>>();

        // Prim
        visit(0);
        while( !ipq.isEmpty() ){
            // 使用最小索引堆找出已经访问的边中权值最小的边
            // 最小索引堆中存储的是点的索引, 通过点的索引找到相对应的边
            int v = ipq.extractMinIndex();
            assert( edgeTo[v] != null );
            mst.add( edgeTo[v] );
            visit( v );
        }

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

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

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

        // 将和节点v相连接的未访问的另一端点, 和与之相连接的边, 放入最小堆中
        for( Object item : G.adj(v) ){
            Edge<Weight> e = (Edge<Weight>)item;
            int w = e.other(v);
            // 如果边的另一端点未被访问
            if( !marked[w] ){
                // 如果从没有考虑过这个端点, 直接将这个端点和与之相连接的边加入索引堆
                if( edgeTo[w] == null ){
                    edgeTo[w] = e;
                    ipq.insert(w, e.wt());
                }
                // 如果曾经考虑这个端点, 但现在的边比之前考虑的边更短, 则进行替换
                else if( e.wt().compareTo(edgeTo[w].wt()) < 0 ){
                    edgeTo[w] = e;
                    ipq.change(w, e.wt());
                }
            }
        }

    }

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

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


    // 测试 Prim
    public static void main(String[] args) {

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

        SparseWeightedGraph<Double> g = new SparseWeightedGraph<Double>(V, false);
        ReadWeightedGraph readGraph = new ReadWeightedGraph(g, filename);

        // Test Prim MST
        System.out.println("Test Prim MST:");
        PrimMST<Double> primMST = new PrimMST<Double>(g);
        Vector<Edge<Double>> mst = primMST.mstEdges();
        for( int i = 0 ; i < mst.size() ; i ++ )
            System.out.println(mst.elementAt(i));
        System.out.println("The MST weight is: " + primMST.result());

        System.out.println();
    }
}

Krusk算法

每次都找最短的一条边，只要不构成环，使得这一条是最小生成树的边<、u>
对所有的边进行排序，每次都取最小的一条，只要不构成环（可以使用并查集来判断是否生成环），所以这一条就是最小生成树的边

// Kruskal算法求最小生成树
public class KruskalMST<Weight extends Number & Comparable> {

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

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

        mst = new Vector<Edge<Weight>>();

        // 将图中的所有边存放到一个最小堆中
        MinHeap<Edge<Weight>> pq = new MinHeap<Edge<Weight>>( graph.E() );
        for( int i = 0 ; i < graph.V() ; i ++ )
            for( Object item : graph.adj(i) ){
                Edge<Weight> e = (Edge<Weight>)item;
                //避免无向图中边被存了两次
                if( e.v() <= e.w() )
                    pq.insert(e);
            }

        // 创建一个并查集, 来查看已经访问的节点的联通情况
        UnionFind uf = new 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.add( e );
            uf.unionElements( e.v() , e.w() );
        }

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

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

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


    // 测试 Kruskal
    public static void main(String[] args) {

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

        SparseWeightedGraph<Double> g = new SparseWeightedGraph<Double>(V, false);
        ReadWeightedGraph readGraph = new ReadWeightedGraph(g, filename);

        // Test Kruskal
        System.out.println("Test Kruskal:");
        KruskalMST<Double> kruskalMST = new KruskalMST<Double>(g);
        Vector<Edge<Double>> mst = kruskalMST.mstEdges();
        for( int i = 0 ; i < mst.size() ; i ++ )
            System.out.println(mst.elementAt(i));
        System.out.println("The MST weight is: " + kruskalMST.result());

        System.out.println();
    }
}

在这里插入图片描述

yang haikun
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
dijkstra算法针对稠密图和稀疏图的两种不同策略
Andy123321aa的博客
10-15 2727
迪杰斯特拉（dijkstra）算法是一种普遍用于求两点之间（或者说一个给定点到图中其他任意点）的最短路径的算法。但当图的连接较为稠密或者较为稀疏的时候，采用两种不同的思路，可以优化算法的执行速度。 应用于稠密连接图的dijkstra算法 所谓稠密连接就是指图之间的连接路径趋近于n的平方（n为图中节点的个数）。在稠密连接的条件下，dijkstra算法的算法复杂度是O(n^2)。 算法思想是分两步走：...
POJ - 3764 The xor-longest Path（树上两点路径边权异或和，01字典树）
Plus Ultra！
08-09 613
链接：POJ - 3764 The xor-longest Path 题意： 给出一棵n(1≤n≤100000)n(1\le n\le100000)n(1≤n≤100000)个结点的树，每条边具有边权w(0≤w≤231)w(0\le w\le 2^{31})w(0≤w≤231)，结点编号从000到n−1n-1n−1。要求求出 异或和最大的路径（即路径上所有边权www异或和最大），所有结点均可作为起...
CF 1189D1和1189D2-树的边权-思维+搜索
Nothing_but_Fight的博客
08-02 377
第一问：D1. Add on a Tree（传送门） Note that this is the first problem of the two similar problems. You can hack this problem only if you solve both problems. You are given a tree with n nodes. In the beginni...
BZOJ4372烁烁的游戏——动态点分治+线段树(点分树套线段树)
weixin_34355559的博客
12-11 113
题目描述 背景：烁烁很喜欢爬树，这吓坏了树上的皮皮鼠。题意：给定一颗n个节点的树，边权均为1，初始树上没有皮皮鼠。烁烁他每次会跳到一个节点u，把周围与他距离不超过d的节点各吸引出w只皮皮鼠。皮皮鼠会被烁烁吸引，所以会一直待在节点上不动。烁烁很好奇，在当前时刻，节点u有多少个他的好朋友---皮皮鼠。大意：给一颗n个节点的树，边权均为1，初始点权均为0，m次操作：Q x：询问x的点权。M x d...
Lambda表达式笔记
qq_45112601的博客
09-09 158
Lambda表达式： 语法： (parameters)->expression 或者 (parameters)->{statements;} 即：(形参)->表达式 (形参)->{代码块} ->:左边的参数作用指向 总结：类似一个function，可以带参与不带参，可以有返回与无返回值 案例： 1.无参数，直接返回结果 ()->1 或 ()->{System.out.print("你好Labmbda!")} 2.带一个参数
第一章 基础算法（二）
weixin_46240542的博客
06-02 181
一维前缀和 const int N = 100010; int n,m; int a[N],b[N]; int main(){ scanf("%d%d",&n,&m); for(int i = 1;i <= n;i++) scanf("%d",&a[i]); for(int i = 1;i <= n;i++) s[i] = s[i - 1] + a[i]; while(m--){ int l,r; scanf("%d%d",&l,&am
第一章 基础算法
QWQ___qwq的博客
08-06 511
文章目录基础算法(一）快速排序归并排序 基础算法(一） 快速排序 void quick_sort(int q[], int l, int r) { if (l >= r) return; int i = l - 1, j = r + 1, x = q[l + r >> 1];//i,j指针取左右两端的两侧,因为后面要直接加1 while (i < j)//知道>=为止 { do i ++ ; while (q[i] < x
普林斯顿算法第一部分
07-03
普林斯顿算法课第一部分，有课程视频讲义以及字幕，可以搭配booksite https://algs4.cs.princeton.edu 使用
吸烟算法数据-第一部分300张
09-10
1.数据源头提供者，可提供各种场景数据资料，有需求请联系我！ 2.数据会分多次上传，供开发者训练使用，用的好请点赞！ 3.数据是算法模型训练之本，有好...7.本资源包含两部分，先发第一部分，有300张，后续会持续上传
Coursera算法第1部分
02-15
《Coursera算法第1部分》是面向编程爱好者和专业人士的一门在线课程，主要教授基础算法和数据结构。这门课程以Java语言为教学工具，深入浅出地讲解了计算机科学中的核心概念，旨在提升学员的算法思维和编程能力。 ...
GMT 0001.3-2012 祖冲之序列密码算法第3部分：基于祖冲之算法的完整性算法.pdf
05-18
### GMT 0001.3-2012 祖冲之序列密码算法第3部分：基于祖冲之算法的完整性算法 #### 1. 概述 本标准文档（GMT 0001.3-2012）详细介绍了祖冲之序列密码算法的第三部分——基于祖冲之算法的完整性算法。该算法主要...
GMT 0001.1-2012 祖冲之序列密码算法第1部分：算法描述.pdf
06-29
根据给出的文件信息，这里是一份关于“祖冲之序列密码算法”第1部分的描述，该算法是中华人民共和国密码行业标准GM/T 0001。文件中介绍了祖冲之算法的三个部分，分别是算法描述、机密性算法和完整性算法。本部分主要...
【bzoj4372】 烁烁的游戏【动态树分治】
2016gdgzoi471
12-20 1481
烁烁的游戏 Description 背景：烁烁很喜欢爬树，这吓坏了树上的皮皮鼠。 题意： 给定一颗n个节点的树，边权均为1，初始树上没有皮皮鼠。 烁烁他每次会跳到一个节点u，把周围与他距离不超过d的节点各吸引出w只皮皮鼠。皮皮鼠会被烁烁吸引，所以会一直待在节点上不动。 烁烁很好奇，在当前时刻，节点u有多少个他的好朋友—皮皮鼠。 大意： 给一颗n个节点的树，边权均为1，初始点权均...
《数据结构与算法分析》学习笔记
热门推荐
Hunger's Blog
08-27 1万+
A Practical Introduction to Data Structures and Algorithm Analysis (C++ Edition).
基于springboot的社区团购系统 源码+数据库（毕业设计）
08-18
基于Vue.js和SpringBoot的社区团购系统是一个高效、易用的电子商务平台，旨在为社区内的居民提供便捷的购物体验。该系统分为管理员和普通用户两个角色，管理员可以进行商品信息管理、商品类型管理、团购信息发布和用户管理等操作，而普通用户则可以浏览商品、参与团购、查看订单等。系统采用前后端分离的架构，前端使用Vue.js框架，后端使用SpringBoot框架，实现了模块化开发和快速迭代。商品信息模块允许管理员添加、编辑和删除商品信息，包括商品名称、价格、库存等；商品类型模块则用于分类管理，方便用户快速找到所需商品；团购信息模块支持管理员发布团购活动，设置团购价格和时间等；用户管理模块则用于管理用户信息，包括用户注册、登录、权限分配等。整个系统界面友好，操作简便，为社区团购提供了一个全面、高效的解决方案。 录屏：https://www.bilibili.com/video/BV1sQ4y1E7Mz 教程：https://space.bilibili.com/417412814/channel/collectiondetail?sid=2242844
Y便利商超数字化方案（43页 PPT）.pptx
最新发布
08-18
Y便利商超数字化方案（43页 PPT）
毕业设计，基于VB+ACCESS开发的通讯录管理信息系统，内含完整源代码，数据库，开题报告，论文答辩，毕业论文
08-18
毕业设计，基于VB+ACCESS开发的通讯录管理信息系统，内含完整源代码，数据库，开题报告，论文答辩，毕业论文 本通讯录信息管理系统用计算机管理电子通讯录的一种计算机应用技术的创新,在计算机还未普及之前通讯管理都是由联系人采用名片,笔录手工记帐的方式来操作的.现在一般的通讯录管理都是采用计算机作为工具的实用的计算机通讯录管理程序来帮助人们进行更有效的通讯录信息管理。通讯录管理系统是典型的信息管理系统(MIS),其开发主要包括后台数据库的建立和维护以及前端应用程序的开发两个方面。对于前者要求建立起数据一致性和完整性强、数据安全性好的库。而对于后者则要求应用程序功能完备,易使用等特点。 经过分析,我们使用 MICROSOFT公司的 VISUAL BASIC开发工具,利用其提供的各种面向对象的开发工具,尤其是数据窗口这一能方便而简洁操纵数据库的智能化对象,首先在短时间内建立系统应用原型,然后,对初始原型系统进行需求迭代,不断修正和改进,直到形成用户满意的可行系统。 关键字: 通讯录信息管理,管理信息系统,visual basic ,access
Selenium：Selenium Grid.zip
08-18
史上最全软件测试技术全套教程，包括： Postman Selenium 单元测试 压力测试 回归测试 安全测试 性能测试 测试工具 集成测试 等流行技术的系列教程
计算机毕业设计jsp房屋出租出售系统vue论文
08-18
计算机毕业设计jsp房屋出租出售系统vue论文
探索贪婪算法与动态规划：第3部分详解
1. 贪婪算法的设计范式：介绍这一算法设计策略的基本原则，强调如何通过每一步局部最优决策来逐步接近全局最优解决方案。 2. 调度问题示例：通过实际问题展示贪婪算法的应用，让读者理解其在优化问题中的作用。 3....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值