Multiple Hungarian Method for k-Assignment Problem

Abstract

The k-assignment problem (or, the k-matching problem) on k-partite graphs is an NP-hard problem for $k\ge 3$. In this paper we introduce five new heuristics. Two algorithms, ${\mathrm{B}}_m$ and ${\mathrm{C}}_m$, arise as natural improvements of Algorithm ${\mathrm{A}}_m$ from (He et al., in: Graph Algorithms And Applications 2, World Scientific, 2004). The other three algorithms, ${\mathrm{D}}_m$, ${\mathrm{E}}_m$, and ${\mathrm{F}}_m$, incorporate randomization. Algorithm ${\mathrm{D}}_m$ can be considered as a greedy version of ${\mathrm{B}}_m$, whereas ${\mathrm{E}}_m$ and ${\mathrm{F}}_m$ are versions of local search algorithm, specialized for the k-matching problem. The algorithms are implemented in Python and are run on three datasets. On the datasets available, all the algorithms clearly outperform Algorithm ${\mathrm{A}}_m$ in terms of solution quality. On the first dataset with known optimal values the average relative error ranges from 1.47% over optimum (algorithm ${\mathrm{A}}_m$) to 0.08% over optimum (algorithm ${\mathrm{E}}_m$). On the second dataset with known optimal values the average relative error ranges from 4.41% over optimum (algorithm ${\mathrm{A}}_m$) to 0.45% over optimum (algorithm ${\mathrm{F}}_m$). Better quality of solutions demands higher computation times, thus the new algorithms provide a good compromise between quality of solutions and computation time.

1. Introduction

1.1. Motivation

Suppose we have k sets of vertices $V_1,V_2,\dots ,V_k$ and we want to consider multi-associations between them. For example, in bioinformatics, $V_1$ can correspond to the set of known (relevant) diseases, $V_2$ to the set of known drugs, and $V_3$ to the set of known genes that are relevant for the observed species (e.g., for Homo Sapiens). Multi-association in this case is a triple $(v_1,v_2,v_3)\in V_1\times V_2\times V_3$, which means that disease $v_1$, drug $v_2$, and gene $v_3$ are related. Such a triple may imply that the gene $v_3$ is activated in disease $v_1$ and is usually silenced by drug $v_2$, hence drug $v_2$ may be considered to be the cure for disease $v_1$. This is related to the very vibrant area of drug re-purposing and precision medicine, see e.g., [1,2,3]. We can represent the data as a complete 3-partite graph where the vertex set is $V_1\cup V_2\cup V_3$ and the edges between vertices from different $V_i$ have weights equal to the strength of the association between the ending vertices. Each triple $(v_1,v_2,v_3)$ is therefore a complete subgraph (3-clique, triangle) of such a graph and its weight is the sum of the weights on its edges. If we want to find a decomposition of this graph into disjoint triangles with a maximum (minimum) total weight, we obtain the 3-assignment problem (3-AP) [4,5,6,7]. The 3-AP can also serve as a model in production planning when we try to assign e.g., workers, machines, and tasks in a way that each worker gets exactly one task at one machine and the total cost is minimal. Many more applications can be found in the literature, see cf. [8] or [9], and the references therein.

1.2. Problem Formulation

Let $G=(V,E,w)$ be a complete weighted k-partite graph where $V=V_1\cup V_2\cup \cdots \cup V_k$ is the vertex set, $V_i$ are the vertices of the i-th partition with cardinality $|V_i|=n$, $E={\bigcup }_{1\le i<j\le k}\{uv\mid u\in V_i,v\in V_j\}$ is the edge set, and $w:E\to \mathbb{R}$ is the weight function that may be given in terms of matrices $W^{ij}$ as $w\left(e\right)=W_{uv}^{ij}$ for $e=uv$, $u\in V_i$, $v\in V_j$. A k-clique is a subset $Q\subset V$ with cardinality k, such that the induced graph $G\left[Q\right]$ is isomorphic to the complete graph $K_k$. This means that a k-clique has exactly one vertex from each $V_i$. In the case when G is a k-partite graph, a k-clique can be also called a k-association. The weight of a k-clique Q, $w\left(Q\right)$, is the sum of the edge weights of $G\left[Q\right]$:

$$w\left(Q\right)=\sum _{e\in E\left(G\right[Q\left]\right)}w\left(e\right).$$

In a complete k-partite graph where each partition has cardinality n, we can always find n pairwise disjoint k-cliques $\mathcal{Q}=\{Q_1,Q_2,\dots ,Q_n\}$. We call such a set of cliques a k-assignment or k-matching, since this is a natural extension of 2-assignments or 2-matchings in the bipartite graphs. Naturally, we define the weight of k-assignment $\mathcal{Q}$ as

$$w\left(\mathcal{Q}\right)=\sum _{i=1}^{n}w\left(Q_i\right).$$

The k-assignment problem, or equivalently, the k-matching problem (k-AP) (1), is the problem of finding a k-assignment of a given k-partite graph G with the minimum weight:

$$\begin{array}{c}\hfill min\{\sum _{\mathcal{Q}}w\left(\mathcal{Q}\right)\mid \mathcal{Q}is a k-assignment in G\}.\end{array}$$

(1)

In the literature [4,5,6,10], this problem is also referred to as the multidimensional assignment problem (MAP). For the case $k=3$ we can also trace the name 3-index assignment problem or 3-dimensional assignment problem in the literature. When $k=2$, it is well-known that the Hungarian algorithm solves the 2-assignment problem to optimality [11] in polynomial time. Kuhn used this name for the method because his invention of the algorithm is based on the work of two Hungarian mathematicians, D. König and E. Egervary. We observe that sometimes the researchers use word matching if the weights on the graph edges are all equal to 1, while for the general case they use assignment.

In this paper, we will also consider the maximum version of (1) because we want to compare our heuristic algorithms with some algorithms from the literature correctly. To make a clear distinction, we use subscripts m and M in the names of heuristic algorithms to denote that we are solving (1) with minimum and maximum objective, respectively.

We conclude the subsection with a useful observation. For $k>2$, every k-assignment $\mathcal{Q}$ implies a 2-assignment on $G[V_i\cup V_j]$, for all $i\ne j$. Thus $\mathcal{Q}$ gives rise to $\left(\genfrac{}{}{0pt}{}{k}{2}\right)$ 2-assignments $M_{i,j}$, $1\le i<j\le k$, between partitions $V_i$ and $V_j$. Therefore, a k-assignment $\mathcal{Q}$ defines $\left(\genfrac{}{}{0pt}{}{k}{\ell }\right)$ℓ-assignments on subgraphs of G induced on $\left(\genfrac{}{}{0pt}{}{k}{\ell }\right)$ different ℓ-partitions.

