#34 Fix HopcroftKarp matching

Author: justcoding121

README.md

@@ -184,7 +184,7 @@ TODO: implement trie compression.
 #### Matching
 
 - [X] Max bipartite matching ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/src/Advanced.Algorithms/Graph/Matching/BiPartiteMatching.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/tests/Advanced.Algorithms.Tests/Graph/Matching/BiPartiteMatching_Tests.cs)) using Edmonds Karp's improved Ford Fulkerson max flow algorithm 
-- [ ] Max bipartite matching ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/src/Advanced.Algorithms/Graph/Matching/HopcroftKarp.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/tests/Advanced.Algorithms.Tests/Graph/Matching/HopcroftKarp_Tests.cs)) using Hopcroft Karp algorithm
+- [X] Max bipartite matching ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/src/Advanced.Algorithms/Graph/Matching/HopcroftKarp.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/tests/Advanced.Algorithms.Tests/Graph/Matching/HopcroftKarp_Tests.cs)) using Hopcroft Karp algorithm
 
 #### Cut
 

src/Advanced.Algorithms/Advanced.Algorithms.csproj

@@ -23,10 +23,6 @@
     <None Remove="Binary\**" />
     <None Remove="DynamicProgramming\**" />
   </ItemGroup>
-  
-  <ItemGroup>
-    <Compile Remove="Graph\Matching\HopcroftKarp.cs" />
-  </ItemGroup>
 
   <ItemGroup>
     <Compile Include="Binary\BaseConversion.cs" />

src/Advanced.Algorithms/Graph/Matching/BiPartiteMatching.cs

@@ -8,7 +8,7 @@ namespace Advanced.Algorithms.Graph
     /// <summary>
     ///  Compute Max BiParitite Edges using Ford-Fukerson algorithm.
     /// </summary>
-    public class BiPartiteMatching<T>
+    public class BiPartiteMatching<T> 
     {
         readonly IBiPartiteMatchOperators<T> @operator;
         public BiPartiteMatching(IBiPartiteMatchOperators<T> @operator)
@@ -118,7 +118,7 @@ private static WeightedDiGraph<T, int> createFlowGraph(IGraph<T> graph,
     /// <summary>
     /// The match result object.
     /// </summary>
-    public class MatchEdge<T>
+    public class MatchEdge<T> 
     {
         public T Source { get; }
         public T Target { get; }
@@ -128,6 +128,28 @@ public MatchEdge(T source, T target)
             Source = source;
             Target = target;
         }
+
+        public override bool Equals(object obj)
+        {
+            if(obj == this)
+            {
+                return true;
+            }
+
+            var tgt = obj as MatchEdge<T>;
+
+            if(tgt is null)
+            {
+                return false;
+            }
+
+            return tgt.Source.Equals(Source) && tgt.Target.Equals(Target);
+        }
+
+        public override int GetHashCode()
+        {
+            return new { Source, Target }.GetHashCode();
+        }
     }
 
     /// <summary>

src/Advanced.Algorithms/Graph/Matching/HopcroftKarp.cs

@@ -13,7 +13,7 @@ public class HopcroftKarpMatching<T>
         /// <summary>
         /// Returns a list of Max BiPartite Match Edges.
         /// </summary>
-        public List<MatchEdge<T>> GetMaxBiPartiteMatching(IGraph<T> graph)
+        public HashSet<MatchEdge<T>> GetMaxBiPartiteMatching(IGraph<T> graph)
         {
             //check if the graph is BiPartite by coloring 2 colors
             var mColorer = new MColorer<T, int>();
@@ -25,182 +25,195 @@ public List<MatchEdge<T>> GetMaxBiPartiteMatching(IGraph<T> graph)
             }
 
             return getMaxBiPartiteMatching(graph, colorResult.Partitions);
-
         }
 
         /// <summary>
         /// Get Max Match from Given BiPartitioned Graph.
         /// </summary>
