The Hungarian Algorithm

The Hungarian algorithm is an algorithm for solving a matching problem or more generally an assignment linear
programming problem. The name was given by H.W.Kuhn in recognition of the work of the two mathematicians
J.Egerváry and D.König. The Hungarian Algorithm is actually a special case of the Primal-Dual Algorithm. It takes a
bipartite graph and produces a maximal matching.
Recall an assignment problem has the standard form

LP:
Minimize ∑ i, j cij xij
Subject to the constraints
∑ j xij = 1 (1 ≤ i ≤ m)
∑ i xij = 1 (1 ≤ i ≤ n)
0 ≤ xij ≤ 1.

Here we should take cij ≥ 0. If m = n, the problem is a typical transportation problem and it always has an optimal
solution. Furthermore, the simplex algorithm only produces integer basic solutions and so xij = 0 or xij = 1. If
xij = 1, then we can say that the ith person is assigned to the jth task. The problem is set up so that every person is
assigned 1 task and so that every task gets done. The cost coefficients measure the suitability of a person to a task
while the objective value measures quantitatively the effectiveness of doing all the tasks. The problem can also be
assignments of machines to different jobs and the cost coefficient can be the cost of a certain machine to do a certain
job.
We can transform various related assignment problems into the standard form of LP.
1) If m ≠ n the problem is said to be unbalanced. We can create a number of false variables to force m = n and
assign costs equal to some large number for the false variables.
WARNING. The Hungarian algorithm can yield a false answer if the problem is unbalanced. We assume that the
assignment problem is balanced and has an m × m matrix.

2) If the problem LP′ is a maximization problem with

Maximize ∑i, j cij xij,
we can change to a minimization problem. Here we need to maintain the positivity of the cost coefficients. So we let
c = Max cij
and consider the linear program LP′′ with new objective term
Minimize ∑i, j (c -cij) xij.
In one of the following theorems, we show that LP′′ is equivalent to the problem with objective
Minimize ∑i, j -cij xij.
3) Suppose the assignment problem has a bottleneck in that it is infeasible to assign certain tasks to certain people.
For example suppose that one person i is totally unprepared for a certain assignment j. To handle this, we assign a
constant cij = M and agree never to use this M in the Hungarian algorithm.
4) Since the assignment problem is a transportation problem with m2 variables xij and 2m equations, the basic
index sets need to have 2m - 1 indices. But since the solution x* consists of only 0’s and 1’s, we see that there are

The Hungarian Algorithm page 1

only m nonzero coordinates in x*. Indeed, if xij is nonzero, then xij = 1 and the demand in the ith row and jth column
is simultaneously satisfied. Thus, only m nonzero coordinates in x* are possible. Also it is clear that x* must have
at least m nonzero coordinates;whence, the feasible solutions have precisely m nonzero coordinates.

Steps for the Assignment Algorithm

The Assignment Algorithm takes the assignment problem LP and replaces it with an new assignment problem
LP′ with the same number of variables but with a new cost matrix A′ = (c′ij) such that the optimal solutions x* (but
not the optimal objectives) of both LP and LP′ are the same. The cost matrix A′ will have “enough” zero elements so
that the i,j with x*ij = 1 satisfying Σi x*ij = 1 and Σj x*ij = 1 can be chosen using only those i,j with c′ij = 0. This
gives the objective value 0 for x* in LP′ and means that x* is optimal for LP′ and consequently for LP.
The algorithm that chooses the i,j with c′ij = 0 is called the Hungarian Algorithm. It is an algorithm that
constructs a maximal matching for a bipartite graph. We discuss this later in this Chapter. Right now we give the
assignment algorithm for LP.

Assignment Algorithm

Ia. Minimum entries are found for each separate row of A and subtracted from each entry in the respective rows.
The original matrix A is replaced by the new matrix.
b. Minimum entries are found for each separate column of A and these are subtracted from each entry in the
respective columns. The original matrix (from 1a) is replaced by the new matrix.
II. Cross out the minimal number of rows and columns in the matrix A to cover all 0 entries of A.
a. (Termination) If m lines are used in II to cover, STOP.
b. If less than m lines are used in II to cover, go to III.
III. (Iteration) Find the minimal entry not crossed out in II. Add this entry to all elements that are doubly crossed
out (by both a horizontal and vertical line) in II and subtract from all entries of A that are not crossed out.
Return to step II with the new matrix.

We defer the verification that the Assignment Algorithm does not change the optimal solution x* until we present
some ideas from graph theory to clarify. We first implement the Assignment Algorithm on an example.

