程序博客网 > 淘宝新店没流量

并查集

来源：互联网 发布：淘宝新店没流量 编辑：程序博客网 时间：2024/05/02 02:57
百度笔试题：  编写一个Java应用程序，对于给定的一个字符串的集合，格式如：
　　{aaa bbb ccc}， {bbb ddd}，{eee fff}，{ggg}，{ddd hhh}
    要求将其中交集不为空的集合合并，要求合并完成后的集合之间无交集，例如上例应输出：
    {aaa bbb ccc ddd hhh}，{eee fff}， {ggg}


解法1

思路是：

1 首先创建一个邻接表，hash值从字符串中得到，邻接链表存放的是集合编号（从0开始），根据字符串分组，将同一个集合放在一起。

2 生成一个集合个数的数组A，初始化为-1；遍历整个邻接表，通过编号将一起的集合组合在一起，做法是：依次找找邻接表的中的项，一个集合编号的list，首先遍历这几个编号看是否之前出现过，如果有出现过，那么都设置成编号的最小值，也就是归入之前最早出现的的集合中（这里有个注意点，比如A为【0101】，当12也在一起的时候很明显0123都该在一起的，因为0和2在一起，1和3在一起的；因此要多一步额外的扫描整个数组，将和1集合相等的3也设置成0）；如果没有出现过，也就是所有数组A中的对应的元素都为-1，则设置成计数器的新值。

最后根据数据组A的编号将元素分组，用Set存放可以挑出重合的元素。


[java] view plaincopy
  1. import java.util.*;  
  2. import java.util.Map.Entry;  
  3.   
  4. public class Test{  
  5.     public static void solve(String[][] a){  
  6.         //遍历元素，elemnts中key值为字符串，value值该字符串所在集合中的编号  
  7.         //集合编号从0开始  
  8.         //其实这个画图出来就是一个邻接表  
  9.         Map<String,List<Integer>> elements = new HashMap<String,List<Integer>>();  
  10.         for(int i=0;i<a.length;i++){  
  11.             for(int j=0;j<a[i].length;j++){  
  12.                 if(elements.get(a[i][j])==null){  
  13.                     List<Integer> list = new ArrayList<Integer>();  
  14.                     list.add(i);  
  15.                     elements.put(a[i][j],list);  
  16.                       
  17.                 }else{  
  18.                     List<Integer> list = elements.get(a[i][j]);  
  19.                     list.add(i);  
  20.                 }  
  21.             }  
  22.         }     
  23.         int[] collections = new int[a.length];//每个位置对应一个集合  
  24.         for(int i=0;i<collections.length;i++){  
  25.             collections[i] = -1;  
  26.         }  
  27.         //遍历整个集合将有相同字符串的集合设置成同一数字  
  28.         int count = 0; //计数器，相同值就是同一个集合  
  29.         for(Iterator<Entry<String,List<Integer>>> it = elements.entrySet().iterator();it.hasNext();){  
  30.             //在同一个list中的集合表明有相同的字符串，因此属于同一个集合  
  31.             List<Integer> list = it.next().getValue();      
  32.             //遍历查找这个list中的集合是否已经和其他集合合并  
  33.             //如果合并了，找出最小的集合编号  
  34.             int min = -2;   
  35.             for(int i=0;i<list.size();i++){  
  36.                 if(collections[list.get(i)]!=-1&&(min==-2||collections[list.get(i)]<min)){  
  37.                     min = collections[list.get(i)];  
  38.                 }  
  39.             }  
  40.             if(min==-2){//所有集合都没出现过  
  41.                 for(int i=0;i<list.size();i++){  
  42.                     collections[list.get(i)] = count;  
  43.                 }  
  44.                 count++;  
  45.             }else{  
  46.                 for(int i=0;i<list.size();i++){  
  47.                     for(int j=0;j<collections.length;j++)  
  48.                         if(collections[j]==collections[list.get(i)]&&collections[j]!=-1)  
  49.                             collections[j] = min;  
  50.                     collections[list.get(i)] = min;  
  51.                 }  
  52.             }  
  53.         }  
  54.           
  55.         //根据collections的编号分组将分组中的元素加入对应的位置  
  56.         Map<Integer,Set<String>> results = new HashMap<Integer,Set<String>>();  
  57.         for(int i=0;i<collections.length;i++){  
  58.             Set<String> set;  
  59.             if(results.get(collections[i])==null){  
  60.                 results.put(collections[i], new HashSet<String>());  
  61.             }  
  62.             set = results.get(collections[i]);  
  63.             for(int j=0;j<a[i].length;j++){  
  64.                 set.add(a[i][j]);  
  65.             }  
  66.         }  
  67.           
  68.         //打印出来  
  69.         for(Iterator<Entry<Integer,Set<String>>> it = results.entrySet().iterator();it.hasNext();){  
  70.             Entry entry = it.next();  
  71.             System.out.print(entry.getKey()+": ");  
  72.             for(Iterator<String> iter = ((Set<String>)entry.getValue()).iterator();iter.hasNext();){  
  73.                 System.out.print(iter.next()+" ");  
  74.             }  
  75.             System.out.println();  
  76.         }  
  77.     }  
  78.     public static void main(String[] args){  
  79.         String[][] a = {  
  80.                 {"aaa", "bbb", "ccc"},  
  81.                 {"bbb","ddd"},  
  82.                 {"eee", "fff"},  
  83.                 {"ggg"},  
  84.                 {"ddd","hhh"}  
  85.         };  
  86.         solve(a);  
  87.     }  
  88. }  


