The Hungarian method is a combinatorial optimization algorithm that solves the
assignment problem in polynomial time and which anticipated later primal-dual
methods. It was developed and published in 1955 by Harold Kuhn, who gave the
name "Hungarian method" because the algorithm was largely based on the
earlier works of two Hungarian mathematicians: Dénes Kőnig and Jenő
Egerváry. James Munkres reviewed the algorithm in
1957 and observed that it is polynomial. Since then the algorithm has been known
also as the Kuhn–Munkres algorithm or Munkres assignment algorithm. The time
complexity of the original algorithm was , however Edmonds and Karp, and
independently Tomizawa noticed that it can be modified to achieve an running
time. Ford and Fulkerson extended the method to general transportation
problems. In 2006, it was discovered that Carl Gustav Jacobi had solved the
assignment problem in the 19th century, and the solution had been published
posthumously in 1890 in Latin. Simple explanation of the assignment
problem In this simple example there are three
workers: Jim, Steve, and Alan. One of them has to clean the bathroom, another
sweep the floors, and the third wash the windows, but they each demand different
pay for the various tasks. The problem is to find the lowest-cost way to assign
the jobs. The problem can be represented in a matrix of the costs of the workers
doing the jobs. For example: The Hungarian method, when applied to
the above table, would give the minimum cost: this is $6, achieved by having Jim
clean the bathroom, Steve sweep the floors, and Alan wash the windows.
Setting We are given a nonnegative n×n matrix,
where the element in the i-th row and j-th column represents the cost of
assigning the j-th job to the i-th worker. We have to find an assignment of
the jobs to the workers that has minimum cost. If the goal is to find the
assignment that yields the maximum cost, the problem can be altered to fit the
setting by replacing each cost with the maximum cost subtracted by the cost.
The algorithm is easier to describe if we formulate the problem using a
bipartite graph. We have a complete bipartite graph with worker vertices
and job vertices, and each edge has a nonnegative cost . We want to find a
perfect matching with minimum cost. Let us call a function a potential if
for each . The value of potential is . It can be seen that the cost of each
perfect matching is at least the value of each potential. The Hungarian method
finds a perfect matching and a potential with equal cost/value which proves the
optimality of both. In fact it finds a perfect matching of tight edges: an edge
is called tight for a potential if . Let us denote the subgraph of tight
edges by . The cost of a perfect matching in equals the value of .
The algorithm in terms of bipartite graphs
During the algorithm we maintain a potential y and an orientation of which
has the property that the edges oriented from T to S form a matching M.
Initially, y is 0 everywhere, and all edges are oriented from S to T. In each
step, either we modify y so that its value increases, or modify the
orientation to obtain a matching with more edges. We maintain the invariant
that all the edges of M are tight. We are done if M is a perfect matching.
In a general step, let and be the vertices not covered by M. Let be the
set of vertices reachable in from by a directed path only following edges that
are tight. This can be computed by breadth-first search.
If is nonempty, then reverse the orientation of a directed path in from
to . Thus the size of the corresponding matching increases by 1.
If is empty, then let . is positive because there are no tight edges between
and . Increase y by on the vertices of and decrease y by on the vertices of .
The resulting y is still a potential. The graph changes, but it still
contains M. We orient the new edges from S to T. By the definition of the set Z
of vertices reachable from increases. We repeat these steps until M is a
perfect matching, in which case it gives a minimum cost assignment. The running
time of this version of the method is : M is augmented n times, and in a phase
where M is unchanged, there are at most n potential changes. The time needed for
a potential change is . Matrix interpretation
Given workers and tasks, and an n×n matrix containing the cost of assigning
each worker to a task, find the cost minimizing assignment.
First the problem is written in the form of a matrix as given below
where a, b, c and d are the workers who have to perform tasks 1, 2, 3 and 4. a1,
a2, a3, a4 denote the penalties incurred when worker "a" does task 1, 2, 3, 4
respectively. The same holds true for the other symbols as well. The matrix is
square, so each worker can perform only one task.
Step 1 Then we perform row operations on the
matrix. To do this, the lowest of all ai is taken and is subtracted from each
element in that row. This will lead to at least one zero in that row. This
procedure is repeated for all rows. We now have a matrix with at least one zero
per row. Now we try to assign tasks to agents such that each agent is doing
only one task and the penalty incurred in each case is zero. This is
illustrated below. The zeros that are indicated as 0' are
the assigned tasks. Step 2
Sometimes it may turn out that the matrix at this stage cannot be used for
assigning, as is the case in for the matrix below.
In the above case, no assignment can be made. Note that task 1 is done
efficiently by both agent a and c. Both can't be assigned the same task. Also
note that no one does task 3 efficiently. To overcome this, we repeat
the above procedure for all columns and then check if an assignment is possible.
In most situations this will give the result, but if it is still not possible
then we need to keep going. Step 3
All zeros in the matrix must be covered by marking as few rows and/or columns as
possible. The following procedure is one way to accomplish this:
First, assign as many tasks as possible. Row 1 has one zero, so it is assigned.
The 0 in row 3 is crossed out because it is in the same column.
Row 2 has one zero, so it is assigned. Row 3's only zero has been crossed out,
so nothing is assigned. Row 4 has two uncrossed zeros. Either
one can be assigned, and the other zero would be crossed out.
Alternatively, the 0 in row 3 may be assigned, causing the 0 in row 1 to be
crossed instead. Now to the drawing part.
Mark all rows having no assignments. Mark all columns having zeros in newly
marked row(s). Mark all rows having assignments in
newly marked columns. Repeat for all non-assigned rows.
Now draw lines through all marked columns and unmarked rows.
The aforementioned detailed description is just one way to draw the minimum
number of lines to cover all the 0s. Other methods work as well.
Step 4 Now remove the marked rows and columns.
This will leave a matrix as follows: Return to step 1 and repeat the process
until the matrix is empty. Bibliography
R.E. Burkard, M. Dell'Amico, S. Martello: Assignment Problems. SIAM,
Philadelphia 2012. ISBN 978-1-61197-222-1
M. Fischetti, "Lezioni di Ricerca Operativa", Edizioni Libreria Progetto
Padova, Italia, 1995. R. Ahuja, T. Magnanti, J. Orlin,
"Network Flows", Prentice Hall, 1993. S. Martello, "Jeno Egerváry: from the
origins of the Hungarian algorithm to satellite communication". Central
European Journal of Operations Research 18, 47–58, 2010
References External links
Bruff, Derek, "The Assignment Problem and the Hungarian Method", [1]
Mordecai J. Golin, Bipartite Matching and the Hungarian Method, Course Notes,
Hong Kong University of Science and Technology.
R. A. Pilgrim, Munkres' Assignment Algorithm. Modified for Rectangular
Matrices, Course notes, Murray State University.
Mike Dawes, The Optimal Assignment Problem, Course notes, University of
Western Ontario. On Kuhn's Hungarian Method – A tribute
from Hungary, András Frank, Egervary Research Group, Pazmany P. setany 1/C,
H1117, Budapest, Hungary. Lecture: Fundamentals of Operations
Research - Assignment Problem - Hungarian Algorithm, Prof. G.
Srinivasan, Department of Management Studies, IIT Madras.
Extension: Assignment sensitivity analysis time complexity), Liu, Shell.
Solve any Assignment Problem online, provides a step by step explanation of
the Hungarian Algorithm. = Implementations =
(Note that not all of these satisfy the time constraint.)
C implementation with time complexity Java implementation of time variant
Python implementation Ruby implementation with unit tests
C# implementation D implementation with unit tests
Online interactive implementation Please note that this implements a variant of
the algorithm as described above. Graphical implementation with options
Serial and parallel implementations. Implementation in Matlab and C
Perl implementation Lisp implementation
C++ implementation C++ implementation
C++ implementation of the algorithm Another C++ implementation with unit
tests Another Java implementation with JUnit
tests MATLAB implementation
C implementation Javascript implementation
The clue R package proposes an implementation, solve_LSAP