Example

Consider the assignment problem with matrix

14 5 8 7
2 12 6 5
A= .
7 8 3 9
2 4 6 10
We compute the row minima as

The Hungarian Algorithm page 2

 Row Min
14 5 8 7 5
2 12 6 5 2
7 8 3 9 3
2 4 6 10 2
and transform by
9 0 3 2
0 10 4 3
4 5 0 6
0 2 4 8
col min 0 0 0 2
where the column minimums have been computed. Now we have the cover of
→ 9 0 3 0
0 10 4 1
→ 4 5 0 4
0 2 4 6
↑
with Row 1, Row 3, Column 1 doing the cover. Since the cover has 3 elements, we implement the third stage of the
algorithm. The minimal non covered entry is 1 and we get
→ 10 0 3 0
0 9 3 0
→ 5 5 0 4
0 1 3 5
↑ ↑
where the minimal covering is Row 1, Row 3, Column 1, Column 4.
Now we read off the basic solution. Many times we can read off the basic solution by inspection. At other
times we need to use the Hungarian algorithm. Here we want to find a basic solution with basic indices (i1, j1), … ,
(i4, j4) such that cij = 0 for all (i, j) in {(i1, j1), … , (i4, j4)}in the preceding matrix and such that
{i1, … , i4} = {j1, … , j4} = {1, … , 4}.
We can do this by inspection here. We
10 0 3 0
0 9 3 0
A′ = → 5 5 0 4 .
0 1 3 5
↑
We set x33 = 1 and then delete the row and column, viz. row 3 and column 3 with the (3, 3) cell. We now get a 3 × 3
submatrix of the remaining reduced cost coefficients with the same property as the original, viz., no fewer than 3 rows
or columns will cover the 0’s We proceed with choosing the next cell to get the basic solution. We
→ 10 0 0
→ 0 9 0
0 1 5
↑
set x31 = 1. Here we can write every thing on the matrix A′ without really deleting the rows and columns, i.e., we
write

The Hungarian Algorithm page 3

 10 0 3 0
0 9 3 0
A′′ = → 5 5 0 4
→ 0 1 3 5
↑ ↑

with x31 = 1. As the last step we see that

→ 0 0
9 0
↑
on the original matrix
10 0 3 0
0 9 3 0
.
5 5 0 4
0 1 3 5

so the last two basis elements are x12 = 1 and x24 = 1. So the basic solution (and assignment) is
x 33 = 1, x31 = 1, x12 = 1, x24 = 1.

Graphs

We first consider some notions from graph theory.

DEFINITION. A graph is an ordered pair G = (V, E) consisting of a finite set and a subset E of elements of the form
(x, y) where x and y are in V. The set V are called the vertices of the graph and the set E are called the edges

DEFINITION. A graph G is said to be a bipartite (or bicolored) graph if the vertices can be partitioned into two
mutually disjoint sets X and Y so that there is no edge of the form (x, x′) with x and x′ in X or of the form (y, y′)
with y and y′ in Y. A bipartite graph will be denoted by G = ({X, Y}, E).

NOTATION. The cardinality of a set X will be denoted by |X|.

Bipartite graphs G = ({X, Y}, E) are represented by matrices. The X vertices are for example used for row indices
and the Y vertices are used as column indices. Generally, the existence of an edge (x, y) is indicated by a 1 in the x,y
cell of the |X| × |Y| matrix; no edge is indicated by 0. For the assignment problem, we are representing an edge by 0
and no edge by a nonzero number.

DEFINITION. A matching for a bipartite graph G = ({X, Y}, E) is a subset M of E such that no two elements of M
have a common vertex.

DEFINITION. If G = ({X, Y}, E) is a bipartite graph, set

ρ(G) = max {|M|  M is a matching of G}.

The Hungarian Algorithm page 4

A matching M such that |M| = ρ(G) will be called a maximal matching.

DEFINITION. A set of vertices V′ is said to be a cover of a set of edges E′ if every edge in E′ is incident on one or
more of the vertices of V′. A set of vertices S will be called a cover of the bipartite graph G = ({X, Y}, E) if every
edge of G is incident on one or more of the vertices of S.

DEFINITION. If G = ({X, Y}, E) is a bipartite graph, set

c(G) = min {|S|  S is a cover of G}.
A cover S such that |S| = c(G) will be called a minimal cover of G.

THEOREM. If G = ({X, Y}, E) is a bipartite graph, then ρ(G) ≤ c(G).