1.3. Literature Review

The problem has been extensively studied in the past. Here we briefly mention some of the relevant results and cite some previous work without the intention to review the literature completely. The problem called 3-dimensional matching (3DM) has already appeared among the NP-hard problems in Karp’s [12] seminal paper. This problem is related to the question of whether there exists a 3-assignment in a 3-partite graph if the partitions of the graph have the same cardinality but the graph is not necessary a complete k-partite graph.

According to [8], 3DM is a special case of the 3-assignment problem with maximum or minimum objective, which they call the axial 3-index assignment problem, hence Karp’s result [12] implies that both minimization and maximization versions of 3-assignment problems are NP-hard.

If $k=3$ and if we consider only the weights on the triples $Q_i$ which must be 0 or 1, then there exists a ($\frac{2}{3}-\epsilon$)-approximation algorithm [13]. If the weights on the triangles are arbitrary, there exists a $(\frac{1}{2}-\epsilon$)-approximation algorithm [14].

For the minimization version of the problem, it is known [15] that there is no polynomial time algorithm that achieves a constant performance ratio unless P=NP and the result holds even in the case when the clique weights are of the form

$$w_{ijk}=d_{ij}+d_{ik}+d_{jk}$$

for all $i,j,k$ (i.e., for the problem defined here as (1)). However, when the triangle inequality holds, Crama and Spieksma show that there is a $\frac{4}{3}$-approximation algorithm [15].

Hence, it is justified to apply heuristics to find near optimal solutions of the 3-AP and in general for k-AP problem instances. In the literature, various heuristics are reported that were designed to handle the k-assignment problem, many focusing on the 3-AP. We mention some of them to illustrate the variety of ideas elaborated. Aiex et al. [16] adopted the heuristic called Greedy Randomized Adaptive Search Algorithm. Huang and Lim in [17] described a new local search procedure which solves the problem by simplifying it to the classical assignment problem. Furthermore, Huang and Lim hybridized their heuristic with a genetic algorithm. An extension of the Huang and Lim heuristic [17] to the multidimensional assignment problem was done in [18,19], while [20] developed another new heuristic named Approximate muscle guided beam search, using the local search of [17]. Karapetyan and Gutin [21] devised a memetic algorithms with an adjustable population size technique and with the same local search as Huang and Lim for the case of 3-AP. The size was calculated as a function of the runtime of the whole algorithm and the average runtime of the local search for the given instance. According to Valencia, Martinez, and Perez [22] this is the best known technique to solve the general case of k-AP. These authors performed an experimental evaluation of a basic genetic algorithm combined with a dimensionwise variation heuristic and showed its effectiveness in comparison to a more complex state-of-the-art memetic algorithm for k-AP. Some other approaches were recently proposed for solving 3-AP [23], the so-called Neighborly algorithm, modified Greedy algorithm with some of the steps used by the Auction algorithm [24], and a probabilistic modification of the minimal element algorithm for solving the axial three-index assignment problem [25], where the idea was to extend the basic greedy-type algorithmic schemes using transition to a probabilistic setup based on variables randomization.

The k-assignment problem can be also formulated as an integer (0–1) linear programming problem in $n^k$ binary variables. This approach yields some interesting theoretical results, but has very limited practical impact due to the huge number of binary variables. More details can be found in [5,26]. Some recent results related to special variants of the k-assignment problem can also be found in [23,27]. An exact algorithm for 3-AP is proposed by Balas and Saltzman [4]. For more information on related work we refer to [8,9] and the references there.

The idea to use the Hungarian algorithm for 2-AP as a tool to attack the k-AP first appears in [28], where the algorithm named ${\mathrm{A}}_m$ (see the descriptions in the next section) for the approximate solution to the minimal k-assignment problem and an algorithm ${\mathrm{A}}_M$ for the approximate solution to the maximal k-assignment problem (or the maximal k-clique problem) of a weighted complete k-partite graph is given. In [28] it is experimentally shown that the Cubic Greedy Algorithms are better than the Random Select Algorithm and that Algorithms ${\mathrm{A}}_m$ and ${\mathrm{A}}_M$ are better than the Cubic Greedy Algorithms. For $k=4$, it is also shown that Algorithms ${\mathrm{A}}_m$ and ${\mathrm{A}}_M$ are better than the 4-clique Greedy Algorithm.

1.4. Our Contribution

As the (1) problem is NP-hard for $k\ge 3$, it is natural to ask whether one can design a useful heuristic based on the Hungarian algorithm that efficiently solves the $k=2$ case to optimality. The first work along this avenue is the implementation of Algorithm A from [28]. We continue the research with the main goal to understand how much the ideas of the Hungarian algorithm can contribute to performance of the heuristics. To this aim, we design several heuristics that are based on the Hungarian algorithm. Our experimental results show that all the algorithms improve the quality of the solutions compared to A, and some of our algorithms are a substantial improvement over the basic algorithm A (see Table 2). We also show that this type of heuristics can provide near optimal solutions for the k-assignment problem of very good quality on the datasets with known optimal values (see Tables 3 and 4).

The experiments are run on two datasets from the literature, one of them providing optimal solutions for the instances. In addition, we run two batches of experiments including instances generated by nonuniform distribution, in contrast to other datasets where the uniform distribution is used. Due to intractability of the k-assignment problem, it is not a surprise that our experimental study shows limitations of particular heuristics. Therefore we also introduce two randomized versions of heuristic algorithm C that lead to local search type heuristics that are observed to be improving the quality of solutions over time and may converge to the optimal solution. In this way we complement the quick heuristics with some alternatives that trade much longer computational times for quality of solutions. Hence we show that the heuristics for the k-assignment problem that are based on the Hungarian algorithm may be a very competitive choice.

The main contributions of this paper are the following:

