java算法事例：连通性

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

java算法事例：连通性

假设现在一个整数对序列，每个整数代表某种类型的对象，用p-q对表示“p连接到q”，又假设连接具有传递性，即p连接到q，q连接到r，则p连接到r。

例一：解决连通性问题的快速查找算法

Java代码 复制代码
  1. public class QuickF {   
  2.   
  3.     public static void main(String[] args) {   
  4.         int N = 10;   
  5.         int id [] = new int[N];   
  6.         for(int i = 0; i < N; i++){   
  7.             id[i] = i;   
  8.         }   
  9.         int [] [] a =  new int [][]{   
  10.                 {3,4},{4,9},{8,0},{2,3},{0,2},{5,6},   
  11.                 {2,9},{5,9},{7,3},{4,8},{5,6},{6,1}   
  12.         };   
  13.         System.out.println(Arrays.toString(id));   
  14.         for(int [] s : a){   
  15.             int p = s[0], q = s[1];   
  16.             int t = id[p];   
  17.             if(t == id[q]){   
  18.                 continue;   
  19.             }   
  20.             for(int i = 0; i < N; i++){   
  21.                 if(id[i] == t){   
  22.                     id[i] = id[q];   
  23.                     System.out.println(" " + p + " " + q);   
  24.                     System.out.println(Arrays.toString(id));   
  25.                 }   
  26.             }   
  27.         }   
  28.            
  29.     }   
  30. }  
public class QuickF {

	public static void main(String[] args) {
		int N = 10;
		int id [] = new int[N];
		for(int i = 0; i < N; i++){
			id[i] = i;
		}
		int [] [] a =  new int [][]{
				{3,4},{4,9},{8,0},{2,3},{0,2},{5,6},
				{2,9},{5,9},{7,3},{4,8},{5,6},{6,1}
		};
		System.out.println(Arrays.toString(id));
		for(int [] s : a){
			int p = s[0], q = s[1];
			int t = id[p];
			if(t == id[q]){
				continue;
			}
			for(int i = 0; i < N; i++){
				if(id[i] == t){
					id[i] = id[q];
					System.out.println(" " + p + " " + q);
					System.out.println(Arrays.toString(id));
				}
			}
		}
		
	}
}

在用快速查找算法时，对序列{p,q}每一对进行处理后，id数组中的值为合并操作。把所有与id[p]值相同的元素值变为id[q]值。

例二：快速合并（并不快速的查找）

Java代码 复制代码
  1. public class QuickFU {   
  2.   
  3.     public static void main(String[] args) {   
  4.         int N = 10;   
  5.         int id [] = new int[N];   
  6.         for(int i = 0; i < N; i++){   
  7.             id[i] = i;   
  8.         }   
  9.         int [] [] a =  new int [][]{   
  10.                 {3,4},{4,9},{8,0},{2,3},{5,6},{2,9},   
  11.                 {5,9},{7,3},{4,8},{5,6},{0,2},{6,1},{5,8}   
  12.         };   
  13.         System.out.println(Arrays.toString(id));   
  14.         for(int [] s : a){   
  15.             int i, j, p = s[0], q = s[1];   
  16.              for(i = p; i != id[i]; i = id[i]);   
  17.              for(j = q; j != id[j]; j = id[j]);   
  18.              if(i == j){   
  19.                  continue;   
  20.              }   
  21.              id [i] = j;   
  22.              System.out.println(" " + p + " " + q);   
  23.              System.out.println(Arrays.toString(id));   
  24.         }   
  25.     }   
  26. }  
public class QuickFU {

	public static void main(String[] args) {
		int N = 10;
		int id [] = new int[N];
		for(int i = 0; i < N; i++){
			id[i] = i;
		}
		int [] [] a =  new int [][]{
				{3,4},{4,9},{8,0},{2,3},{5,6},{2,9},
				{5,9},{7,3},{4,8},{5,6},{0,2},{6,1},{5,8}
		};
		System.out.println(Arrays.toString(id));
		for(int [] s : a){
			int i, j, p = s[0], q = s[1];
			 for(i = p; i != id[i]; i = id[i]);
			 for(j = q; j != id[j]; j = id[j]);
			 if(i == j){
				 continue;
			 }
			 id [i] = j;
			 System.out.println(" " + p + " " + q);
			 System.out.println(Arrays.toString(id));
		}
	}
}

在快速查找算法中，只需经过一个连接就可以找到节点；而在快速合并中中，可能需要多个节点才能找到。

例三：快速合并的加权版本

