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

Last Updated : 08 Mar, 2024

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 the augmenting path, we need to add the found path to the existing Matching. Here adding a 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 the left side and all vertices on the right side. The following arrays are used to find augmenting paths. Distance to NIL is initialized as INF (infinite). If we start from a dummy vertex and come back to it using alternating paths of distinct vertices, then there is an augmenting path.

1. pairU[]: An array of size m+1 where m is the number of vertices on the left side of the Bipartite Graph. pairU[u] stores paa r of u on the right side if u is matched and NIL otherwise.
2. pairV[]: An array of size n+1 where n is several vertices on the right side of the Bipartite Graph. pairV[v] stores a pair of v on the left side if v is matched and NIL otherwise.
3. dist[]: An array of size m+1 where m is several vertices on the left side of the 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.

## 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[] 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 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());` `}` `}`

## 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()}`);`

## C++14

 `// C++ implementation of Hopcroft Karp algorithm for` `// maximum matching` `#include` `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;` `}`

## 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())`

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.

Previous
Next
Share your thoughts in the comments