A 2/3-Approximation Algorithm for Vertex-weighted Matching

TL;DR

This paper presents a 2/3-approximation algorithm for the maximum vertex-weighted matching problem in non-bipartite graphs, with efficient implementation and superior performance on large graphs compared to existing algorithms.

Contribution

It introduces a novel 2/3-approximation algorithm for non-bipartite graphs by limiting augmenting path length, with proven approximation ratio and practical efficiency.

Findings

Algorithm runs in under a minute on large graphs with tens of millions of vertices.

Outperforms existing algorithms in speed and solution quality on test problems.

Handles graphs where exact algorithms fail to terminate within 100 hours.

Abstract

We consider the maximum vertex-weighted matching problem (MVM) for non-bipartite graphs. In earlier work we have described a 2/3-approximation algorithm for the MVM on bipartite graphs (Dobrian, Halappanavar, Pothen and Al-Herz, SIAM J. Scientific Computing, 2019). Here we show that a 2/3-approximation algorithm for MVM on non-bipartite graphs can be obtained by restricting the length of augmenting paths to at most three. The algorithm has time complexity $O(m \log \Delta + n \log n)$, where $n$ is the number of vertices, $m$ is the number of edges, and $\Delta$ is the maximum degree of a vertex. The approximation ratio of the algorithm is obtained by considering failed vertices, i.e., vertices that the approximation algorithm fails to match but the exact algorithm does. We show that there are two distinct heavier matched vertices that we can charge each failed vertex to. Our proof techniques characterize the structure of augmenting paths in a novel way. We have implemented the 2/3-approximation algorithm and show that it runs in under a minute on graphs with tens of millions of vertices and hundreds of millions of edges. We compare its performance with five other algorithms: an exact algorithm for MVM, an exact algorithm for the maximum edge-weighted matching (MEM) problem, as well as three approximation algorithms. In our test set of nineteen problems, there are graphs on which the exact algorithms fail to terminate in 100 hours. The new 2/3-approximation algorithm for MVM outperforms the other approximation algorithms by either being faster (often by orders of magnitude) or obtaining better weights.

Figures

Tables

Table 1. Table 1: The set of test problems.

Graph	$\left|V\right|$	Degree			$\left|E\right|$
		Max.	Mean	SD/Mean
G34	2,000	4	4.00	0.00	4,000
G39	2,000	210	11.78	1.17	11,778
de2010	24,115	45	4.81	0.62	58,028
shipsec8	114,919	131	56.90	0.25	3,269,240
kron_g500-logn17	131,072	29,935	94.78	4.40	5,113,985
mt2010	132,288	139	4.83	0.74	319,334
fe_ocean	143,437	6	5.71	0.12	409,593
tn2010	240,116	89	4.97	0.60	596,983
kron_g500-logn19	524,288	80,674	106.46	5.76	21,780,787
tx2010	914,231	121	4.87	0.63	2,228,136
kron_g500-logn21	2,097,152	213,904	117.92	7.47	91,040,932
M6	3,501,776	10	5.99	0.14	10,501,936
hugetric-00010	6,592,765	3	2.99	0.01	9,885,854
rgg_n_2_23_s0	8,388,608	40	15.14	0.26	63,501,393
hugetrace-00010	12,057,441	3	2.99	0.01	18,082,179
nlpkkt200	16,240,000	27	26.60	0.09	215,992,816
hugebubbles-00010	19,458,087	3	2.99	0.01	29,179,764
road_usa	23,947,347	9	2.41	0.39	28,854,312
europe_osm	50,912,018	13	2.12	0.23	54,054,660

Table 2. Table 2: Running times (seconds) and relative performance of several exact and approximation algorithms for the MEM and MVM problems. The exact algorithms include the LEDA implementations for MEM, with no initialization and a fractional matching initialization, and the exact MVM algorithm described in this paper. The approximation algorithms include the 1/2-MVM, the 2/3-MVM, Round Robin 2 / 3 − ϵ 2 3 italic-ϵ 2/3-\epsilon MEM with ϵ = 0.01 italic-ϵ 0.01 \epsilon=0.01 with and without GPA initialization, and the 1 − ϵ 1 italic-ϵ 1-\epsilon -Scaling MEM approximation algorithm with ϵ = 1 / 3 italic-ϵ 1 3 \epsilon=1/3 . Vertex weights are random integers in the range [ 1 1000 ] delimited-[] 11000 [1\,1000] . The three groups of problems indicate those for which the LEDA implementation with no initialization terminated in under four hours; those for which the LEDA implementation with a fractional matching initialization terminated in under four hours but the first algorithm did not; and a problem for which none of the exact algorithms terminated in 100 hours.

	Time (s)	Relative Performance
Graph	Exact	Exact	Exact	$1-ϵ$	GPA, RR	RR	2/3-	1/2-
	LEDA1	LEDA2	MVM	Scal.	$2/3-ϵ$		MVM	MVM
				$ϵ=1/3$	$ϵ=0.01$
G34	1.4E-1	1.9E+0	1.3E+1	1.9E+1	2.0E+1	4.0E+1	4.5E+2	7.4E+2
G39	1.2E+0	1.0E+2	4.6E+1	9.4E+1	8.7E+1	1.5E+2	2.2E+3	5.7E+3
de2010	3.9E+0	1.4E+1	7.6E+0	2.7E+1	3.7E+1	8.0E+1	7.3E+2	1.3E+3
kron_g500-logn17	1.2E+2	1.4E+1	3.2E+1	3.0E+1	1.5E+1	6.9E+1	1.6E+3	4.4E+3
mt2010	1.5E+1	1.0E+1	1.1E+1	1.9E+1	2.2E+1	6.2E+1	4.3E+2	7.3E+2
fe_ocean	6.5E+2	7.8E-1	5.8E+0	8.7E+2	8.0E+2	2.0E+3	1.5E+4	2.5E+4
tn2010	2.3E+2	2.3E+1	1.7E+1	9.2E+1	1.6E+2	4.3E+2	3.2E+3	5.3E+3
kron_g500-logn19	6.1E+2	1.5E+1	3.5E+1	2.2E+1	1.4E+1	7.6E+1	1.8E+3	4.8E+3
tx2010	1.9E+3	2.9E+1	2.1E+1	1.5E+2	2.6E+2	7.2E+2	5.3E+3	1.0E+4
kron_g500-logn21	3.3E+3	1.6E+1	3.1E+1	1.8E+1	1.4E+1	6.2E+1	1.7E+3	5.2E+3
road_usa	1.2E+3	9.0E+0	1.8E+1	3.5E+0	6.8E+0	1.8E+1	1.2E+2	1.7E+2
europe_osm	4.1E+3	1.6E+1	4.9E+1	7.0E+0	1.1E+1	3.5E+1	2.1E+2	2.8E+2
Geo. Mean		1.2E+1	1.9E+1	3.5E+1	3.8E+1	1.1E+2	1.2E+3	2.4E+3
		Time (s)	Relative Performance
shipsec8		5.9E+0	2.1E-1	3.3E+0	1.1E+0	4.7E+0	9.9E+0	1.5E+2
M6		1.2E+3	6.5E-1	1.3E+1	3.1E+1	8.8E+1	5.7E+2	1.3E+3
hugetric-00010		3.7E+2	4.1E-1	3.9E+0	8.1E+0	2.1E+1	1.4E+2	2.2E+2
rgg_n_2_23_s0		6.0E+3	2.7E+0	3.7E+1	2.7E+1	8.6E+1	3.8E+2	1.7E+3
hugetrace-00010		6.4E+2	4.4E-1	3.9E+0	7.2E+0	2.0E+1	1.3E+2	2.0E+2
hugebubbles-00010		1.8E+3	5.7E-1	5.9E+0	1.2E+1	3.2E+1	2.2E+2	3.3E+2
Geo. Mean			5.8E-1	7.3E+0	9.3E+0	2.8E+1	1.4E+2	4.0E+2
				Time(s)
nlpkkt200				263.6	786.7	185.5	51.9	8.2

Table 3. Table 3: The weights computed by the exact MEM and MVM algorithms, and the gap to optimality of the weights of the matching obtained from the approximation algorithms. For the last problem, the weights are shown since the Exact algorithms did not terminate. Random integer weights in the range [1 1000] are used.

	Weight	Gap to optimal weight $(\%)$
Graph	Exact	$1-ϵ$-	GPA-RR	RR	2/3-	1/2-
	algs.	Scal.	$2/3-ϵ$		MVM	MVM
		$ϵ=1/3$	$ϵ=0.01$