Java代码 复制代码
  1. public class QuickFW {   
  2.   
  3.     public static void main(String[] args) {   
  4.         int N = 10;   
  5.         int id [] = new int[N];   
  6.         int sz [] = new int[N];   
  7.         for(int i = 0; i < N; i++){   
  8.             id[i] = i;   
  9.             sz[i] = 1;   
  10.         }   
  11.         int [] [] a =  new int [][]{   
  12.                 {3,4},{4,9},{8,0},{2,3},{5,6},{2,9},   
  13.                 {5,9},{7,3},{4,8},{5,6},{0,2},{6,1}   
  14.         };   
  15.         System.out.println(Arrays.toString(id));   
  16.         for(int [] s : a){   
  17.             int i, j, p = s[0], q = s[1];   
  18.              for(i = p; i != id[i]; i = id[i]);   
  19.              for(j = q; j != id[j]; j = id[j]);   
  20.              if(i == j){   
  21.                  continue;   
  22.              }   
  23.              if(sz[i] < sz[j]){   
  24.                  id[i] = j;    
  25.                  sz[j] += sz[i];   
  26.              }else{   
  27.                  id[j] = i;   
  28.                  sz[i] += sz[j];   
  29.              }   
  30.              System.out.println(" " + p + " " + q);   
  31.              System.out.println(Arrays.toString(id));   
  32.              System.out.println(Arrays.toString(sz));   
  33.         }   
  34.     }   
  35. }  
public class QuickFW {

	public static void main(String[] args) {
		int N = 10;
		int id [] = new int[N];
		int sz [] = new int[N];
		for(int i = 0; i < N; i++){
			id[i] = i;
			sz[i] = 1;
		}
		int [] [] a =  new int [][]{
				{3,4},{4,9},{8,0},{2,3},{5,6},{2,9},
				{5,9},{7,3},{4,8},{5,6},{0,2},{6,1}
		};
		System.out.println(Arrays.toString(id));
		for(int [] s : a){
			int i, j, p = s[0], q = s[1];
			 for(i = p; i != id[i]; i = id[i]);
			 for(j = q; j != id[j]; j = id[j]);
			 if(i == j){
				 continue;
			 }
			 if(sz[i] < sz[j]){
				 id[i] = j; 
				 sz[j] += sz[i];
			 }else{
				 id[j] = i;
				 sz[i] += sz[j];
			 }
			 System.out.println(" " + p + " " + q);
			 System.out.println(Arrays.toString(id));
			 System.out.println(Arrays.toString(sz));
		}
	}
}

加权快速合并算法在典型情况下，可以在线性时间内解决实际问题。

路径压缩，在合并操作中，经过每条路径就加一条连线，把一路上遇到的对应的每个顶点的id数组值都设为到树根上，逼近了快速查找算法的理想状态。

例四：压缩方法：使在通向树根的路中的每条连线都指向路劲中的下一个节点，即折半路径压缩的加权快速合并

Java代码 复制代码
  1. public class QuickFH {   
  2.   
  3.     public static void main(String[] args) {   
  4.         int N = 10;   
  5.         int id [] = new int[N];   
  6.         int sz [] = new int[N];   
  7.         for(int i = 0; i < N; i++){   
  8.             id[i] = i;   
  9.             sz[i] = 1;   
  10.         }   
  11.         int [] [] a =  new int [][]{   
  12.                 {3,4},{4,9},{8,0},{2,3},{5,6},{2,9},   
  13.                 {5,9},{7,3},{4,8},{5,6},{0,2},{6,1}   
  14.         };   
  15.         System.out.println(Arrays.toString(id));   
  16.         for(int [] s : a){   
  17.             int i, j, p = s[0], q = s[1];   
  18.              for(i = p; i != id[i]; i = id[i]){   
  19.                  id[i] = id[id[i]];   
  20.              }   
  21.              for(j = q; j != id[j]; j = id[j]){   
  22.                  id[j] = id[id[j]];   
  23.              }   
  24.              if(i == j){   
  25.                  continue;   
  26.              }   
  27.              if(sz[i] < sz[j]){   
  28.                  id[i] = j;    
  29.                  sz[j] += sz[i];   
  30.              }else{   
  31.                  id[j] = i;   
  32.                  sz[i] += sz[j];   
  33.              }   
  34.              System.out.println(" " + p + " " + q);   
  35.              System.out.println(Arrays.toString(id));   
  36.              System.out.println(Arrays.toString(sz));   
  37.         }   
  38.     }   
  39. }  
public class QuickFH {

