union find算法

最新推荐文章于 2020-05-26 15:02:12 发布
最新推荐文章于 2020-05-26 15:02:12 发布
阅读量307 收藏
点赞数
分类专栏： Java算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/angjk152208/article/details/78137389
版权

这个星期要做Union-find算法的作业，一直在想怎么引进.txt文件，同学找到一种方法：

1.首先把.txt文件保存到同一个包（不同的包也可以，但要用import导包）；


2.选择Run下面的run  configuration，然后点击Common，会出现如下界面

3.选择File，点击Workspace，就会出现如下界面，选择你需要导入的文件，ok，然后点击apply，运行之后就会出结果。

以上的方法有一些eplise是没有这种方法的，但是不急还有另一种方法，因为老师检查的时候，要比较几个不同算法的快慢，所以我三种的都写了。


1.UF最原始的，但是也是时间最长的。

package algorithm;

import java.io.File;
import java.util.Scanner;

public class UF {

private int[] parent; // parent[i] = parent of i
private byte[] rank; // rank[i] = rank of subtree rooted at i (never more than 31)
private int count; // number of components


public UF(int n) {
if (n < 0) throw new IllegalArgumentException();
count = n;
parent = new int[n];
rank = new byte[n];
for (int i = 0; i < n; i++) {
parent[i] = i;
rank[i] = 0;
}
}


public int find(int p) {
validate(p);
while (p != parent[p]) {
parent[p] = parent[parent[p]]; // path compression by halving
p = parent[p];
}
return p;
}


public int count() {
return count;
}


public boolean connected(int p, int q) {
return find(p) == find(q);
}


public void union(int p, int q) {
int rootP = find(p);
int rootQ = find(q);
if (rootP == rootQ) return;

// make root of smaller rank point to root of larger rank
if (rank[rootP] < rank[rootQ]) parent[rootP] = rootQ;
else if (rank[rootP] > rank[rootQ]) parent[rootQ] = rootP;
else {
parent[rootQ] = rootP;
rank[rootP]++;
}
count--;
}

// validate that p is a valid index
private void validate(int p) {
int n = parent.length;
if (p < 0 || p >= n) {
throw new IllegalArgumentException("index " + p + " is not between 0 and " + (n-1));
}
}


public static void main(String[] args) throws Exception {

// 数据从外部文件读入，“data.txt”放在项目的根目录下
Scanner input = new Scanner(new File("tinyUF.txt"));
//tinyUF
//mediumUF
//largeUF
int n = input.nextInt();
WeightedQuickUnionUF uf = new WeightedQuickUnionUF(n);
StdOut.println(n);
while (input.hasNext()) {
int p = input.nextInt();
int q = input.nextInt();
if (uf.connected(p, q)) continue;
uf.union(p, q);
StdOut.println(p + " " + q);
}
StdOut.println(uf.count() + " components");
}

}
2.QuickFindUF 
package algorithm;

import java.io.File;
import java.util.Scanner;

 

public class QuickFindUF {
    private int[] id;    // id[i] = component identifier of i
    private int count;   // number of components

   
    public QuickFindUF(int n) {
        count = n;
        id = new int[n];
        for (int i = 0; i < n; i++)
            id[i] = i;
    }
 
    public int count() {
        return count;
    }
  
   
    public int find(int p) {
        validate(p);
        return id[p];
    }

    // validate that p is a valid index
    private void validate(int p) {
        int n = id.length;
        if (p < 0 || p >= n) {
            throw new IllegalArgumentException("index " + p + " is not between 0 and " + (n-1));
        }
    }

   
    public boolean connected(int p, int q) {
        validate(p);
        validate(q);
        return id[p] == id[q];
    }
  
    
    public void union(int p, int q) {
        validate(p);
        validate(q);
        int pID = id[p];   // needed for correctness
        int qID = id[q];   // to reduce the number of array accesses

        // p and q are already in the same component
        if (pID == qID) return;

        for (int i = 0; i < id.length; i++)
            if (id[i] == pID) id[i] = qID;
        count--;
    }

 
 public static void main(String[] args) throws Exception {
    	
    	// 数据从外部文件读入，“data.txt”放在项目的根目录下
        Scanner input = new Scanner(new File("largeUF.txt"));
        //tinyUF
        //mediumUF
        //largeUF
        int n = input.nextInt();
        WeightedQuickUnionUF uf = new WeightedQuickUnionUF(n);
        StdOut.println(n);
        while (input.hasNext()) {
            int p = input.nextInt();
            int q = input.nextInt();
            if (uf.connected(p, q)) continue;
            uf.union(p, q);
            StdOut.println(p + " " + q);
        }
        StdOut.println(uf.count() + " components");
    }


}
3.QuickUnionUF 