G34	1.0E+6	1.89	0.31	0.30	0.47	2.88
G39	1.0E+6	1.63	0.04	0.06	0.06	2.92
de2010	1.2E+7	3.46	0.90	0.93	0.99	6.75
shipsec8	5.7E+7	0.02	0.00	0.00	0.00	0.05
kron_g500-
logn17	4.4E+7	5.82	1.97	2.09	2.13	14.47
mt2010	6.5E+7	3.86	1.10	1.14	1.21	7.61
fe_ocean	7.2E+7	1.06	0.14	0.15	0.21	2.26
tn2010	1.2E+8	3.46	0.95	0.99	1.04	7.02
kron_g500-
logn19	1.6E+8	5.29	1.72	1.81	1.95	14.33
tx2010	4.5E+8	2.25	0.83	0.87	0.94	6.40
kron_g500-
logn21	5.5E+8	5.05	1.52	1.61	1.79	14.09
M6	1.8E+9	0.70	0.16	0.16	0.21	2.39
hugetric-
00010	3.3E+9	1.57	0.50	0.64	0.81	4.43
rgg_n_2_23_s0	4.2E+9	0.20	0.03	0.03	0.03	0.56
hugetrace-
00010	6.0E+9	1.56	0.49	0.62	0.79	4.39
hugebubbles-
00010	9.7E+9	1.57	0.50	0.63	0.81	4.42
road_usa	1.2E+10	3.35	1.16	1.50	1.74	7.81
europe_osm	2.5E+10	3.08	0.53	1.81	2.00	6.77
Geom. Mean		1.64	0.33	0.39	0.46	3.88
		Weights
nlpkkt200		8.06E+09	8.07E+09	8.07E+09	8.08E+09	8.04E+09

Table 4. Table 4: The cardinality of the matchings obtained by the exact algorithms and the gap to optimality of the approximation algorithms. For the last problem, cardinalities are shown since the Exact algorithm did not terminate. Random integer weights in [1   1000].

	Card.	Gap to optimality ($\%$)
Graph	Exact	$1-ϵ$-	GPA, RR	RR	2/3-	1/2-
	algs.	Scal.	$2/3-ϵ$		MVM	MVM
		$ϵ=1/3$	$ϵ=0.01$
G34	1,000	7.59	2.53	2.53	3.58	9.01
G39	1,000	7.29	1.03	1.13	1.22	9.74
de2010	11,853	9.86	3.98	4.05	4.42	14.07
shipsec8	57,459	0.91	0.14	0.15	0.17	1.13
kron_g500-
logn17	38,823	6.82	2.90	3.06	2.85	16.93
mt2010	63,685	9.96	4.08	4.15	4.56	14.52
fe_ocean	71,718	6.10	1.75	1.77	2.41	8.19
tn2010	117,989	9.84	4.06	4.17	4.50	14.41
kron_g500
-logn19	136,770	5.65	2.40	2.51	2.45	16.24
tx2010	449,167	7.35	3.73	3.81	4.26	13.55
kron_g500-
logn21	482,339	5.16	2.10	2.21	2.21	15.69
M6	1,750,888	4.75	1.92	1.97	2.36	8.48
hugetric-
00010	3,296,382	6.96	3.34	3.54	4.63	11.61
rgg_n_2_23_s0	4,194,303	2.57	0.77	0.79	0.93	3.85
hugetrace-
00010	6,028,720	6.88	3.26	3.45	4.55	11.51
hugebubbles-
00010	9,729,043	6.94	3.32	3.52	4.61	11.58
road_usa	11,325,669	7.09	3.34	3.81	4.59	13.37
europe_osm	25,149,787	8.22	1.91	5.23	6.29	13.57
Geom. Mean		6.01	2.12	2.34	2.72	10.14
		Cardinality
nlpkkt200		7.88E+06	7.99E+06	7.99E+06	7.99E+06	7.82E+06

Table 5. Table 5: Running times (seconds) of the Exact algorithm, and relative performance of five algorithms: the 1/2-MVM; the 2/3-MVM; Round Robin, GPA followed by Round Robin 2 / 3 − ϵ 2 3 italic-ϵ 2/3-\epsilon -approximation MEM for ϵ = 0.01 italic-ϵ 0.01 \epsilon=0.01 ; and the 1 − ϵ 1 italic-ϵ 1-\epsilon -Scaling MEM approximation algorithm with ϵ = 1 / 3 italic-ϵ 1 3 \epsilon=1/3 . Vertex weights are random reals in the range [ 1 1.3 ] delimited-[] 11.3 [1\,1.3] . The last row shows the times of the approximation algorithms for a problem on which the exact algorithm did not terminate.

	Time (s)	Relative Performance
Graph	Exact	$1-ϵ$	GPA, RR	RR	2/3-	1/2-
	MVM	Scal.	$2/3-ϵ$		MVM	MVM
		$ϵ=1/3$	$ϵ=0.01$
G34	8.8E-3	6.4E+0	1.4E+0	2.8E+0	3.2E+1	4.1E+1
G39	1.7E-2	7.0E+0	1.4E+0	2.5E+0	3.6E+1	7.2E+1
de2010	2.3E-1	6.5E+0	2.3E+0	5.1E+0	5.0E+1	7.2E+1
shipsec8	6.5E+0	1.4E+1	1.2E+0	5.1E+0	1.1E+1	1.6E+2
kron_g500-
logn17	3.4E+0	3.6E+0	4.2E-1	2.0E+0	5.0E+1	1.2E+2
mt2010	7.3E-1	3.5E+0	1.1E+0	2.9E+0	2.2E+1	3.3E+1
fe_ocean	6.1E+1	4.5E+2	7.5E+1	1.9E+2	1.4E+3	2.3E+3
tn2010	4.9E+0	8.7E+0	3.3E+0	9.0E+0	7.1E+1	1.1E+2
kron_g500-
logn19	1.8E+1	2.4E+0	4.1E-1	2.2E+0	5.4E+1	1.3E+2
tx2010	3.4E+1	1.1E+1	4.5E+0	1.3E+1	1.0E+2	1.8E+2
kron_g500-
logn21	9.8E+1	2.0E+0	4.2E-1	1.9E+0	5.3E+1	1.6E+2
M6	6.4E+2	3.4E+1	1.6E+1	4.7E+1	3.2E+2	7.0E+2
hugetric-
00010	3.4E+2	1.7E+1	7.4E+0	2.0E+1	1.4E+2	2.0E+2
rgg_n_2_23_s0	6.5E+2	1.6E+1	3.0E+0	9.1E+0	4.6E+1	1.8E+2
hugetrace-
00010	5.7E+2	1.7E+1	6.5E+0	1.7E+1	1.2E+2	1.8E+2
hugebubbles-
00010	1.2E+3	1.8E+1	7.9E+0	2.1E+1	1.5E+2	2.2E+2
road_usa	4.8E+1	5.8E-1	2.9E-1	7.7E-1	5.2E+0	7.2E+0
europe_osm	7.2E+1	5.0E-1	2.0E-1	6.4E-1	3.8E+0	5.1E+0
Geom. Mean		7.7E+0	2.1E+0	6.1E+0	5.4E+1	1.1E+2
		Time (s)
nlpkkt200		4.35E+01	8.37E+02	1.90E+02	4.61E+01	8.03E+00

Table 6. Table 6: The weight obtained by the exact MEM and MVM algorithms, and the gaps to optimality of the matching computed by the approximation algorithms. For the last problem, weights are shown since the exact algorithm did not terminate. Random real-valued weights in the range [ 1 1.3 ] delimited-[] 11.3 [1\,1.3] are used.

	Weight	Gap to exact weight $(\%)$
Graph	Exact	$1-ϵ$-	GPA, RR	RR	2/3-	1/2-
	algs.	Scal.	$2/3-ϵ$		MVM	MVM
		$ϵ=1/3$	$ϵ=0.01$
G34	2.30E+03	1.89	2.27	2.23	3.17	8.16
G39	2.30E+03	1.90	0.99	1.22	1.05	8.78
de2010	2.73E+04	6.88	3.54	3.65	4.07	12.64
shipsec8	1.32E+05	0.00	0.13	0.13	0.14	0.99
kron_g500-
logn17	9.08E+04	5.71	2.72	2.87	2.74	16.33
mt2010	1.47E+05	6.29	3.69	3.77	4.09	13.27
fe_ocean	1.65E+05	1.44	1.55	1.56	2.13	7.23
tn2010	2.72E+05	6.43	3.66	3.74	4.05	13.07
kron_g500-
logn19	3.20E+05	5.92	2.31	2.43	2.38	15.76
tx2010	1.03E+06	3.71	3.34	3.44	3.82	12.28
kron_g500-
logn21	1.13E+06	5.51	2.02	2.13	2.15	15.26
M6	4.03E+06	0.82	1.70	1.74	2.08	7.50
hugetric-
00010	7.58E+06	2.73	2.97	3.17	4.13	10.30
rgg_n_2_23_s0	9.65E+06	0.07	0.68	0.70	0.81	3.34
hugetrace-
00010	1.39E+07	2.65	2.91	3.09	4.06	10.20
hugebubbles-
00010	2.24E+07	2.76	2.95	3.15	4.11	10.26
road_usa	2.62E+07	6.62	3.05	3.51	4.21	12.25
europe_osm	5.79E+07	6.33	1.73	4.79	5.73	12.15
Geom. Mean		3.79	2.35	2.64	3.06	10.63
		Weights
nlpkkt200		1.84E+7	1.84E+7	1.84E+7	1.84E+7	1.81E+7