-        private List<MatchEdge<T>> getMaxBiPartiteMatching(IGraph<T> graph,
+        private HashSet<MatchEdge<T>> getMaxBiPartiteMatching(IGraph<T> graph,
             Dictionary<int, List<T>> partitions)
         {
-            var leftMatch = new Dictionary<T, T>();
-            var rightMatch = new Dictionary<T, T>();
+            var matches = new HashSet<MatchEdge<T>>();
+
+            var leftToRightMatchEdges = new Dictionary<T, T>();
+            var rightToLeftMatchEdges = new Dictionary<T, T>();
 
+            var freeVerticesOnRight = bfs(graph, partitions, leftToRightMatchEdges, rightToLeftMatchEdges);
             //while there is an augmenting Path
-            while (bfs(graph, partitions, leftMatch, rightMatch))
+            while (freeVerticesOnRight.Count > 0)
             {
-                foreach (var vertex in partitions[2])
+                var visited = new HashSet<T>();
+                var paths = new HashSet<MatchEdge<T>>();
+
+                foreach (var vertex in freeVerticesOnRight)
                 {
-                    if (!rightMatch.ContainsKey(vertex))
+                    var path = dfs(graph,
+                      leftToRightMatchEdges, rightToLeftMatchEdges, vertex, default, visited, true);
+
+                    if (path != null)
                     {
-                        var visited = new HashSet<T> { vertex };
+                        union(paths, path);
+                    }
+                }
 
-                        var pathResult = dfs(graph.GetVertex(vertex),
-                          leftMatch, rightMatch, visited, true);
+                xor(matches, paths, leftToRightMatchEdges, rightToLeftMatchEdges);
 
-                        //XOR remaining done here (partially done inside DFS)
-                        foreach (var pair in pathResult)
+                freeVerticesOnRight = bfs(graph, partitions, leftToRightMatchEdges, rightToLeftMatchEdges);
+            }
+
+            return matches;
+        }
+
+        /// <summary>
+        /// Returns list of free vertices on right if there is an augmenting Path from left to right.
+        /// An augmenting path is a path which starts from a free vertex 
+        /// and ends at a free vertex via UnMatched (left -> right) and Matched (right -> left) edges alternatively.
+        /// </summary>
+        private List<T> bfs(IGraph<T> graph,
+            Dictionary<int, List<T>> partitions,
+            Dictionary<T, T> leftToRightMatchEdges, Dictionary<T, T> rightToLeftMatchEdges)
+        {
+            var queue = new Queue<T>();
+            var visited = new HashSet<T>();
+
+            var freeVerticesOnRight = new List<T>();
+
+            foreach (var vertex in partitions[1])
+            {
+                //if this left vertex is free
+                if (!leftToRightMatchEdges.ContainsKey(vertex))
+                {
+                    queue.Enqueue(vertex);
+                    visited.Add(vertex);
+
+                    while (queue.Count > 0)
+                    {
+                        var current = queue.Dequeue();
+
+                        //unmatched edges left to right
+                        foreach (var leftToRightEdge in graph.GetVertex(current).Edges)
                         {
-                            if (pair.isRight)
+                            if (visited.Contains(leftToRightEdge.TargetVertexKey))
                             {
-                                rightMatch.Add(pair.A, pair.B);
-                                leftMatch.Add(pair.B, pair.A);
+                                continue;
+                            }
+
+                            //checking if this right vertex is free
+                            if (!rightToLeftMatchEdges.ContainsKey(leftToRightEdge.TargetVertex.Key))
+                            {
+                                freeVerticesOnRight.Add(leftToRightEdge.TargetVertex.Key);
                             }
                             else
                             {
-                                leftMatch.Add(pair.A, pair.B);
-                                rightMatch.Add(pair.B, pair.A);
+                                foreach (var rightToLeftEdge in leftToRightEdge.TargetVertex.Edges)
+                                {
+                                    //matched edge right to left
+                                    if (leftToRightMatchEdges.ContainsKey(rightToLeftEdge.TargetVertexKey)
+                                        && !visited.Contains(rightToLeftEdge.TargetVertexKey))
+                                    {
+                                        queue.Enqueue(rightToLeftEdge.TargetVertexKey);
+                                    }
+                                }
                             }
+
+                            visited.Add(leftToRightEdge.TargetVertexKey);
                         }
                     }
-
                 }
-
             }
 
-            //now gather all 
-            var result = new List<MatchEdge<T>>();
-
-            foreach (var item in leftMatch)
-            {
-                result.Add(new MatchEdge<T>(item.Key, item.Value));
-            }
-            return result;
+            return freeVerticesOnRight;
         }
 
         /// <summary>
-        /// Trace Path for DFS
+        /// Find an augmenting path that start from a given free vertex on right and ending
+        /// at a free vertex on left. Return the matching edges along that path.
         /// </summary>
-        private class PathResult
+        private HashSet<MatchEdge<T>> dfs(IGraph<T> graph,
+            Dictionary<T, T> leftToRightMatchEdges,
+            Dictionary<T, T> rightToLeftMatchEdges,
+            T current,
+            T previous,
+            HashSet<T> visited,
+            bool currentIsRight)
         {
-            public T A { get; }
-            public T B { get; }
-            public bool isRight { get; }
+            var currentIsLeft = !currentIsRight;
 
-            public PathResult(T a, T b, bool isRight)
+            if (visited.Contains(current))
             {
-                A = a;
-                B = b;
-                this.isRight = isRight;
+                return null;
             }
-        }
 
-        private List<PathResult> dfs(IGraphVertex<T> current,
-            Dictionary<T, T> leftMatch, Dictionary<T, T> rightMatch,
-            HashSet<T> visitPath,
-            bool isRightSide)
-        {
-            if (!leftMatch.ContainsKey(current.Key)
-                && !isRightSide)
+            //free vertex on left found!
+            if (currentIsLeft && !leftToRightMatchEdges.ContainsKey(current))
             {
-                return new List<PathResult>();
+                visited.Add(current);
+                return new HashSet<MatchEdge<T>>() { new MatchEdge<T>(current, previous) };
             }
 
-            foreach (var edge in current.Edges)
+            //right to left should be unmatched edges
+            if (currentIsRight && !rightToLeftMatchEdges.ContainsKey(current))
             {
-                //do not re-visit ancestors in current DFS tree
-                if (visitPath.Contains(edge.TargetVertexKey))
-                {
-                    continue;
-                }
-
-                if (!visitPath.Contains(edge.TargetVertexKey))
-                {
-                    visitPath.Add(edge.TargetVertexKey);
-                }
-                var pathResult = dfs(edge.TargetVertex, leftMatch, rightMatch, visitPath, !isRightSide);
-                if (pathResult == null)
+                foreach (var edge in graph.GetVertex(current).Edges)
                 {
-                    continue;
+                    var result = dfs(graph, leftToRightMatchEdges, rightToLeftMatchEdges, edge.TargetVertexKey, current, visited, !currentIsRight);
+                    if (result != null)
+                    {
+                        result.Add(new MatchEdge<T>(edge.TargetVertexKey, current));
+                        visited.Add(current);
+                        return result;
+                    }
                 }
+            }
 
-                //XOR (partially done here by removing same edges)
-                //other part of XOR (adding new ones) is done after DFS method is finished
-                if (leftMatch.ContainsKey(current.Key)
-                    && leftMatch[current.Key].Equals(edge.TargetVertexKey))
-                {
-                    leftMatch.Remove(current.Key);
-                    rightMatch.Remove(edge.TargetVertexKey);
-                }
-                else if (rightMatch.ContainsKey(current.Key)
-                         && rightMatch[current.Key].Equals(edge.TargetVertexKey))
-                {
-                    rightMatch.Remove(current.Key);
-                    leftMatch.Remove(edge.TargetVertexKey);
-                }
-                else
+            //left to right should be matched edges
+            if (currentIsLeft && leftToRightMatchEdges.ContainsKey(current))
+            {
+                foreach (var edge in graph.GetVertex(current).Edges)
                 {
-                    pathResult.Add(new PathResult(current.Key, edge.TargetVertexKey, isRightSide));
+                    var result = dfs(graph, leftToRightMatchEdges, rightToLeftMatchEdges, edge.TargetVertexKey, current, visited, !currentIsRight);
+                    if (result != null)
+                    {
+                        result.Add(new MatchEdge<T>(current, edge.TargetVertexKey));
+                        visited.Add(current);
+                        return result;
+                    }
                 }
-
-                return pathResult;
-
             }
 
             return null;
         }
-
-        /// <summary>
-        /// Returns true if there is an augmenting Path from left to right.
-        /// An augmenting path is a path which starts from a free vertex 
-        /// and ends at a free vertex via Matched/UnMatched edges alternatively.
-        /// </summary>
-        private bool bfs(IGraph<T> graph,
-            Dictionary<int, List<T>> partitions,
-            Dictionary<T, T> leftMatch, Dictionary<T, T> rightMatch)
+        
+        private void union(HashSet<MatchEdge<T>> paths, HashSet<MatchEdge<T>> path)
         {
-            var queue = new Queue<T>();
-            var visited = new HashSet<T>();
-
-            var leftGroup = new HashSet<T>();
-
-            foreach (var vertex in partitions[1])
+            foreach (var item in path)
             {
-                leftGroup.Add(vertex);
-                //if vertex is free
-                if (!leftMatch.ContainsKey(vertex))
+                if (!paths.Contains(item))
                 {
-                    queue.Enqueue(vertex);
-                    visited.Add(vertex);
+                    paths.Add(item);
                 }
             }
+        }
 
-            while (queue.Count > 0)
+        private void xor(HashSet<MatchEdge<T>> matches, HashSet<MatchEdge<T>> paths,
+            Dictionary<T, T> leftToRightMatchEdges, Dictionary<T, T> rightToLeftMatchEdges)
+        {
+            foreach (var item in paths)
             {
-                var current = queue.Dequeue();
-
-                //if vertex is free
-                if (!leftGroup.Contains(current) &&
-                    !rightMatch.ContainsKey(current))
+                if (matches.Contains(item))
                 {
-                    return true;
+                    matches.Remove(item);
+                    leftToRightMatchEdges.Remove(item.Source);
+                    rightToLeftMatchEdges.Remove(item.Target);
                 }
-
-                foreach (var edge in graph.GetVertex(current).Edges)
+                else
                 {
-                    if (visited.Contains(edge.TargetVertexKey))
-                    {
-                        continue;
-                    }
-
-                    queue.Enqueue(edge.TargetVertexKey);
-                    visited.Add(edge.TargetVertexKey);
+                    matches.Add(item);
+                    leftToRightMatchEdges.Add(item.Source, item.Target);
+                    rightToLeftMatchEdges.Add(item.Target, item.Source);
                 }
-
             }
-
-            return false;
         }
+
     }
 }

tests/Advanced.Algorithms.Tests/Advanced.Algorithms.Tests.csproj

@@ -118,6 +118,7 @@
     <Compile Include="Distributed\LRUCache_Tests.cs" />
     <Compile Include="Geometry\BentleyOttmann_Tests.cs" />
     <Compile Include="Geometry\PointRotation_Tests.cs" />
+    <Compile Include="Graph\Matching\HopcroftKarp_Tests.cs" />
     <Compile Include="Graph\ShortestPath\AStar_Tests.cs" />
     <Compile Include="Graph\ShortestPath\TravellingSalesman_Tests.cs" />
     <Compile Include="Geometry\ClosestPointPair_Tests.cs" />