解法2 并查集

http://www.roading.org//algorithm/introductiontoalgorithm/Disjoint_set.html

并查集包括3个基本操作：

  1. 将每个元素看成单独的集合，设置不同序号 make_set
  2. 查找自己所处的集合 find_set
  3. 合并两个集合 union

数组式并查集

对于数组式并查集，数组下标代表元素，内容代表集合编号，因此

  1. make_set函数中，直接将数组内容都设置成下标，表示不同元素初始化在不同的集合中；
  2. find_set函数中，直接根据下标返回内容
  3. union函数中，设置其中一个元素的集合编号为参考点，然后遍历数组，将要合并的集合中的元素所有元素的集合编号都设置成这个参考点，因为遍历，因此每次合并都是O（n）复杂度

具体代码见：

http://hi.baidu.com/gropefor/item/054967409f55e2af61d7b9b6


对于这个问题，首先将字符串映射成数字，然后申请最大数字长度的数组，然后将集合中相邻元素所在的集合依次合并在一起，最后用hasMap将相同集合的元素放在一起输出。代码如下：

[java] view plaincopy
  1. import java.util.*;  
  2. import java.util.Map.Entry;  
  3.   
  4.   
  5. public class Test{  
  6.     private static int[] elements;  
  7.     private static Map<String,Integer> map;  
  8.       
  9.     //初始化  
  10.     static void make_set(String[][] a){  
  11.         int count = 0;  
  12.         Map<String,Integer> map = new HashMap<String,Integer>();  
  13.         for(int i=0;i<a.length;i++){  
  14.             for(int j=0;j<a[i].length;j++){  
  15.                 if(map.get(a[i][j])==null){  
  16.                     map.put(a[i][j], count++);  
  17.                 }  
  18.             }  
  19.         }  
  20.         Test.map = map;  
  21.         elements = new int[count];  
  22.         for(int i=0;i<count;i++){  
  23.             elements[i] = i;  
  24.         }  
  25.     }  
  26.       
  27.     //将相邻元素所在的集合合并  
  28.     static void union(String[][] a){  
  29.         for(int i=0;i<a.length;i++){  
  30.             for(int j=0;j<a[i].length-1;j++){  
  31.                 int n1 = elements[map.get(a[i][j])];  
  32.                 int n2 = elements[map.get(a[i][j+1])];  
  33.                 for(int k=0;k<elements.length;k++){  
  34.                     if(elements[k]==n2){  
  35.                         elements[k] = n1;  
  36.                     }  
  37.                 }  
  38.             }  
  39.         }  
  40.     }  
  41.       
  42.     //根据elements中的结果将元素合并并打印  
  43.     static void print(){  
  44.           
  45.         HashMap<Integer,List<String>> results = new HashMap<Integer,List<String>>();  
  46.           
  47.         //迭代map找到字符串和对应的下标  
  48.         for(Iterator<Entry<String,Integer>> it = Test.map.entrySet().iterator();it.hasNext();){  
  49.             Entry<String,Integer> entry = it.next();  
  50.             String s = entry.getKey();  
  51.             int collectionNumber = elements[entry.getValue()]; //所属的集合  
  52.             if(results.get(collectionNumber)==null){  
  53.                 results.put(collectionNumber, new ArrayList<String>());  
  54.             }  
  55.             List<String> list = results.get(collectionNumber);  
  56.             list.add(s);  
  57.         }  
  58.           
  59.         for(Iterator<List<String>> it=results.values().iterator();it.hasNext();){  
  60.             List<String> list = it.next();  
  61.             for(String s:list){  
  62.                 System.out.print(s+" ");  
  63.             }  
  64.             System.out.println();  
  65.         }  
  66.     }  
  67.       
  68.     public static void main(String[] args){  
  69.         String[][] a = {  
  70.                 {"aaa", "bbb", "ccc"},    
  71.                 {"bbb","ddd"},    
  72.                 {"eee", "fff"},    
  73.                 {"ggg"},    
  74.                 {"ddd","hhh"}  
  75.         };  
  76.           
  77.         make_set(a);  
  78.         union(a);  
  79.         print();  
  80.     }  
  81. }  