Table 7. Table 7: The The cardinality of the matchings obtained by the exact algorithms and the gap to optimality of the approximation algorithms. For the last problem, cardinalities are shown since the Exact algorithm did not terminate. Random real weights in [ 1 1.3 ] delimited-[] 11.3 [1\,1.3] .

	Card.	Gap to optimality ($\%$)
Graph	Exact	$1-ϵ$-	GPA, RR	RR	2/3-	1/2-
	algs.	Scal.	$2/3-ϵ$		MVM	MVM
		$ϵ=1/3$	$ϵ=0.01$
G34	1,000	2.08	2.57	2.52	3.58	9.25
G39	1,000	2.04	1.13	1.39	1.20	9.76
de2010	11,853	7.26	3.94	4.06	4.53	13.96
shipsec8	57,459	0.00	0.15	0.15	0.17	1.15
kron_g500-
logn17	38,823	4.99	2.86	3.01	2.85	16.92
mt2010	63,685	6.54	4.09	4.18	4.53	14.56
fe_ocean	71,718	1.58	1.76	1.77	2.41	8.20
tn2010	117,989	6.75	4.07	4.16	4.50	14.41
kron_g500-
logn19	136,770	5.17	2.41	2.53	2.46	16.24
tx2010	449,167	3.84	3.73	3.82	4.26	13.57
kron_g500-
logn21	482,339	4.70	2.10	2.22	2.21	15.67
M6	1,750,888	0.90	1.93	1.98	2.36	8.49
hugetric-
00010	3,296,382	2.91	3.34	3.55	4.63	11.62
rgg_n_2_23_s0	4,194,303	0.08	0.78	0.80	0.93	3.85
hugetrace-
00010	6,028,720	2.83	3.27	3.46	4.55	11.51
hugebubbles-
00010	9,729,043	2.95	3.32	3.52	4.61	11.58
road_usa	11,325,669	6.73	3.35	3.82	4.59	13.38
europe_osm	25,149,787	6.67	1.91	5.24	6.29	13.57
Geom. Mean		3.81	2.60	2.91	3.38	11.63
		Cardinality
nlpkkt200		8.00E+06	7.99E+06	7.99E+06	7.99E+06	7.82E+06

Equations

$$\sum _{u}d(u)\log d(u)\le \sum _{u}d(u)\log \Delta =m\log \Delta .$$

Full text

The approximation ratio of the algorithm is obtained by considering failed vertices, i.e., vertices that the approximation algorithm fails to match but the exact algorithm does. We show that there are two distinct heavier matched vertices that we can charge each failed vertex to. Our proof techniques characterize the structure of augmenting paths in a novel way.

We have implemented the $2/3$-approximation algorithm and show that it runs in under a minute on graphs with tens of millions of vertices and hundreds of millions of edges. We compare its performance with five other algorithms: an exact algorithm for MVM, an exact algorithm for the maximum edge-weighted matching (MEM) problem, as well as three approximation algorithms. The approximation algorithms include a $1/2$-approximation algorithm for MVM, and $(2/3-\epsilon)$- and $(1-\epsilon)$-approximation algorithms for the MEM. In our test set of nineteen problems, there are graphs on which the exact algorithms fail to terminate in $100$ hours. In addition, the new $2/3$-approximation algorithm for MVM outperforms the other approximation algorithms by either being faster (often by orders of magnitude) or obtaining better weights.

1 Introduction

We consider a variant of the matching problem in non-bipartite graphs in which weights are assigned to the vertices of a graph, the weight of a matching is the sum of the weights of the matched vertices, and we find a matching of maximum weight. We call this the maximum vertex-weighted matching problem (MVM). In this paper we describe a $2/3$-approximation algorithm for the MVM that has $O(m\log\Delta+n\log n)$ time complexity, where $n$ is the number of vertices, $m$ is the number of edges, and $\Delta$ is the maximum degree of a vertex. We implement this algorithm as well as a few other approximation algorithms for this problem, and show that the $2/3$-approximation algorithm runs fast on large graphs, obtains weights that are close to optimal, and is faster or obtains greater weights than the other algorithms on our test set.

Consider an undirected vertex weighted graph $G=(V,E,\phi)$, where $|V|\equiv n$ is the number of vertices, $|E|\equiv m$ is the number of edges, and $\phi:V\mapsto R_{\geq 0}$ is a non-negative weight function on the vertices. The MVM problem can be solved in polynomial time by an exact algorithm [26] with $O(\sqrt{n}m\log n)$ time complexity. We have designed and implemented an exact algorithm with $O(mn)$ time complexity [7], since it is easier to implement, and it is well-known that the practical performance of a matching algorithm does not necessarily correlate with its worst-case time complexity. We show that this exact algorithm can be slow for many large graphs with millions of vertices and edges, and can even fail to terminate in $100$ hours. Thus, there is a need for faster approximation algorithms that can return a matching with a guaranteed fraction of the maximum weight.

Many linear time approximation algorithms have been designed for the maximum edge weighted matching problem (MEM), but we are not aware of earlier approximation algorithms for the MVM problem on non-bipartite graphs. We have designed and implemented a $2/3$-approximation algorithm for MVM in bipartite graphs [7]. The MVM problem arises in applications such as the design of network switches [27], schedules for training of astronauts [4], computation of sparse bases for the null space or the column space of a rectangular matrix [5, 22, 23], etc.

The MVM problem can be transformed to a maximum edge weighted matching problem (MEM) by assigning each edge a weight obtained by summing the weights at its endpoints. Hence algorithms for the MEM can be used to solve MVM problems. However, we have shown that this transformation can lead to increase in run times for an exact algorithm by three orders of magnitude or more [7]. A simpler and more efficient exact algorithm is obtained by solving the MVM problem directly by processing vertices in non-increasing order of weights and then matching an unmatched vertex to a heaviest unmatched neighbor it can reach by augmenting paths. In this sense the MVM problem is more similar to maximum cardinality matching than MEM. When we consider approximation algorithms, restricting augmenting paths to length three does not lead to $2/3$-approximation algorithm for the MEM; however $2/3-\epsilon$-algorithms are available [21]. The first $2/3$-approximation algorithm for MVM on bipartite graphs was proposed by us and our coauthors [7]. The idea is to decompose the problem into two ‘one-side-weighted’ problems, solve them individually by restricting the length of augmenting paths to at most three, and then combine the two matchings into a final matching by invoking the Mendelsohn-Dulmage theorem [20]. However, the proof technique used for bipartite graphs cannot be extended to non-bipartite graphs because the Mendelsohn-Dulmage theorem applies only to the former. While the algorithm is simple to state, the proof that its approximation ratio is $2/3$ requires several new concepts and involves a careful study of the structure of augmenting paths.

2 Background and Related Work

2.1 Background on Matchings

We define the basic terms we use here, and additional background on matchings is available in several books, such as [25]. The endpoints of an edge $(u,v)$ are the vertices $u$ and $v$. A matching $M$ in a graph $G=(V,E)$ is a set of edges that do not share a common end-point; hence at most one edge from $M$ is incident on each vertex in the graph. An edge $(u,v)\in E$ is matched if $(u,v)\in M$, and otherwise it is unmatched. A vertex $v\in V$ is matched if it is an end point of a matched edge, and otherwise it is unmatched. A heaviest unmatched neighbor of $u$ is denoted by $HUN(u)$; note that $HUN(u)$ might not be unique, but its weight is.

A path $P$ in $G$ is a finite sequence of distinct vertices $\{v_{i},v_{i+1},..v_{i+k}\}$ such that $(v_{j},v_{j+1})\in E$ for $i\leq j\leq i+k-1$. The length of a path $|P|$ is the number of edges in the path. A cycle is a path such that the first and the last vertex are the same. An alternating path $P$ with respect to $M$ is a path whose edges alternate between $M$-matched and $M$-unmatched edges. If the first and last vertices on an $M$-alternating path $P$ are unmatched, then it is an $M$-augmenting path, which necessarily has an odd number of edges. The matching $M$ can be augmented by matching the edges in the symmetric difference $M\oplus P$.

When an augmentation is performed, we distinguish between the origin (the vertex from which an augmenting path search is initiated), and the terminus (the vertex at which the augmenting path search ends). We will denote the origin of the $i-$th augmentation step by $o_{i}$, and the terminus by $t_{i}$, where $i\geq 1$. When a vertex is not explicitly denoted by $o_{i}$ or $t_{i}$, then it could be either an origin or a terminus, or neither, unless mentioned otherwise. Note that if we begin with the empty matching, then for each matched edge we need one augmentation step, so that $|M|$ is equal to the number of origins or termini. We will say that the $i$-th origin and the $i$-th terminus correspond to each other, so that $o_{i}(t_{i})$ is the corresponding vertex of the vertex $t_{i}(o_{i})$. An alternating path $P$ with respect to two matchings, $M_{1}\oplus M_{2}$, is a path whose edges alternate between $M_{1}$-matched edges and $M_{2}$-matched edges.

2.2 Related Work