• We design five new heuristics for (1). More precisely, we propose algorithms named B, C, D, E, and F for finding near optimal solutions to the (1). (All the algorithms have both the minimization and maximization versions, that are respectively denoted c.f. ${\mathrm{X}}_m$ and ${\mathrm{X}}_M$, for algorithm X.) The algorithms rely on heavy usage of the Hungarian algorithm [11] and arise as natural improvements of Algorithm ${\mathrm{A}}_m$ from [28]. The last two algorithms, E and F, can be considered as versions of iterative improvement type local search algorithms, as opposed to the steepest descent nature of, e.g., C.
• We implement and test the algorithms on three datasets:

  (a)

  The set of random graphs generated as suggested in [28]. Here we also reproduce their results.

  (b)

  We design two random datasets using both the uniform and a nonuniform distribution for the second batch of experiments.

  (c)

  We test our algorithms on the dataset of hard instances from [15], for which the optimal solutions are known.

• Our experimental results show that (on all datasets used) all the algorithms improve the quality of the solutions compared to algorithm A. We also observe the algorithms performance considering the quality of solutions versus computation time.

The rest of the paper is organized as follows. In Section 2 we introduce the notation that is used throughout the paper, and in Section 3 we outline the algorithms. In Section 4 we provide results of our experiments, where we evaluate the existing and the new algorithms on the three datasets. In Section 5 we summarize the results and discuss the methods of choice.

2. Preliminaries

From k-Assignment Problem to 2-Assignment Problem

The Hungarian method [11] is a classical and polynomial-time exact method for solving the 2-assignment problem, therefore it is very natural that we explore the idea to find near optimal feasible solutions of k-assignment problem by solving a series of 2-assignment problems.

Below we are going to present several new algorithms for (1), which strongly rely on the repetitive use of the Hungarian method on selected bipartite subgraphs and contracting the original graphs along the assignments computed by this method. Note that all algorithms return feasible solutions because we have a complete k-partite graph where the Hungarian method always finds an optimum solution for any induced graph $G[V_i\cup V_j]$, which can be easily used to reconstruct a feasible solution of (1) via operator *, see Section 3. Given an ℓ-partite weighted graph G and a 2-assignment $M_{i,j}$ between partitions $V_i$ and $V_j$ of G, we wish to contract the (weighted) edges which constitute $M_{i,j}$ in G. We therefore associate to $M_{i,j}$ the quotient graph $G/M_{i,j}=G{/}_{\sim }$, where $u\sim v\iff uv\in M_{i,j}$. The construction is explained in more detail below. The new weight function of $G/M_{i,j}$ is obtained by summing the weights of contracted edges adjacent to $M_{i,j}$. Formally, the vertices of $G/M_{i,j}$ are the equivalence classes consisting of either the singleton $\left\{v\right\}$ if the vertex v is not adjacent to an edge in the assignment $M_{i,j}$ or $\{u,v\}$ if $uv$ is an edge in $M_{i,j}$. Loosely speaking, in $G/M_{i,j}$, pairs of elements of $V_i$ and $V_j$ are merged along $M_{i,j}$ to form a new partition $U^{\prime }$ while the other $V_k$, $k\ne i,k\ne j$ are not changed. (See Figure 1a,b.) More formally,

$$U^{\prime }=\{\{u,v\}\mid uv\in M_{i,j}\}\mathrm{and}{V}_{\ell }^{\prime }=\{\left\{v\right\}\mid v\in V_{\ell }\}.$$

By construction, the elements of $U^{\prime }$ and $V_{\ell }^{\prime }$ are equivalence classes, and formally we have $\{u,v\}=\left[u\right]=\left[v\right]$ and $\left\{u\right\}=\left[u\right]$. However, we will (warning that it is abuse of notation) often not distinguish between $V_{\ell }^{\prime }$ and $V_{\ell }$, (i.e., identify $V_{\ell }^{\prime }=V_{\ell }$) and also consider the elements of $U^{\prime }$ as sets of two elements, the union of two singleton sets. Formally, $G/M_{i,j}=(V^{\prime },E^{\prime },w^{\prime })$, is the graph with the vertex set

$$V^{\prime }=U^{\prime }\cup \bigcup _{\begin{array}{c}1\le l\le k\\ \ell \ne i,\ell \ne j\end{array}}{V}_{\ell }^{\prime },$$

and the edge set

$$E^{\prime }=F^{\prime }\cup \bigcup _{\begin{array}{c}1\le i^{\prime }<j^{\prime }\le k\\ \{i^{\prime },j^{\prime }\}\cap \{i,j\}=\varnothing \end{array}}{E}_{i^{\prime },j^{\prime }}$$

where $F^{\prime }=\{\left\{u\right\}\{v,v^{\prime }\}\mid u\in V\backslash (V_i\cup V_j),v{v}^{\prime }\in M_{i,j}\}$ and $E_{i^{\prime },j^{\prime }}=\{\left\{u\right\}\left\{v\right\}\mid uv\in E\backslash M_{i,j}\}$. Or, recalling the simplified notation above, simply $E_{i^{\prime },j^{\prime }}=E_{i,j}$.

The new weight function is defined by summing the weights on the edges adjacent to the identified vertices: if $u,v\in V\backslash (V_i\cup V_j)$, then we have

$$w^{\prime }\left(\left\{u\right\}\left\{v\right\}\right)=w\left(uv\right)$$

and if $u\in V\backslash (V_i\cup V_j)$ and $v{v}^{\prime }\in M_{i,j}$, we have

$$w^{\prime }\left(\left\{u\right\}\{v,v^{\prime }\}\right)=w\left(uv\right)+w\left(u{v}^{\prime }\right).$$

In other words, the weights on $E_{i^{\prime },j^{\prime }}=E_{i,j}$ are not changed, and the weights on the edge set $F^{\prime }$ are the weights of pairs of edges that were contracted to obtain triangles $\{u,v,v^{\prime }\}$.

3. Algorithms

In this section we first recall Algorithm ${\mathrm{A}}_m$ for (1) from [28] and then enhance it using different well-known greedy and local search approaches. Let A be a set and f a function $f:A⟶\mathbb{R}$. Denote by

$$\underset{x\in A}{\arg \min }f\left(x\right)=\{x\mid \forall y\in A:f\left(y\right)\ge f\left(x\right)\},$$

the set of minimal elements in A under the function f. Let $M_{i,j}$ be an arbitrary assignment between the i-th and j-th partition and let ${\mathcal{M}}^{\prime }$ be a $(k-1)$-assignment for the $(k-1)$-partite graph $G/M_{i,j}$. We denote by ${\mathcal{M}}^{\prime }\ast M_{i,j}$ the unique k-assignment for G reconstructed from ${\mathcal{M}}^{\prime }$ and $M_{i,j}$, i.e.,

