Two Algorithms for Maximum and Minimum Weighted Bipartite Matching

(1)

Two Algorithms for Maximum and Minimum Weighted

Bipartite Matching

Advisor: Prof. Yuh-Dauh Lyuu Hung-Pin Shih

Department of Computer Science and Information Engineering

National Taiwan University

(2)

Abstract

This thesis applies two algorithms to the maximum and minimum weighted bipartite matching problems. In such matching problems, the maximization and minimization problems are essentially same in that one can be transformed into the other by replacing the weight on each edge with an inverse of the weight. Depending on the algorithms we used, we will choose the maximization or minimization problems for illustrations. We apply the ant colony optimization (ACO) algorithm on a minimum weighted bipartite matching problem by transforming the problem to a traveling salesman problem (TSP).

It may seem that makes the problem more complicated, but in reality it does not. We call this algorithm “ant-matching,” which can solve any weighted bipartite matching problems with or without a perfect matching. Besides, we also apply the Metropolis algorithm to solve the maximum weighted bipartite matching problem. To analyze the performance on these two algorithms, we compare the algorithms with the exact Hungarian algorithm, a well-known combinatorial optimization method for solving the weighted bipartite matching problem.

Keywords: Metropolis algorithm, Ant colony optimization, Maximum weighted bipartite matching, Minimum weighted bipartite matching

(3)

List of Figures

3.1 Transforming a bipartite matching problem to a TSP: (1) The original bipartite graph G. (2) Add u⁰₁ and its corresponding edges. (3) The final graph G⁰. . . 10 4.1 The running time of each algorithm on the complete bipartite

graph. . . 20 4.2 The running time of each algorithm on the bipartite graph

where each vertex ui ∈ U has at most 2% ∗ |V | edges. . . 21 4.3 The running time of each algorithm on the bipartite graph

where each vertex u_i ∈ U has at most 5 edges. . . 22 4.4 The running times of the ant-matching algorithm on each dif-

ferent bipartite graph. . . 24 4.5 The weights found by the ant-matching algorithm as propor-

tions to the weights of the optimal solution on each different bipartite graph. . . 24 4.6 The weight found by the Metropolis algorithm as proportions

to the weights of the optimal solution on each different bipartite graph. . . 25

(5)

List of Tables

4.1 Comparison of complexity . . . 17 4.2 The weights as proportions to the weights of the optimal so-

lution on the complete bipartite graph. . . 19 4.3 The weights as proportions to the weights of the optimal so-

lution on the bipartite graph where each vertex u_i ∈ U has at most 2% ∗ |V | edges. . . 21 4.4 The weights as proportions to the weight of the optimal solu-

tion on the bipartite graph where each vertex u_i ∈ U has at most 5 edges. . . 23 4.5 Results on each algorithm for complete bipartite graphs. . . . 26 4.6 Results on each algorithm for the bipartite graphs where each

vertex has at most 50% ∗ |V | edges. . . 27 4.7 Results on each algorithm for the bipartite graphs where each

vertex has at most 5 edges. . . 32 4.12 Results on each algorithm for the bipartite graphs where each

vertex has at most 10 edges. . . 33 4.13 Results on each algorithm for the bipartite graphs where each

vertex has at most 20 edges. . . 34

(6)

Chapter 1 Introduction

The maximum/minimum weighted bipartite matching problem is a combinatorial optimization problem, and there exist many optimization algorithms to solve the matching problem. But here we try some heuristic or sampling methods and expect them to generate reasonable sub-optimal solutions within reasonable time bounds. Specifically we use the ant colony optimization (ACO) and the Metropolis algorithm. In the ACO algorithm, we transform this matching problem to a traveling salesman problem (TSP) and use the concepts of ACO algorithm as a basis for a new method to solve the matching problem. We call the new method “ant-matching.” In the Metropolis algorithm, we randomly select a matching edge in each iteration to generate an approximate solution. Then we compare the performances of these two algorithms with the exact Hungarian algorithm [2], which is a optimization algorithm used to solve the weighted matching problems.

The structure of this thesis is organized as follows: In Chapter 1 and Chapter 2, we define the problem of maximum/minimum weighted bipartite matching and introduce the background of the two above-mentioned algorithms. In Chapter 3, we transform the weighted bipartite matching problem to a traveling salesman problem (TSP) and apply the concepts of ant colony optimization (ACO) algorithm as a basis for a new matching algorithm called “ant-matching.” In the latter part of Chapter 3, we apply the Metropolis algorithm to solve the maximum weighted bipartite matching problem. Finally, Chapter 4 compares these algorithms with other methods in solving the weighted matching problems, and we conclude in Chapter 5.

(7)

Chapter 2 Preliminaries

2.1 Maximum/Minimum Weighted Bipartite Matching

2.1.1 Weighted Bipartite Graph

A bipartite graph G = (U, V, E) is a graph whose vertices can be divided into two disjoint sets U and V such that each edge (u_i, v_j) ∈ E connects a vertex u_i ∈ U and one v_j ∈ V . If each edge in graph G has an associated weight w_ij, the graph G is called a weighted bipartite graph.

2.1.2 Maximum/Minimum Weighted Bipartite Matching

In a bipartite graph G = (U, V, E), a matching M of graph G is a subset of E such that no two edges in M share a common vertex. If the graph G is a weighted bipartite graph, the maximum/minimum weighted bipartite matching is a matching whose sum of the weights of the edges is maximum/minimum. The maximum/minimum weighted bipartite matching can be formulated as follows:

