Movatterモバイル変換

Jump to content

Hungarian algorithm

From Wikipedia, the free encyclopedia

Polynomial-time algorithm for the assignment problem

TheHungarian method is acombinatorial optimization algorithm that solves theassignment problem inpolynomial time and which anticipated laterprimal–dual methods. It was developed and published in 1955 byHarold Kuhn, who gave it the name "Hungarian method" because the algorithm was largely based on the earlier works of two Hungarian mathematicians,Dénes Kőnig andJenő Egerváry.^[1]^[2] However, in 2006 it was discovered thatCarl Gustav Jacobi had solved the assignment problem in the 19th century, and the solution had been published posthumously in 1890 in Latin.^[3]

James Munkres reviewed the algorithm in 1957 and observed that it is(strongly) polynomial.^[4] Since then the algorithm has been known also as theKuhn–Munkres algorithm orMunkres assignment algorithm. Thetime complexity of the original algorithm was $O(n^{4})$ , howeverEdmonds andKarp, and independently Tomizawa, noticed that it can be modified to achieve an $O(n^{3})$ running time.^[5]^[6]Ford andFulkerson extended the method to general maximum flow problems in form of theFord–Fulkerson algorithm.

The problem

Main article:Assignment problem

Example

In this simple example, there are three workers: Alice, Bob and Carol. One of them has to clean the bathroom, another sweep the floors and the third washes 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 amatrix of the costs of the workers doing the jobs. For example:

Task Worker	Clean bathroom	Sweep floors	Wash windows
Alice	$8	$4	$7
Bob	$5	$2	$3
Carol	$9	$4	$8

The Hungarian method, when applied to the above table, would give the minimum cost: this is $15, achieved by having Alice clean the bathroom, Carol sweep the floors, and Bob wash the windows. This can be confirmed using brute force:

Clean Sweep	Alice	Bob	Carol
Alice	—	$17	$16
Bob	$18	—	$18
Carol	$15	$16	—

(the unassigned person washes the windows)

Matrix formulation

In the matrix formulation, we are given ann×nmatrix, where the element in thei-th row andj-th column represents the cost of assigning thej-th job to thei-th worker. We have to find an assignment of the jobs to the workers, such that each job is assigned to one worker and each worker is assigned one job, such that the total cost of assignment is minimum.

This can be expressed as permuting the rows of a cost matrixC to minimize thetrace of a matrix,

\min _{P}\operatorname {Tr} (PC)\;,

whereP is apermutation matrix. (Equivalently, the columns can be permuted usingCP.)

If the goal is to find the assignment that yields themaximum cost, the problem can be solved by negating the cost matrixC.

Bipartite graph formulation

The algorithm can equivalently be described by formulating the problem using a bipartite graph. We have acomplete bipartite graph $G=(S,T;E)$ withn worker vertices (S) andn job vertices (T), and the edges (E) each have a cost $c(i,j)$ . We want to find aperfect matching with a minimum total cost.

The algorithm in terms of bipartite graphs

Let us call a function $y:(S\cup T)\to \mathbb {R}$ apotential if $y(i)+y(j)\leq c(i,j)$ for each $i\in S,j\in T$ .

Thevalue of potentialy is the sum of the potential over all vertices:

\sum _{v\in S\cup T}y(v)

.

The cost of each perfect matching is at least the value of each potential: the total cost of the matching is the sum of costs of all edges it contains; the cost of each edge is at least the sum of potentials of its endpoints; since the matching is perfect, each vertex is an endpoint of exactly one edge; hence the total cost is at least the total potential.

The Hungarian method finds a perfect matching and a potential such that the matching cost equals the potential value. This proves that both of them are optimal. In fact, the Hungarian method finds a perfect matching oftight edges: an edge $i j {\displaystyle ij}$ is called tight for a potentialy if $y(i)+y(j)=c(i,j)$ . Let us denote thesubgraph oftight edges by $G_{y}$ . The cost of a perfect matching in $G_{y}$ (if there is one) equals the value ofy.