PROOF. Let S be a cover with |S| = c(G). Let M be a matching. Then each e in M has at least one of its vertices in
S. If |M| > S, then by the pigeonhole principle, two edges e1 and e2 meet the same vertex v in S. This contradicts
the definition of a matching. So we have that |M| ≤ |S| = c(G). Q.E.D.

Graphs for the Assignment Problem

The assignment problem corresponds to a bipartite graph. The vertices V may be partitioned into two sets: (1)
the assigned tasks and (2) the assignees. The edges consist of (unordered) pairs connected the assigned tasks and the
assignees. Since we allow the theoretic possibility of assigning any task to any assignee, the graph for the assignment
problem consists of vertices V = (X, Y) where X = {x1, … , xm} and Y = {y1, … , ym} and edges consisting of all
combinations E = {(xi, yj)  1 ≤ i ≤ m, 1 ≤ j ≤ m}. We can denote the incidence matrix of this graph as an m × m
matrix consisting entirely of 1’s and we can use the matrix as a substitute for the graph. This has some disadvantage
in that an index, say 1, can denote x1 or y1 and so the row and column indices should be kept separate.
In the next section we consider subgraphs of the assignment problem. For example, let (aij) be the m × m cost
matrix of the assignment problem and let G′ be the subgraph whose edges are all (i, j) with aij = 0 and all vertices
incident on any of the edges. If we are considering i as row indices and j as column indices, the vertices will consist of
all rows of A which have a 0 entry and all columns of A which have a zero entry.

Verification of the Assignment Algorithm

We verify the assignment algorithm terminates at some stage with a cover of size m. The proof is obtained by
noting that sum of the current cost matrices is strictly decreasing at each stage provided there is a minimal cover of size
less than m. We use the viewpoint of the previous section.

THEOREM. Let be A = (aij) be an m × m matrix of positive entries. Suppose that there is a cover S of the set E′ of
edges (i, j) with aij = 0 of size less than or equal to m - 1. Let D = { (i, j) ∈ E′ both i and j are in S}. Let a0 be
the minimum of {aij  i ∉ S, j ∉ S}. Suppose that

The Hungarian Algorithm page 5

 a ij + a 0 (i, j) ∈ D
b ij = a ij – a 0 (i, j) ∉ E′ .
a ij otherwise
Then B = (bij) is a positive matrix with ∑ aij > ∑bij.

REMARK. We can paraphrase the theorem as follows. Suppose that 0’s of A are crossed by crossing out the rows
and columns containing a 0. Suppose that the minimal number of crossed out rows and columns necessary to cross
out all the 0’s of A is less than m - 1. Suppose that the minimal entry in the entries not crossed out by the minimal
number of crossed out rows and columns is added to all doubly crossed out entries of A and subtracted from all non
crossed out entries to give a matrix B = (bij). Then B is a positive matrix and ∑ aij > ∑bij.

PROOF. Let s and t be any integers with 0 ≤ s + t ≤ m - 1 and suppose that s rows and t columns are crossed out,
i.e., the cover C consists of s vetices of X and t vertices of Y. Then there are st doubly crossed out elements,
m(s + t) – st crossed out elements, and m(s + t) singly crossed out elements. So there are
m 2 - m(s + t) + st
entries that are not crossed out. Now suppose that the minimal (nonzero) entry in the uncrossed out part of A is r.
Since all the zero entries are crossed out r, we get that r > 0. So we get
∑ a ij - ∑bij = - rst + r(m2 - m(s + t) + st ) = rm(m - (s + t)) >0
since m > s + t. Also note that all bij ≥ 0 since the minimal entry is subtracted. Q.E.D.

The process of adding to double crossed out entries and subtracting from non crossed out entries is a combination
of operations that does not change the optimal solution of the assignment problem.

THEOREM. Suppose that step I or III in the assignment algorithm is implemented. Then the optimal solution of the
assignment problem with the new cost matrix does not change.
PROOF. For step I note that the optimal solution x* does not change if a constant is subtracted from any row or
column. To see this suppose that c is subtracted from every element in the first row of the cost coefficient matrix.
Then the problem becomes

Minimize ∑ j (c1j - c) x1j + ∑ i ≥ 2, j cijxij

Subject to the constraints
∑ j xij = 1 (1 ≤ i ≤ m)
∑ i xij = 1 (1 ≤ i ≤ n)
0 ≤ xij ≤ 1.

But we note that

