zoukankan      html  css  js  c++  java

  • java算法事例：连通性

    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. }  

    在用快速查找算法时，对序列{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. }  

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

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

    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. }  

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

    路径压缩，在合并操作中，经过每条路径就加一条连线，把一路上遇到的对应的每个顶点的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. }  

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

    通过一系列的算法：找到了解决实际问题的好算法，它比较容易实现，且运行实际保证在收集数据项所花费时间的常数因子范围内。在这些算法中需要仔细和复杂的分析，才能找到最优算法。
  • 相关阅读:
    Spring Boot 之 RabbitMQ 消息队列中间件的三种模式
    各浏览器驱动下载地址
    idea配置jdk
    谷歌打不开应用商店临时方法
    airtest下载网址
    hive不分区增量更新
    hive建表结构
    Hive 常用命令
    Hive内部表与外部表区别
    java代码中的坑
  • 原文地址：https://www.cnblogs.com/wuyida/p/6301163.html
Copyright © 2011-2022 走看看