$${\mathcal{M}}^{\prime }\ast M_{i,j}=\{uv\mid \left[u\right]\left[v\right]\in {\mathcal{M}}^{\prime }\}\cup \left(\bigcup _{\begin{array}{c}\left[u\right]\left[v{v}^{\prime }\right]\in {\mathcal{M}}^{\prime }\\ v{v}^{\prime }\in M_{i,j}\end{array}}\{uv,u{v}^{\prime }\}\right).$$

For an example see Figure 1. In the case when G is a bipartite graph, $G/M_{i,j}$ contains only one partition and thus does not allow any assignment, for completeness we thus define $\varnothing \ast M_{i,j}=M_{i,j}$. Recall that in the case $n=2$ an optimal 2-assignment can be found using the Hungarian algorithm [11]. The result of this algorithm on bipartite graph G will be denoted by Hungarian$\left(G\right)$.

Algorithm 1, ${\mathrm{A}}_m$. The following algorithm, which we denote by ${\mathrm{A}}_m$, for finding near optimal solution for the minimal k-assignment problem of k-partite graph G has been proposed in  [28].

Algorithm 1 [28].

1: function ${\mathrm{A}}_m$(G) 2:     if $k=1$ then 3:         return ∅ 4:     else 5:         $M_{1,2}=$Hungarian($G[V_1\cup V_2]$) 6:         return ${\mathrm{A}}_m$($G/M_{1,2}$)$\ast M_{1,2}$

In short, the algorithm finds an optimal 2-assignment for $G[V_1\cup V_2]$, takes the quotient by this assignment and recursively repeats this process. The final result is a complete k-assignment $\mathcal{M}$ reconstructed from the previously computed $(k-1)$-assignments.

Example 1.

Let G be a complete 3-partite graph with partitions $V=V_1\cup V_2\cup V_3$, $V_1=\{1,2,3\},V_2=\{4,5,6\},V_3=\{7,8,9\}$ and the following (weighted) adjacency matrix

where the entries generate the weight function $w:uv\mapsto W_{u,v}$; $u,v\in \{1,\dots ,9\}$.

In Algorithm ${\mathrm{A}}_m$ we first compute the optimal assignment $M_{1,2}$ between partitions $V_1$ and $V_2$ (Figure 1a), then we compute the quotient graph $G/M_{1,2}$, presented in Figure 1b, and finally we compute the optimal assignment for this graph (Figure 1c). At the end, we reconstruct the 3-assignment $\mathcal{M}$ and obtain a solution of weight 44 (Figure 1d).

Algorithm 2, ${\mathrm{B}}_m$. Algorithm ${\mathrm{A}}_m$ is greedy in the sense that it takes (lexicographically) the first pair of partitions and merges them according to the best assignment among them. If the order of partitions is changed, ${\mathrm{A}}_m$ would provide a different result. The idea of ${\mathrm{B}}_m$ is to consider all the pairs for possible first merge, and take the best result. Note that ${\mathrm{B}}_m$ is also greedy as it always takes the minimal assignment between the two partitions that are merged. (In a sense, one may say that ${\mathrm{B}}_m$ is somehow more greedy than ${\mathrm{A}}_m$ because it looks a bit farther for the seemingly best option in sight.)

Algorithm 2 (${\mathrm{B}}_m$, improvement of ${\mathrm{A}}_m$).

1: function ${\mathrm{B}}_m$(G) 2:     if $k=1$ then 3:         return ∅ 4:     else 5:         $\{a,b\}\in {\arg \min }_{1\le i<j<k}w\left({\mathrm{B}}_m\left(G/Hungarian\left(G[V_i\cup V_j]\right)\right)\right)$ 6:         return ${\mathrm{B}}_m$($G/M_{a,b}$)$\ast M_{a,b}$

Algorithm ${\mathrm{B}}_m$ searches through all possible pairs $(V_i,V_j)$ of partitions, recursively runs on the quotient graph $G/M$, where M is the optimal 2-assignment on $V_i\cup V_j$, and among these partitions chooses the one with the best assignment of $G/M$. If there are more minimal partitions, the algorithm chooses a random partition of minimal weight. Clearly, Algorithm ${\mathrm{B}}_m$ returns a k-assignment that is determined by the $(k-1)$ 2-assignments that were chosen in the recursive calls of ${\mathrm{B}}_m$.

Example 2.

We take the same graph as in Example 1. In contrast to ${\mathrm{A}}_m$, Algorithm ${\mathrm{B}}_m$ finds optimal assignments $M_{1,2}$, $M_{1,3}$, and $M_{2,3}$ for the induced subgraphs $G[V_1\cup V_2]$, $G[V_1\cup V_3]$, and $G[V_2\cup V_3]$, see Figure 2a–c, respectively. The algorithm continues its search recursively on the bipartite graphs $G/M_{1,2}$, $G/M_{1,3}$, and $G/M_{2,3}$. As Figure 2b shows, we obtain a k-assignment of weight 40.

Algorithm 3, ${\mathrm{C}}_m$. Observe that Algorithm ${\mathrm{B}}_m$ is much more time consuming than Algorithm ${\mathrm{A}}_m$ as it calls the Hungarian algorithm subroutine

$$\left(\genfrac{}{}{0pt}{}{k}{2}\right)\left(\genfrac{}{}{0pt}{}{k-1}{2}\right)\cdots \left(\genfrac{}{}{0pt}{}{3}{2}\right)=\frac{k!(k-1)!}{2^{k-1}}$$

times as opposed to only $(k-1)$ calls by Algorithm ${\mathrm{A}}_m$.

However, note that Algorithm ${\mathrm{B}}_m$ is greedy because it always takes the minimal 2-assignment. As the k-assignment problem (for $k>2$) is intractable, a deterministic greedy algorithm can not solve the problem to optimality unless P=NP. We therefore consider an iterative improvement of the solutions by taking a nearly optimal solution (that may be the result of ${\mathrm{B}}_m$) to define an initial solution. The neighbors of the given solution are the results of the following procedure: fix one of the 2-assignments, say M, and run Algorithm ${\mathrm{B}}_m$ on $G/M$. After repeating the process by fixing all 2-assignments, we get a set of new solutions. If at least one of them is an improvement over the previously known best solution, we continue the improvement process. The process stops when there is no better solution among the set of new solutions.