树状并查集

对于树状并查集，存储还是用的数组（数组结构存放树，加一个父亲编号从孩子单向映射到父亲，这个比堆或者完全二叉树还有适用一些；和堆不同的是，堆根据下标确定在树结构中的位置，内容是具体的值；而这个树形结构下标只是位置，内容是父亲编号和自身具体的内容，这里特殊一些，下标既表示位置又表示内容），数组下标代表元素，数组内容是自己的父亲节点的编号，因此

  1. make_set函数中，将数组内容设计成自身下标，表示父亲还是自己；
  2. find_set函数中，一直往上查找父亲，父亲编号区分集合；同时用路径压缩，其实就是将自身到父亲经过的所有节点直接连接到父亲上减少树的高度
  3. union函数中，找到父亲编号，然后拼接在一起

具体代码见：

http://hi.baidu.com/gropefor/item/02ecb7e912e50c3e86d9deb9

这里有个错的地方是，元素个数不代表树的高度，比如a下面有bcdefg孩子，因此这棵树AA有7个节点，而h下面有ij孩子，j下面有k，因此这棵树BB有4个孩子，而拼接的时候还是要将AA拼接在BB的下面，而不是相反。

对于这个问题，初始化过程和数组式并查集一样；然后遍历集合将相邻元素代表的集合用union合并；最后遍历数组根据最高父节点将元素合并，然后输出。