During the algorithm we maintain a potentialy and anorientation of $G_{y}$ (denoted by ${\overrightarrow {G_{y}}}$ ) which has the property that the edges oriented fromT toS form a matchingM. Initially,y is 0 everywhere, and all edges are oriented fromS toT (soM is empty). In each step, either we modifyy so that its value increases, or modify the orientation to obtain a matching with more edges. We maintain the invariant that all the edges ofM are tight. We are done ifM is a perfect matching.

In a general step, let $R_{S}\subseteq S$ and $R_{T}\subseteq T$ be the vertices not covered byM (so $R_{S}$ consists of the vertices inS with no incoming edge and $R_{T}$ consists of the vertices inT with no outgoing edge). LetZ be the set of vertices reachable in ${\overrightarrow {G_{y}}}$ from $R_{S}$ by a directed path. This can be computed bybreadth-first search.

If $R_{T}\cap Z$ is nonempty, then reverse the orientation of all edges along a directed path in ${\overrightarrow {G_{y}}}$ from $R_{S}$ to $R_{T}$ . Thus the size of the corresponding matching increases by 1.

If $R_{T}\cap Z$ is empty, then let

\Delta :=\min\{c(i,j)-y(i)-y(j):i\in Z\cap S,j\in T\setminus Z\}.

Δ is well defined because at least one such edge $i j {\displaystyle ij}$ must exist whenever the matching is not yet of maximum possible size (see the following section); it is positive because there are no tight edges between $Z\cap S$ and $T\setminus Z$ . Increasey byΔ on the vertices of $Z\cap S$ and decreasey byΔ on the vertices of $Z\cap T$ . The resultingy is still a potential, and although the graph $G_{y}$ changes, it still containsM (see the next subsections). We orient the new edges fromS toT. By the definition ofΔ the setZ of vertices reachable from $R_{S}$ increases (note that the number of tight edges does not necessarily increase). If the vertex added to $Z\cap T$ is unmatched (that is, it is also in $R_{T}$ ), then at the next iteration the graph will have an augmenting path.

We repeat these steps untilM is a perfect matching, in which case it gives a minimum cost assignment. The running time of this version of the method is $O(n^{4})$ :M is augmentedn times, and in a phase whereM is unchanged, there are at mostn potential changes (sinceZ increases every time). The time sufficient for a potential change is $O(n^{2})$ .

Proof that the algorithm makes progress

We must show that as long as the matching is not of maximum possible size, the algorithm is always able to make progress — that is, to either increase the number of matched edges, or tighten at least one edge. It suffices to show that at least one of the following holds at every step:

M is of maximum possible size.
$G_{y}$ contains an augmenting path.
G contains aloose-tailed path: a path from some vertex in $R_{S}$ to a vertex in $T\setminus Z$ that consists of any number (possibly zero) of tight edges followed by a single loose edge. The trailing loose edge of a loose-tailed path is thus from $Z\cap S$ , guaranteeing thatΔ is well defined.