max / min X

(ui,vj)∈E

w_ijx_ij

|U |

X

i=1

x_ij = 1, ∀j = 1, ..., |V |

|V |

X

j=1

xij = 1, ∀i = 1, ..., |U |

(8)

x_ij ∈ {0, 1}

where x_ij is 1 denotes edge (u_i, v_j) is an edge in the maximum/minimum weighted bipartite matching.

2.2 Ant Colony Optimization

In the real world, ants are social insects and communicate with some inter- esting behavior. Each ant lays down pheromone on the path. When ants find foods, they will go back to its nest. If some other ants encounter the path, they will follow it based on the density of pheromone deposited. The pheromone on the path that ants found initially will be reinforcing. Eventu- ally, ants will find the foods.

Over time, the pheromone on the path evaporates, thus reducing its at- tracting strength. The longer path an ant travels down and back, the more time the pheromone has to evaporate. On a shorter path, an ant travels down the path and back faster, and the pheromone density remains high as the pheromone is laid on as fast as it can evaporate. Assume the ant colony converges to a path. If a shorter path is found by some ants, because the path is shorter than the original path that the ant colony converged to, the ants travel down the path and back faster. The density of pheromone on the shorter path will increase gradually and the density on the original path will decrease. After a period of time, the ant colony will converge to the shorter path. It will prevent the ant colony from converging to a local optimal solution.

The ant colony optimization (ACO) algorithm comes from observing the behavior of the ants. It simulates the ants and the pheromone evaporation on the paths. In each iteration, the ants select the paths according to the density of pheromone deposited. If the path has higher density, it will be selected with higher probability. After finding a path, the ants lay down pheromone on the path. In the ACO algorithm, each path represents a solution. Besides, the pheromone evaporates gradually. The ACO algorithm is illustrated in Algorithm 1.

Algorithm 1 ACO Algorithm for TSP while termination condition not met do

generate solutions pheromone update end while

(9)

The ACO algorithm has been used in solving the traveling salesman problem (TSP) to find a nearly optimal solution [4]. In the TSP problem, there are n cities. Each city has to be visited exactly once, and the tour ends at the starting city. The problem is to find a shortest tour to visit these n cities. Let d_ij be the distance between the city i and the city j and τ_ij be the pheromone on the edge connects i and j.

Each of the m ants decides independently on the city to be visited next.

They base their decision on the density of pheromone τ_ij and a heuristic function η_ij. The probability of choosing the next city j from current city i at the tth iteration is

p^k_ij = [τ_ij(t)]^α(η_ij)^β P

l∈N_l^k[τ_il(t)]^α(η_ij)^β , ∀j ∈ N_i^k (2.1) where ηij = _d¹

ij is a commonly used heuristic function, α and β are two parameters to determine the relative influences of the pheromone and the distance, and N_i^k is a list of cities that the kth ant has yet to visit.

After all ants have constructed their complete tours, we update the pheromone on each edge thus:

τ_ij(t + 1) = (1 − ρ)τ_ij(t) +

m

X

k=1

∆τ_ij^k(t) (2.2)

where 0 < ρ ≤ 1 is the pheromone evaporation rate, ∆τ_ij^k(t) is the pheromone that the kth ant deposited at the tth iteration, which is defined as follows:

∆τ_ij^k(t) = 1/L^k(t) if(i, j) ∈ T^k(t)

0 if(i, j) /∈ T^k(t) (2.3)

where L^k(t) is the length of the kth ant’s tour at the tth iteration, T^k(t) is the kth ant’s tour at the tth iteration. The shorter the tour the ants found, the more pheromone is deposited. After a number of iterations, the ant colony will converge to a nearly shortest tour. Finally, select any starting city and follow the edge with the highest density of pheromone to visit as the next city. After completing the tour, the tour is a solution of the TSP problem.

2.3 Metropolis Algorithm

The Metropolis algorithm is an algorithm to generate a sequence of samples from a probability distribution that is hard to sample directly. It uses the Markov chain Monte Carlo simulation to approximate the distribution [1].

(10)

The Metropolis algorithm can generate samples from any unknown probability distribution P (x) and requires only a function proportional to the density of P (x) that can be calculated at x. The algorithm generates a Markov chain in which each state x^t+1 depends only on the previous state x^t. Let Q(x^t, x⁰) denotes the candidate-generating density, where R Q(x^t, x⁰)dx⁰ = 1.

The algorithm depends on the current state x^t to generate a new sample x⁰ from Q(x^t, ·)¹. The sample x⁰ is accepted as the next state x^t+1if α ∈ U (0, 1) satisfies Eq. (2.4):

α < P (x⁰)Q(x⁰, x^t)

P (x^t)Q(x^t, x⁰) (2.4)

If α satisfies Eq. (2.4), x^t+1 = x⁰. Otherwise, the current state x^t is retained, i.e., x^t+1 = x^t. The algorithm is illustrated in Algorithm 2.

Algorithm 2 Metropolis Algorithm for t = 1, 2, ..., N do

sample x⁰ from Q(x^t, ·) and α from U (0, 1) {U (0, 1) is the uniform distribution on(0, 1)}