The third algorithm, denoted as Algorithm ${\mathrm{C}}_m$, can be considered as a steepest descent algorithm on the set of all k-assignments, where the next solution is chosen to be a minimal solution in a suitably defined neighborhood.

Algorithm 3 (${\mathrm{C}}_m$, steepest descent based on ${\mathrm{B}}_m$).

1: function ${\mathrm{C}}_m$(G) 2:     $\mathcal{M}=$ ${\mathrm{B}}_m$(G) 3:     repeat 4:         ${\mathcal{M}}_{\mathrm{previous}}=\mathcal{M}$ 5:         $M_{a,b}={\arg \min }_{M_{i,j}\in \mathcal{M}}w\left({\mathrm{B}}_m(G/M_{i,j})\right)$ 6:         $\mathcal{M}={\mathrm{B}}_m(G/M_{a,b})\ast M_{a,b}$ 7:     until $w\left({\mathcal{M}}_{\mathrm{previous}}\right)=w\left(\mathcal{M}\right)$ 8:     return $\mathcal{M}$

Example 3.

Taking the same instance as in Examples 1 and 2, Algorithm ${\mathrm{C}}_m$ starts with finding a 3-assignment $\mathcal{M}=\{M_{1,2},M_{1,3},M_{2,3}\}$ using ${\mathrm{B}}_m$ and continues by recursively searching graphs $G/M_{1,2}$ and $G/M_{2,3}$ (we can skip $G/M_{1,3}$, since the initial 3-assignment was already obtained from $G/M_{1,3}$). As Figure 3 shows, the best solution of weight 37 is obtained from contracting $M_{2,3}$. If we continue with the iteration, we can see that the solution has stabilized and no further improvements can be made.

Algorithm 4, ${\mathrm{D}}_m$. Algorithms ${\mathrm{B}}_m$ and ${\mathrm{C}}_m$ heavily rely on the Hungarian method and are very time-consuming in comparison to ${\mathrm{A}}_m$. Therefore we define another greedy algorithm based on the Hungarian method that is faster. We denote by ${\mathrm{D}}_m$ the greedy algorithm that takes the minimal 2-assignment $M_{i,j}$ in the k-partite graph G, and continues considering the $(k-1)$-partite graph $G/M_{i,j}$ until only one partition is left.

Algorithm 4 (${\mathrm{D}}_m$, Greedy iterative)

1: function ${\mathrm{D}}_m$(G) 2:     if $k=1$ then 3:         return ∅ 4:     else 5:         $\{a,b\}\in {\arg \min }_{1\le i<j<k}w\left(Hungarian\left(G[V_i\cup V_j]\right)\right)$ 6:         return ${\mathrm{D}}_m$($G/M_{a,b}$)$\ast M_{a,b}$

Note that Algorithm ${\mathrm{D}}_m$ has the shortest average running time among algorithms B, C, and D. On the other hand, it is at the same time also the most short-sighted greedy algorithm among the rest of the algorithms, since its choice is based on the quality of the 2-assignment at hand, $w\left(M\right)$, and not by looking at the quality of $w(G/M)$.

Algorithm 5, ${\mathrm{E}}_m$. The algorithms considered above were in principle deterministic. Except breaking ties randomly in case of more than one minimal choice, all the steps are precisely defined, i.e., the algorithms are deterministic. In the final experiment, we are interested in the effect of randomization.

The next algorithm, ${\mathrm{E}}_m$, is an alternative randomized version of ${\mathrm{C}}_m$. The main idea is to loop through all 2-assignments in random order and accept the first assignment $M_{i,j}$ that yields a better solution, instead of searching for the minimal 2-assignment $M_{i,j}$. Thus algorithm ${\mathrm{E}}_m$ is obtained by changing the main loop of ${\mathrm{C}}_m$. As algorithm ${\mathrm{E}}_m$ accepts the first better solution in the neighborhood of the current solution, it is a kind of iterative improvement algorithm as opposed to ${\mathrm{C}}_m$, which is a steepest descent type local search algorithms, because it always looks for the best solution in the neighborhood.

Algorithm 5 (${\mathrm{E}}_m$)

1: function ${\mathrm{E}}_m$(G) 2:     $\mathcal{M}$ = ${\mathrm{B}}_m$ (G) 3:     repeat 4:         $min\_weight=w\left(\mathcal{M}\right)$ 5:         for $(i,j)\in$Shuffle($\left(\genfrac{}{}{0pt}{}{k}{2}\right)$) do 6:            $\mathcal{M}=min\{\mathcal{M},{\mathrm{B}}_m(G/M_{i,j})\ast M_{i,j}\}$ 7:            if $min\_weight\ne w\left(\mathcal{M}\right)$ then 8:                break    9:     until $min\_weight=w\left(\mathcal{M}\right)$ 10:     return $\mathcal{M}$

We denote by ${\mathrm{E}}_m\left(n\right)$ the algorithm that takes the best solution of ${\mathrm{E}}_m$ out of n trials (restarts).

Algorithm 6, ${\mathrm{F}}_m$. The Algorithm ${\mathrm{E}}_m$ stops when there is no better solution, even if there are solutions of the same quality (weight) in the neighbourhood of the current solution. These neighborhood solutions might later give improvement, therefore we introduce another variant, called ${\mathrm{F}}_m$(n), which in such case chooses randomly one solution of equal weight and continues, but stops after at most n steps, since it does not necessarily terminate (e.g., it can iterate between two equally good solutions).

Algorithm 6 (${\mathrm{F}}_m$, multistart local search)

1: function ${\mathrm{F}}_m$($G,n$) 2:     $\mathcal{M}$ = $B_m$ (G) 3:     $last\_assignment=\mathbf{none}$ 4:     for $counter=1,\dots ,n$ do 5:         $assignments={\arg \min }_{M_{i,j}\in \mathcal{M}}w\left({\mathrm{B}}_m(G/M_{i,j})\ast M_{i,j}\right)$ 6:         if $last\_assignment$ in $assignments$ then 7:            remove $last\_assignment$ from $assignments$ 8:         if $assignments=\varnothing$ then 9:            break  10:         $M_{a,b}=$Choose_Random($assignments$) 11:         $\mathcal{M}={\mathrm{B}}_m(G/M_{a,b})\ast M_{a,b}$ 12:     return $\mathcal{M}$

