Hopcroft–Karp Algorithm for Maximum Matching | Set 2 (Implementation)

We strongly recommend to refer below post as a prerequisite.
Hopcroft–Karp Algorithm for Maximum Matching | Set 1 (Introduction)

There are few important things to note before we start implementation. 

1. We need to find an augmenting path (A path that alternates between matching and not matching edges, and has free vertices as starting and ending points).
2. Once we find alternating path, we need to add the found path to existing Matching. Here adding path means, making previous matching edges on this path as not-matching and previous not-matching edges as matching.

The idea is to use BFS (Breadth First Search) to find augmenting paths. Since BFS traverses level by level, it is used to divide the graph in layers of matching and not matching edges. A dummy vertex NIL is added that is connected to all vertices on left side and all vertices on right side. Following arrays are used to find augmenting path. Distance to NIL is initialized as INF (infinite). If we start from dummy vertex and come back to it using alternating path of distinct vertices, then there is an augmenting path.

1. pairU[]: An array of size m+1 where m is number of vertices on left side of Bipartite Graph. pairU[u] stores pair of u on right side if u is matched and NIL otherwise.
2. pairV[]: An array of size n+1 where n is number of vertices on right side of Bipartite Graph. pairV[v] stores pair of v on left side if v is matched and NIL otherwise.
3. dist[]: An array of size m+1 where m is number of vertices on left side of Bipartite Graph. dist[u] is initialized as 0 if u is not matching and INF (infinite) otherwise. dist[] of NIL is also initialized as INF

Once an augmenting path is found, DFS (Depth First Search) is used to add augmenting paths to current matching. DFS simply follows the distance array setup by BFS. It fills values in pairU[u] and pairV[v] if v is next to u in BFS. 

Below is the implementation of above Hopkroft Karp algorithm.

C++14

// C++ implementation of Hopcroft Karp algorithm for
// maximum matching
#include<bits/stdc++.h>
using namespace std;
#define NIL 0
#define INF INT_MAX

// A class to represent Bipartite graph for Hopcroft
// Karp implementation
class BipGraph
{
    // m and n are number of vertices on left
    // and right sides of Bipartite Graph
    int m, n;

    // adj[u] stores adjacents of left side
    // vertex 'u'. The value of u ranges from 1 to m.
    // 0 is used for dummy vertex
    list<int> *adj;

    // These are basically pointers to arrays needed
    // for hopcroftKarp()
    int *pairU, *pairV, *dist;

public:
    BipGraph(int m, int n); // Constructor
    void addEdge(int u, int v); // To add edge

    // Returns true if there is an augmenting path
    bool bfs();

    // Adds augmenting path if there is one beginning
    // with u
    bool dfs(int u);

    // Returns size of maximum matching
    int hopcroftKarp();
};

// Returns size of maximum matching
int BipGraph::hopcroftKarp()
{
    // pairU[u] stores pair of u in matching where u
    // is a vertex on left side of Bipartite Graph.
    // If u doesn't have any pair, then pairU[u] is NIL
    pairU = new int[m+1];

    // pairV[v] stores pair of v in matching. If v
    // doesn't have any pair, then pairU[v] is NIL
    pairV = new int[n+1];

    // dist[u] stores distance of left side vertices
    // dist[u] is one more than dist[u'] if u is next
    // to u'in augmenting path
    dist = new int[m+1];

    // Initialize NIL as pair of all vertices
    for (int u=0; u<=m; u++)
        pairU[u] = NIL;
    for (int v=0; v<=n; v++)
        pairV[v] = NIL;

    // Initialize result
    int result = 0;

    // Keep updating the result while there is an
    // augmenting path.
    while (bfs())
    {
        // Find a free vertex
        for (int u=1; u<=m; u++)

            // If current vertex is free and there is
            // an augmenting path from current vertex
            if (pairU[u]==NIL && dfs(u))
                result++;
    }
    return result;
}

// Returns true if there is an augmenting path, else returns
// false
bool BipGraph::bfs()
{
    queue<int> Q; //an integer queue

    // First layer of vertices (set distance as 0)
    for (int u=1; u<=m; u++)
    {
        // If this is a free vertex, add it to queue
        if (pairU[u]==NIL)
        {
            // u is not matched
            dist[u] = 0;
            Q.push(u);
        }

        // Else set distance as infinite so that this vertex
        // is considered next time
        else dist[u] = INF;
    }

    // Initialize distance to NIL as infinite
    dist[NIL] = INF;

    // Q is going to contain vertices of left side only.
    while (!Q.empty())
    {
        // Dequeue a vertex
        int u = Q.front();
        Q.pop();

        // If this node is not NIL and can provide a shorter path to NIL
        if (dist[u] < dist[NIL])
        {
            // Get all adjacent vertices of the dequeued vertex u
            list<int>::iterator i;
            for (i=adj[u].begin(); i!=adj[u].end(); ++i)
            {
                int v = *i;

                // If pair of v is not considered so far
                // (v, pairV[V]) is not yet explored edge.
                if (dist[pairV[v]] == INF)
                {
                    // Consider the pair and add it to queue
                    dist[pairV[v]] = dist[u] + 1;
                    Q.push(pairV[v]);
                }
            }
        }
    }

    // If we could come back to NIL using alternating path of distinct
    // vertices then there is an augmenting path
    return (dist[NIL] != INF);
}