	public static void main(String[] args) {
		int N = 10;
		int id [] = new int[N];
		int sz [] = new int[N];
		for(int i = 0; i < N; i++){
			id[i] = i;
			sz[i] = 1;
		}
		int [] [] a =  new int [][]{
				{3,4},{4,9},{8,0},{2,3},{5,6},{2,9},
				{5,9},{7,3},{4,8},{5,6},{0,2},{6,1}
		};
		System.out.println(Arrays.toString(id));
		for(int [] s : a){
			int i, j, p = s[0], q = s[1];
			 for(i = p; i != id[i]; i = id[i]){
				 id[i] = id[id[i]];
			 }
			 for(j = q; j != id[j]; j = id[j]){
				 id[j] = id[id[j]];
			 }
			 if(i == j){
				 continue;
			 }
			 if(sz[i] < sz[j]){
				 id[i] = j; 
				 sz[j] += sz[i];
			 }else{
				 id[j] = i;
				 sz[i] += sz[j];
			 }
			 System.out.println(" " + p + " " + q);
			 System.out.println(Arrays.toString(id));
			 System.out.println(Arrays.toString(sz));
		}
	}
}

得到的与例三一样的净结果，比全路径压缩算法更简单。

通过一系列的算法：找到了解决实际问题的好算法，它比较容易实现，且运行实际保证在收集数据项所花费时间的常数因子范围内。在这些算法中需要仔细和复杂的分析，才能找到最优算法。