All of the above algorithms can be easily adapted to solve maximization assignment problems, i.e., to solve (1) where the objective is maximum. We denote the maximization variants of the algorithms $A,B,C,D,E$ and F by ${\mathrm{A}}_M$, ${\mathrm{B}}_M$, ${\mathrm{C}}_M$, ${\mathrm{D}}_M$, ${\mathrm{E}}_M$, and ${\mathrm{F}}_M$, respectively.

Remark 1.

Clearly, the algorithms C, D, E, and F always return a feasible assignment because any solution is obtained by a recursive call of B. However, many calls of B and thus many runs of the Hungarian algorithm are expensive in terms of computation time. Therefore, it is an interesting question whether the present local search heuristics may be sped up by considering other neighborhoods, for example applying the idea of variable neighborhood search [29].

4. Numerical Results

In this section, we present numerical evaluations of the algorithms introduced in Section 3. We compare them with the algorithms from [28] and to each other. In particular, we

• reproduce the results on random graphs as given in [28] and compare them with the results of our Algorithms ${\mathrm{B}}_m$ to ${\mathrm{F}}_m$ and their maximization variants ${\mathrm{B}}_M$ to ${\mathrm{F}}_M$,
• evaluate the performance of the algorithms against ${\mathrm{A}}_M$ as the number of vertices increases,
• test our algorithms on the instances provided in [15].

4.1. Datasets

Numerical evaluations are done using three sets of random complete k-partite graphs. The first set was constructed according to [28], as follows: It consists of two sets of 1000 random complete k-partite graphs with $k=3,4$ and $n=30,100$, respectively. The weights on the edges were selected randomly from given set S with probability density function $p\left(x\right)=\frac{1}{\left|S\right|},\forall x\in S$, where $S=\{0,1,\dots ,9\}$, if $k=3$ and $S=\{1,\dots ,100\}$, if $k=4$.

The second dataset is our contribution. It has been designed to compare how our algorithms scale with increasing size of the instances. It consists of two subsets, each consisting of instances with $k=3$ and $k=4$. The first subset was generated as follows. For each $k\in \{3,4\}$ we range the number of vertices n in each partition from 2 to 100 and the weights on edges connecting vertices from different partitions are chosen randomly according to discrete uniform distribution on the set $S=\{0,\dots ,n-1\}$. The second subset was obtained similarly, we only changed the distribution of the edge weights. The edges between the different partitions are assigned random weights chosen according to discrete uniform distribution on the set $S=\{2^0,2^1,\dots ,2^{10}\}$. We expect that these random instances are more difficult, because the very important edges are sufficiently rare. For each pair $k,n$ we generated 1000 random instances.

The third set is the same as in [15]. For this set, the optimum value of 3-AP is known. We retrieved it from [30]. This dataset includes 18 instances of complete 3-partite graphs:

• 6 graphs with 33 vertices and 6 graphs with 66 vertices in each of the 3 partitions, where the weights of edges between different partitions are random integers which should, according to the description given by the authors [30], range from 0 to 99. However, we point out that some of the weights in these instances are larger than 100.
• 3 graphs with 33 vertices and 3 graphs with 66 vertices in each partition, where the weights take only values 1 or 2. We call these graphs binary graphs.

At the beginning of the web page [30] it is explained how the numerical results from [15] relate to these instances.

4.2. First Experiment–Dataset from He et al. (2004)

In the first experiment we compare the algorithms used in [28] (namely, the Random, Greedy, and ${\mathrm{A}}_M$ algorithm) with our Algorithms ${\mathrm{B}}_M$, ${\mathrm{C}}_M$, ${\mathrm{D}}_M$, ${\mathrm{E}}_M$, ${\mathrm{E}}_M$(10), and ${\mathrm{F}}_M$(100) on the first set of random k-partite graphs, which we generated as described in [28], see Section 4.1. We run these 5 algorithms on each group of 1000 graph instances and report the average values in

Table 1. Comparison of Random, Greedy and ${\mathrm{A}}_M$ algorithms from [28] with ${\mathrm{B}}_M$ to ${\mathrm{F}}_M$ algorithms for the maximization version of 3-AP. Each row contains average values of solutions obtained by these algorithms, computed over 1000 random instances of complete k-partite graphs with n vertices, which are generated as described in Section 4.1. We can see that Algorithms ${\mathrm{B}}_M$ to ${\mathrm{F}}_M$ return substantially better results.

	$\mathit{k}=3,\mathit{n}=30,$			$\mathit{k}=4,\mathit{n}=100,$
	$\mathbf{S}=\{\mathbf{0},\cdots ,\mathbf{9}\}$			$\mathbf{S}=\{\mathbf{1},\cdots ,\mathbf{100}\}$
Algorithm	val	${\Delta }_{{\mathrm{A}}_{\mathit{M}}}(\%)$	Time	val	${\Delta }_{{\mathrm{A}}_{\mathit{M}}}(\%)$	Time
Random	405	−45.9	-	41806	−23.5	-
Greedy	736	−1.8	-	52801	−3.0	-
${\mathrm{A}}_M$	749.2	0	1	54,421.7	0	1
${\mathrm{B}}_M$	753.8	0.6	3.0	54,634.1	0.4	14.4
${\mathrm{C}}_M$	759.4	1.4	6.1	54,731.5	0.6	46.7
${\mathrm{D}}_M$	749.4	0.0	2.4	54,442.9	0.0	3.7
${\mathrm{E}}_M$	759.3	1.3	5.3	54,730.5	0.6	37.9
${\mathrm{E}}_M$(10)	759.9	1.4	53.0	54,761.1	0.6	378.7
${\mathrm{F}}_M$(100)	760.4	1.5	94.8	54,732.0	0.6	674.7

and

Table 2. The rows contain (respectively) the average values obtained by algorithms Random, Greedy, ${\mathrm{A}}_m$ from [28], and by our Algorithms ${\mathrm{B}}_m$ to ${\mathrm{C}}_m$ over 1000 random complete 3-partite graphs, respectively. We can see that our Algorithms ${\mathrm{B}}_m$ to ${\mathrm{F}}_m$ outperform the algorithms from [28].

	$\mathit{k}=3,\mathit{n}=30,$
	$\mathbf{S}=\{\mathbf{0},\cdots ,\mathbf{9}\}$