// Returns true if there is an augmenting path beginning with free vertex u
bool BipGraph::dfs(int u)
{
    if (u != NIL)
    {
        list<int>::iterator i;
        for (i=adj[u].begin(); i!=adj[u].end(); ++i)
        {
            // Adjacent to u
            int v = *i;

            // Follow the distances set by BFS
            if (dist[pairV[v]] == dist[u]+1)
            {
                // If dfs for pair of v also returns
                // true
                if (dfs(pairV[v]) == true)
                {
                    pairV[v] = u;
                    pairU[u] = v;
                    return true;
                }
            }
        }

        // If there is no augmenting path beginning with u.
        dist[u] = INF;
        return false;
    }
    return true;
}

// Constructor
BipGraph::BipGraph(int m, int n)
{
    this->m = m;
    this->n = n;
    adj = new list<int>[m+1];
}

// To add edge from u to v and v to u
void BipGraph::addEdge(int u, int v)
{
    adj[u].push_back(v); // Add u to v’s list.
}

// Driver Program
int main()
{
    BipGraph g(4, 4);
    g.addEdge(1, 2);
    g.addEdge(1, 3);
    g.addEdge(2, 1);
    g.addEdge(3, 2);
    g.addEdge(4, 2);
    g.addEdge(4, 4);

    cout << "Size of maximum matching is " << g.hopcroftKarp();

    return 0;
}

Java

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

class GFG{

static final int NIL = 0;
static final int INF = Integer.MAX_VALUE;

static class BipGraph
{
    int m, n;
    List<Integer>[] adj;
    int[] pairU, pairV, dist;
    int hopcroftKarp()
    {
        pairU = new int[m + 1];
        pairV = new int[n + 1];
        dist = new int[m + 1];
        Arrays.fill(pairU, NIL);
        Arrays.fill(pairV, NIL);
        int result = 0;
        while (bfs())
        {

            for(int u = 1; u <= m; u++)

                if (pairU[u] == NIL && dfs(u))
                    result++;
        }
        return result;
    }
    boolean bfs()
    {

        Queue<Integer> Q = new LinkedList<>();

        for(int u = 1; u <= m; u++)
        {
            if (pairU[u] == NIL)
            {

                dist[u] = 0;
                Q.add(u);
            }

            else
                dist[u] = INF;
        }
        dist[NIL] = INF;

        while (!Q.isEmpty())
        {
            int u = Q.poll();
            if (dist[u] < dist[NIL])
            {
                for(int i : adj[u])
                {
                    int v = i;
                    if (dist[pairV[v]] == INF)
                    {
                        dist[pairV[v]] = dist[u] + 1;
                        Q.add(pairV[v]);
                    }
                }
            }
        }
        return (dist[NIL] != INF);
    }
    boolean dfs(int u)
    {
        if (u != NIL)
        {
            for(int i : adj[u])
            {
                int v = i;
                if (dist[pairV[v]] == dist[u] + 1)
                {
                    if (dfs(pairV[v]) == true)
                    {
                        pairV[v] = u;
                        pairU[u] = v;
                        return true;
                    }
                }
            }
            dist[u] = INF;
            return false;
        }
        return true;
    }

    // Constructor
    @SuppressWarnings("unchecked")
    public BipGraph(int m, int n)
    {
        this.m = m;
        this.n = n;
        adj = new ArrayList[m + 1];
        Arrays.fill(adj, new ArrayList<>());
    }
    void addEdge(int u, int v)
    {
        adj[u].add(v);
    }
}
public static void main(String[] args)
{

    BipGraph g = new BipGraph(4, 4);
    g.addEdge(1, 2);
    g.addEdge(1, 3);
    g.addEdge(2, 1);
    g.addEdge(3, 2);
    g.addEdge(4, 2);
    g.addEdge(4, 4);

    System.out.println("Size of maximum matching is " +
                       g.hopcroftKarp());
}
}

Python3

# Python3 implementation of Hopcroft Karp algorithm for
# maximum matching
from queue import Queue