if α < ^{P (x}_{P (x}⁰t^)Q(x)Q(x⁰^t^,x,x^t⁰⁾) then x^t+1 = x⁰

else

x^t+1 = x^t end if end for

return {x⁽¹⁾, x⁽²⁾, ..., x^{(N )}}

1Lyuu: but if you do not know what Q is how can you generate x’ ????

Hung-Pin: We don’t know Q at first. But we can observe the possible transitions between the current state and the next state to find a possible Q. The possible Q may be correct or wrong, but it will describe the transitions. This is reasonable, if we don’t know the probability distribution P (x), we observe the transitions between the current state and the next state and infer a possible Q. We can use Q to sample the other next states and find the unknown probability distribution P (x).

(11)

Chapter 3 Maximum/Minimum Weighted Bipartite Matching Problems

In a weighted bipartite graph G = (U, V, E), we want to find a maximum/minimum weighted bipartite matching (maximum/minimum-weighted BM) whose sum of the weights of the edges is maximum/minimum. To solve this matching problem, we present two methods. For illustrations, we will introduce each method on a different matching problem. Specifically we apply the ACO algorithm to solve the minimum-weighted BM problems and the Metropolis algorithm to solve the maximum-weighted BM problems.

3.1 ACO Algorithm for Minimum-Weighted Bipartite Matching

In a weighted bipartite graph G = (U, V, E), we want to find a matching whose sum of the weights of the edges is minimum. Here we apply the concepts of ACO algorithm as a basis for a new method to solve the matching problem. First, we transform the matching problem to a TSP problem. It may seem that makes the matching problem more complicated, but in reality it does not. Second, we apply the ACO algorithm on the TSP problem and perform some simplifications to be explained later on solving the TSP problem. The result is a new method for solving the minimum-weighted BM problem. In this chapter, the TSP refers to the problem of finding a minimum weighted complete tour on the complete graph with multiple edges between vertices, and the number of edges between vertices will change as the different tour selection.

(12)

Figure 3.1: Transforming a bipartite matching problem to a TSP: (1) The original bipartite graph G. (2) Add u⁰₁ and its corresponding edges. (3) The final graph G⁰.

3.1.1 Transforming Minimum-Weighted Bipartite Matching to Traveling Salesman Problem

In a weighted bipartite graph G = (U, V, E), we choose either U or V as the base vertices and transform the minimum-weighted BM problem to a TSP problem. We choose the vertices set U as our base vertices for illustrations.

First, for each u_i ∈ U , we create a corresponding virtual vertex u⁰_i ∈ U⁰, where U⁰ is the set of vertices correspond to U and |U⁰| = |U |. Then, for each (u_i, v_j) ∈ E where u_i ∈ U, v_j ∈ V , we create a corresponding back edge (u⁰_i, v_j) ∈ E⁰ with an associated weight 0, where E⁰ contains the edges we create. Furthermore, we create another back edge (u_i, u⁰_i) ∈ E⁰ with a large associated weight w_max. Here we define this large associated weight w_max as 20 ∗ maxi∈|U |,j∈|V |w_ij. Finally, for each virtual vertex u⁰_i ∈ U⁰, we create the edges (u⁰_i, u_k) ∈ E⁰ to connect each vertex u_k ∈ U, u_k6= u_i, with an associated weight w_ik = 0. Thus, we have a new graph G⁰ = (U, V, E, U⁰, E⁰). The above steps are illustrated in Algorithm 3 and Figure 3.1. In Figure 3.1, each back edge (u⁰_i, v_j) ∈ E⁰ is in green and (u_i, u⁰_i) ∈ E⁰ is in red. Besides, the edges (u⁰_i, u_k) connect each vertex u⁰_i to all the other vertices in U are in grey.

In the new graph G⁰ = (U, V, E, U⁰, E⁰), on each base vertex u_i ∈ U , we define that if we choose the edge (u_i, v_j) ∈ E, then we will follow the edge (v_j, u⁰_i) ∈ E⁰ back to vertex u⁰_i ∈ U⁰. Thus, for each base vertex u_i ∈ U , there are some paths u_i− v_j− u⁰_i where (u_i, v_j) ∈ E and (v_j, u⁰_i) ∈ E⁰, and the path

(13)

Algorithm 3 Transform Graph G to G⁰

Input: Weighted bipartite graph G = (U, V, E) and each edge (u_i, v_j) ∈ E has a weight w_ij. E⁰ = ∅

for ui ∈ U do

create vertex u⁰_i ∈ U⁰ for (u_i, v_j) ∈ E do

add back edge (u⁰_i, vj) to E⁰ with weight 0 end for

add back edge (u_i, u⁰_i) to E⁰ with weight w_max for uk∈ U do

add edge (u⁰_i, u_k) to E⁰ with weight 0 end for

end for

return graph G⁰ = {U, V, E, U⁰, E⁰}

u_i− u⁰_i where (u_i, u⁰_i) ∈ E⁰. So there exist a edge from u_i to its corresponding virtual vertex u⁰_i ∈ U⁰. Furthermore, each virtual vertex u⁰_i is connected to all the other base vertices u_k ∈ U . Thus, if we start from any base vertex u_i ∈ U on the graph G⁰, we can visit each base vertex in U exactly once and end at u_i (a Hamiltonian cycle). If we want to find a matching M in the bipartite graph G, we can find it with a Hamiltonian cycle in the graph G⁰ as follows.

Let Avail_i(V ) ⊆ V be the vertex set adjacent to the vertex u_i ∈ U such that for each vertex v_j ∈ Avail_i(V ), each edge (u_l, v_j) ∈ E is not yet an matching edge in the matching M . On each vertex u_i ∈ U , the ant may select¹² the edge (u_i, v_j) ∈ E followed by (v_j, u⁰_i) ∈ E⁰ where v_j ∈ Avail_i(V ), or select the edge (u_i, u⁰_i) ∈ E⁰. If the ant select the edge (u_i, v_j) ∈ E followed by (v_j, u⁰_i) ∈ E⁰, we add a new matching edge (u_i, v_j) to M . If the ant select the edge (u_i, u⁰_i) ∈ E⁰, we do not change M . After visiting all the base vertex u_i ∈ U exactly once, we will find the matching M .

1Lyuu: what do you mean by select? what if both are possible, which one do you select?

Hung-Pin: We choose edge based on the pheromone. It will be explained later. Here we just explain the reduction.

2Lyuu: this is strange. if you are only describing a reduction, why bring up ”select”?

Also if you use ”select”, it is better to write ”the ant may select”?

Hung-Pin: I replace reduction with transformation. Moreover, because there are multi- paths between ui and u⁰_i, the different selection has different means in the matching M . I use the ”select” to explain the differences and the relations between the matching problem and the TSP problem.

(14)

Thus, if we find a tour to visit each base vertex u_i ∈ U exactly once and then return to the starting base vertex, and the total weight of this tour is minimum, we have a minimum weighted bipartite matching M on the weighted bipartite graph G. Now, we have successfully transformed the minimum-weighted BM problem to the TSP problem.

3.1.2 Using ACO Algorithm to Solve Minimum- Weighted Bipartite Matching

After transforming the weighted bipartite graph G = (U, V, E) to a new graph G⁰ = (U, V, E, U⁰, E⁰), we can use the ACO algorithm to solve the TSP problem on G⁰ and find the solutions of the original matching problem.

But here we can perform some simplifications on solving the TSP problem.

In the graph G⁰, the algorithm needs to visit all vertices in the set U and corresponding set U⁰ of U to do matching. With the simplification, because we define that if the ant select the base vertex u_i ∈ U , then the ant will follow the paths u_i − v_j − u⁰_i or the path u_i − u⁰_i back to the vertex u⁰_i, we can see U and U⁰ same because if the algorithm visits the base vertex u_i ∈ U , it will visit its corresponding virtual vertex u⁰_i ∈ U⁰ next.³ Therefore, the algorithm can just visit each u_i ∈ U and select a matching edge (u_i, v_j) ∈ E. It will help this method more efficient and applicable for the minimum-weighted BM problems. We call this new method “ant-matching.”

In the ACO algorithm, the ants choose the next vertex independently based their decision on the density of pheromone and a heuristic function.

In the ant-matching algorithm, the ants choose the next vertex based on the same mechanisms. In each iteration t, the ants choose the next base vertex u_i ∈ Avail^k(U )(t) based on the density of pheromone τ_p(i)i(t) as Eq. (3.1), where Avail^k(U )(t) is the set of available base vertices that the kth ant has yet to visit at the tth iteration and u_p(i) ∈ U is the predecessor of the vertex u_i. Let N_i^k(t) ⊆ V be the set of the kth ant’s available adjacent vertices of u_i at the tth iteration. If |N_i^k(t)| > 0, each of the m ants chooses one vertex v_j ∈ N_i^k(t) to do matching based on the density of pheromone τ_ij(t) and a heuristic function η_ij(t) as Eq. (2.1), then adds the weight w_ij to L^k(t), where L^k(t) is the length of the kth ant’s tour in iteration t. Otherwise, the

3Lyuu: I do not think this is true, as we discussed last Thursday. You want it to be true, but it may not be true for a general TSP solver. you need to say YOUR TSP solver will impose this condition

Hung-Pin: I add a sentence before this sentence to explain the condition. Besides, at the end of the section 3.1, I redefine the TSP problem in the transformation. It is not a general TSP. It likes a related TSP problem which generalized TSP deals with ”states”.

Thus, I redefine the TSP problem.

(15)

ant does nothing but adds a large associated weight w_max to L^k(t). After each of m ants visiting all the vertices in the set U , update the pheromone on each edge and start the next iteration. The pheromone deposited on each edge (u_i, u_k) ∈ E⁰ represents an order relation such that if one ant chooses the vertex u_i, it will choose the vertex u_k next time. And a large amount of pheromone on the edge (u_i, v_j) represents that the edge (u_i, v_j) is a preferred matching edge. Thus, we have the order relations to do matching on the vertex set U and the preferred matching edges on each vertex u_i ∈ U . We can find the solutions of the matching problems according to the density of pheromone. The algorithm is listed in Algorithm 4, and Algorithm 5 is the detail.

p^k_p(i)i = [τ_p(i)i(t)]^α P

l∈Avail^k(U )(t)[τ_p(i)l(t)]^α ∀i ∈ Avail^k(U )(t) (3.1) Algorithm 4 Ant-Matching Algorithm

for t = 1 to t_max do

for k = 1 to NumberOfAnts do

choose u_i ∈ Avail^k(U )(t) based on τ_p(i)i(t)

choose vertex v_j ∈ N_i^k(t) based on τ_ij(t) and η_ij(t) end for

update pheromone end for

3.1.3 The Complexity of Ant-Matching Algorithm

In the ant-matching algorithm, each ant visits each vertex u_i in the vertex set U and searchs each edge adjacent to u_i exactly once. Thus, generating a solution costs O(U + E). Moreover, it costs O(U² + E) to update the density of pheromone on each edge (u_i, u_k) where u_i, u_k ∈ U and on each edge (u_i, v_j) ∈ E. If there are m ants and t_maxiterations. The total complexity of the ant-matching algorithm is O(t_max(m(U + E) + U²+ E)).

3.2 Metropolis Algorithm for Maximum- Weighted Bipartite Matching

In a weighted bipartite graph G = (U, V, E), we can choose the vertex set U or V arbitrarily to do matching. We choose the vertex set U for illustrations. We

(16)

Algorithm 5 Ant-Matching Algorithm in Detail Input: Weighted bipartite graph G = (U, V, E)

and each edge (u_i, v_j) ∈ E has a weight w_ij. MatchingList_Best= []

Weight_min = ∞ for t = 1 to t_max do

{Generate Solution}

for k = 1 to NumberOfAnts do Avail^k(U )(t) = U ;

MatchingList_k(t) = []

Weight_k(t) = 0

while |Avail^k(U )(t)| > 0 do

choose available u_i ∈ Avail^k(U )(t) based on τ_ij(t) remove u_i in Avail^k(U )(t)

if u_i has available adjacent vertices N_i^k(t) ⊆ V then choose vj ∈ N_i^k(t) based on τij(t) and ηij

add (u_i, v_j) into MatchingList_k(t) Weight_k(t) = Weight_k(t) + w_ij else

add (ui, φ) into MatchingList_k(t) Weight_k(t) = Weight_k(t) + w_max end if

end while

if Weight_k(t) ≤ Weight_min(t) then MatchingList_Best = MatchingList_k(t) end if

end for

{Update pheromone}

for k = 1 to NumberOfAnts do

for l = 1 to |MatchingList_k(t)| and (x_l, y_l) ∈ MatchingList_k(t) do

∆τ_x^k

l−1,xl(t) = 1/Weight_k(t) if y_l6= φ then

∆τ_x^k

l,yl(t) = 1/Weight_k(t) else

∆τ_x^k

l,xl(t) = 1/Weight_k(t) end if

end for end for

for (ui, vj) ∈ E do

τ_ij(t + 1) = (1 − ρ)τ_ij(t) +Pm

k=1∆τ_ij^k(t) end for

for u_i, u_j ∈ U, u_i 6= u_j do

τij(t + 1) = (1 − ρ)τij(t) +Pm

k=1∆τ_ij^k(t) end for

t = t + 1;

end for

(17)

apply the Metropolis algorithm on the maximum weighted bipartite matching (maximum-weighted BM) problem. Let x be the current search state. x ∈ {0, 1}^|E| describes the set of matchings (u_i, v_j), where x_ij = 1 denotes a matching edge, x_ij = 0 denotes not.

In each iteration, choose (u_i, v_j) ∈ E at random and flip x_ij. Thus, in the current state x, choose a new search state x⁰ = {x⁰₀₀, ..., x⁰_{|U ||V |}} where x⁰_ij = 1 − x_ij, and x⁰_gh = x_gh, if the edges (u_g, v_h) 6= (u_i, v_j).

After choosing a new state x⁰, using a fitness function f to decide if we choose the new search state x⁰ as the next state. If f (x⁰) ≥ f (x), select x⁰. If f (x⁰) < f (x), select x⁰ with the probability ef (x0)−f (x)

K , where K is a constant, otherwise, select x. The algorithm is illustrated in Algorithm 6.

Algorithm 6 Apply Metropolis Algorithm to Maximum-Weighted BM Input: Weighted bipartite graph G = (U, V, E)

and each edge (u_i, v_j) ∈ E has a weight w_ij. loop

choose (u_i, v_j) ∈ E at random and flip x_ij sample α from U (0, 1)

if f (x⁰) ≥ f (x) then select x⁰

else

if α ≤ ef (x0)−f (x)

K then

select x⁰ end if end if end loop

Here we choose 0^m as the starting state x for the maximization problems and choose a fitness function f , where f (x) = 0 for the state x which there exist two edges in the matching sharing a common vertex, and f (x) =P

ui∈U,vj∈V x_ijw_ij for the state x, not which has two edges that share the same vertex. This fitness function f will guarantee the matching is reasonable in each iteration.

3.2.1 The Complexity of Metropolis Algorithm

In the Metropolis algorithm, generating a new search state costs a little. To generate a new search state we choose a edge (u_i, v_j) ∈ E at random and flip x_ij. It will cost O(1) to generate a new search state. Then, it costs O(1) to calculate the weight of the new search state and costs O(1) to verify if the

(18)

new state is reasonable. If the new search state is better than the best state, record the new search state as the best state and it will cost O(U ). Thus, if there are c iterations, the complexity of the Metropolis algorithm is O(cU ).

(19)

Chapter 4 Experimental Results

After introducing the two methods on solving the weighted bipartite matching problems, we write them in programs to do some experiments and compare them with the Hungarian algorithm, a well-known algorithm for solving the weighted bipartite matching problems. In a weighted bipartite graph G = (U, V, E) and each edge (u_i, v_j) ∈ E has an associated weight w_ij. We replace each edge weight w_ij with _w¹

ij to transform a maximum weighted bipartite matching problem to a minimum weighted bipartite matching problem. Thus, we can use these algorithms to solve the maximum or minimum weighted bipartite matching problem.

4.1 Comparison of Complexity

Before the experiments, we compare the complexity first. The complexity of each algorithm is listed as follows:

Table 4.1: Comparison of complexity

Algorithm Complexity

Ant-Matching O(t_max(m(U + E) + U²+ E))

Metropolis Algorithm O(cU ) Hungarian Algorithm O(V³)

In Table 4.1, we can easily find that the complexity of the Metropolis Algorithm is the smallest. But we can’t easily compare the complexity of the ant-matching algorithm with the Hungarian algorithm. To verify that if the

(20)

ant-matching algorithm is faster than the Hungarian algorithm or not, we will do some experiments. Moreover, we also test if the Metropolis algorithm and the ant-matching algorithm can generate a reasonable solution for the weighted bipartite matching problem within a smaller time and discuss their usability.

4.2 Graph Sampling Algorithm

Before the experiments, we build some graph generating algorithms to generate the weighted bipartite graphs. There are two graph generating algorithms:

• Generating algorithm of complete bipartite graphs.

The generating algorithm is used to generate the complete weighted bipartite graph, which ∀u_i ∈ U, ∀v_j ∈ V, ∃(u_i, v_j) ∈ E.

• Generating algorithm of sparse bipartite graphs.

The graph generating algorithm generate a weighted bipartite graph G = (U, V, E) randomly and each vertex u_i ∈ U has at most a specified number of adjacent vertices. It does not ensure that the generated graphs has a perfect matching.

We will use these algorithms to generate the graph samples to do the experiments.

4.3 Results

In the experiments, we configure some variables at first. In the ant-matching algorithm, there are 200 iterations and 20 ants in each iteration and we make α = 2 and β = 1 to make the relative influence of the pheromone doubles that of the distance. In the Metropolis algorithm, we initialize 1, 000, 000, 000 cycles to generate the new search states. After configuring the variables, we start the experiments, and the results are listed as follows. We will analyze the results in different aspects:

• Time

The cost of time in solving the weighted bipartite matching problems.

• Weight

The maximum weight found by each algorithm. We solve the maximum weighted bipartite matching problems in our experiments.

(21)

Size Ant-Matching Metropolis Size Ant-Matching Metropolis

100x100 95.13% 60.87% 1100x1100 91.20% 52.07%

200x200 94.21% 56.73% 1200x1200 91.10% 52.29%

300x300 92.94% 55.75% 1300x1300 91.52% 51.98%

400x400 92.93% 54.93% 1400x1400 90.96% 51.59%

500x500 92.94% 53.81% 1500x1500 90.93% 51.64%

600x600 92.67% 54.49% 1600x1600 90.95% 51.72%

700x700 92.36% 52.79% 1700x1700 90.95% 50.92%

800x800 91.66% 52.40% 1800x1800 90.75% 51.25%

900x900 92.16% 52.84% 1900x1900 90.58% 51.59%

1000x1000 91.73% 52.54% 2000x2000 90.62% 51.71%

Table 4.2: The weights as proportions to the weights of the optimal solution on the complete bipartite graph.

4.3.1 Results on Complete Bipartite Graphs

We use the ant-matching algorithm, the Metropolis algorithm, and the Hun- garian algorithm to solve the maximum weighted bipartite matching problems on each complete bipartite graph with different problem size. Table 4.5 is the numeral result in solving the matching problems. In Table 4.5, the result found by the Hungarian algorithm is optimal. Table 4.2 lists the weights found by the ant-matching algorithm and the Metropolis algorithm as proportions to the weights of the optimal solution. In Table 4.5, we can see that the weights found by the ant-matching algorithm are close to the weights of the optimal solution. In Figure 4.1, the running time of the ant-matching algorithm increases gradually depending on the sizes of matching problems.

Even the running time of the ant-matching algorithm is larger than the running time of the Hungarian algorithm, but the growth rate of running time of the ant-matching algorithm is smaller than the Hungarian algorithm. Thus, if the problem size is very large, the ant-matching algorithm will be faster than the Hungarian algorithm.

The weights found by the Metropolis algorithm are close to the half of the weights of the optimal solution. But the running time of the Metropolis algorithm is very small. In practice, we can find the result with less number of cycles in the Metropolis algorithm. The initialized 1, 000, 000, 000 cycles is used to raise the running time, it will help to draw the transitions on different problem sizes in Figure 4.1.

(22)

Figure 4.1: The running time of each algorithm on the complete bipartite graph.

4.3.2 Results on Sparse Bipartite Graphs

In the sparse bipartite graph G = (U, V, E) which each vertex u_i ∈ U has at most 2% ∗ |V | edges, the numeral result of this matching problem is listed in Table 4.10. Table 4.3 is the result of weights found by the ant-matching algorithm and the Metropolis algorithm as proportions to the weights of the optimal solution. In Table 4.3, the weights found by the ant-matching algorithm are close to the weights of the optimal solution. And in Figure 4.2, the running time of the ant-matching algorithm is much less than that of the Hungarian algorithm as the problem size increases. Thus, in a large scale bipartite matching problem, we can use the ant-matching algorithm to find a solution in a smaller time, and the result is close to the optimal solution.

In Table 4.3, we can see the weights found by the Metropolis algorithm are close to half of the weights of the optimal solution. In Figure 4.2, even we initializes 1, 000, 000, 000 cycles in the Metropolis algorithm, the running time is still small. Thus, if we want to find a matching in a rapid time and don’t care the weight, we can use the Metropolis algorithm to find a solution.

(23)

Figure 4.2: The running time of each algorithm on the bipartite graph where each vertex u_i ∈ U has at most 2% ∗ |V | edges.

100x100 96.81% 72.27% 100x100 95.57% 47.06%

200x200 98.42% 56.44% 200x200 95.18% 47.56%

300x300 98.35% 53.23% 300x300 95.53% 46.97%

400x400 97.37% 50.95% 400x400 94.82% 47.81%

500x500 97.31% 48.83% 500x500 95.28% 47.09%

600x600 97.11% 48.83% 600x600 95.03% 47.43%

700x700 96.64% 47.78% 700x700 94.58% 47.00%

800x800 96.86% 48.52% 800x800 94.59% 47.25%

900x900 96.09% 48.37% 900x900 94.56% 46.99%

1000x1000 95.80% 48.16% 1000x1000 94.28% 47.30%

Table 4.3: The weights as proportions to the weights of the optimal solution on the bipartite graph where each vertex u_i ∈ U has at most 2% ∗ |V | edges.

(24)

Figure 4.3: The running time of each algorithm on the bipartite graph where each vertex u_i ∈ U has at most 5 edges.

Here is another sparse bipartite graph G = (U, V, E) where each vertex u_i ∈ U has at most 5 edges, and the numeral result of this matching problem is listed in Table 4.11. Figure 4.3 is the graphic illustration of the time costs by each algorithm. We can see that the running times of the ant-matching algorithm and the Metropolis algorithm are still much less than the running times of the Hungarian algorithm. In Table 4.4, the weights found by the ant-matching algorithm are close to the optimal solutions. Thus, in a large scale and very sparse graph, we can use the ant-matching algorithm to find a matching in a smaller time and the weight of the matching is close to the weight of the optimal solution.

(25)

100x100 98.23% 66.07% 1100x1100 97.53% 50.51%

200x200 97.75% 59.71% 1200x1200 97.17% 51.07%

300x300 96.00% 56.68% 1300x1300 97.61% 51.01%

400x400 96.57% 56.24% 1400x1400 97.33% 49.85%

500x500 97.93% 54.29% 1500x1500 97.06% 49.63%

600x600 96.74% 52.85% 1600x1600 97.38% 49.12%

700x700 97.27% 52.71% 1700x1700 97.01% 49.21%

800x800 97.35% 51.83% 1800x1800 97.22% 49.01%

900x900 97.42% 51.61% 1900x1900 96.99% 48.63%

1000x1000 96.80% 51.61% 2000x2000 97.06% 48.65%

Table 4.4: The weights as proportions to the weight of the optimal solution on the bipartite graph where each vertex u_i ∈ U has at most 5 edges.

4.3.3 Results on Ant-Matching Algorithm

In addition to the above-mentioned bipartite matching problems, we also solve the matching problems on different bipartite graphs in our experiments.

The numeral results are listed in Tables 4.5–4.13. We will analyze the results and indicate the features of each algorithm.

In the ant-matching algorithm, Figure 4.4 is the graphic illustration for the running times on each different bipartite matching problem. In Figure 4.4, we can easily see that the running time of the ant-matching algorithm depends on number of edges. The less the number of edges in the bipartite graph, the less time the ant-matching algorithm costs on solving the matching problem.

Figure 4.5 illustrates the transitions of the weights on each different graph on different problem sizes. In Figure 4.5, as the problem size increases, the weights found by the ant-matching algorithm on each different graph as proportions to the weights of the optimal solution decrease slowly. Besides, the weights as proportions to the optimal solution are greater than 90%. With the advantages of the smaller running time, we can use the ant-matching algorithm to find a matching in a smaller time, which the weight is close to the optimal solution.

(26)

Figure 4.4: The running times of the ant-matching algorithm on each different bipartite graph.

Figure 4.5: The weights found by the ant-matching algorithm as proportions to the weights of the optimal solution on each different bipartite graph.

(27)

Figure 4.6: The weight found by the Metropolis algorithm as proportions to the weights of the optimal solution on each different bipartite graph.

4.3.4 Results on Metropolis Algorithm

The running time of the Metropolis algorithm is much smaller than the other two algorithms. Even the cost times have slight change on different problem sizes, but they are still smaller than the other two algorithms. But the weights found by the Metropolis algorithm are not as impressive. In Figure 4.6, as the problem size increases, we can see that the weights found by the Metropolis algorithm as proportions to the optimal solution lie in between 45% and 55%. Thus, if we don’t care the weights found by the Metropolis algorithm, we can use the Metropolis algorithm to solve the bipartite matching problem within a small time.

(28)

Table4.5:Resultsoneachalgorithmforcompletebipar- titegraphs. Time(ms)Weight SizeAntMetropolisHungarianAntMetropolisHungarian 100x100124221274547893.7621278459.9913797598.56287138 200x200283281261401094186.7533713112.4511809198.2346859 300x300679691441724125277.2871941166.3360957298.3417949 400x40011987519862510438370.1943328218.8004151398.3521658 500x50018689128162520219463.1564475268.1571713498.3220945 600x60026828132642234484554.4458956326.003062598.293561 700x70036300033717264781644.9132094368.5894278698.2666038 800x800474672345922105953731.7736169418.3070854798.3324054 900x900602469371109146204827.9483202474.6728236898.3740431 1000x1000742375376828204000915.8608818524.5644648998.4223776 1100x11009026403725313000311001.691501571.89600811098.35845 1200x120010686094175313951251091.736157626.56685021198.356802 1300x130012536093857815370321188.241281674.89352371298.347934 1400x140014484064003437088901272.006474721.39617441398.370254 1500x150016681253956729073751362.458324773.79706961498.416469 1600x1600189523439967210980311453.659121826.6484541598.367255 1700x1700215092241945314244211544.753336864.87784891698.379739 1800x1800246317240937517858431631.940541921.61150561798.37223 1900x1900269170342848521109991719.485088979.42624411898.372438 2000x2000297348542682826628531810.807451033.3922591998.351143

(29)

Table4.6:Resultsoneachalgorithmforthebipartite graphswhereeachvertexhasatmost50%∗|V|edges. Time(ms)Weight SizeAntMetropolisHungarianAntMetropolisHungarian 100x10049221275319492.7278062760.3616938596.86275204 200x200193281311101047187.1510867113.034867196.8652595 300x300434851331883953276.3326725163.4122039296.5828484 400x400774061422978813366.0217489216.409315396.7368031 500x50012100020237520172456.8639815264.6425751496.741958 600x60017412525793734109549.5275268312.2918048596.6812997 700x70023650029109356641641.3882497366.1369673696.8035924 800x80030892231820392219734.1128885417.2432508796.7329625 900x900390672345640139641818.4287195467.2815802896.6588299 1000x1000482782361360199453913.0191076522.0801954996.915783 1100x11005882503734213125161002.04486566.10896351096.640389 1200x12007013593894224032181098.590562614.33450731196.7346 1300x13008266253808755694531184.955507668.58402561296.792552 1400x14009612503857667071721273.914744720.9959461396.763585 1500x150011016413934069009851367.074562779.05653911496.718364 1600x1600125404739201611337661453.96136817.48394711596.719021 1700x1700141400041084413652971545.651154863.53699431696.774299 1800x1800158639141361016916871630.413165917.12763541796.742078 1900x1900176645340489120639851724.556971974.17303041896.714927 2000x2000195975042154724929841813.187711028.6354551996.763675

(30)

(31)

(32)

(33)

(34)

Table4.11:Resultsoneachalgorithmforthebipartite graphswhereeachvertexhasatmost5edges. Time(ms)Weight SizeAntMetropolisHungarianAntMetropolisHungarian 100x10026101441257871.0163280447.7675417972.29785256 200x20095471479541078144.326146788.1606114147.6499849 300x300207191429693625209.4333408123.6406937218.1550131 400x400361091454539172274.9515693160.1249942284.7093798 500x5005578214582818890353.1550806195.7581271360.6097908 600x6008065714692236235418.2425001228.5038435432.3359955 700x70010925015593763484491.7125773266.4793163505.5378906 800x80014171914996899828566.709767301.7321196582.129979 900x900176953151015155328642.0896993340.1776528659.1108085 1000x1000219563150344227000705.2530634376.0164821728.5519891 1100x1100270328153859325188782.8807543405.4215758802.6950651 1200x1200321468150578468969836.8582344439.8375131861.2299184 1300x1300379110152547581547919.6835791480.6155806942.1875666 1400x1400440797153016714781991.7097025507.9210431018.95962 1500x15005076101517039458121058.513904541.32116371090.621186 1600x160057968815276611866561127.451401568.6919671157.792919 1700x170065321915595415812661191.915721604.58551351228.676967 1800x180072653115340718541561270.577832640.53868861306.944366 1900x190080336015460922972341340.351306672.03554651381.98123 2000x200088353115493827738281414.73028709.13559421457.643701

(35)

(36)

(37)

Chapter 5 Conclusions

This thesis presents two methods for the maximum and minimum weighted bipartite matching problems. In the ant-matching algorithm, we can find a matching which the weight is close to the optimal solution. And if in a large scale weighted bipartite matching problem, using the ant-matching algorithm to find a matching will be faster than using the Hungarian algorithm. In the Metropolis algorithm, we can use the algorithm to find a matching in a very short time, but the weight of the matching as proportions to the optimal solution is not good. If we want to find a matching in a large weighted bipartite graph within a rapid time, the Metropolis algorithm is the best choice.

Besides, with the property of the ant colony optimization algorithm which the pheromone on the path changes gradually, the ant-matching algorithm will be useful in solving the dynamic weighted bipartite matching problems where the vertices and edges in the bipartite graph change with the time. In the Metropolis algorithm, in each iteration the algorithm randomly chooses an edge as a matching edge or not. It will not be influenced by the change of the bipartite graph. Thus, it is applicable on solving the dynamic weighted matching problems.

(38)

Bibliography

[1] S. Chib and E. Greenberg. (1995) Understanding the Metropolis- Hasting Algorithm. The American Statistician, Vol. 49, No. 4 (Novem- ber 1995), pp. 327–335.

[2] J. Munkres. (1957) Algorithms for the Assignment and Transporta- tion Problems. Journal of the Society of Industrial and Applied Math- ematics, Vol. 5, No. 1 (March 1957), pp. 32–38.

[3] Y. Nakamichi and T. Arita. (2001) Diversity Control in Ant Colony Optimization. Proceedings of the Inaugural Workshop on Arti- ficial Life (AL’01), pp. 70–78, Adelaide, Australia, December 2001.

[4] T. St¨utzle, M. Dorigo. (1999) ACO Algorithms for the Travel- ing Salesman Problem. In K. Miettinen, M. Makela, P. Neittaanmaki, and J. Periaux, editors, Evolutionary Algorithms in Engineering and Computer Science. Wiley, 1999.

[5] I, Wegener. (2005) Simulated Annealing Beats Metropolis in Com- binatorial Optimization. ICALP 2005. LNCS 3580, pp. 589–601.

Two Algorithms for Maximum and Minimum Weighted Bipartite Matching