IfM is of maximum possible size, we are of course finished. Otherwise, byBerge's lemma, there must exist an augmenting pathP with respect toM in the underlying graphG. However, this path may not exist in $G_{y}$ : Although every even-numbered edge inP is tight by the definition ofM, odd-numbered edges may be loose and thus absent from $G_{y}$ . One endpoint ofP is in $R_{S}$ , the other in $R_{T}$ ; w.l.o.g., suppose it begins in $R_{S}$ . If every edge onP is tight, then it remains an augmenting path in $G_{y}$ and we are done. Otherwise, let $u v {\displaystyle uv}$ be the first loose edge onP. If $v\notin Z$ then we have found a loose-tailed path and we are done. Otherwise,v is reachable from some other pathQ of tight edges from a vertex in $R_{S}$ . Let $P_{v}$ be the subpath ofP beginning atv and continuing to the end, and let $P^{'} {\displaystyle P'}$ be the path formed by traveling alongQ until a vertex on $P_{v}$ is reached, and then continuing to the end of $P_{v}$ . Observe that $P^{'} {\displaystyle P'}$ is an augmenting path inG with at least one fewer loose edge thanP.P can be replaced with $P^{'} {\displaystyle P'}$ and this reasoning process iterated (formally, using induction on the number of loose edges) until either an augmenting path in $G_{y}$ or a loose-tailed path inG is found.

Proof that adjusting the potentialy leavesM unchanged

To show that every edge inM remains after adjustingy, it suffices to show that for an arbitrary edge inM, either both of its endpoints, or neither of them, are inZ. To this end let $v u {\displaystyle vu}$ be an edge inM fromT toS. It is easy to see that ifv is inZ thenu must be too, since every edge inM is tight. Now suppose, toward contradiction, that $u\in Z$ but $v\notin Z$ .u itself cannot be in $R_{S}$ because it is the endpoint of a matched edge, so there must be some directed path of tight edges from a vertex in $R_{S}$ tou. This path must avoidv, since that is by assumption not inZ, so the vertex immediately precedingu in this path is some other vertex $v'\in T$ . $v^{'} u {\displaystyle v'u}$ is a tight edge fromT toS and is thus inM. But thenM contains two edges that share the vertexu, contradicting the fact thatM is a matching. Thus every edge inM has either both endpoints or neither endpoint inZ.

Proof thaty remains a potential

To show thaty remains a potential after being adjusted, it suffices to show that no edge has its total potential increased beyond its cost. This is already established for edges inM by the preceding paragraph, so consider an arbitrary edgeuv fromS toT. If $y(u)$ is increased byΔ, then either $v\in Z\cap T$ , in which case $y(v)$ is decreased byΔ, leaving the total potential of the edge unchanged, or $v\in T\setminus Z$ , in which case the definition ofΔ guarantees that $y(u)+y(v)+\Delta \leq c(u,v)$ . Thusy remains a potential.

The algorithm inO(n³) time

Suppose there are $J {\displaystyle J}$ jobs and $W {\displaystyle W}$ workers ( $J\leq W$ ). We describe how to compute for each prefix of jobs the minimum total cost to assign each of these jobs to distinct workers. Specifically, we add the $j {\displaystyle j}$ th job and update the total cost in time $O(jW)$ , yielding an overall time complexity of $O\left(\sum _{j=1}^{J}jW\right)=O(J^{2}W)$ . Note that this is better than $O(W^{3})$ when the number of jobs is small relative to the number of workers.

Adding the j-th job inO(jW) time

We use the same notation as the previous section, though we modify their definitions as necessary. Let $S_{j}$ denote the set of the first $j {\displaystyle j}$ jobs and $T {\displaystyle T}$ denote the set of all workers.

Before the $j {\displaystyle j}$ th step of the algorithm, we assume that we have a matching on $S_{j-1}\cup T$ that matches all jobs in $S_{j-1}$ and potentials $y {\displaystyle y}$ satisfying the following condition: the matching is tight with respect to the potentials, and the potentials of all unmatched workers are zero, and the potentials of all matched workers are non-positive. Note that such potentials certify the optimality of the matching.

During the $j {\displaystyle j}$ th step, we add the $j {\displaystyle j}$ th job to $S_{j-1}$ to form $S_{j}$ and initialize $Z=\{j\}$ . At all times, every vertex in $Z {\displaystyle Z}$ will be reachable from the $j {\displaystyle j}$ th job in $G_{y}$ . While $Z {\displaystyle Z}$ does not contain a worker that has not been assigned a job, let

\Delta :=\min\{c(j,w)-y(j)-y(w):j\in Z\cap S_{j},w\in T\setminus Z\}

and $w_{\text{next}}$ denote any $w {\displaystyle w}$ at which the minimum is attained. After adjusting the potentials in the way described in the previous section, there is now a tight edge from $Z {\displaystyle Z}$ to $w_{\text{next}}$ .

If $w_{\text{next}}$ is unmatched, then we have anaugmenting path in the subgraph of tight edges from $j {\displaystyle j}$ to $w_{\text{next}}$ . After toggling the matching along this path, we have now matched the first $j {\displaystyle j}$ jobs, and this procedure terminates.
Otherwise, we add $w_{\text{next}}$ and the job matched with it to $Z {\displaystyle Z}$ .

Adjusting potentials takes $O(W)$ time. Recomputing $\Delta$ and $w_{\text{next}}$ after changing the potentials and $Z {\displaystyle Z}$ also can be done in $O(W)$ time. Case 1 can occur at most $j-1$ times before case 2 occurs and the procedure terminates, yielding the overall time complexity of $O(jW)$ .

Implementation in C++

For convenience of implementation, the code below adds an additional worker $w_{W}$ such that $y(w_{W})$ stores the negation of the sum of all $\Delta$ computed so far. After the $j {\displaystyle j}$ th job is added and the matching updated, the cost of the current matching equals the sum of all $\Delta$ computed so far, or $-y(w_{W})$ .

This code is adapted from e-maxx :: algo.^[7]

/** * Solution to https://open.kattis.com/problems/cordonbleu using Hungarian * algorithm. */import<cassert>;importstd;template<typenameT,typenameU>usingPair=std::pair<T,U>;template<typenameT>usingVector=std::vector<T>;template<typenameT>usingNumericLimits=std::numeric_limits<T>;/** * @brief Checks if b < a * * Sets a = min(a, b) * @param a The first parameter to check * @param b The second parameter to check * @tparam The type to perform the check on * @return true if b < a */template<typenameT>constexprboolckmin(T&a,constT&b){returnb<a?a=b,true:false;}/** * @brief Performs the Hungarian algorithm. * * Given J jobs and W workers (J <= W), computes the minimum cost to assign each * prefix of jobs to distinct workers. * * @tparam T a type large enough to represent integers on the order of J * * max(|C|) * @param C a matrix of dimensions JxW such that C[j][w] = cost to assign j-th * job to w-th worker (possibly negative) * * @return a vector of length J, with the j-th entry equaling the minimum cost * to assign the first (j+1) jobs to distinct workers */template<typenameT>Vector<T>hungarian(constVector<Vector<T>>&C){constintJ=static_cast<int>(C.size());constintW=static_cast<int>(C[0].size());assert(J<=W);// job[w] = job assigned to w-th worker, or -1 if no job assigned// note: a W-th worker was added for convenienceVector<int>job(W+1,-1);Vector<T>ys(J);Vector<T>yt(W+1);// potentials// -yt[W] will equal the sum of all deltasVector<T>answers;constTinf=NumericLimits<T>::max();for(intjCur=0;jCur<J;++jCur){// assign jCur-th jobintwCur=W;job[wCur]=jCur;// min reduced cost over edges from Z to worker wVector<T>minTo(W+1,inf);Vector<int>prev(W+1,-1);// previous worker on alternating pathVector<bool>inZ(W+1);// whether worker is in Zwhile(job[wCur]!=-1){// runs at most jCur + 1 timesinZ[wCur]=true;constintj=job[wCur];Tdelta=inf;intwNext;for(intw=0;w<W;++w){if(!inZ[w]){if(ckmin(minTo[w],C[j][w]-ys[j]-yt[w]))prev[w]=wCur;if(ckmin(delta,minTo[w]))wNext=w;}}// delta will always be nonnegative,// except possibly during the first time this loop runs// if any entries of C[jCur] are negativefor(intw=0;w<=W;++w){if(inZ[w]){ys[job[w]]+=delta;yt[w]-=delta;}else{minTo[w]-=delta;}}wCur=wNext;}// update assignments along alternating pathfor(intw;wCur!=W;wCur=w)job[wCur]=job[w=prev[wCur]];answers.push_back(-yt[W]);}returnanswers;}/** * @brief Performs a sanity check for the Hungarian algorithm. * * Sanity check: https://en.wikipedia.org/wiki/Hungarian_algorithm#Example * First job (5): *   clean bathroom: Bob -> 5 * First + second jobs (9): *   clean bathroom: Bob -> 5 *   sweep floors: Alice -> 4 * First + second + third jobs (15): *   clean bathroom: Alice -> 8 *   sweep floors: Carol -> 4 *   wash windows: Bob -> 3 */voidsanityCheckHungarian(){Vector<Vector<int>>costs{{8,5,9},{4,2,4},{7,3,8}};assert((hungarian(costs)==Vector<int>{5,9,15}));std::println(stderr,"Sanity check passed.");}/** * @brief solves https://open.kattis.com/problems/cordonbleu */voidcordonBleu(){intN;intM;std::cin>>N>>M;Vector<Pair<int,int>>B(N);Vector<Pair<int,int>>C(M);Vector<Pair<int,int>>bottles(N);Vector<Pair<int,int>>couriers(M);for(constPair<int,int>&b:bottles)std::cin>>b.first>>b.second;for(constPair<int,int>&c:couriers)std::cin>>c.first>>c.second;Pair<int,int>rest;std::cin>>rest.first>>rest.second;Vector<Vector<int>>costs(N,Vector<int>(N+M-1));autodist=[&](constPair<int,int>&x,constPair<int,int>&y)->int{returnstd::abs(x.first-y.first)+std::abs(x.second-y.second);};for(intb=0;b<N;++b){for(intc=0;c<M;++c)// courier -> bottle -> restaurantcosts[b][c]=dist(couriers[c],bottles[b])+dist(bottles[b],rest);for(int_=0;_<N-1;++_)// restaurant -> bottle -> restaurantcosts[b][_+M]=2*dist(bottles[b],rest);}std::println(hungarian(costs).back());}/** * @brief Entry point into the program. * * @return The return code of the program. */intmain(){sanityCheckHungarian();cordonBleu();}

Connection to successive shortest paths

The Hungarian algorithm can be seen to be equivalent to the successive shortest path algorithm for minimum cost flow,^[8]^[9] where the reweighting technique fromJohnson's algorithm is used to find the shortest paths.The implementation from the previous section is rewritten below in such a way as to emphasize this connection; it can be checked that the potentials $h {\displaystyle h}$ for workers $0\dots W-1$ are equal to the potentials $y {\displaystyle y}$ from the previous solution up to a constant offset. When the graph is sparse (there are only $M {\displaystyle M}$ allowed job, worker pairs), it is possibleto optimize this algorithm to run in $O(JM+J^{2}\log W)$ time by using aFibonacci heap to determine $w_{\text{next}}$ instead of iterating over all $W {\displaystyle W}$ workers to find the one with minimum distance (alluded tohere).

template<typenameT>Vector<T>hungarian(constVector<Vector<T>>&C){constintJ=static_cast<int>(C.size());constintW=static_cast<int>(C[0].size());assert(J<=W);// job[w] = job assigned to w-th worker, or -1 if no job assigned// note: a W-th worker was added for convenienceVector<int>job(W+1,-1);Vector<T>h(W);// Johnson potentialsVector<T>answers;TansCur=0;constTinf=NumericLimits<T>::max();// assign jCur-th job using Dijkstra with potentialsfor(intjCur=0;jCur<J;++jCur){intwCur=W;// unvisited worker with minimum distancejob[wCur]=jCur;Vector<T>dist(W+1,inf);// Johnson-reduced distancesdist[W]=0;Vector<bool>vis(W+1);// whether visited yetVector<int>prev(W+1,-1);// previous worker on shortest pathwhile(job[wCur]!=-1){// Dijkstra step: pop min worker from heapTminDist=inf;vis[wCur]=true;intwNext=-1;// next unvisited worker with minimum distance// consider extending shortest path by wCur -> job[wCur] -> wfor(intw=0;w<W;++w){if(!vis[w]){// sum of reduced edge weights wCur -> job[wCur] -> wTedge=C[job[wCur]][w]-h[w];if(wCur!=W){edge-=C[job[wCur]][wCur]-h[wCur];assert(edge>=0);// consequence of Johnson potentials}if(ckmin(dist[w],dist[wCur]+edge))prev[w]=wCur;if(ckmin(minDist,dist[w]))wNext=w;}}wCur=wNext;}for(intw=0;w<W;++w){// update potentialsckmin(dist[w],dist[wCur]);h[w]+=dist[w];}ans_cur+=h[wCur];for(intw;wCur!=W;wCur=w)job[wCur]=job[w=prev[wCur]];answers.push_back(ansCur);}returnanswers;}

Matrix interpretation

This variant of the algorithm follows the formulation given by Flood,^[10] and later described more explicitly by Munkres, who proved it runs in ${\mathcal {O}}(n^{4})$ time.^[4] Instead of keeping track of the potentials of the vertices, the algorithm operates only on a matrix:

a_{ij}:=c(i,j)-y(i)-y(j)

where $c(i,j)$ is the original cost matrix and $y(i),y(j)$ are the potentials from the graph interpretation. Changing the potentials corresponds to adding or subtracting from rows or columns of this matrix. The algorithm starts with $a_{ij}=c(i,j)$ . As such, it can be viewed as taking the original cost matrix and modifying it.

Givenn workers and tasks, the problem is written in the form of ann×n cost matrix

a₁	a₂	a₃	a₄
b₁	b₂	b₃	b₄
c₁	c₂	c₃	c₄
d₁	d₂	d₃	d₄

where a, b, c and d are workers who have to perform tasks 1, 2, 3 and 4. a₁, a₂, a₃, and a₄ denote the penalties incurred when worker "a" does task 1, 2, 3, and 4 respectively.

The problem is equivalent to assigning each worker a unique task such that the total penalty is minimized. Note that each task can only be worked on by one worker.

Step 1

For each row, its minimum element is subtracted from every element in that row. This causes all elements to have nonnegative values. Therefore, an assignment with a total penalty of 0 is by definition a minimum assignment.

This also leads to at least one zero in each row. As such, a naivegreedy algorithm can attempt to assign all workers a task with a penalty of zero. This is illustrated below.

0	a₂	a₃	a₄
b₁	b₂	b₃	0
c₁	0	c₃	c₄
d₁	d₂	0	d₄

The zeros above would be the assigned tasks.

Worst-case there aren! combinations to try, since multiple zeroes can appear in a row if multiple elements are the minimum. So at some point this naive algorithm should be short circuited.

Step 2

Sometimes it may turn out that the matrix at this stage cannot be used for assigning, as is the case for the matrix below.

0	a₂	0	a₄
b₁	0	b₃	0
0	c₂	c₃	c₄
0	d₂	d₃	d₄

To overcome this, we repeat the above procedure for all columns (i.e.the minimum element in each column is subtracted from all the elements in that column) and then check if an assignment with penalty 0 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. Steps 3 and 4 formone way to accomplish this.

For each row, try to assign an arbitrary zero. Assigned tasks are represented by starring a zero. Note that assignments can't be in the same row or column.

We assign the first zero of Row 1. The second zero of Row 1 can't be assigned.
We assign the first zero of Row 2. The second zero of Row 2 can't be assigned.
Zeros on Row 3 and Row 4 can't be assigned, because they are on the same column as the zero assigned on Row 1.

We could end with another assignment if we choose another ordering of the rows and columns.

0*	a₂	0	a₄
b₁	0*	b₃	0
0	c₂	c₃	c₄
0	d₂	d₃	d₄

Step 4

Cover all columns containing a (starred) zero.

×	×
0*	a₂	0	a₄
b₁	0*	b₃	0
0	c₂	c₃	c₄
0	d₂	d₃	d₄

Find a non-covered zero and prime it (mark it with aprime symbol). If no such zero can be found, meaning all zeroes are covered, skip to step 5.

If the zero is on the same row as a starred zero, cover the corresponding row, and uncover the column of the starred zero.
Then, GOTO "Find a non-covered zero and prime it."
- Here, the second zero of Row 1 is uncovered. Because there is another zero starred on Row 1, we cover Row 1 and uncover Column 1.
- Then, the second zero of Row 2 is uncovered. We cover Row 2 and uncover Column 2.

	×
0*	a₂	0'	a₄	×
b₁	0*	b₃	0
0	c₂	c₃	c₄
0	d₂	d₃	d₄


0*	a₂	0'	a₄	×
b₁	0*	b₃	0'	×
0	c₂	c₃	c₄
0	d₂	d₃	d₄

Else the non-covered zero has no assigned zero on its row. We make a path starting from the zero by performing the following steps:
1. Substep 1: Find a starred zero on the corresponding column. If there is one, go to Substep 2, else, stop.
2. Substep 2: Find a primed zero on the corresponding row (there should always be one). Go to Substep 1.

The zero on Row 3 is uncovered. We add to the path the first zero of Row 1, then the second zero of Row 1, then we are done.


0*	a₂	0'	a₄	×
b₁	0*	b₃	0'	×
0'	c₂	c₃	c₄
0	d₂	d₃	d₄

(Else branch continued) For all zeros encountered during the path, star primed zeros and unstar starred zeros.
- As the path begins and ends by a primed zero when swapping starred zeros, we have assigned one more zero.

0	a₂	0*	a₄
b₁	0*	b₃	0
0*	c₂	c₃	c₄
0	d₂	d₃	d₄

(Else branch continued) Unprime all primed zeroes and uncover all lines.
Repeat the previous steps (continue looping until the above "skip to step 5" is reached).
- We cover columns 1, 2 and 3. The second zero on Row 2 is uncovered, so we cover Row 2 and uncover Column 2:

×		×
0	a₂	0*	a₄
b₁	0*	b₃	0'	×
0*	c₂	c₃	c₄
0	d₂	d₃	d₄

All zeros are now covered with a minimal number of rows and columns.

The aforementioned detailed description isjust one way to draw the minimum number of lines to cover all the 0s. Other methods work as well.

Step 5

If the number of starred zeros isn (or in the general case $min(n,m)$ , wheren is the number of people andm is the number of jobs), the algorithm terminates. See theResult subsection below on how to interpret the results.

Otherwise, find the lowest uncovered value. Subtract this from every uncovered element and add it to every element covered by two lines. Go back to step 4.

This is equivalent to subtracting a number from all rows which are not covered and adding the same number to all columns which are covered. These operations do not change optimal assignments.

Result

If following this specific version of the algorithm, the starred zeros form the minimum assignment.

From Kőnig's theorem,^[11] the minimum number of lines (minimum vertex cover^[12]) will ben (the size of maximum matching^[13]). Thus, whenn lines are required, minimum cost assignment can be found by looking at only zeroes in the matrix.

Bibliography

R.E. Burkard, M. Dell'Amico, S. Martello:Assignment Problems (Revised reprint). SIAM, Philadelphia (PA.) 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 Operational Research 18, 47–58, 2010

References

^Harold W. Kuhn, "The Hungarian Method for the assignment problem",Naval Research Logistics Quarterly,2: 83–97, 1955. Kuhn's original publication.
^Harold W. Kuhn, "Variants of the Hungarian method for assignment problems",Naval Research Logistics Quarterly,3: 253–258, 1956.
^"Presentation". Archived fromthe original on 16 October 2015.
^^a ^bJ. Munkres, "Algorithms for the Assignment and Transportation Problems",Journal of the Society for Industrial and Applied Mathematics,5(1):32–38, 1957 March.
^Edmonds, Jack; Karp, Richard M. (1 April 1972)."Theoretical Improvements in Algorithmic Efficiency for Network Flow Problems".Journal of the ACM.19 (2):248–264.doi:10.1145/321694.321699.S2CID 6375478.
^Tomizawa, N. (1971). "On some techniques useful for solution of transportation network problems".Networks.1 (2):173–194.doi:10.1002/net.3230010206.ISSN 1097-0037.
^"Hungarian Algorithm for Solving the Assignment Problem".e-maxx :: algo. 23 August 2012. Retrieved13 May 2023.
^Jacob Kogler (20 December 2022)."Minimum-cost flow - Successive shortest path algorithm".Algorithms for Competitive Programming. Retrieved14 May 2023.
^"Solving assignment problem using min-cost-flow".Algorithms for Competitive Programming. 17 July 2022. Retrieved14 May 2023.
^Flood, Merrill M. (1956). "The Traveling-Salesman Problem".Operations Research.4 (1):61–75.doi:10.1287/opre.4.1.61.ISSN 0030-364X.
^Kőnig's theorem (graph theory) Konig's theorem
^Vertex cover minimum vertex cover
^Matching (graph theory) matching

External links

Bruff, Derek,The Assignment Problem and the Hungarian Method (matrix formalism).
Mordecai J. Golin,Bipartite Matching and the Hungarian Method (bigraph formalism), Course Notes,Hong Kong University of Science and Technology.
Hungarian maximum matching algorithm (both formalisms), in Brilliant website.
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 (with O(n^4) 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 $O(n^{3})$ time complexity, even if they claim so. Some may contain errors, implement the slower $O(n^{4})$ algorithm, or have other inefficiencies. In the worst case, a code example linked from Wikipedia could later be modified to include exploit code. Verification and benchmarking is necessary when using such code examples from unknown authors.

Retrieved from "https://en.wikipedia.org/w/index.php?title=Hungarian_algorithm&oldid=1309386844"

Hidden categories:

[8]ページ先頭

©2009-2025 Movatter.jp