算法-朋友分组问题

从业务上抽离出来的问题。

条件：

假设有一个已知的list:

List<String>  list= new ArrayList<String>();

list.add("A");

list.add("B");

list.add("C");

list.add("D");

……

假设每一个字母代表一个人，人与人之间有两种关系：相容与互斥。通过isFriendly（a,b）可以获得两人之间的关系。

一个朋友圈中所有人都必须相容，且无法再加入其他成员。

例如list有4个人A、B、C、D， AB互斥  其他均相容 ，则可以得到两个朋友圈{ACD}  {BCD}

——————

求：如何得到所有不同的朋友圈？

思路1：将所有人两两组合，形成两人朋友圈，接着两人朋友圈尝试添加其他人，形成3人朋友圈……直至所有朋友圈无法加人:，剔除掉重复朋友圈后得到所有不同的朋友圈。

（思路1光想想就脑壳痛……而且当所有人相容的时候显得很傻比= =）

 

思路2： 设置核心人物，以核心人物为中心，找到包含该人物的所有朋友圈。

　　　　而与核心人物互斥的人，则形成另一个新的核心人物。

　　       当不再产生新的核心人物，则可以得到所有的朋友圈。  

如果还有其他思路欢迎大家指教。

 

思路2详解：

　　看到思路2的时候，也许会有疑问：此思路只能够找出核心人物的所有朋友圈，那如何保证非核心人物的所有朋友圈也已经找出呢？

        我们假设核心为A，非核心人物B，AB相容组成一个朋友圈。此时，一个人物C有四种可能：1与A相容  2与A互斥  3与B相容  4与B互斥  

        于是有：

       　　a、 当C与核心A相容，代表C也在核心A的朋友圈中，那么下一步很简单：与B相容， 那么形成ABC模式的3人朋友圈，与B互斥，那么形成AC朋友圈。

      　　 b、当C与核心A互斥，则代表C可以形成新的核心，以C为核心的朋友圈将会重新考虑与B的关系

        由此可以看出，尽管以A为核心，B与C的关系也完全被考虑，加上D、E、F……等也是一样的

        当核心人物与非核心人物都纳入考虑的时候，只要找出所有核心人物，即可找出所有朋友圈的关系。而这一点当然不难……在比较核心人物与所有非核心人物的时候，这个过程能自然而然的找出所有核心。

        PS：一个核心只产生一个新的核心即可，因为第三个核心可以由第二个核心产生，这样可以一些减少重复的操作。 

        

  

思路2实现：

   public static void main(String[] args) {  2         
        List<String> list = new ArrayList<String>();
        list.add("A");
        list.add("B");
        list.add("C");
        list.add("D");
        list.add("E");
    
        
        List<String> linkList = new ArrayList<String>();
        int printIndex = 0;
        
        //核心成员列表
        List<String> coreItemList = new ArrayList<String>();
        //将第一个成员放入核心列表中
        coreItemList.add(list.get(0));
        
        System.out.println("朋友圈寻链过程：");
        //循环核心列表
        for(int i=0;i<coreItemList.size();i++){
            String coreItem = coreItemList.get(i);
            
            //新核心是否已经产生
            boolean isNewCoreCreat = false;
            
            //链头列表  链头 = coreItem + 另一个其他成员
            List<List<String>> itemLinkHeadList = new ArrayList<List<String>>();
            //还是链头列表,用于判断链头是否已经存在。String 链头 = coreItem,其他一个成员
            List<String> itemLinkHeadValidateList = new ArrayList<String>();
            
            //将核心元素作为第一个链头
            itemLinkHeadList.add(new ArrayList<String>(Arrays.asList(coreItem)));
            itemLinkHeadValidateList.add(coreItem);
            
            //循环链头
            for(int j=0; j<itemLinkHeadList.size() ;j++){
                List<String> itemLinkHead = itemLinkHeadList.get(j);
                
                //循环成员，用以检查 是否能够融入链中
                for(String item:list){
                    if(itemLinkHead.contains(item)){//不检验链头
                        continue;
                    }
                    
                    //如果该成员能够融入链头中
                    if(isFriendly(itemLinkHead,item)){
                        itemLinkHead.add(item);
                    }else{
                        //检验能否与核心相容
                        if(isFriendly(coreItem,item)){//如果相容，则可以产生链头
                            //链头必须为新链头，避免重复计算
                            if(!itemLinkHeadValidateList.contains(coreItem+","+item)){
                                itemLinkHeadValidateList.add(coreItem+","+item);
                                itemLinkHeadList.add(new ArrayList<String>(Arrays.asList(coreItem,item)));
                            }
                        }else{//无法与核心相容，该成员可形成新的核心
                            if(!isNewCoreCreat && !coreItemList.contains(item) && !isFriendly(coreItemList,item)){
                                coreItemList.add(item);
                                isNewCoreCreat = true;
                            }
                        }
                    }
                    
                }
                
                //链头itemLinkHead此刻已经完善为一条完整的朋友圈，可以放入结果集中
                Collections.sort(itemLinkHead);
                String itemLink = StringUtils.join(itemLinkHead, ",");
                printIndex++;
                System.out.println("第"+printIndex+"条："+itemLink);
                if(!linkList.contains(itemLink)){
                    linkList.add(itemLink);
                }
            }
        }
        
        System.out.println("朋友圈已形成结果：");
        for(int i= 0,ilength = linkList.size();i<ilength;i++){
            System.out.println("第"+(i+1)+"条："+linkList.get(i));
        }
        
    }
    
    /**
     * 检验item是否能够融入链头itemLinkHead
     * @param itemLinkHead
     * @param item
     * @return
     */
    public boolean isFriendly(List<String> itemLinkHead,String item){
        for(String linkItem:itemLinkHead){
            if(!isFriendly(linkItem,item)){
                return false;
            }
        }
        return true;
    }
    
    /**
     * 检验a\b是否能够相容
     * @param a
     * @param b
     * @return
     */
    public boolean isFriendly(String a,String b){
        boolean flag = true;
        if("A".equals(a) && "E".equals(b) || "A".equals(b) && "E".equals(a)){
            flag = false;
        }else if("B".equals(a) && "C".equals(b) || "B".equals(b) && "C".equals(a)){
            flag = false;
        }else if("B".equals(a) && "D".equals(b) || "B".equals(b) && "D".equals(a)){
            flag = false;
        }
        return flag;
    }
    
    

 

代码中人物有A、B、C、D、E  ；其中A、E互斥，B、C互斥，B、D互斥;其他相容。

运行结果如下：

朋友圈寻链过程：
第1条：A,B
第2条：A,C,D
第3条：A,C,D
第4条：A,B
第5条：B,E
第6条：C,D,E
第7条：C,D,E
第8条：B,E
朋友圈已形成结果：
第1条：A,B
第2条：A,C,D
第3条：B,E
第4条：C,D,E

可以看出，寻找的时候还是出现了重复的朋友圈。这是因为当AB组成链头去检查C、D的时候，由于C、D 均与B互斥，于是形成了 AC、AD两个新链头,最终两个链头都形成了ACD。这一点是无法避免的，所幸的是，在同一个核心里，最多产生list.size()-1个链头。

 

如有错误或者可以改进之处，欢迎大佬指出！