The Hungarian Job Assignment

Date: 03/10/2011 at 04:17:34
From: Agan
Subject: assignment problem.
I have n people and n machines for them to operate. Each person operates a
single machine and commands a different wage for operating that machine.
How can I assign the machines among my employees so that I have to pay
them the least money in total?
I have a solution from crossing different rows and arranging them in a
specific order, but I need to understand the process. I think I have to
consider all the possible combinations, which is difficult for even a
modest value of n.
This is a practical problem, but it looks like it has no easy answer.
Please help!

Date: 03/11/2011 at 03:21:18
From: Agan
Subject: assignment problem.
Sorry I didn't explain that properly. Let me try again with an example.
I have 3 engineers (A, B, and C) and 3 projects (P, Q, and R) to do.
Here is the money each wants to undertake each project:
P Q R
+-----------
A | 15 18 18
B | 17 23 17
C | 20 18 17
As the manager of the engineers, what project should be given to whom to
minimize my total payroll?
How do I solve this scenario for larger and generalised cases?

Date: 03/13/2011 at 06:48:23
From: Doctor Jacques
Subject: Re: assignment problem.
Hi Agan,
This problem can be solved by linear programming, but there is a much more
efficient method, called the Hungarian algorithm.
We start with an n*n matrix with integer entries representing the costs of
the assignments (you can use negative costs to represent profits). The
goal is to select one entry from each row and column to make the total
cost minimal.
As an example, we will use the following cost matrix:
1 2 3 4 5
+----------
A | 8 3 5 4 3
B | 2 6 9 4 7
C | 6 1 8 4 3
D | 5 7 9 8 8
E | 5 7 9 4 3
A first observation is that, since you must use one entry in each row, the
optimal assignment is not changed if you subtract the same number from all
the costs in a row. The total cost will not be the same, but once you have
found the optimal assignment, you can go back to the original table to
find the corresponding cost. Just keep track of the adjustments you make.
In this case, we subtract from each row the smallest cost of that row.
This gives the table:
1 2 3 4 5
+----------
A | 5 0 2 1 0
B | 0 4 7 2 5
C | 5 0 7 3 2
D | 0 2 4 3 3
E | 2 4 6 1 0
We can now do the same thing with the columns:
1 2 3 4 5
+----------
A | 5 0 0 0 0
B | 0 4 5 1 5
C | 5 0 5 2 2
D | 0 2 2 2 3
E | 2 4 4 0 0
By construction, this table only contains non-negative entries, and it
contains at least one 0 in each row and column. As stated before, the
optimal assignment for this table is the same as for the original table.
In particular, since any assignment in this table will have a non-negative
cost, an assignment that uses only cells containing 0 will be optimal, if
such an assignment exists.
The algorithm will consist in the repeated execution of the following
steps:
1. Try to assign as many rows as possible using only the 0 cells.
2. If we have assigned all the rows (5 in this case), we are done.
3. Try to modify the assignments to assign more rows, without
modifying the table. If this is successful, go back to step 2.
4. Modify the table (in such a way that the optimal assignment is
not changed) to create more 0 cells, possibly removing
unassigned 0 cells (but not the assigned cells), and go back to
step 2.
Before going into the details, I would like to outline the ideas involved.
In step 3, we try to assign more 0 cells without changing the table. Let
us assume that a row is currently not assigned. We know that this row
contains at least one 0, because of the initial steps. We could not assign
that 0, because there was already another 0 assigned in the same column.
We can try to displace that 0 to another column of the same row; this may
now create a conflict in the new column. We try to repeat the process
until we reach a currently unassigned column. If we end up in such a
column, we can move all the assignments in the path, which will allow us
to assign another 0.
In step 4, we will try to cover all the 0s with the smallest possible
number of rows and columns. As a result, the cells that are not covered
will all be strictly positive, and we can modify the table to create at
least one additional 0 in these cells.
It is a consequence of a theorem in Graph Theory that the smallest number
of rows and columns needed to cover all the 0s is equal to the largest
number of 0s that can be assigned together. The method I will describe is
actually based on some ideas used in the proof of that theorem, and the
nice thing is that the same computation will produce the data needed for
step 3 and step 4.
We start with step 1. In this case, we will simply look at each row in
turn, and assign the first 0 cell in that row that is not in a currently
assigned column, if there is such a cell. Marking them with asterisks,
this gives the following assignments:
1 2 3 4 5
+--------------
A | 5 0* 0 0 0
B | 0* 4 5 1 5
C | 5 0 5 2 2
D | 0 2 2 2 3
E | 2 4 4 0* 0
If you solve a small problem by hand, you will probably use various
heuristics to get a better assignment; for example, you could start with
the rows that only contain one 0. I did not do that in this case, in order
to show you the general method while keeping the example small enough.
Currently, we have only assigned 3 cells, and we are not done yet. To
execute step 3, we will need to keep track of the cells we have visited;
this will allow us to retrace our steps if we find a way to change the
assignments and assign a new cell. In order to do that, we need to include
additional information in our table.
We attach to row 'i' a row tag rt(i). This field can contain the following
information:
i) 0 (or blank) to represent the initial state.
ii) -1 if the row is not assigned.
iii) >0 if rt(i) contains the number of the column where a
conflict was detected and caused the assignment of
this row to be changed.
We also attach to column 'j' a column tag ct(j) that contains the
following information:
i) 0 (or blank) to represent the initial state.
ii) >0 if ct(j) contains the number (I will use letters
instead) of the row in which we tried to assign a cell
in this column.
We can also add to each row and column a flag to indicate that the
corresponding tag was modified during the last pass; this will save some
work (I do not show these flags here).
We have some general rules:
* We make passes alternately on the row tags and the column tags
(starting with the rows); in each pass, we look only at the tags
that have been modified since the last pass.
* We only change tags that are in their initial blank state; once
a tag has been modified, it is never modified again in the same
run of step 3.
Now, let us look at the details.
In a row pass, we look at all the row tags that have been modified since
the last pass. If the tag of row 'i' has been modified:
* We look at all the unassigned 0s in row 'i' (there may be none).
* If (i,j) is such a 0, and if ct(j) is blank, we let ct(j) = i
and we mark ct(j) as modified.
When all rows have been processed, we turn to a column pass. In a column
pass, we look at the column tags that have been modified since the last
pass; if there is none, step 3 terminates unsuccessfully (this cannot
happen for row tags). If the tag of column 'j' has been modified:
* We look at the assigned 0 in column 'j.' If there is none, we
have found a way to assign one more cell. We do this by
retracing all the operations that led to this column (using the
row and column tags), and moving the assignments in the path.
This will be explained in more detail using the example.
* If, on the other hand, cell (i,j) contains an assigned 0, and if
rt(i) is blank, we let rt(i) = j, and we mark rt(i) as modified.
When all columns have been processed, and if step 3 is not yet finished,
we go back to another row pass.
To allow you to follow the explanations, I will show here the table after
the execution of step 3:
1 2 3 4 5 rt
+---------------+--
A | 5 0* 0 0 0 | 2
B | 0* 4 5 1 5 | 1
C | 5 0 5 2 2 |-1
D | 0 2 2 2 3 |-1
E | 2 4 4 0* 0 |
+---------------+--
ct| D C A A A |
We start by clearing all the row and column tags; we then let rt(i) = -1
for the currently unassigned rows (C and D).
In the first row pass, we look at the modified rows (C and D). Row C
contains an unassigned 0 in column 2: we let ct(2) = C (if ct(2) had not
been blank, we would have left it alone). In a similar way, row D contains
an unassigned 0 in column 1, and we let ct(1) = D.
We now start a column pass, by looking at the modified columns 1 and 2. In
column 1, we have an assigned 0 in row B; we therefore let rt(B) = 1. In
the same way, we let rt(A) = 2 because of the assigned 0 in A2.
We start another row pass, looking at the modified rows A and B. In row A,
we have unassigned 0s in A3, A4, and A5; accordingly, we let
ct(3) = ct(4) = ct(5) = A. In row B, we have no unassigned 0, and we do
nothing.
We start a new column pass, on the modified columns 3, 4, and 5. In column
3, we have no assigned 0. This means that we can use that column for a new
assignment. We can now retrace our steps:
* We are in column 3. rt(3) = A, which means that we can assign
the cell A3, and we must look at row A.
* We are now in row A. Since we have assigned a new cell in A3, we
have a conflict. The position of the conflict is given by
rt(A) = 2: we must remove the assignment in A2 and move to
column 2.
* Since we have removed the assignment in A2, we must assign a new
cell in column 2. The position of that cell is given by
ct(2) = C. We assign cell C2 and move to row C.
* Since rt(C) = -1, we are done.
We have changed assignments on the path A3 -> (A2) -> C2, where the
parentheses are used to identify removed assignments. The new table is as
follows (I have also included the results of the next execution of step 2):
1 2 3 4 5 rt
+---------------+--
A | 5 0 0* 0 0 |
B | 0* 4 5 1 5 | 1
C | 5 0* 5 2 2 |
D | 0 2 2 2 3 |-1
E | 2 4 4 0* 0 |
+---------------+--
ct| D |
We now have 4 assignments, and the job is not yet finished. We execute
step 3 again:
* Row D is unassigned, and has a 0 in D1. We let ct(1) = D.
* Column 1 has an assigned 0 in B1. We let rt(B) = 1.
* Row B has no unassigned 0.
Since no column tags have been modified in the last row pass, step 3
terminates unsuccessfully. We now define a set of rows R and a set of
columns C in the following way:
* R contains the rows where rt(i) is blank; in this case,
R = {A, C, E}
* C contains the columns where ct(j) is not blank; in this case,
C = {1}
We write r and c for the number of rows in R and columns in C,
respectively. We can now make a few observations, and it is possible to
prove them by thinking (hard) about what happened in step 3:
* Each 0 (assigned or not) is in R or C (or both): R and C cover
all 0s.
* Each assigned 0 is in R or C, but not both. This confirms that
r + c is equal to the number of assigned 0s (4 in this case), as
stated before.
A consequence of this is that the uncovered cells (the intersections of
rows {B,C} and columns {2,3,4,5}) only contain strictly positive entries.
Let d be the smallest of these entries (in this case, d = 1, corresponding
to cell B4). We now modify the table as follows:
* We subtract d from each uncovered cell. By the definition of d,
these cells will remain non-negative, and at least one of them
will become 0.
* We add d to each cell that is covered twice (by a row in R and
by a column in C). As the unmarked 0s are only covered once,
this will not disturb them. Some of the unassigned (and
therefore unused) 0s may disappear, however.
This modification does not change the optimal assignment, because it is
equivalent to subtracting d from the uncovered rows and adding d to the
covered columns. This results in a new table (in which I already included
the results of the next application of step 3):
1 2 3 4 5 rt
+---------------+--
A | 6 0 0* 0 0 |
B | 0* 3 4 0 4 | 1
C | 6 0* 5 2 2 |
D | 0 1 1 1 2 |-1
E | 3 4 4 0* 0 | 4
+---------------+--
ct| D B E |
As the assigned cells have not been modified, we can keep them assigned;
there is no need to execute step 1 again.
We see that we have created a new 0 in B4; however, we cannot use it
directly, because of the cells B1 and E4. We execute step 3 again. I will
let you do that; the results are in the table.
Step 3 ends in column 5, where there is no assigned 0. This means that we
can improve our assignment, using this path:
E5 -> (E4) -> B4 -> (B1) -> D1
Though it is not complete, this is the final assignment:
1 2 3 4 5
+---------------
A | 6 0 0* 0 0
B | 0 3 4 0* 4
C | 6 0* 5 2 2
D | 0* 1 1 1 2
E | 3 4 4 0 0*
Going back to the original table, we find that the total cost of this
assignment is:
5 + 4 + 1 + 5 + 3 = 18
We could also have kept track of the adjustments in the course of the
algorithm:
* The row minima were 3, 2, 1, 5, 3, for a total of 14
* The column minima (in the second step) were 0, 0, 2, 1, 0, for a
total of 3
* In step 4, we subtracted 1 from two rows (B and D) and added 1
to one column (1), for a total decrease of 1.
This confirms that the total cost was decreased by 14 + 3 + 1 = 18; as the
total cost is 0 in the final table, the original cost was 18.
Note that, after step 4, step 3 allowed us to assign one more cell. This
is not always the case. It may happen that you have to execute step 4 more
than once before you can assign a new cell; the results will be different,
because the table is modified each time you execute step 4. However, the
algorithm will always terminate after a finite number of steps.
To see this, notice that each time we execute step 2, either we assign a
new cell (which can only happen a finite number of times), or we execute
step 4. In step 4, we subtract d from (n - r)(n - c) cells, and we add d
to r*c cells; the total of the table is thus increased by:
d(rc - (n - r)(n - c)) = dn(r + c - n)
As noted before, r + c is equal to the total number of assigned cells, and
this is less than n (otherwise we would have finished). This shows that
the expression above is negative; the total decreases each time you
execute step 4; as the total must be non-negative, this also can only
happen a finite number of times.
Please feel free to write back if you require further assistance.
- Doctor Jacques, The Math Forum
http://mathforum.org/dr.math/