INF = 2147483647
NIL = 0

# A class to represent Bipartite graph for Hopcroft
# 3 Karp implementation
class BipGraph(object):
    # Constructor
    def __init__(self, m, n):
        # m and n are number of vertices on left
        # and right sides of Bipartite Graph
        self.__m = m
        self.__n = n
        # adj[u] stores adjacents of left side
        # vertex 'u'. The value of u ranges from 1 to m.
        # 0 is used for dummy vertex
        self.__adj = [[] for _ in range(m+1)]

    # To add edge from u to v and v to u
    def addEdge(self, u, v):
        self.__adj[u].append(v)  # Add u to v’s list.

    # Returns true if there is an augmenting path, else returns
    # false
    def bfs(self):
        Q = Queue()
        # First layer of vertices (set distance as 0)
        for u in range(1, self.__m+1):
            # If this is a free vertex, add it to queue
            if self.__pairU[u] == NIL:
                # u is not matched3
                self.__dist[u] = 0
                Q.put(u)
            # Else set distance as infinite so that this vertex
            # is considered next time
            else:
                self.__dist[u] = INF
        # Initialize distance to NIL as infinite
        self.__dist[NIL] = INF
        # Q is going to contain vertices of left side only.
        while not Q.empty():
            # Dequeue a vertex
            u = Q.get()
            # If this node is not NIL and can provide a shorter path to NIL
            if self.__dist[u] < self.__dist[NIL]:
                # Get all adjacent vertices of the dequeued vertex u
                for v in self.__adj[u]:
                    #  If pair of v is not considered so far
                    # (v, pairV[V]) is not yet explored edge.
                    if self.__dist[self.__pairV[v]] == INF:
                        # Consider the pair and add it to queue
                        self.__dist[self.__pairV[v]] = self.__dist[u] + 1
                        Q.put(self.__pairV[v])
        # If we could come back to NIL using alternating path of distinct
        # vertices then there is an augmenting path
        return self.__dist[NIL] != INF

    # Returns true if there is an augmenting path beginning with free vertex u
    def dfs(self, u):
        if u != NIL:
            # Get all adjacent vertices of the dequeued vertex u
            for v in self.__adj[u]:
                if self.__dist[self.__pairV[v]] == self.__dist[u] + 1:
                    # If dfs for pair of v also returns true
                    if self.dfs(self.__pairV[v]):
                        self.__pairV[v] = u
                        self.__pairU[u] = v
                        return True
            # If there is no augmenting path beginning with u.
            self.__dist[u] = INF
            return False
        return True

    def hopcroftKarp(self):
        # pairU[u] stores pair of u in matching where u
        # is a vertex on left side of Bipartite Graph.
        # If u doesn't have any pair, then pairU[u] is NIL
        self.__pairU = [0 for _ in range(self.__m+1)]

        # pairV[v] stores pair of v in matching. If v
        # doesn't have any pair, then pairU[v] is NIL
        self.__pairV = [0 for _ in range(self.__n+1)]

        # dist[u] stores distance of left side vertices
        # dist[u] is one more than dist[u'] if u is next
        # to u'in augmenting path
        self.__dist = [0 for _ in range(self.__m+1)]
        # Initialize result
        result = 0

        # Keep updating the result while there is an
        # augmenting path.
        while self.bfs():
            # Find a free vertex
            for u in range(1, self.__m+1):
                # If current vertex is free and there is
                # an augmenting path from current vertex
                if self.__pairU[u] == NIL and self.dfs(u):
                    result += 1
        return result


# Driver Program
if __name__ == "__main__":
    g = BipGraph(4, 4)
    g.addEdge(1, 2)
    g.addEdge(1, 3)
    g.addEdge(2, 1)
    g.addEdge(3, 2)
    g.addEdge(4, 2)
    g.addEdge(4, 4)
    print("Size of maximum matching is %d" % g.hopcroftKarp())

C#

// GFG
// C# code for this approach
using System;
using System.Collections.Generic;
using System.Linq;

class HopcroftKarp
{
    const int NIL = 0;
    const int INF = int.MaxValue;

    static void Main()
    {
        int n = 4; // number of nodes in set U
        int m = 4; // number of nodes in set V

        var g = new BipGraph(n, m);
        g.addEdge(1, 2);
        g.addEdge(1, 3);
        g.addEdge(2, 1);
        g.addEdge(3, 2);
        g.addEdge(4, 2);
        g.addEdge(4, 4);

        Console.WriteLine("Size of maximum matching is " +
                           g.hopcroftKarp());
    }

    class BipGraph
    {
        private readonly int m;
        private readonly int n;
        private readonly List<int>[] adj;
        private int[] pairU;
        private int[] pairV;
        private int[] dist;