[java] view plaincopy
  1. import java.util.*;  
  2. import java.util.Map.Entry;  
  3.   
  4.   
  5. public class Test{  
  6.     private static int[] elements;  
  7.     private static Map<String,Integer> map;  
  8.       
  9.     //初始化  
  10.     static void make_set(String[][] a){  
  11.         int count = 0;  
  12.         Map<String,Integer> map = new HashMap<String,Integer>();  
  13.         for(int i=0;i<a.length;i++){  
  14.             for(int j=0;j<a[i].length;j++){  
  15.                 if(map.get(a[i][j])==null){  
  16.                     map.put(a[i][j], count++);  
  17.                 }  
  18.             }  
  19.         }  
  20.         Test.map = map;  
  21.         elements = new int[count];  
  22.         for(int i=0;i<count;i++){  
  23.             elements[i] = i;  
  24.         }  
  25.     }  
  26.       
  27.     //将相邻元素所在的集合合并  
  28.     static void union(String[][] a){  
  29.         for(int i=0;i<a.length;i++){  
  30.             for(int j=0;j<a[i].length-1;j++){  
  31.                 int n1 = map.get(a[i][j]);  
  32.                 int n2 = map.get(a[i][j+1]);  
  33.                 while(n1!=elements[n1])  
  34.                     n1 = elements[n1];  
  35.                 elements[n1] = n2;  
  36.             }  
  37.         }  
  38.     }  
  39.       
  40.     //根据elements中的结果将元素合并并打印  
  41.     static void print(){  
  42.         HashMap<Integer,List<String>> results = new HashMap<Integer,List<String>>();  
  43.         //迭代map找到字符串和对应的下标  
  44.         for(Iterator<Entry<String,Integer>> it = Test.map.entrySet().iterator();it.hasNext();){  
  45.             Entry<String,Integer> entry = it.next();  
  46.             String s = entry.getKey();  
  47.             int n1 = entry.getValue();  
  48.             //根据n1寻找父亲  
  49.             while(n1!=elements[n1])  
  50.                 n1 = elements[n1];  
  51.             if(results.get(n1)==null){  
  52.                 results.put(n1, new ArrayList<String>());  
  53.             }  
  54.             List<String> list = results.get(n1);  
  55.             list.add(s);  
  56.         }  
  57.           
  58.         for(Iterator<List<String>> it=results.values().iterator();it.hasNext();){  
  59.             List<String> list = it.next();  
  60.             for(String s:list){  
  61.                 System.out.print(s+" ");  
  62.             }  
  63.             System.out.println();  
  64.         }  
  65.     }  
  66.       
  67.     public static void main(String[] args){  
  68.         String[][] a = {  
  69.                 {"aaa", "bbb", "ccc"},    
  70.                 {"bbb","ddd"},    
  71.                 {"eee", "fff"},    
  72.                 {"ggg"},    
  73.                 {"ddd","hhh"}  
  74.         };  
  75.           
  76.         make_set(a);  
  77.         union(a);  
  78.         print();  
  79.     }  
  80. }  
0 0
淘宝新店没流量 淘宝新店没流量
原创粉丝点击
热门IT博客
腾讯国内足球数据腾讯国内足球数据
Ping应用的端口号Ping应用的端口号
软件驻场项目
视频监控管理平台软件
老牛登录器源码
用手机怎样开淘宝网店
网络p2p投资
mysql 数据导入mysql
java订单号
大数据医疗行业应用
网络借贷监管
计算机算法指的是
日本柠檬tv网络电视
caffe pdf
华歌尔淘宝旗舰店质量
小豆蔻儿的淘宝店
mac下安装php开发环境
阿里云 免费 开通码
怎样在淘宝用网银卡
java log4j sl4j教程
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 紫藤花 紫藤树 紫火 2018派派出紫火装备技巧 万族帝尊宇宙紫火 万族帝尊 宇宙紫火 紫灵 紫灵公主在现代 紫焰ol 霸道总裁爱上我 熏紫樱桃 紫燕 紫燕熟食店 紫燕食品 紫燕夫妻肺片 一对紫燕双双飞 紫燕的夫妻肺片 百味紫燕鸡 紫燕百味 上海紫燕百味鸡 防臭袜子 紫百味鸡 张紫燕 十世劫 九命紫林猫 紫猫 猫尾 紫玉 紫玉花园二手房 紫玉公司岳风 紫玉公司 紫玫 紫琪 紫琼作品 紫琼 霸道老公深度爱 紫琼 紫璃 紫璇 老公教授 紫璇 紫点 紫电 曦澄车紫电play qq飞车紫电

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里