∑ j (c1j - c) x1j + ∑ i ≥ 2, j cijxij = ∑ i , j cijxij - ∑ jcx1j = ∑ i , j cijxij - c.
So the optimal solution for the original problem is exactly the optimal solution for the perturbed problem. The same
holds for all other rows and columns. So I of the algorithm does not change the optimal solution.
Now suppose c is added to each cost of a doubly covered entry and c is subtracted from each cost of an uncovered

The Hungarian Algorithm page 6

entry. This is equivalent to adding c to each covered column and subtracting c from each uncovered row. To see this
suppose c is added to the covered column 1 and subtracted from the uncovered row 1. Suppose column 2 is uncovered
and row 2 is covered. Then we get the northwest 2 × 2 corner is
cov ( + c) uncov (no action)
uncov ( – c) c–c=0 –c
cov (no action) +c 0
which covers all 4 cases. So the action in step III is a series of action in step I and the optimal solution does not
change. Q.E.D.

Maximal Matchings using the Hungarian Algorithm

Let G = ((X, Y}, E) be a bipartite graph. Let M be a matching for G. The Hungarian Algorithm either shows
that M is a maximal matching for G or finds a matching M′ for G with |M′| = |M| + 1.

I. Label all vertices in X with (*) when the vertices do not meet an edge of M and call all vertices untested.
II. If in the previous step no new labels have been given to a vertex of X, then STOP. Otherwise, go to III.
III. While there is a labeled but untested vertex xi of X, label with xi all vertices yj of Y that have not yet been
labeled and that can be connected to xi with an edge NOT IN M. The vertex xi is now tested (even if no edge is added)
and the vertices yj are now labeled.
IV. If no new label has been given in III, then STOP. Otherwise, find an untested but labeled vertex yj of Y and
label with yj any unlabeled vertex xk of X which is joined to yj by an edge IN M. The vertex yj is now tested (even if
no edge is added) and vertex xk is now labeled. If yj cannot be connected to an unlabeled vertex in X, then STOP and
an Augmenting Tree has been found.
V. Return to II.

The algorithm stops after a finite number of iterations since each vertex is receiving at most one label and each
vertex is tested at most once. There are two possibilities:

I. (Augmenting Tree) There is a labeled vertex of Y that does not meet an edge of M. This has the following
diagram.
x1 y1 x2 y2 x3 y3

where the dashed lines represent edges in M and the solid lines represent edges not in M. In this case the size of the
matching can be increased by switching edges to look like

x1 y1 x2 y2 x3 y3

where an additional vertex x1 has been matched to y1.

II. (Hungarian Tree) A diagram of the form

x1 y1 x2 y2 x3 y63 x4

where no increase in the matching to include x1 is possible.

The Hungarian Algorithm page 7

 The termination is obtained when all unmatched elements in X have been matched or produce Hungarian trees.
Elements that produce Hungarian trees are called Hungarian acorns.

THEOREM. Suppose that G = ((X, Y}, E) be a bipartite graph and that M is a matching for G. Suppose that a
Augmenting Tree {x1, y1 , … , xn, yn} has been found using the Hungarian algorithm. Let S be the set of edges
given by
S = {(y1, x2), (y2, x3) , … , {yn - 1, xn)}
and let M1 be the set of edges
M 1 = {(x1, y2), (x2, y2) , … , (xn, yn)}.
Then the set of edges M′ given by
M′ = S ∪(M - M1)
is a matching for G with |M′| = |M| + 1.
PROOF. First note that yn cannot be attached to a labeled vertex x by an edge e = (yn, x) in M; otherwise, the vertex
yn would have to be a labeled and an unlabeled vertex at the stage when {x1, y1 , … , xn} is formed. To see that yn is
labeled at this stage, we see that the vertex x cannot be a * vertex (since * vertices are incident on no edges of M), and
therefore, x must have been labeled by some y using an edge (y, x) in M. This would mean that y = yn since both
(yn, x) and (y, x) are in the matching M and have a vertex in common. So x must have been labeled by yn and this
implies that yn must have been labeled. To see yn is unlabeled, we see that the vertex yn is labeled by xn in the
algorithm only if yn is unlabeled.
Now we show that M′ is a matching by showing each vertex z is incident on at most one edge in M′. If z is in
{y1, x2, … , yn - 1, xn}, then z is incident on an edge (yi, xi + 1) in M1 and no other edge in M. So z is incident on
one edge in M′. If z= x1, then z is *-vertex and z is incident on no edge in M and incident only on the edge (x1, y1) in
M′. If z = yn, then z is incident on one edge (xn, yn) since yn is incident on no edge of M; otherwise, (yn, x) would
be in M but x cannot be labeled by the preceding paragraph or unlabeled by the fact that the Hungarian Algorithm has
stopped on yn. So we get that the Augmenting Tree produces a matching M′.
We note that the matching M′ has one more edge than M. Q.E.D.