        public BipGraph(int m, int n)
        {
            this.m = m;
            this.n = n;
            adj = new List<int>[m + 1];
            for (int i = 0; i <= m; i++)
            {
                adj[i] = new List<int>();
            }
        }

        public void addEdge(int u, int v)
        {
            adj[u].Add(v);
        }

        public int hopcroftKarp()
        {
            pairU = Enumerable.Repeat(NIL, m + 1).ToArray();
            pairV = Enumerable.Repeat(NIL, n + 1).ToArray();
            dist = Enumerable.Repeat(0, m + 1).ToArray();

            int result = 0;
            while (bfs())
            {
                for (int u = 1; u <= m; u++)
                {
                    if (pairU[u] == NIL && dfs(u))
                    {
                        result++;
                    }
                }
            }
            return result;
        }

        private bool bfs()
        {
            var Q = new Queue<int>();

            for (int u = 1; u <= m; u++)
            {
                if (pairU[u] == NIL)
                {
                    dist[u] = 0;
                    Q.Enqueue(u);
                }
                else
                {
                    dist[u] = INF;
                }
            }
            dist[NIL] = INF;

            while (Q.Count > 0)
            {
                int u = Q.Dequeue();
                if (dist[u] < dist[NIL])
                {
                    foreach (int v in adj[u])
                    {
                        if (dist[pairV[v]] == INF)
                        {
                            dist[pairV[v]] = dist[u] + 1;
                            Q.Enqueue(pairV[v]);
                        }
                    }
                }
            }
            return dist[NIL] != INF;
        }

        private bool dfs(int u)
        {
            if (u != NIL)
            {
                foreach (int v in adj[u])
                {
                    if (dist[pairV[v]] == dist[u] + 1)
                    {
                        if (dfs(pairV[v]))
                        {
                            pairV[v] = u;
                            pairU[u] = v;
                            return true;
                        }
                    }
                }
                dist[u] = INF;
                return false;
            }
            return true;
        }
    }
}
// Thic is written by Sundaram

Javascript

// Javascript implementation of Hopcroft Karp algorithm for maximum matching

class BipGraph {
  constructor(m, n) {
    this.__m = m;
    this.__n = n;
    this.__adj = [...Array(m + 1)].map(() => []);
  }

  addEdge(u, v) {
    this.__adj[u].push(v); // Add u to v’s list.
  }

  bfs() {
    const Q = [];
    for (let u = 1; u <= this.__m; u++) {
      if (this.__pairU[u] === NIL) {
        this.__dist[u] = 0;
        Q.push(u);
      } else {
        this.__dist[u] = INF;
      }
    }
    this.__dist[NIL] = INF;
    while (Q.length > 0) {
      const u = Q.shift();
      if (this.__dist[u] < this.__dist[NIL]) {
        for (const v of this.__adj[u]) {
          if (this.__dist[this.__pairV[v]] === INF) {
            this.__dist[this.__pairV[v]] = this.__dist[u] + 1;
            Q.push(this.__pairV[v]);
          }
        }
      }
    }
    return this.__dist[NIL] !== INF;
  }

  dfs(u) {
    if (u !== NIL) {
      for (const v of this.__adj[u]) {
        if (this.__dist[this.__pairV[v]] === this.__dist[u] + 1) {
          if (this.dfs(this.__pairV[v])) {
            this.__pairV[v] = u;
            this.__pairU[u] = v;
            return true;
          }
        }
      }
      this.__dist[u] = INF;
      return false;
    }
    return true;
  }

  hopcroftKarp() {
    this.__pairU = Array(this.__m + 1).fill(0);
    this.__pairV = Array(this.__n + 1).fill(0);
    this.__dist = Array(this.__m + 1).fill(0);
    let result = 0;
    while (this.bfs()) {
      for (let u = 1; u <= this.__m; u++) {
        if (this.__pairU[u] === NIL && this.dfs(u)) {
          result++;
        }
      }
    }
    return result;
  }
}

const INF = 2147483647;
const NIL = 0;

// Driver Program
const g = new BipGraph(4, 4);
g.addEdge(1, 2);
g.addEdge(1, 3);
g.addEdge(2, 1);
g.addEdge(3, 2);
g.addEdge(4, 2);
g.addEdge(4, 4);
console.log(`Size of maximum matching is ${g.hopcroftKarp()}`);

Output

Size of maximum matching is 4

Time Complexity : O(√V x E), where E is the number of Edges and V is the number of vertices.

Auxiliary Space : O(V) as we are using extra space for storing u and v.

The above implementation is mainly adopted from the algorithm provided on Wiki page of Hopcroft Karp algorithm.

This article is contributed by Rahul Gupta. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.