package algorithm;

import java.io.File;
import java.util.Scanner;

 
public class QuickUnionUF {
    private int[] parent;  // parent[i] = parent of i
    private int count;     // number of components

  
    public QuickUnionUF(int n) {
        parent = new int[n];
        count = n;
        for (int i = 0; i < n; i++) {
            parent[i] = i;
        }
    }

 
    public int count() {
        return count;
    }
  
 
    public int find(int p) {
        validate(p);
        while (p != parent[p])
            p = parent[p];
        return p;
    }

    // validate that p is a valid index
    private void validate(int p) {
        int n = parent.length;
        if (p < 0 || p >= n) {
            throw new IllegalArgumentException("index " + p + " is not between 0 and " + (n-1));
        }
    }

 
    public boolean connected(int p, int q) {
        return find(p) == find(q);
    }

  
 
    public void union(int p, int q) {
        int rootP = find(p);
        int rootQ = find(q);
        if (rootP == rootQ) return;
        parent[rootP] = rootQ; 
        count--;
    }

 
public static void main(String[] args) throws Exception {
    	
    	// 数据从外部文件读入，“data.txt”放在项目的根目录下
        Scanner input = new Scanner(new File("largeUF.txt"));
        //tinyUF
        //mediumUF
        //largeUF
        int n = input.nextInt();
        WeightedQuickUnionUF uf = new WeightedQuickUnionUF(n);
        StdOut.println(n);
        while (input.hasNext()) {
            int p = input.nextInt();
            int q = input.nextInt();
            if (uf.connected(p, q)) continue;
            uf.union(p, q);
            StdOut.println(p + " " + q);
        }
        StdOut.println(uf.count() + " components");
    }


}
4.WeightedQuickUnionUF 
package algorithm;

import java.io.File;
import java.util.Scanner;

public class WeightedQuickUnionUF {
    private int[] parent;   // 父链接数组（由触点索引）
    private int[] size;     // 各个根节点所对应的分量的大小
    private int count;      // 连通分量的数量
 
    public WeightedQuickUnionUF(int n) { // 初始化时，N个点有N个分量
        count = n;
        parent = new int[n];
        size = new int[n];
        for (int i = 0; i < n; i++) {
            parent[i] = i;
            size[i] = 1;
        }
    }
 
    // 返回连通分量数
    public int count() {
        return count;
    }
  
    
    public int find(int p) {
        validate(p);
        //跟随链接找到根节点
        while (p != parent[p])
            p = parent[p];
        return p;
    }

    // 验证P是有效的索引
    private void validate(int p) {
        int n = parent.length;
        if (p < 0 || p >= n) {
            throw new IllegalArgumentException("index " + p + " is not between 0 and " + (n-1));  
        }
    }

    //如果p和q存在于同一个分量中则返回true
    public boolean connected(int p, int q) {
        return find(p) == find(q);
    }

    //在p和q之间添加一条连接
    public void union(int p, int q) {
    	//将p与q的根节点统一
        int rootP = find(p);
        int rootQ = find(q);
        if (rootP == rootQ) return;

        // 将小树的根节点连接到大树的根节点
        if (size[rootP] < size[rootQ]) {
            parent[rootP] = rootQ;
            size[rootQ] += size[rootP];
        }
        else {
            parent[rootQ] = rootP;
            size[rootP] += size[rootQ];
        }
        count--;
    }


  
    public static void main(String[] args) throws Exception {
    	
    	// 数据从外部文件读入，“data.txt”放在项目的根目录下
        Scanner input = new Scanner(new File("largeUF.txt"));
        //tinyUF.txt
        //mediumUF.txt
        //largeUF.txt
        int n = input.nextInt();
        WeightedQuickUnionUF uf = new WeightedQuickUnionUF(n);
        StdOut.println(n);
        while (input.hasNext()) {
            int p = input.nextInt();
            int q = input.nextInt();
            if (uf.connected(p, q)) continue;
            uf.union(p, q);
            StdOut.println(p + " " + q);
        }
        StdOut.println(uf.count() + " components");
    }

}
层层递进，第四中方法是最快的，所以我给老师检查的是第四种，都有注释。