We now describe more fully the work we have done earlier with our colleagues on exact algorithms for MEM on general graphs, and a $2/3$-approximation algorithm for this problem on bipartite graphs [7]. When vertex weights are non-negative, we can choose a maximum vertex-weighted matching to be one of maximum cardinality, and from now on we assume that this choice has been made.

For a matching $M$, an $M$-reversing path * is an alternating path with even number of edges consisting of an equal number of matched and unmatched edges. An $M$-increasing path* is an $M$-reversing path whose unmatched endpoint has higher weight than its matched endpoint. By switching the matched and unmatched edges on this path, we can increase the weight of the matching, much as we would using an augmenting path. There are two ways of characterizing maximum vertex-weighted matchings in a general graph. The first is that a matching $M$ is an MVM if and only if there is $(i)$ neither an $M$-augmenting path ($(ii)$ nor an $M$-increasing path in the graph. The second is to list the weights of matched vertices in non-increasing order in a vector (this is the weight vector of the matching $M$). Then a matching $M$ is an MVM if and only if its weight vector is lexicographically maximum among all the weight vectors of matchings.

These two characterizations lead to two extreme algorithms for computing an MVM. The first begins with the empty matching, and at each step matches a currently heaviest unmatched vertex to a heaviest unmatched vertex it can reach by augmenting path. In this algorithm once a vertex is matched, it will always remain matched, since augmentation does not change a matched vertex to an unmatched vertex.

An algorithm with the approximation ratio of $2/3$ for MVM on bipartite graphs was designed and implemented in [7].

The second exact algorithm for solving the MVM problem begins with a maximum cardinality matching. It then looks for increasing paths or cycles with respect to the current matching and terminates when there are none such. This second, speculative, algorithm has the advantage that it has more concurrency whereas the first algorithm has to process vertices in a specified order. We will discuss the speculative algorithm in future work.

Now we turn to approximation algorithms that have been designed for the maximum edge weighted matching problem (MEM). The well-known Greedy algorithm [3] iteratively adds a heaviest edge to the matching, and deletes all edges incident on the endpoints of the added edge. This algorithm is $1/2$-approximate and requires $O(m\log n)$ time. Another $1/2$-approximation algorithm, the Locally Dominant edge algorithm [24], avoids sorting the edges by choosing locally dominant edges (an edge that is the heaviest edge incident on both of its endpoints) to add to the matching. A more recent $1/2$-approximation algorithm is the Suitor algorithm [16], which employs a proposal-based approach similar to the classical algorithms for stable matching. The Suitor and other algorithms have been extended to find $1/2$-approximate $b$-Matchings [15]. Other papers improve the performance ratios: For any fixed $\epsilon>0$, $(2/3-\epsilon)$- and $(3/4-\epsilon)$-approximation algorithms have been proposed [8, 9, 13, 21, 17]. Furthermore, a $(1-\epsilon)$-approximation algorithm, based on a scaling approach has been proposed by Duan and Pettie [10] which has time complexity $O(m\,\epsilon^{-1}\log(\epsilon^{-1}))$. We show that the $(1-\epsilon)$-approximation algorithm when applied to the MVM problem is significantly slower than the $1/2$- and $2/3$-approximation algorithms, and surprisingly, does not compute greater matching weights for relevant values of $\epsilon$. The MEM problem appears in applications such as placing large elements on the diagonal of sparse matrices [11, 12], multilevel graph partitioning [14], scheduling, etc.

3 A Two-third Approximation Algorithm for MVM

In this section we describe a $2/3$-approximation algorithm for MVM, discuss its relation to an exact algorithm, and then prove its correctness.

3.1 Exact and $2/3$-Approximation Algorithms

The approximation algorithm, described in Algorithm 1, sorts the vertices in non-increasing order of weights, and inserts the sorted vertices into a queue $Q$. The algorithm begins with the empty matching, and attempts to match the vertices in $Q$ in the given order. Each unmatched vertex $u$ is removed from $Q$, and beginning at $u$ the algorithm searches for a heaviest unmatched vertex $v$ reachable by an augmenting path of length at most three. If such an augmenting path is found, then the matching is augmented by the path that leads to a heaviest unmatched vertex, and the vertex $v$ is also removed from $Q$. If no augmenting path of length at most three is found, we search from the next heaviest unmatched vertex (even though longer augmenting paths might exist in the graph). The algorithm terminates when all vertices are processed.

The $2/3$-approximation algorithm may be viewed as one obtained from an exact algorithm for MVM. In the exact algorithm for MVM, at each step we search from a currently heaviest unmatched vertex for a heaviest unmatched vertex reachable by an augmenting path of any length. If an augmenting path is found, we choose the path that leads to a heaviest unmatched vertex, and then augment by this path. If no augmenting path is found, we search from the next heaviest unmatched vertex. This algorithm was proved correct by Dobrian, Halappanavar, Pothen and Al-Herz in [7]. The time complexity of this algorithm is $O(nm)$.

Consider running the Exact algorithm and the 2/3-approximation algorithm simultaneously using the vertices in the same queue $Q$. Both consider vertices in non-increasing order of weights, and break ties among weights consistently. If a vertex $u$ is matched by the exact algorithm but not by the approximation algorithm (because the augmenting path is longer than three), then we call $u$ a failure or a failed vertex, because the approximation algorithm failed to match it while the exact algorithm succeeded.

3.2 Time Complexity of the Two-Thirds Approximation Algorithm

Theorem 3.1

The time complexity of the Two-Thirds approximation algorithm is $O(m\log\Delta+n\log n)$, where $\Delta$ is the maximum degree.

Proof: We sort the adjacency list of each vertex in non-increasing order of weights, and maintain a pointer to a heaviest unmatched neighbor of each vertex. Since the adjacency list is sorted, each list is searched once from highest to lowest weight in the algorithm.

Let $N(u)$ be the set of neighbors of a vertex $u$ and $d(u)=|N(u)|$. In each iteration of the while loop, we choose an unmatched vertex $u$ and examine all vertices in $N(u)$ to find a heaviest unmatched neighbor, if one exists. If $u$ has a matched neighbor $v$, then we form an augmenting path of length three by taking the matched edge $(v,w)$, and finding a heaviest unmatched neighbor $x$ of $w$. All neighbors of $u$, unmatched and matched, can be found in $O(d(u))$ time, and finding the matched vertex $w$ and a heaviest unmatched neighbor $x$ can be done in constant time, since the adjacency lists are sorted. Thus the search for augmenting paths in the algorithm takes $O(m)$ time. Sorting the adjacency lists takes time proportional to

[TABLE]

Sorting the vertices in non-increasing order of weights takes $O(n\log n)$ time. $\quad\blacksquare$

3.3 Correctness of the Algorithm

In this subsection we will prove (Theorem 3.7) that Algorithm 1 computes a $\frac{2}{3}$-approximate MVM, $M_{A}$. Let $\phi(F)$ denote the sum of the weights of the failures, $\phi(M_{A})$ the weight of the approximate matching, and $\phi(M_{opt})$ the weight of an optimal matching. In order to prove the theorem, it suffices to prove that $\phi(F)\leq\frac{1}{2}\phi(M_{A})$, since $\phi(M_{opt})\leq\phi(M_{A})+\phi(F)$.

To prove that $\phi(F)\leq\frac{1}{2}\phi(M_{A})$, we show that for every failure there are two distinct vertices that are matched in $M_{A}$, with weight at least as heavy as the failure. This is achieved in Lemma 3.6 by considering $M_{opt}\oplus M_{A}$-alternating paths, using a charging technique in which each failure charges two distinct vertices matched in $M_{A}$. Each failure is an endpoint of the $M_{opt}\oplus M_{A}$-alternating path. The two distinct vertices are obtained as the corresponding vertices (the other ends of the augmenting paths) of two of the first three vertices on the $M_{opt}\oplus M_{A}$-alternating path.

We prove the approximation ratio by means of several Lemmas. The key Lemma 3.6 is proved using Lemmas 3.2, 3.3, 3.4 and  3.5. We begin by proving each of the latter Lemmas.

Lemma 3.2

Let $(u,v)$ be a matched edge in a matching $M$ at some step in the $2/3$-approximation algorithm, and let $w=HUN(v)$ be a heaviest unmatched neighbor of $v$. Suppose $(u,v)$ is changed to a matched edge $(u,v^{\prime})$ in a future augmentation step, and let $w^{\prime}=HUN(v^{\prime})$ denote a heaviest unmatched neighbor of $v^{\prime}$, then $\phi(w)\geq\phi(w^{\prime})$.

Proof: The proof is by induction on $i$, the number of augmentation steps that include $u$ on the augmenting path. Let $v^{\prime}_{i}$ be the matched neighbor of $u$ after $i$ augmentation steps involving $u$, and let $w^{\prime}_{i}$ be its heaviest unmatched neighbor $HUN(v^{\prime}_{i})$. There are two possible augmentation steps that include the matched edge $(u,v)$. (1) $\{o_{i},u,v,t_{i}\}$, and (2) $\{o_{i},v,u,t_{i}\}$, where $o_{i}$ ($t_{i}$) is the origin (terminus) of the augmenting path.

For the base case, $i=1$), consider Figure 1. If the augmentation path is $\{o_{1}=w,v,u,t_{1}=v^{\prime}_{1}\}$, clearly $\phi(w)\geq\phi(w^{\prime}_{1})$, since the algorithm processes vertices in non-increasing order of weights. If the augmenting path is $\{o_{1}=v^{\prime}_{1},u,v,t_{1}=w\}$, then $\phi(w)\geq\phi(w^{\prime}_{1})$ because $w$ was matched in preference to $w^{\prime}_{1}$.