阿-杰
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
两点之间的连线java_java计算图两点之间的路径实例代码
weixin_42407617的博客
02-23 594
java计算图两点之间的路径总结本文实例为大家分享了java计算图两点之间的所有路径的具体代码，供大家参考，具体内容如下1.给定图如下:2.求0到3之间可达的所有路径这里问题就是关于搜索遍历的问题,但其中需要注意到不能产生回路或环.算法描述如下:top_node:当前栈顶元素adjvex_node;当前top_node已经访问的邻接点next_node:即将访问的元素(top_node的第adjv...
Java算法-1.连通性问题
Aim
09-07 1099
/**  * 问题描述：  * 假设现在有一个整数对序列，每个整数代表某种类型的对象，我们用p-q对表示"p连接到q"，并且这种连接具有传递性：  * 即如果p连接到q，而q又连接到r则p连接到r。我们的目标是写一个程序，把多余的对从集合中过滤掉：  * 当程序输入p-q对时，程序判断以前的数对是否包含了p-q连接，如果没有则添加否则忽略。  *   *   *分析：  * 我们的
算法练习_图的连通性问题（JAVA）
afgu10594的博客
01-06 335
一.问题 1.问题描述： 　　有n个点（1...n），输入整数对（8，9），表示8，9点之间存在相互的连接关系。 　　动态连通性问题--编写一段程序过滤掉所以无意义的整数对，即为在不破坏图连通性的前提下，以最简单的方式表示图的连通性。2.实现方案：设计数据结构保存已经存在的整数对，并且用他们来判断新数对是否满足新相连关系。3.实例应用：网络连接问题，电子触电设计，社交网络关系等等 ...
动态连通性 java_算法-动态连通性
weixin_35617554的博客
02-27 122
概念实现思路成本模型quick-find算法分析quick-union算法分析缺陷加权quick-union实现概念简单点理解就是连接两点，如果已经是连通的则忽略，比如下图： 应用网络连通性：判断大型计算机网络中，两台计算机是否需要新连接才能通信变量名等价性：能判断两变量名是否等价数学集合：两个数是否在一个集合中实现思路要实现这样的算法需要下面方法：初始化N个点，给它们标号得到一个点所属的标号连接...
JAVA编程题全集(50题及答案)
yangxin11001的专栏
02-12 8159
【程序1】    题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？    //这是一个菲波拉契数列问题 publicclass lianxi01 { public static void main(String[] args) { System.out.println("第1个月的兔子对数
解决连通性问题的四种算法
weixin_34217711的博客
01-28 1545
最近做 B 站弹幕分析 的项目，学习 Jieba 中文分词的动态规划算法，发现自己的算法知识待系统的学习，遂读 Sedgewick 的《算法 C 实现第三版》，这一系列算法的代码放在 Github，文章会同步到 SF，随意转载。 连通性问题 问题概述 先来看一张图： 在这个彼此连接和断开的点网络中，我们可以找到一条 p 点到 q 点的路...
java_algorithm:Java算法集合：排序、高级排序、堆和堆排序、二分搜索树、并查表、图的基础、最小生成树、最短路径
04-27
Java_Algorithm（Java算法集合） 学习算法是为了什么？ 1、应对大型IT公司的算法面试题； 2、IDE即对编译算法的封装； 3、搜索引擎中对几千、几亿数据进行优劣排序； 4、游戏对算法的引用是非常丰富的； 5、算法对...
JAVA代码：KMP算法
最新发布
03-22
kmp算法
JAVA近百种算法大全
05-29
3. Kruskal算法和Prim算法：求解最小生成树，用于网络连接优化。 4. Ford-Fulkerson算法：计算网络的最大流，解决分配问题。 五、动态规划 1. 背包问题：在容量限制下，选择物品以最大化价值。 2. 最长公共子序列：...
Java算法：大学课程文件
02-21
Java算法创建于： 2020年10月22日，最后更新： 2020年11月13日目标： 了解抽象类，接口，提高OOP技能。 了解如何编写异常。 了解如何编写JUnit测试。 了解如何使用策略模式。描述存储库包含各种不相关的练习。外部...
JAVA-Algrithm:Java算法练习代码
06-05
JAVA-Algrithm Java Algrithm Practice Code 该项目用于私人算法练习 主要来源： > LeetCode 目前进度:已跟进，与LeetCode同步。 部分问题： 1 - Array.SurroundedRegions - 改变搜索策略
java将两点进行连线,c++ 算法 栅格中两点之间连线
weixin_30792221的博客
03-09 239
#include #include using namespace std;void paint(int,int);void paint(int i,int j){//画出点位cout<}int main () {int A[]= {7,2};//起点int B[]={7,2};//终点int Ax=-1,Ay=-1,Bx=-1,By=-1;Ax=A[0];Ay=A[1];Bx=B[0];B...
java算法实例_合并元素&&判断元素是否连通
LZJWXJ树袋熊
10-03 399
案例1:简单的实现方式，直接遍历 代码： package me.ele.union_find; import java.util.Arrays; import java.util.List; /** * 快速查找 UC（union find） * &lt;p&gt; * 有一些元素 a b c d e f g h ...... * * @author LZJ * @creat...
Java动态连通性：union-find算法
qq_43743819的博客
08-09 269
目录动态连通性定义union-findquick-union加权的quick-union性能特征 动态连通性 定义 对于解决大型问题中，比如网络，（计算机）都有很大的作用。 union-find public class quick_find{ private int count; private int[] id; quick_find(int n){ count=n; id=new int[count];// for(int i
查找算法 java_JAVA算法1——连通性问题之快速查找算法
weixin_33208553的博客
02-22 134
假设现在有一个整数对序列，每个整数对代表某周类型的对象，我们用P-Q对表示“P链接到Q”。我们假设这种关系具有传递性，即如果p链接到q，而q又连接到r，则p连接到r。下面的程序是一个简单算法的实现，这个算法是解决连通性问题的快速查找算法。该算法的基础是一个整数数组，当且仅当第p个数组元素和第q个数组元素是相等的，则p与q是相连的。我们把第i个元素初始化为i(0 ≤i≤N)。要完成p和q的合并操作，...
java连通图_算法练习_图的连通性问题（JAVA）
weixin_29848477的博客
02-21 748
一.问题1.问题描述：有n个点(1...n)，输入整数对(8，9)，表示8，9点之间存在相互的连接关系。动态连通性问题--编写一段程序过滤掉所以无意义的整数对，即为在不破坏图连通性的前提下，以最简单的方式表示图的连通性。2.实现方案：设计数据结构保存已经存在的整数对，并且用他们来判断新数对是否满足新相连关系。3.实例应用：网络连接问题，电子触电设计，社交网络关系等等二.解决1.定义问题--设计ap...
OJ(Online Judge)系统及ACM测试题库大全
undoner
11-05 9454
OJ是Online Judge系统的简称，用来在线检测程序源代码的正确性。著名的OJ有RQNOJ、URAL等。国内著名的题库有北京大学题库、浙江大学题库等。国外的题库包括乌拉尔大学、瓦拉杜利德大学题库等。 简介： 　　Online Judge系统（简称OJ）是一个在线的判题系统。用户可以在线提交程序多种程序（如C、C++）源代码，系统对源代码进行编译和执行，并通过预先设计的测试数据来检验程序源
Java算法精粹：从兔子问题到水仙花数
"JAVA经典算法大全包含40个经典算法实例，旨在帮助Java开发者进阶。其中包括计算兔子繁殖数量的斐波那契数列问题、判断素数的问题以及找出水仙花数的算法。" 在Java编程中，算法是解决问题的关键，它们可以帮助我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值