淡然ang
关注
专栏目录
Union-Find算法详解
流楚丶格念的博客
06-01 3568
原文地址：https://www.jianshu.com/p/5f0db63ba54b今天讲讲 Union-Find 算法，也就是常说的并查集算法，主要是解决图论中「动态连通性」问题的。名词很高端，其实特别好理解，等会解释，另外这个算法的应用都非常有趣。说起这个 Union-Find，应该算是我的「启蒙算法」了，因为《算法4》的开头就介绍了这款算法，可是把我秀翻了，感觉好精妙啊！后来刷了 LeetCode，并查集相关的算法题目都非常有意思，而且《算法4》给的解法竟然还可以进一步优化，只要加一个微小的修改就可
算法4第4章加权无向图/Prim/Kruskal算法计算最小生成树讲解
cyj88jyc的专栏
06-29 896
加权无向图 加权图是为每条边关联一个权值的图模型，这种图可以自然的表示很多应用，在一副航班图中边表示航线，权值代表距离或价格，电路图中边表示电线，权值代表电线长度 边的权重不一定是距离,也可能是时间，费用，也可能是0或负数 加权无向图代码实现如下,只用把Graph实现里的Bag<Integer>换成Bag<Edge>,用Edge表示有权重的边 public class Ed...
Union Find原理及模板
pcc386115710的博客
05-26 244
实质：多叉树 功能：快速合并和查找 时间复杂度：Union - O(1) Find - O(1) 核心思想：连接根 底层数据结构： 父亲表示法——用一个Array/HashTable来记录每个节点的父亲是谁 father[A] = B 查询所在集合： 用所在集合最顶层的老大哥节点来代表这个集合 合并两个集合： 找到两个集合中最顶层的两个老大哥节点A和B father[A] = B or father[B] = A Python模板： f = {} #初始化父亲表 for e...
Union find算法总结
gentelyang的博客
06-06 373
最近比较忙，就不怎么整理了，看这三个博客+算法课本1.5https://blog.csdn.net/zjkC050818/article/details/62419111https://blog.csdn.net/dm_vincent/article/details/7655764https://blog.csdn.net/dm_vincent/article/details/7769159...
IDEA里面如何使用自带命令行和重定向功能
richard1230的博客
03-30 2663
引言 我在学习算法第四版这本书的时候发现书里面的程序有时候会需要添加重定向和命令行参数,这里记录一下; 添加重定向 java UF < tinyUF.txt take standard input from a file in IntelliJ IDEA. 在 IntelliJ 中给程序添加重定向: 添加命令行参数 #上面图里面设置好以后,在运行程序的时候相当于加了命令行参数(这里为t...
data_struct_and_algo：练习数据结构和算法
02-12
数据结构与算法实践 练习数据结构和算法，目前主要在python中进行 环境设定 推荐-使用诗歌和pyenv 装 使用 for python 3.7.9设置python虚拟环境（有关确切版本，请参考pyproject.toml） 激活虚拟环境 运行poetry install 备用-使用您喜欢的虚拟环境 使用在您喜欢的环境中从诗歌生成的requirements.txt 使用requirements-dev.txt添加测试和其他开发工具 测试和代码覆盖率 在所有测试的根目录下运行python -m pytest 在根目录下运行pytest --cov以运行所有测试并获得覆盖 在项目的根目录运行coverage run -m pyest以生成coverage 运行coverage report以查看覆盖率 运行coverage html以生成显示行覆盖率的详细html报告 运行ptw
学习笔记——union-find算法
weixin_43102379的博客
08-26 263
问题介绍 union-find算法即连通性算法解决的是一个在很多领域广泛应用的问题，它被用来计算网络中各个触点之间的连通性。 问题如下: 问题的输入是一列整数对，其中每个整数都表示一个某种类型的对象，一对整数pq可以被理解为“p和q是相连的”。我们假设“相连”是一种等价关系，这也就意味着它具有: 自反性:p和p是相连的； 对称性:如果p和q是相连的，那么q和p也是相连的； 传递性:如果p和q是相...
UnionFind算法应用.md
11-17
UnionFind算法应用.md
UnionFind算法详解.md
11-17
UnionFind算法详解.md
SW练习_union_find算法
01-06
带权重的union_find可以有效降低树的高度，...public class UnionFind { private int count;//连通分量的个数 private int[] pid;//保存父亲连接节点的id private int[] sonSize;//保存各个节点作为根节点的分量大小
算法原理系列：并查集
Demon-初来驾到
06-01 1027
算法原理系列：并查集《算法》当中第一章节就介绍了该数据结构，但并不知道它到底有何用，也就一直没有研究它。当做过一系列数组+链表+树的题目之后，再看看这并查集似乎又有点意思了，今天就探寻下。　介绍我对并查集的具体应用还不了解，所以就从一些基本的题目引出并查集。 并查含义：合并集合，查找集合。 可以有的操作如下： 给定两个“结点”，检查它们是否同属一个集合。（在同一集合中，所有元素均同质，因此判断两
并查集和Union-Find算法及其改进
程序人生
10-19 944
并查集 定义        并查集（Union-Find Sets）也叫不相交集合（Disjoint Sets），是一种用于维护若干个不相交元素所构成的集合的一种树型数据结构。并查集常用来处理一些不相交元素的合并与查询问题，在使用中常常用森林来表示。   主要操作         一个并查集数据结构维护了一个不相交动态集的集合。我们用一个代表（根节点）来标识每个集合，它是这个集合的某个成...
windows上三款能打开超大文本的工具比较：Large Text File Viewer+PilotEdit+LogView
绣春刀的博客
03-08 7万+
因需要打开一个16G的txt文件，下载了三款大佬推荐的软件：Large Text File Viewer5.2，PilotEdit，LogView（下文附下载链接） 先直接说结论：强烈推荐LogView，其余两个不推荐。 现在来逐个体验一下： 1.Large Text File Viewer 下载地址：点击下载 解压后看完readme，心里凉了一截：LTFViewer 5.2u supp...
动态连通性问题 四种解决方法 及其对比 《算法第四版》
zqzwzd的博客
03-04 533
问题： 输入n对数，判断两个数是否连通，并且输出连通的个数 输入样例： 法一： quick-find public class QuickFindUF { private int[] id; // id[i] = component identifier of i private int count; // number of components ...
并查集(Union-Find)算法介绍
热门推荐
不忘初心，好好沉淀
06-12 23万+
本文主要介绍解决动态连通性一类问题的一种算法，使用到了一种叫做并查集的数据结构，称为Union-Find。 更多的信息可以参考Algorithms 一书的Section 1.5，实际上本文也就是基于它的一篇读后感吧。 原文中更多的是给出一些结论，我尝试给出一些思路上的过程，即为什么要使用这个方法，而不是别的什么方法。我觉得这个可能更加有意义一些，相比于记下一些结论。
【并查集】并查集（Union-Find）算法框架
weixin_42956047的博客
05-26 270
并查集（Union-Find）算法框架 class UF { // 记录连通分量个数 private int count; // 存储若干棵树 private int[] parent; // 记录树的“重量” private int[] size; public UF(int n) { this.count = n; parent = new int[n]; size = new int[n];
Union-Find 算法实现
博观约取
07-01 2459
Union-Find 动态连接问题描述： 给定一个n个序列的对象，有两种操作：      -Union command：连接两个对象；      -Find/connected query：两个对象是否连接（有路径） 算法实现方式 1.用一个数组保存着每个对象所在的connected component，这种方式可以快速进行FIND，但是在union操作时需要遍历整
联合查找算法Union Find的一些分析
Pxjw.Home
08-19 2728
最近在学习Robert  Sedgewic,Kevin  Wayne的Algorithms第四版，谈谈有关并查集的概念。 首先，我们知道并查集是一种树型的数据结构，用于处理一些不相交集合，而最重要的就是联合查找算法，Union Find。 并查集的基本操作： makeSet(s)：建立一个新的并查集，其中包含 s 个单元素集合。 unionSet(x, y)：把元素 x 和元素 y 所在的
动态连接：UnionFind算法详解与应用
"UnionFind算法是计算机科学中用于处理动态连通性问题的数据结构和算法。它主要由快速查找（QuickFind）和快速联合（QuickUnion）两种策略组成，并通过一系列改进来提高效率和性能。在实际应用中，UnionFind算法常...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值