FB面经Prepare: Bipartite a graph

input friends relations{{1,2}, {2,3}, {3,4}}
把人分成两拨，每拨人互相不认识，
所以应该是group1{1,3}, group2{2,4}

这道题应该是how to bipartite a graph

Taken from GeeksforGeeks

Following is a simple algorithm to find out whether a given graph is Birpartite or not using Breadth First Search (BFS) :-

1. Assign RED color to the source vertex (putting into set U).
2. Color all the neighbors with BLUE color (putting into set V).
3. Color all neighbor’s neighbor with RED color (putting into set U).
4. This way, assign color to all vertices such that it satisfies all the constraints of m way coloring problem where m = 2.
5. While assigning colors, if we find a neighbor which is colored with same color as current vertex, then the graph cannot be colored with 2 vertices (or graph is not Bipartite).

Also, NOTE :-

-> It is possible to color a cycle graph with even cycle using two colors.

-> It is not possible to color a cycle graph with odd cycle using two colors.

EDIT :-

If a graph is not connected, it may have more than one bipartition. You need to check all those components separately with the algorithm as mentioned above.

So, for various disconnected sub-graph of the same graph, you need to perform this bipartition check on all of them separately using the same algorithm discussed above. All of those various disconnected sub-graph of the same graph will account for its own set of bipartition.

And, the graph will be termed bipartite, IF AND ONLY IF, each of its connected components are proved to be bipartite .

 package fbOnsite;

 import java.util.*;

 public class Bipartite {
     HashSet<Integer> list1 = new HashSet<Integer>();
     HashSet<Integer> list2 = new HashSet<Integer>();

     public void bfs(int[][] relations) {
         HashMap<Integer, HashSet<Integer>> graph = new HashMap<Integer, HashSet<Integer>>();
         for (int[] each : relations) {
             if (!graph.containsKey(each[0]))
                 graph.put(each[0], new HashSet<Integer>());
             if (!graph.containsKey(each[1]))
                 graph.put(each[1], new HashSet<Integer>());
             graph.get(each[0]).add(each[1]);
             graph.get(each[1]).add(each[0]);
         }

         Queue<Integer> queue = new LinkedList<Integer>();
         queue.offer(relations[0][0]);
         list1.add(relations[0][0]);
         HashSet<Integer> visited = new HashSet<Integer>();
         visited.add(relations[0][0]);
         int count = 1;
         while (!queue.isEmpty()) {
             int size = queue.size();
             for (int i=0; i<size; i++) {
                 int person = queue.poll();
                 HashSet<Integer> friends = graph.get(person);
                 for (int each : friends) {
                     if (list1.contains(each)&&list1.contains(person) || list2.contains(each)&&list2.contains(person)) {
                         list1.clear();
                         list2.clear();
                         return;
                     }

                     if (!visited.contains(each)) {
                         if (count%2 == 1) list2.add(each);
                         else list1.add(each);
                         queue.offer(each);
                         visited.add(each);
                     }
                 }
             }
             count++;
         }
     }

     /**
      * @param args
      */
     public static void main(String[] args) {
         // TODO Auto-generated method stub
         Bipartite sol = new Bipartite();
         int[][] relations1 = new int[][]{{1,2},{2,3},{3,4}};
         int[][] relations2 = new int[][]{{1,2},{1,4},{1,6},{1,8},{2,3},{3,4},{3,6},{2,5},{4,5},{5,6},{5,8}};
         int[][] relations3 = new int[][]{{1,2},{2,3},{3,1}};
         sol.bfs(relations2);
         System.out.println(sol.list1);
         System.out.println(sol.list2);
     }

 }