Algorithm	val	${\Delta }_{{\mathrm{A}}_{\mathit{m}}}(\%)$	Time
Random	405	566.7	-
Greedy	218	258.9	-
${\mathrm{A}}_m$	60.7	0	1
${\mathrm{B}}_m$	56.2	−7.4	3
${\mathrm{C}}_m$	50.8	−16.4	6.1
${\mathrm{D}}_m$	60.6	−0.2	2.4
${\mathrm{E}}_m$	50.9	−16.2	5.3
${\mathrm{E}}_m$(10)	50.3	−17.2	53
${\mathrm{F}}_m$(100)	49.8	−18.0	95.2

.

In order to compare the algorithms with ${\mathrm{A}}_m$ (resp. ${\mathrm{A}}_M$), we define the relative gap with respect to the value obtained by ${\mathrm{A}}_m$ (resp. ${\mathrm{A}}_M$) by

$${\Delta }_{{\mathrm{A}}_m}=100·\frac{\mathtt{val}-{\mathtt{val}}_{{\mathrm{A}}_m}}{{\mathtt{val}}_{{\mathrm{A}}_m}}\left(\mathrm{resp}.{\Delta }_{{\mathrm{A}}_M}=100·\frac{\mathtt{val}-{\mathtt{val}}_{{\mathrm{A}}_M}}{{\mathtt{val}}_{{\mathrm{A}}_M}}\right).$$

4.3. Second Experiment on Random Instances

In this subsection we compare Algorithms ${\mathrm{B}}_M$, ${\mathrm{C}}_M$, ${\mathrm{D}}_M$, ${\mathrm{E}}_M$, ${\mathrm{E}}_M$(10), and ${\mathrm{F}}_M$(100) on the second dataset, introduced in Section 4.1. We run all three algorithms on each of two subsets, consisting of 1000 instances for each pair $(k,n)\in \{3,4\}\times \{2,3,4,\dots ,100\}$. For each pair $(k,n)$ and each algorithm, we compute the average value of solutions given by the algorithm over the corresponding 1000 instances. Then, we compute quotients of the average values for ${\mathrm{B}}_M$ and for ${\mathrm{A}}_M$ and denote it by ${\mathrm{B}}_M$/${\mathrm{A}}_M$. Similarly we compute quotient ${\mathrm{C}}_M$/${\mathrm{A}}_M$, and so on. Figure 4, Figure 5, Figure 6 and Figure 7 contain plots and interpretations of these quotients.

The results on the first subset (with uniform distribution of weights) are depicted on Figure 4 and Figure 5. They show that Algorithm ${\mathrm{E}}_M$(10) clearly finds the best solutions. The Algorithms ${\mathrm{C}}_M$, ${\mathrm{E}}_M$ and ${\mathrm{F}}_M$(100) perform similarly, and are clearly outperforming ${\mathrm{B}}_M$ and ${\mathrm{D}}_M$. Note that taking into account time complexity and considering $k=3$, the clear winners among the faster algorithms (${\mathrm{A}}_M$, ${\mathrm{B}}_M$, ${\mathrm{C}}_M$, ${\mathrm{D}}_M$, and ${\mathrm{E}}_M$) are ${\mathrm{C}}_M$ and ${\mathrm{E}}_M$, and among the more time consuming ${\mathrm{E}}_M$(10) and ${\mathrm{F}}_M$(100), the winner is ${\mathrm{E}}_M$(10). Note that ${\mathrm{E}}_M$(n) may potentially find even better solutions with larger n (and consequently may need more time). The differences are much less obvious for $k=4$ (see Figure 5). With larger n, the ratios seem to stabilize at certain constants.

Considering the results on the first dataset (Table 1) and the first sample of the second dataset (Figure 4 and Figure 5) suggest that there is no significant difference in quality of solutions among the algorithms C, E, and F. However, the results on the second subset (the set with a special distribution of weights), in particular for $k=3$, show that Algorithms C, E, and F substantially outperform B and D (see Figure 6), and the differences of ratios tend to grow with larger n. This allows us to conclude that Algorithms ${\mathrm{C}}_M$, ${\mathrm{E}}_M$(n) and ${\mathrm{F}}_M$(n) are significantly better than ${\mathrm{B}}_M$ and ${\mathrm{D}}_M$ (at least on most of our instances). For $k=4$ (see Figure 7), the differences are small again.

Remark 2.

When experimentally testing the performance of heuristics, it is well known that random instances are often among the simplest and many heuristics perform remarkably well on such datasets. It is often difficult to generate instances that are hard, or better to say, that are hard for a specific heuristic algorithm. The dataset generated using a nonuniform distribution of weights is obviously harder for the algorithms B and D. It may be of some interest to see what distribution of weights may show further significant differences in performance among the algorithms that are of interest here.

4.4. Third Experiment–Dataset Crama and Spieksma (1992)

In this subsection, we compare Algorithms ${\mathrm{A}}_m$, ${\mathrm{B}}_m$, ${\mathrm{C}}_m$, ${\mathrm{D}}_m$, ${\mathrm{E}}_m$, ${\mathrm{E}}_m$(10), and ${\mathrm{F}}_m$(100) with the optimal solution of 3-AP on the problems from the second database, which were taken from [30], see also Section 4.1.

For these instances, we know the optimum value of 3-AP (denoted by $\mathtt{OPT}$), so we can report the relative gap, defined by

$$\delta =100·\frac{\mathtt{val}-\mathtt{OPT}}{\mathtt{OPT}}.$$

The results are given in

Table 3. Comparison of Algorithms ${\mathrm{A}}_m$, ${\mathrm{B}}_m$, ${\mathrm{C}}_m$, ${\mathrm{D}}_m$, ${\mathrm{E}}_m$, ${\mathrm{E}}_m$(10), and ${\mathrm{F}}_m$(100) on the first group of instances of 3-AP from [15,30]. Column 2 contains the optimum value of the problem, as reported in [30]. For each algorithm, we report the value that it returns. Average relative errors $\delta$ and average computation times are given in the last two rows. Algorithms ${\mathrm{C}}_m$, ${\mathrm{E}}_m$, ${\mathrm{E}}_m$(10), and ${\mathrm{F}}_m$(100) have the best performance and, on average, differ from the optimal solution by 0.1% or less (see the last row).