Assume the claim is true for $k$ augmentation steps. By using the same argument as in the base case we have $\phi(w^{\prime}_{k})\geq\phi(w^{\prime}_{k+1})$ at the $k+1$-st augmentation step. Now by the inductive hypothesis we have $\phi(w)\geq\phi(w^{\prime}_{k})$, and by combining the two inequalities, we obtain $\phi(w)\geq\phi(w^{\prime}_{k+1})$. $\quad\blacksquare$

Lemma 3.3

*Let $M_{A}^{x}$ denote the $2/3$-approximate matching at the $x^{\text{th}}$ failure $f_{x}$, and let $P=\{f_{x},v_{1},v_{2},...\}$ be an alternating path that begins with $f_{x}$ in $M_{opt}\oplus M_{A}^{x}$.

(1) If $v_{1}$ is an origin $o_{i}$ of some prior augmentation step, then $\phi(t_{i})\geq\phi(f_{x})$.

(2) $\phi(v_{2})\geq\phi(f_{x})$.*

Proof: (1) If $v_{1}$ is an origin $o_{i}$, then we have $\phi(t_{i})\geq\phi(f_{x})$, because $t_{i}$ was matched in preference to $f_{x}$.

(2) In this case, we have to consider three possibilities.

(a) The vertex $v_{2}$ is an origin, in which case $\phi(v_{2})\geq\phi(f_{x})$, since $v_{2}$ was processed before $f_{x}$.

(b) The vertex $v_{2}$ is a terminus that is matched by an augmenting path that includes $v_{1}$. An example of this case is shown in Figure 2. In this case we have two possibilities: either $v_{1}$ is an origin and $v_{2}$ is the corresponding terminus, or $v_{1}$ is previously matched in which case we have an augmenting path $\{o_{i},x,v_{1},v_{2}\}$. In both possibilities $v_{2}$ was matched in preference to $f_{x}$, so $\phi(v_{2})\geq\phi(f_{x})$.

(c) The vertex $v_{2}$ is a terminus that is matched by an augmenting path that includes a vertex $u\neq v_{1}$, where $u$ is adjacent to $v_{2}$. An example of this case is shown in Figure 3. Let $HUN(u)$ be a heaviest unmatched neighbor of $u$ after $v_{2}$ is matched. In this case, again we have two possibilities: $u$ is an origin and $v_{2}$ is the corresponding terminus, or $u$ is previously matched in which case we have an augmenting path $\{o_{i},x,u,v_{2}\}$. In both possibilities $v_{2}$ was matched in preference to $HUN(u)$ so we have $\phi(v_{2})\geq\phi(HUN(u))$. By Lemma 3.2 when the matched edge $(u,v_{2})$ is changed to the matched edge $(v_{1},v_{2})$, we have $\phi(HUN(u))\geq\phi(f_{x})$. By combining these two inequalities, we obtain $\phi(v_{2})\geq\phi(f_{x})$. $\quad\blacksquare$

Lemma 3.4

*Let $M_{A}^{x}$ denote the $2/3$-approximate matching at the $x^{\text{th}}$ failure $f_{x}$, and let $P=\{f_{x},v_{1},v_{2},v_{3},...\}$ be an $M_{opt}\oplus M_{A}^{x}$-alternating path that begins with $f_{x}$. If the vertex $v_{3}$ is an origin $o_{i}$ of some prior augmentation step in the Approximation algorithm, and if $\phi(t_{i})<\phi(f_{x})$, then 1) immediately prior to the step when the Approximation algorithm matches the vertex $v_{3}$, the vertex $v_{2}$ is matched to a vertex $u\neq v_{1}$, and $\{v_{2},v_{3},u\}$ is a cycle.

2. the $i$-th augmenting path is $\{v_{3}=o_{i},u,v_{2},t_{i}\}$.*

Proof:

1. First we will establish that $v_{2}$ is matched to some vertex $u$ prior to the step when $v_{3}$ is matched. To obtain a contradiction, assume that $v_{2}$ is not matched to some vertex $u$ prior to the step of matching $v_{3}$. Then after $v_{3}$ is matched, the terminus $t_{i}$ is either $v_{2}$ or a vertex that is matched in preference to $v_{2}$. In both possibilities we have $\phi(t_{i})\geq\phi(v_{2})$. We know from Lemma 3.3 that $\phi(v_{2})\geq\phi(f_{x})$. Combining the two inequalities, we have $\phi(t_{i})\geq\phi(f_{x})$, which contradicts the assumption in the Lemma.

Now we show that the vertex $u\neq v_{1}$. Assume for a contradiction that $u=v_{1}$, then at the step of matching $v_{3}$ there exists an augmenting path from $v_{3}$ to $f_{x}$ of length three. After we match $v_{3}$, we have $\phi(t_{i})\geq\phi(f_{x})$, since it was matched in preference to $f_{x}$. This again contradicts the assumption in the Lemma.

Now we show that $\{v_{2},v_{3},u\}$ is a cycle by showing that $v_{3}=HUN(u)$. Assume $v_{3}\neq HUN(u)$ and let some vertex $q=HUN(u)$, as shown in Figure 4. Note that by Lemma 3.2 we have $\phi(q)\geq\phi(HUN(v_{1}))\geq\phi(f_{x})$ (A), since we know the matching edge $(v_{2},u)$ is changed to $(v_{2},v_{1})$. Also, immediately prior to the step when $v_{3}$ is matched, there exists an augmenting path of length three from $v_{3}$ to $q$. So after we match $v_{3}$, $t_{i}$ is either $q$ or a vertex that is matched in preference to $q$, so $\phi(t_{i})\geq\phi(q)$ (B). Combining (A) and (B) we get $\phi(t_{i})\geq\phi(f_{x})$. Thus, $v_{3}=HUN(u)$. Hence $\{v_{2},v_{3},u\}$ is a cycle since we have established the existence of the edge $(u,v_{3})$ (the existence of the other two edges of the cycle were established earlier).

2. We establish this result by contradiction as well. Suppose the augmenting path is not $\{o_{i},u,v_{2},t_{i}\}$. Then we have two cases:

Case 1: The augmenting path is $\{o_{i},v_{2},u,t_{i}\}$ as shown in Figure 5. In this case there must exist an unmatched vertex $w$ adjacent to $v_{3}$, since after matching the edge $(v_{2},v_{3})$ it must be changed to $(v_{2},v_{1})$ by an augmenting path of length three. After matching $v_{3}$, assume without loss of generality that $w$ becomes $HUN(v_{3})$. After the augmentation step, we have $\phi(t_{i})\geq\phi(w)$ (A), since there existed an augmenting path from $v_{3}$ to $w$ when $t_{i}$ was matched. Also, $(v_{2},v_{3})$ was matched in this step, and it must be changed to the matched edge $(v_{2},v_{1})$. By Lemma 3.2 we have $\phi(w=HUN(v_{3}))\geq\phi(HUN(v_{1}))\geq\phi(f_{x})$ (B). Combining (A) and (B), we obtain $\phi(t_{i})\geq\phi(f_{x})$. Again we have a contradiction of the condition of the Lemma.

Case 2: The augmentation step does not include the edge $(v_{2},u)$ as shown in Figure 6. In this case there must exist an unmatched vertex $q$ adjacent to $u$ since the matched edge $(v_{2},u)$ must be changed to $(v_{2},v_{1})$ by an augmenting path of length three. After matching $v_{3}$, assume without loss of generality that $q$ becomes $HUN(u)$. After the augmentation step, we have $\phi(t_{i})\geq\phi(q)$ (A), since there existed an augmenting path from $v_{3}$ to $q$. Note that $(v_{2},u)$ is still matched and must be changed to $(v_{2},v_{1})$. By Lemma 3.2 $\phi(q=HUN(u))\geq\phi(HUN(v_{1}))\geq\phi(f_{x})$ (B). Again, combining (A) and (B), we obtain $\phi(t_{i})\geq\phi(f_{x})$.

In both cases we obtain $\phi(t_{i})\geq\phi(f_{x})$, a contradiction to the condition of the Lemma. Therefore, the $i$-th augmentation step must be $\{v_{3}=o_{i},u,v_{2},t_{i}\}$. $\quad\blacksquare$

Lemma 3.5

Consider the symmetric difference $M_{opt}\oplus M_{A}^{x}$, corresponding to the $2/3$-approximate matching at the $x$-th failure. Let $P=\{f_{x},v_{1},v_{2},v_{3},v_{4}\}$ be an $M_{opt}\oplus M_{A}^{x}$-alternating path, then the alternating subpath $P=\{f_{x},v_{1},v_{2},v_{3}\}$ will not change in future augmentation steps of the approximation algorithm.