We see that the Hungarian algorithm terminates after a finite number of iterations. On each level the points are
tested one after the other and after all the points are tested or perhaps before the algorithm ends. As a whole the
algorithm either terminates when the only X elements left are Hungarian acorns.

THEOREM. Suppose M is a matching of the bipartite graph G = ({X, Y}, E) and suppose the Hungarian algorithm
produces only Hungarian trees for all unmatched X. Let Xun be all unlabeled X vertices and Ylab be all labeled Y
vertices. Then
1) S = Xun ∪ Ylab is a minimal cover of G, and
2) |M| = |S| and M is a maximal matching of G.
PROOF. First we show S is a cover. We argue by contradiction. Suppose (x, y) ∈ E and assume x ∈ Xlab and
y ∈ Yun. We show that such an edge does not exist. First assume (x, y) ∈ M. Since x is labelled and (x, y) is in
M, the vertex cannot be the first vertex in a path labelled with a (*) due to I of the algorithm. So x must be part of
chain of the form
x1------- y1 - - - - x2 ------- y2 - - - - ... - - - - xk ------- yk - - - - xk + 1 = x.

The Hungarian Algorithm page 8

where the solid lines are not in M and the dashed lines are in M. But there is at most one edge in M incident of x and
this edge is (x, y). So we must have that (x, y) = (x, yk) and y = yk. The vertex yk is labelled and this contradicts the
assumption that y is not labelled. Now suppose the (x, y) ∉ M. Since x is labeled, it follows that y must be labeled
which is a contradiction. So we have a contradiction in all cases. This means that S is a cover.
Now we show that |M| = |S|. This shows that M is a maximal matching and S is a minimal cover. We find a
one–one function f of S onto M. If y ∈ Ylab, then y cannot be a termination of some tree starting at a (*); otherwise,
there would be an augmenting step. So y meets an edge {y, x} of M. Since M is a matching, {y, x) is the unique
edge of M that y meets. Note that x gets a label from y and so x is not in Xun. So we set f(y) = (y, x) ∈ M. Now let
x′ ∈ Xun. Note that x′ meets an edge (x′, y′) of M; otherwise, the vertex x′ would have the label (*). As before the
edge (x′, y′) is the only edge in M that x meets. Finally, the element y′ is unlabeled. Indeed, if y′ were labeled, then
there would be a labeled x′′ with an edge (x′′, y′) not in M and with (y′, x′) in M and so there would be an augmenting
tree through y′. We let f(x′) = (x′, y′).
Now we see that the function f is one-one. In fact, f(y) = f(y′) implies that y = y′ since y is the unique y element
on which f(y) is incident. Also f(x) = f(x′) implies x = x′ and finally f(x) = f(y) is not possible as we have already
shown. So f is one-one.
Since f is one-one, we have that |S| ≤ |M|. But we have already seen that |M| ≥ |S|. So we get that |S| = |M|. Q.E.D.

COROLLARY. Let G = ({X, Y}, E) be a bipartite graph. Then ρ(G) = c(G).

PROOF. We have that ρ(G) ≤ c(G). But let M be a maximal matching for G, i.e., a matching with |M| = ρ(G). Then
the Hungarian algorithm terminates on M without a breakthrough and the preceding theorem implies that there is a
cover S with |S| = |M|. So we get that c(G) = |S| = |M| ≤ ρ(G). So we get that ρ(G) = c(G). Q.E.D.

COROLLARY. Let G = ({X, Y}, E) be a bipartite graph with |X| = |Y|. Suppose that G has a minimal cover S with
|S| = |X|. Then there is a matching M such that M is incident on all vertices of G.
PROOF. Since S is a minimal cover, there is a matching M with ρ(M) = |S| = |X|. Since no vertex of G is incident
on more than one edge of M, we must have that M is incident on 2|X| vertices which must mean the M is incident on
all vertices of G. Q.E.D.

Now back to the algorithm for the assignment problem running on a cost matrix of dimension m × m. The first
part of the algorithm runs until a minimal cover of size M is for the zeroes in the cost matrix. The first part of the
algorithm goes to termination since the sum of all the costs decreases at every stage when the minimal cover has less that
m vertices. When the minimal cover is reached with m vertices, we run the Hungarian algorithm on the bipartite graph
defined by the zeroes in the final cost matrix. A matching of size m is obtained to give the minimal cost assignment.

The Hungarian Algorithm page 9