Problem	OPT	${\mathbf{A}}_{\mathit{m}}$	${\mathbf{B}}_{\mathit{m}}$	${\mathbf{C}}_{\mathit{m}}$	${\mathbf{D}}_{\mathit{m}}$	${\mathbf{E}}_{\mathit{m}}$	${\mathbf{E}}_{\mathit{m}}$(10)	${\mathbf{F}}_{\mathit{m}}$(100)
3DA198N1	2662	2696	2669	2663	2669	2663	2663	2663
3DA198N2	2449	2498	2467	2458	2467	2458.4	2457.1	2457.4
3DA198N3	2758	2811	2778	2764	2778	2764	2764	2764
3DA99N1	1608	1617	1617	1608	1617	1608.0	1608.0	1608.0
3DA99N2	1401	1420	1411	1402	1415	1402.0	1402.0	1402.0
3DA99N3	1604	1612	1612	1604	1612	1604.0	1604.0	1604.0
3DI198N1	9684	9830	9765	9695	9765	9693.3	9689.2	9689.8
3DI198N1	8944	9132	9121	8949	9177	8949.7	8947.4	8948.4
3DI198N3	9745	9930	9876	9750	9876	9749.6	9747.6	9748.5
3DIJ99N1	4797	4882	4839	4800	4882	4801.3	4798	4799.3
3DIJ99N2	5067	5145	5136	5074	5145	5071.8	5069.6	5071.1
3DIJ99N3	4287	4338	4338	4291	4371	4290.5	4287.8	4289.6
$\overline{\delta }[\%]$	0	1.47	0.92	0.10	1.15	0.10	0.07	0.08
Time	-	1	2.9	11.8	2.3	9.0	89.1	150.9

for non-binary problems and in

Table 4. Numerical result for Algorithms ${\mathrm{A}}_m$, ${\mathrm{B}}_m$, and ${\mathrm{C}}_m$ on the second group of instances from [30] (called binary graphs). The optimum values $\mathtt{OPT}$ are taken from [30], and the values $\mathtt{val}$ are computed by Algorithms ${\mathrm{A}}_m$, ${\mathrm{B}}_m$, ${\mathrm{C}}_m$, ${\mathrm{D}}_m$, ${\mathrm{E}}_m$, ${\mathrm{E}}_m$(10), and F(100). Average relative errors $\delta$ and average computation times are given in the last two rows. We can see that ${\mathrm{F}}_m$(100) has the best performance.

Problem	OPT	${\mathbf{A}}_{\mathit{m}}$	${\mathbf{B}}_{\mathit{m}}$	${\mathbf{C}}_{\mathit{m}}$	${\mathbf{D}}_{\mathit{m}}$	${\mathbf{E}}_{\mathit{m}}$	E(10)	${\mathbf{F}}_{\mathit{m}}$(100)
3${\mathrm{D}}_m$198N1	286	298	294	287	295	286.5	286.0	286.4
3${\mathrm{D}}_m$198N2	286	294	293	286	294	286.2	286.0	286.2
3${\mathrm{D}}_m$198N3	282	294	294	285	294	284.9	284.3	283.7
3${\mathrm{D}}_m$299N1	133	140	134	134	134	134.0	134.0	133.4
3${\mathrm{D}}_m$299N2	131	139	137	134	137	134.0	134.0	133.0
3${\mathrm{D}}_m$299N3	131	136	136	132	136	132.0	132.0	131.0
$\overline{\delta }[\%]$	0	4.41	3.11	0.87	3.22	0.84	0.77	0.45
Time	0	1	2.7	6.8	2.4	5.4	54.0	89.7

for binary problems.

For non-binary graphs, with results presented in Table 3, Algorithms ${\mathrm{C}}_m$, ${\mathrm{E}}_m$, ${\mathrm{E}}_m$(10), and F(100) have, as expected, the best performance and on average differ from the optimal solution by 0.1% or less (see last row in Table 3). In addition, they are in some cases also able to find the optimal solution.

For binary graphs, with results presented in Table 4, we can observe that the relative performances are, due to the low weight sum, worse than those of non-binary graphs. As the problems are binary, a solution that differs from the optimal in one element may have, due to small total weight of the assignments, a considerably large relative error. As in the case of non-binary graphs, ${\mathrm{C}}_m$, ${\mathrm{E}}_m$, ${\mathrm{E}}_m$(10), and F(100) outperform ${\mathrm{A}}_m$, ${\mathrm{B}}_m$, and ${\mathrm{D}}_m$. Algorithm ${\mathrm{F}}_m$(100) finds the optimal solution in most cases (see the last column), and Algorithms ${\mathrm{C}}_m$, and ${\mathrm{E}}_m$ find the optimal solution in some cases.

We point out that these algorithms are fast. Our implementation, which could be further optimised, takes a fraction of a second (on a 3.0 Ghz PC) on each of these instances. Relative computation times (relative to algorithm A) and average relative errors (compared to known optimal solutions) are evident from Figure 8.

5. Summary and Conclusions

We have introduced Algorithms A, B, C, D, E, and F to approximately solve (1). The algorithms are all based on extensive use of the Hungarian algorithm and thus arise as natural improvements of Algorithm A from [28]. Algorithms A, B, C, and D are in principle deterministic, whereas Algorithms E and F incorporate randomization. We implemented the algorithms in Python and evaluated them on three benchmark datasets. Numerical tests show that new algorithms in minimization or maximization variant, in terms of solution quality, outperform A on all of the chosen datasets. Summing up, our study shows that multiple usage of the classic Hungarian method can provide very tight solutions for (1), in some cases even an optimal solution.

Another important issue when regarding algorithms’ performance is computational time. For smaller instances, E has relatively good speed and on average misses the optimal solution by merely 0.1%, thus, we propose it as our method of choice. Among the deterministic algorithms, our study suggests using Algorithm C. However, we wish to note that when we consider large instances of (1), both in number of partitions and in size of each partition, we must be very careful how often we will actually run the Hungarian method because many repetitions of the Hungarian method substantially increase computation time. The main goal of the reported research was to explore the potential of the Hungarian algorithm for solving the k-assignment problem. We have designed several heuristics based on the Hungarian method that have shown to be competitive. While, on one hand, some of our algorithms provide very good (near optimal or even optimal) results in a short time, we also designed two heuristics based on local search [31,32,33]. Local search type heuristics improve the quality of solutions over time and may converge to the optimal solution. This type of heuristics are very useful when the quality of solutions is more important than computational time. We believe that further development of a multistart local search heuristics based on the Hungarian algorithm may lead to a very competitive heuristics for (1) with hopefully competitive fast convergence to optimal solutions.

In the future, a more comprehensive experimental study of local search based on the Hungarian algorithm may be a very promising avenue of research.