Proof: Assume for the sake of contradiction that after $f_{x}$ is determined to be a failure, the edge $(v_{1},v_{2})$ is changed by a future augmenting path of length three, say $\{u,v_{1},v_{2},q\}$, as shown in Figure 7. Then, the augmenting path $\{f_{x},v_{1},v_{2},q\}$ must exist when $f_{x}$ was determined as a failure, and in this case $f_{x}$ could not have been a failure. Hence the matched edge $(v_{1},v_{2})$ in the approximate matching $M_{A}^{x}$ cannot be changed in future augmentations. $\quad\blacksquare$

Lemma 3.6

Consider the symmetric difference $M_{opt}\oplus M_{A}$, where $M_{A}$ is the matching computed by the $2/3$-Approximation algorithm. For every failure $f$ there are two distinct matched vertices in $M_{A}$ that are at least as heavy as $f$.

Proof: First run the approximation algorithm and at the $i$-th augmentation step label the origin by $o_{i}$ and the terminus by $t_{i}$. Recall that we denote $o_{i}$ as the corresponding vertex of $t_{i}$, and vice versa. Consider the symmetric difference between $M_{opt}$ and $M_{A}$ which results in alternating paths and cycles. We can ignore alternating cycles since every vertex in a cycle is matched in both $M_{opt}$ and $M_{A}$. Since failures are matched by the optimal matching but not the approximate matching, they are at the ends of alternating paths.

By Lemma 3.5 the first four vertices of an alternating path beginning with a failure do not change, which makes it possible to identify the origins and termini which are used to construct the alternating path. We will number each failure $f_{x}$ in the order that it was discovered in the approximation algorithm. A failure $f_{x}$ could be an end of an alternating path which has one failure or two failures. We will consider these two types of alternating paths in the following.

$(i)$ First consider an alternating path with one failure, and denote the path as $P=\{f_{x},v_{1}^{x},v_{2}^{x},v_{3}^{x},v_{4}^{x}\}$. We charge two distinct vertices for $f_{x}$ as follows:

$(i-1)$ If the vertex $v_{1}^{x}$ is a terminus, then charge the corresponding origin, which must be at least as heavy as the failure $f_{x}$ since it was processed before $f_{x}$. If $v_{1}^{x}$ is an origin then charge the corresponding terminus, which by Lemma 3.3 (1) must be at least as heavy as $f_{x}$.

$(i-2)$ If the vertex $v_{3}^{x}$ is a terminus, then charge the corresponding origin which must be at least as heavy as the failure $f_{x}$ since it was processed before $f_{x}$. If $v_{3}^{x}$ is an origin, and the corresponding terminus is at least as heavy as $f_{x}$, then charge the corresponding terminus. If the corresponding terminus is strictly lighter than $f_{x}$, then by Lemma 3.4 we have immediately prior to the step in which $v_{3}^{x}$ is matched, the vertex $v_{2}^{x}$ is matched to some vertex $u$, $u\neq v_{1}^{x}$ such that $\{v_{2}^{x},v_{3}^{x},u\}$ is a cycle, as shown in Figure 8. In this case we consider $v_{2}^{x}$ instead of $v_{3}^{x}$ to find a vertex to charge. If the vertex $v_{2}^{x}$ is a terminus (in a prior augmentation step), then charge the corresponding origin which must be at least as heavy as $f_{x}$, since it was processed before the latter. If $v_{2}^{x}$ is an origin in the prior augmentation step, then charge the corresponding terminus which must be at least as heavy as $f_{x}$ since it was matched in preference to $v_{3}^{x}$ which is an origin.

$(ii)$ Now we consider an alternating path with two failures $f_{x}$ and $f_{y}$ as its endpoints. We assume without loss of generality that $\phi(f_{x})\geq\phi(f_{y})$.

For the failure $f_{x}$ we charge two distinct vertices as we did in Part $(i)$ of this Lemma. Now we consider charging for the failure $f_{y}$. If the length of the alternating path is at least seven edges, then we can label two alternating subpaths $\{f_{x},v_{1}^{x},v_{2}^{x},v_{3}^{x}\}$ and $\{f_{y},v_{1}^{y},v_{2}^{y},v_{3}^{y}\}$, and these do not overlap. Hence we can charge two distinct vertices for $f_{y}$ as we did in Part $(i)$ of the Lemma.

If the length of the alternating path is five then $\{v_{2}^{x},v_{3}^{x}\}$ and $\{v_{2}^{y},v_{3}^{y}\}$ overlap. Thus $v_{2}^{x}=v_{3}^{y}$, and $v_{3}^{x}=v_{2}^{y}$. So, we charge one vertex $v_{1}^{y}$ for $f_{y}$ as we did in $(i-1)$ and we will charge the other distinct vertex as follows.

Case 1: If $f_{x}$ charged the corresponding vertex of $v_{2}^{x}$ then $f_{y}$ must charge the corresponding vertex of $v_{2}^{y}=v_{3}^{x}$. Referring to $(i-2)$, the vertex $f_{x}$ charged the corresponding vertex of $v_{2}^{x}$ because $v_{3}^{x}=v_{2}^{y}$ must be an origin and the corresponding terminus is strictly lighter than $f_{x}$. Let the origin $v_{3}^{x}$ be denoted by $o_{i}$, and the corresponding terminus be $t_{i}$, for some augmentation step $i$. By Lemma  3.4 we have (1) at the step of matching $v_{3}^{x}$ but before it is matched, $v_{2}^{x}$ is matched to some $u$, where $u\neq v_{1}^{x}$, and $\{v_{2}^{x},v_{3}^{x},u\}$ is a cycle; (2) the augmenting path is $\{v_{3}^{x}=o_{i},u,v_{2}^{x},t_{i}\}$.

We will show that $\phi(t_{i})\geq\phi(f_{y})$, and thus $f_{y}$ can be charged to $t_{i}$. We consider two subcases:

Subcase 1: $f_{y}$ is adjacent to $u$, as shown in Figure 9. Note that $\phi(t_{i})\geq\phi(f_{y})$, since at the step of matching $v_{3}^{x}$ there existed an augmenting path from $v_{3}^{x}$ to $f_{y}$.

Subcase 2: The failure $f_{y}$ is not adjacent to $u$ as shown in Figure 10. Note there must exist some unmatched vertex $q$ that is adjacent to $u$ because after augmenting by the path $\{v_{3}^{x}=o_{i},u,v_{2}^{x},t_{i}\}$ the matched edge $(v_{2}^{y}=v_{3}^{x},u)$ must be changed to $(v_{2}^{y},v_{1}^{y})$, which can be done with an augmenting path of length three. After the augmentation step, we have $\phi(t_{i})\geq\phi(q)$ (A), because there existed an augmenting path from $v_{2}^{y}$ to $q$. After $v_{2}^{y}$ is matched, assume without loss of generality that $q=HUN(u)$. By Lemma 3.2, after $(v_{2}^{y},u)$ is changed to $(v_{2}^{y},v_{1}^{y})$ we have $\phi(q=HUN(u))\geq\phi(HUN(v_{1}^{y}))\geq\phi(f_{y})$ (B). Combining (A) and (B) we obtain $\phi(t_{i})\geq\phi(f_{y})$.

Case 2: If $f_{x}$ charged the corresponding vertex of $v_{3}^{x}=v_{2}^{y}$, then $f_{y}$ must charge the corresponding vertex of $v_{3}^{y}=v_{2}^{x}$. We will show that the corresponding vertex of $v_{3}^{y}$ is at least as heavy as $f_{y}$. Suppose that the corresponding vertex is strictly lighter than $f_{y}$ which is true if it is a terminus, say $t_{i}$ in the $i$th augmenting step. By Lemma 3.4 we have (1) at the step when the vertex $v_{3}^{y}$ is matched but prior to matching it, the vertex $v_{2}^{y}$ is matched to some $u$, with $u\neq v_{1}^{y}$, such that $\{v_{2}^{y},v_{3}^{y},u\}$ is a cycle; and (2) the augmenting path is $\{v_{3}^{y}=o_{i},u,v_{2}^{y},t_{i}\}$. By symmetry and using the same argument as in Case 1 we get $\phi(t_{i})\geq\phi(f_{x})$. Since by assumption we have $\phi(f_{x})\geq\phi(f_{y})$, it follows that $\phi(t_{i})\geq\phi(f_{y})$.

Note that each matched vertex has a unique corresponding vertex, since once they (the vertex and its corresponding vertex) are matched they will not be unmatched. So, to charge a vertex twice, a vertex $u$ must be considered by two failures (and the corresponding vertex of $u$ must be charged twice). But two failures cannot consider the same vertex. For two failures in different alternating paths, it is not possible since the alternating paths are vertex disjoint. For two failures in the same alternating path, by our charging method, no two failures consider the same vertex for charging purposes. $\quad\blacksquare$

Theorem 3.7

Algorithm 1 computes a ${2}/{3}$-approximation for the MVM problem.

