## Min-Cost Perfect Matching

If you would like to play with a minimum-cost perfect matching, klein-tardos.cc is a C++ implementation. It requires indexedlist.h and priqueue.h. The intent of the implementation was to know how the algorithm works. Also, most of the C++ I know is from my experience with this problem. So use should probably be limited to understanding and experimentation of the algorithm. My implementation is based on the algorithm presented in Algorithm Design by Kleinberg, Tardos. priqueue.h is an implementation of priority queue with deletion. indexedList.h provides an abstraction for two lists with a reverse function, which switches element from one list to other. It is used to represent the outgoing and incoming list of a vertex. Reverse function could be used to switch an edge from outgoing list to incoming list.

The algorithm in general is called Hungarian algorithm. The implemented algorithm is different from the once here, here and here. Each iteration finds and augments the shortest augmenting path from the bipartite graph using the Dijkstra’s algorithm. But essentially, it also uses the same fundamental concepts to solve the problem. The idea is to create a matching which doesn’t have negative cycle in its residual graph. A little more formal treatment would be.

Consider a bipartite graph G = (V,E) having cost associated with each edge. If M is a matching in G, G_{M} denotes corresponding residual graph for M. Quoting from Algorithm Design.

Let M be a perfect matching. If there are no negative-cost directed cycles C in G_{M}, then M is a minimum-cost perfect matching.

Prof. Golin’s notes explain the same concept as Equality graph.

Hungarian algorithm counts on this fact to find the minimum-cost matching. A more general version of this statement is also the basis for minimum-cost flow algorithms.

Hungarian algorithm, in each iteration, builds a larger matching while
maintaining G_{M} free from negative-cost directed cycles. In
the end, algorithm reaches the perfect matching which also is a
minimum-cost matching.

Tougher part is to avoid the negative-cost cycles. Thats where the
labeling comes in (Feasible labeling in Prof. Golin’s notes). After
each augmentation the graph is relabeled, with reduced costs, which
don’t change the solution, and also keep the G_{M} free of
negative loops.

If you want to know more, you should read the above mentioned notes and if possible Algorithm Design. I have tried to make the core part quite visible in the implementation. Infact, the main loop of the algorithm is just

```
void min_weight_assignment() {
initiate_node_prices();
for (int i=0; i<x.size(); i++) {
dijkstra_spath(s); // shortest paths from source
augment_spath();
reduce_node_prices();
}
}
```

An observation. As I mentioned, all approaches are almost equivalent. The matrix method seems to be different from the others, but the similarity could be seen by considering column nodes as left nodes in bipartite graph, and the row nodes as right once.