Proof: Let $M_{A}$ be the matching computed by the approximation algorithm, and $M_{opt}$ be a matching of maximum vertex weight. Consider all paths in the symmetric difference between $M_{A}$ and $M_{opt}$. Let $\phi(F)$ denote the sum of weights of all the failures, let $\phi(M_{opt})$ denote the weight of the maximum-weighted matching, and let $\phi(M_{A})$ denote the weight of the approximate matching. Then, $\phi(M_{opt})=\phi(M_{A})+\phi(F)-\phi(M_{A}\setminus M_{opt})\leq\phi(M_{A})+\phi(F)$, and we know from Lemma 3.6 that $\phi(F)\leq\frac{1}{2}\phi(M_{A})$ since for every failure we have two distinct vertices that are at least as heavy as the failures. Hence $\phi(M_{opt})-\phi(M_{A})\leq\phi(F)\leq\frac{1}{2}\phi(M_{A})$. Thus we have $\phi(M_{opt})\leq\frac{3}{2}\phi(M_{A})$. This completes the proof. $\quad\blacksquare$

4 Experiments and Results

4.1 Experimental Setup and Algorithms Being Compared

We used an Intel Xeon E5-2660 processor-based system (part of the Purdue University Community Cluster), called Rice111https://www.rcac.purdue.edu/compute/rice/ for the experiments. The machine consists of two processors, each with ten cores running at 2.6 GHz (20 cores in total) with 25 MB unified L3 cache and 64 GB of memory. The operating system is Red Hat Enterprise Linux release 6.9. All code was developed using C++ and compiled using the g++ compiler (version: 4.4.7) using the -O3 flag. Our test set consists of nineteen real-world graphs taken from the University of Florida Matrix collection [6] covering several application areas. Table 1 gives some statistics on our test set. The graphs are listed in increasing order of the number of vertices. The largest number of vertices of any graph is nearly 51 million, and the largest number of edges is nearly 216 million. For each graph we list the maximum and average vertex degrees and the ratio of the standard deviation of the degrees and the mean degree. The average degrees vary from $2$ to $118$, and the graphs are diverse with respect to their degree distributions. The three kron_g500 graphs of different sizes have high maximum degrees, and high ratios of the standard deviation of the degrees and mean degree, but most problems have low values.

We compare the $2/3$-approximation algorithm for MVM (we will call this Two-thirds algorithm) with a number of other algorithms.

The Exact algorithm for MVM is similar to Algorithm 1 except that there is no restriction on the augmenting path length, and it is discussed in Section 3, and in more detail in [7]. The complexity of the Exact algorithm we have implemented is $O(nm)$. The Spencer and Mayr algorithm [26] has $O(m\sqrt{n}\,\log n)$ time complexity, but is more complicated to implement, it is not clear if it would lead to better practical performance, and our focus in this paper is on approximation algorithms for MVM with much lower time complexity. We improved the practical performance of the Exact algorithm for MVM by two modifications: (1) If a search for an augmenting path fails, we mark all visited vertices, and when these vertices are encountered in a future search, the algorithm quits searching along those paths. (2) At the step of matching a vertex $u_{i}$ we find the heaviest unmatched vertex $u_{j}$ in the sorted list of 5 vertices such that $j>i$. If an augmenting path from $u_{i}$ to a vertex $v$ is found such that $\phi(v)=\phi(u_{j})$, then the algorithm stops the search and augments the matching.

We have included an exact algorithm for the maximum edge-weighted matching problem (MEM) implemented in LEDA [1, 18] in our comparisons. This is a primal-dual algorithm implemented with advanced priority queues and efficient dual weight updates, with time complexity $O(nm\log n)$ [19]. Since this is a commercial code, we can only run the object code, and we ran it with no initialization and with a fractional matching initialization that obtains a $\{0,1/2,1\}$ solution to the linear programming formulation of maximum weighted matching by ignoring the odd-set constraints (computed combinatorially), and then rounding the solution to $\{0,1\}$ values [2]. We call these two variants LEDA1 and LEDA2, respectively.

The Greedy Half approximation algorithm for MVM (Half) matches the vertices in non-increasing order of weights, matching an unmatched vertex to a heaviest unmatched neighbor, and then deletes other edges incident on the endpoints of the matched edge. Its time complexity is $O(m+n\log n)$ [7].

We used two implementations (Random and Round-Robin) of the $(2/3-\epsilon)$ approximation algorithm for MEM due to Pettie and Sanders [21], and Maue and Sanders [17] with $\epsilon=0.01$. Before describing each implementation we will describe a 2-augmentation centered at a vertex $v$ which is an operation that is used in both implementations. We define an arm of $v$ to be either $\{v,u\}$ or $\{v,u,u^{\prime}\}$, where $(v,u)$ is an unmatched edge, and $(u,u^{\prime})$ is a matched edge. The gain of an augmentation or exchange of edges is the increase in weight obtained by the transformation. There are two cases:

Case 1) $v$ is unmatched: find an arm of $v$ with the highest positive gain.

Case 2) $v$ is matched to a vertex $v^{\prime}$: find the highest positive gain by checking the gains of the following paths or cycles:

(1) Alternating cycles of length four that include the edge $(v,v^{\prime})$.

(2) Alternating paths of length at most four, which is done as follows: Find two vertex disjoint arms of $v$, with the highest gains $P$ and $P^{\prime}$, then find an arm of $v^{\prime}$ with highest gain $Q$. If $P$ and $Q$ are vertex disjoint then $P\cup(v,v^{\prime})\cup Q$ is a highest gain alternating path; otherwise choose $P^{\prime}\,\cup(v,v^{\prime})\cup Q$ as a highest gain alternating path.

There are two implementations of this algorithm. The Random implementation chooses a random vertex $v$ and performs a 2-augmentation centered at $v$ with the highest-gain. This is repeated $k=\frac{1}{3}\log{\epsilon}^{-1}$ times. The Round-Robin implementation randomly permutes the order of vertices, and for each vertex $v$ in the permuted order performs 2-augmentation with the highest-gain centered at $v$. This is repeated for $k=\frac{1}{3}\,\log{\epsilon^{-1}}$ phases. If no further improvement can be achieved after finishing a phase then the algorithm quits. The algorithm can be initialized with the $1/2$-approximation algorithm called the Global Paths algorithm (GPA) [17], which sorts the edges in non-increasing order of their weights. It constructs sets of paths and cycles of even length by considering the edges in non-increasing order of their weights. Then it computes a maximum weight matching for each path and cycle by dynamic programming, and it deletes the matched edges and their adjacent edges. The algorithm repeats until all edges are deleted. The time complexity of the GPA algorithm is $O(m\log n)$, and that of the Round-robin $2/3$-approximation algorithm is $O(m\log{\epsilon}^{-1})$. Maue and Sanders [17] have reported that the Round-robin implementation with GPA initialization computed heavier matchings than the other three variants albeit at the expense of higher running times; we have obtained similar results, and find that the Round-robin implementation with no initialization was the fastest among the four variants. Hence we report results from these two variants, called RR and GPA-RR, respectively.

The final algorithm we implemented is a $(1-\epsilon)$-approximate scaling algorithm for MEM (Scaling) due to Duan and Pettie [10], with the choice of $\epsilon=1/3$, $1/4$, and $1/6$. The algorithm is based on a primal dual formulation of the problem with relaxed feasibility and complementary slackness conditions imposed at each scale. The time complexity of the Scaling algorithm is $O(m\,\epsilon^{-1}\log(\epsilon^{-1}))$.

In total, we have two exact algorithms for MEM and MVM, and four approximation algorithms. The exact MEM algorithm and the $(2/3-\epsilon)$-approximation algorithm have two options for initialization.

Integer weights of vertices were generated uniformly at random in the range $[1\,1000]$, and real-valued weights were chosen randomly in the range $[1.0,1.3]$. The reported results are average of ten trials of randomly generated weights. The standard deviations for run-time, weight ratio, and cardinality ratio are close to zero, so there is not much variation on these metrics for each algorithm.

4.2 Performance of the Algorithms

[FIGURE:]

In Table 2 we group the problems into three sets based on our results. In the first set, the time taken by the Exact MEM algorithm from LEDA without initialization (LEDA1), and the relative performance of the other algorithms (the ratio of the time taken by LEDA1 to the time taken by the other algorithm), are reported. Numbers greater than one indicate that the latter algorithms are faster. For the second set of problems, the LEDA algorithm with no initialization did not complete in four hours. Hence we report the time taken by LEDA2, the code with fractional matching initialization, and relative performance for the other algorithms. For the third set consisting of one problem, none of the exact algorithms completed in 100 hours, and we report the run times of the approximation algorithms.

On the first set of problems, in geometric mean, the exact algorithms LEDA2 and MVM are $12$ and $19$ times, respectively, faster than LEDA1; the Scaling algorithm and the GPA-RR algorithms are about $35$ and $38$ times faster, respectively; and the RR algorithm is $110$ times faster; the Two-thirds MVM algorithm is $1,200$ times faster, and the Half algorithm is $2,400$ times faster.

On the second set of problems, the Exact MVM algorithm is slower than the exact MEM algorithm LEDA2 by a factor of about $1.7$. The approximation algorithms are all faster than LEDA2, the fastest again being the Half algorithm (by a factor of $400$), and the Two-thirds algorithm is faster by a factor of $140$. The scaling and the RR algorithms are $7$ and $28$ times faster than LEDA2.

For the nlpkkt200 problem, the Two-thirds algorithm computed the matching in $52$ seconds on the integer weights; the Half approximation algorithm took about $8$ seconds, while the Scaling algorithm solved the same problem in $264$ seconds. The GPA-RR and RR algorithms took $787$ and $186$ seconds, respectively. This graph has an interesting structure. It comes from a nonlinear programming problem (it is a symmetric Kuhn-Tucker-Karush matrix), which can be partitioned into two subsets of vertices $V_{1}$ and $V_{2}$; vertices in the set $V_{1}$ are connected to each other and to vertices in the set $V_{2}$, but the latter is an independent set of vertices, i.e., no edge joins a vertex in $V_{2}$ to another vertex in $V_{2}$. There are $8,240,000$ vertices in $V_{1}$ and $8,000,000$ vertices in $V_{2}$. This structure creates a large number of augmenting paths for the exact algorithms, and we conjecture this is why these algorithms do not terminate.

We also report the maximum time taken by an algorithm over all problems on which it terminated. For LEDA1, it is $4,076$ seconds on the europe_osm problem; for LEDA2, $5,952$ s on the rgg problem; the Exact MVM algorithm needed $3,139$ s on the huge_bubbles problem. The Scaling algorithm took $579$ s on the europe_osm problem, and the Half algorithm took $15$ s on the same problem. The problem nlpkkt200 needed the most time for the other approximation algorithms: $787$ s for the GPA-RR, $186$ s for the RR algorithm, and $52$ s for the Two-thirds algorithm.

The runtimes of the some of these algorithms are plotted in a semi-logarithmic plot in Figure 11.

We compare the weight of the matching computed by the algorithms with integer weights in range $[1\,1000]$ in Table 3. All the exact algorithms compute the same maximum weight, which is reported in the first column; the approximation algorithms compute nearly optimal weights, and in order to differentiate among them, we report the gap to optimality as a percent. Hence we report $100\,(1-w(A)/w_{\rm opt})$, where $w(A)$ is the weight computed by an algorithm $A$ and $w_{\rm opt}$ is the optimal weight computed by the exact algorithms. The Half algorithm computes weights higher than $96\%$ of the optimal, and the Scaling algorithm computes weights higher than $98\%$ of the optimal. The other approximation algorithms obtain weights higher than $99.99\%$ of the optimal. The best among these is GPA-RR, which it accomplishes taking run times at least $20$ times higher than the Two-thirds algorithm. Note that the weights obtained in practice are much better than the worst-case approximation guarantees. These results are plotted in Figure 12.

In Table 5, we report run times from the Exact MVM algorithm and the relative performance of the approximation algorithms when the vertex weights are real-valued in the range $[1\ 1.3]$. These weights are favorable to the Scaling approximation algorithm, since the number of scales needed is low. LEDA unfortunately does not work with real-valued weights. In geometric mean, the Half algorithm is faster than the Exact MVM algorithm by a factor of $110$; the Two-thirds algorithm by a factor of $54$; and the other approximation algorithms are faster by factor less than $8$. On the nlpkkt200 problem, the Exact MVM algorithm did not terminate; notice that the Scaling algorithm is faster with the smaller range of weights here when compared to the integer weights with a larger range. The run times of the other approximation algorithms are consistent with the rankings discussed earlier.

Table 6 includes results for the real-valued weights in the range $[1\,1.3]$. The Half approximation algorithm obtains about 89% of the maximum weight (geometric mean of these problems), and is the worst performer. The other approximation algorithms are all comparable in the weights they compute, two or three percent off the optimal. Again the best performer is the GPA-RR algorithm, which it achieves taking about a factor of nine more time than the Two-thirds algorithm.

Now we consider the cardinality of the matchings obtained by the algorithms in Tables 4 and 7. The exact algorithm for MVM computes a maximum cardinality matching when the vertex weights are positive, and since the MEM problems are derived from MVM problems by summing the weights, the MEM algorithms also compute maximum cardinality matchings. The Half approximation algorithm is about ten percent off the maximum cardinality, and the Scaling algorithm about six percent off. The other approximation algorithms are about two percent off the cardinality, with the GPA-RR algorithm the best performer. For eight of the nineteen problems, the exact algorithms obtained perfect matchings (cardinality equal to $n/2$ or $(n-1)/2$). Similar results are obtained when real weights with a smaller range is used, except that this time the Scaling algorithm finds higher cardinalities. To see how the Two-third algorithm fares against the Scaling algorithm for a smaller $\epsilon$, we compared it with $3/4$- and $5/6$-Scaling approximation algorithms. For integer weights in the range $[1\,1000]$ the Two-third algorithm is $37$ times faster than the $3/4$-approximation, and $54$ times faster than the $5/6$-Scaling approximation algorithm. In geometric mean the Two-third algorithm obtained greater weight by $1.2\%$ and $1.9\%$, and higher cardinality by $3.1\%$ and $3.8\%$, relative to the $3/4$- and $5/6$-approximate Scaling algorithm. For real-valued weights in $[1\,1.3]$ the Two-third algorithm is $9.6$ and $12.6$ times faster than the $3/4$ and $5/6$-Scaling approximation algorithms, respectively. In geometric mean the Two-third algorithm obtained greater weights by $4.7\%$ than the $3/4$-approximation; it was worse by $0.9\%$ than the $5/6$-approximation; the cardinality was higher by $4.7\%$ over the $3/4$-approximation, and worse by $1.1\%$ relative to the $5/6$-approximation.

5 Conclusions

We have described an augmentation-based $2/3$-approximation algorithm for MVM on non-bipartite graphs whose time complexity is $O(m\log{\Delta}+n\log n)$, whereas the time complexity of an exact algorithm is $O(n^{1/2}m\log n)$. The approximation algorithm is derived in a natural manner from an exact algorithm for computing maximum weighted matchings by restricting the length of augmenting paths to at most three.

The $2/3$-MVM algorithm has been implemented efficiently in C++, and on a set of nineteen graphs, some with hundreds of millions of edges, it computes the approximate matchings in less than $52$ seconds. The weight of the approximate matching is greater than $98\%$ ($94\%$) of the weight of the Optimal matching for these problems on integer weights in $[1\,1000]$ (real weights in $[1.0\,1.3]$). A Greedy Half-approximation algorithm is faster than the $2/3$-MVM algorithm by about a factor of two, but the weight it computes is lower, and can be as low as $84\%$ on the worst problem. All of these algorithms obtain weights that are much higher than the worst-case approximation guarantees.

In addition, on geometric mean the $2/3$-MVM algorithm is faster than a Scaling based $(1-\epsilon)$ approximation algorithm by a factor of 28 on the integer weights in range $[1\,1000]$, which is expected due to the large overheads needed for the handling of blossoms and dual variable updates. While the Scaling algorithm is faster on real-valued weights in a narrower range $[1.0\,1.3]$ since there are fewer scales, the $2/3$-MVM algorithm is still faster than it on average by a factor of 7. The $2/3$-approximate MVM algorithm obtains better matching weight than the Scaling approximation algorithm for relevant values of $\epsilon$ in all instances on the integer weights, and all but two graphs for the real-valued weights (on those two problems, the weights are close).

The $(2/3-\epsilon)$-approximation algorithm for MEM, with Round-robin selection of augmentations and initialization with the Global Paths algorithm, computes higher weights than the $2/3$-approximation algorithm for MVM, but at a cost of an order of magnitude or more time. The weight differences are quite small for integer weights in a range $[1\,1000]$, but are about $0.7\%$ for real-valued weights in the range $[1\,1.3]$.

We have also compared our algorithms with exact algorithms for the MEM problem from LEDA with a fractional matching initialization, and show that the exact MVM algorithm is quite competitive with it. The $2/3$-approximation algorithm for MVM is two to three orders of magnitude faster than these exact algorithms, and there are problems on which the exact algorithms do not terminate in hundreds of hours.

Half-approximation algorithms for MEM (e.g., the Locally Dominant edge and Suitor algorithms) do not require sorting and can be used or adapted to obtain $1/2$-approximate matchings for the MVM. The $2/3$-approximation algorithm for MVM designed here processes the vertices in non-increasing order of weights, but an algorithm based on the idea of searching for weight-increasing paths and cycles can avoid doing so, leading to a potentially parallel algorithm. This is the scope of our current work.

Acknowledgements

We thank Jens Maue (Zurich) and Peter Sanders of the Karlsruhe Institute of Technology for sharing the code for the GPA and $(2/3-\epsilon)$-approximation algorithms with us.

This work was supported in part by NSF grant CCF-1637534; the U.S. Department of Energy through grant DE-FG02-13ER26135; and the Exascale Computing Project (17-SC-20-SC), a collaborative effort of the DOE Office of Science and the NNSA.

Appendix A Tables with random real weights in the range $[1\,1.3]$