A Match in Time Saves Nine: Deterministic Online Matching With Delays

TL;DR

This paper introduces the first deterministic online algorithm for Min-cost Perfect Matching with Delays, achieving a polynomial competitive ratio independent of metric parameters, advancing online matching theory.

Contribution

It presents the first deterministic algorithm for MPMD with a polynomial competitive ratio, not requiring prior knowledge of the metric space.

Findings

Deterministic algorithm with $O(m^{2.46})$ competitive ratio.

Algorithm does not depend on metric space parameters.

First such deterministic solution for MPMD.

Abstract

We consider the problem of online Min-cost Perfect Matching with Delays (MPMD) introduced by Emek et al. (STOC 2016). In this problem, an even number of requests appear in a metric space at different times and the goal of an online algorithm is to match them in pairs. In contrast to traditional online matching problems, in MPMD all requests appear online and an algorithm can match any pair of requests, but such decision may be delayed (e.g., to find a better match). The cost is the sum of matching distances and the introduced delays. We present the first deterministic online algorithm for this problem. Its competitive ratio is $O(m^{\log_2 5.5})$ $ = O(m^{2.46})$, where $2 m$ is the number of requests. This is polynomial in the number of metric space points if all requests are given at different points. In particular, the bound does not depend on other parameters of the metric, such as its aspect ratio. Unlike previous (randomized) solutions for the MPMD problem, our algorithm does not need to know the metric space in advance.

Equations

$${\text{wait}}_{\tau }(p)=\tau -\text{atime}(p)$$

$${\text{budget}}_{\tau }(p)=\alpha \cdot {\text{wait}}_{\tau }(p).$$

$${\text{cost}}_{\mathrm{ALG}}(e)={\text{cost}}_{\mathrm{ALG}}(p,q)=\text{dist}(p,q)+{\text{wait}}_{\tau }(p)+{\text{wait}}_{\tau }(q).$$

$$\text{cost}(P)\ge$$

$$\ge$$

$${\text{cost}}_{\mathrm{ALG}}(e)\le (1+\alpha )\cdot (\beta +1)\cdot \max \{{\alpha }^{-1},\beta /(\beta -1)\}\cdot \min \{\text{cost}(P),\text{cost}(Q)\}.$$

$${\text{cost}}_{\mathrm{ALG}}(p,q)$$

$$\le {\text{budget}}_{\tau }(p)+{\text{budget}}_{\tau }(q)+{\text{wait}}_{\tau }(p)+{\text{wait}}_{\tau }(q)$$

$$=(1+\alpha )\cdot ({\text{wait}}_{\tau }(p)+{\text{wait}}_{\tau }(q))$$

$$\le (1+\alpha )\cdot (\beta +1)\cdot \min \{{\text{wait}}_{\tau }(p),{\text{wait}}_{\tau }(q)\}.$$

$$\text{weight}(T)\le (\xi +2)\cdot |\text{L}(T){|}^{{\log }_2(\xi /2+1)}\cdot \text{weight}(\text{L}(T)),$$

$${\text{cost}}_{\mathrm{ALG}-\mathrm{NF}}(C)\le \text{weight}(T)\le$$

$$\le$$

$$=$$

$${\text{cost}}_{\mathrm{ALG}}(e)\le (1+\alpha )\cdot ({\text{wait}}_{\tau }(p)+{\text{wait}}_{\tau }(q)).$$

$$(\beta -1)\cdot ({\text{wait}}_{\tau }(p)+{\text{wait}}_{\tau }(q))=$$

$$=$$

$${\text{wait}}_{\tau }(p)+{\text{wait}}_{\tau }(q)\le \max \left\{{\alpha }^{-1},\frac{\beta +1}{\beta -1}\right\}\cdot (\text{dist}(p,q)+|\text{atime}(q)-\text{atime}(p)|).$$

$$\text{dist}(p,q)+|\text{atime}(q)-\text{atime}(p)|\le \text{cost}(P)={\text{cost}}_{\mathrm{ALG}-\mathrm{NF}}(C)+{\text{cost}}_{\mathrm{OPT}}(C).$$

$$\frac{{\text{cost}}_{\mathrm{ALG}}(C)}{{\text{cost}}_{\mathrm{OPT}}(C)}\le \frac{5.5\cdot {\text{cost}}_{\mathrm{ALG}-\mathrm{NF}}(C)+4.5\cdot {\text{cost}}_{\mathrm{OPT}}(C)}{{\text{cost}}_{\mathrm{OPT}}(C)}\le O(m^{{\log }_{2}5.5})=O(m^{2.46}),$$

$$\xi \cdot \min \{f(x),f(y)\}+f(x)+f(y)=$$

$$=$$

$$\le$$

$$\text{ws}(w)=\text{weight}(w)\cdot \frac{|\text{L}(T)|}{\text{weight}(\text{L}(T))}.$$

$$\text{ws}(T_w)\le \text{size}(T_w{)}^{{\log }_2(\xi +2)}.$$

$$\text{ws}(T_w)=\text{ws}(\text{L}(T_w))\le \text{size}(T_w)\le \text{size}(T_w{)}^{{\log }_2(\xi +2)},$$

$$\text{ws}(T_w)$$

$$\le \text{ws}(T_u)+\text{ws}(T_v)+\xi \cdot \min \{\text{ws}(T_u),\text{ws}(T_v)\}$$

$$\le \text{size}(T_u{)}^{{\log }_2(\xi +2)}+\text{size}(T_v{)}^{{\log }_2(\xi +2)}+\xi \cdot \min \{\text{size}(T_u{)}^{{\log }_2(\xi +2)},\text{size}(T_v{)}^{{\log }_2(\xi +2)}\}$$

$$\le (\text{size}(T_u)+\text{size}(T_v){)}^{{\log }_2(\xi +2)}$$

$$=\text{size}(T_w{)}^{{\log }_2(\xi +2)}.$$

$$\frac{\text{weight}(T)}{\text{weight}(\text{L}(T))}=\frac{\text{ws}(T)}{\text{ws}(\text{L}(T))}\le \frac{(\xi +2)\cdot |\text{L}(T){|}^{{\log }_2(\xi +2)}}{|\text{L}(T)|}=(\xi +2)\cdot |\text{L}(T){|}^{{\log }_2(\xi /2+1)},$$

Full text

We present the first deterministic online algorithm for this problem. Its competitive ratio is $O(m^{\log_{2}5.5})$ $=O(m^{2.46})$, where $2m$ is the number of requests. This is polynomial in the number of metric space points if all requests are given at different points. In particular, the bound does not depend on other parameters of the metric, such as its aspect ratio. Unlike previous (randomized) solutions for the MPMD problem, our algorithm does not need to know the metric space in advance.

1. Introduction

In this paper, we give a deterministic online algorithm for the problem of Min-cost Perfect Matching with Delays (MPMD) [22, 5]. For an informal description, imagine that there are human players who are logging in real time into a gaming website, each wanting to play chess against another human player. The system pairs the players according to their known capabilities, such as playing strength. A decision with whom to match a given player can be delayed until a reasonable match is found. That is, the website tries to simultaneously minimize two objectives: the waiting times of players and their dissimilarity, i.e., each player would like to play with another one with similar capabilities. An algorithm running the website has to work online, without the knowledge about future player arrivals and make its decision irrevocably: once two players are paired, they remain paired forever.

1.1. Problem definition

More formally, in the MPMD problem there is a metric space $\mathcal{X}$ with a distance function $\textsf{dist}:\mathcal{X}\times\mathcal{X}\to\mathbb{R}$, both known from the beginning to an online algorithm. An online part of the input is a sequence of $2m$ requests $\{(p_{i},t_{i})\}_{i=1}^{2m}$, where point $p_{i}\in\mathcal{X}$ corresponds to a player in our informal description above and $t_{i}$ is the time of its arrival. Clearly, $t_{1}\leq t_{2}\leq\ldots\leq t_{2m}$. The integer $m$ is not known a priori to an online algorithm. At any time $\tau$, an online algorithm may decide to match any pair of requests $(p_{i},t_{i})$ and $(p_{j},t_{j})$ that have already arrived ($\tau\geq t_{i}$ and $\tau\geq t_{j}$) and have not been matched yet. The cost incurred by such matching edge is $\textsf{dist}(p_{i},p_{j})+(\tau-t_{i})+(\tau-t_{j})$, i.e., is the sum of the connection cost and the waiting costs of these two requests.

The goal is to eventually match all requests and minimize the total cost. We use a typical yardstick to measure the performance: a competitive ratio [13], defined as the maximum, over all inputs, of the ratios between the cost of an online algorithm and the cost of an optimal offline solution Opt that knows the entire input sequence in advance.

1.2. Previous work

The MPMD problem was introduced by Emek et al. [22], who presented a randomized $O(\log^{2}n+\log\Delta)$-competitive algorithm. There, $n$ is the number of points in the metric space $\mathcal{X}$ and $\Delta$ is its aspect ratio (the ratio between the largest and the smallest distance in $\mathcal{X}$). The competitive ratio was subsequently improved by Azar et al. [5] to $O(\log n)$. They showed that the ratio of any randomized algorithm is at least $\Omega(\sqrt{\log n})$. The currently best lower bound of $\Omega(\log n/\log\log n)$ for randomized solutions was given by Ashlagi et al. [3].

So far, the construction of a competitive deterministic algorithm for general metric spaces remained an open problem. It was hypothesized that competitive ratios achievable by deterministic algorithms might be superpolynomial in $n$ (cf. Section 5 of [5]). Deterministic algorithms were known only for simple spaces: Azar et al. [5] gave an $O(\textnormal{height})$-competitive algorithm for trees and Emek et al. [23] constructed a $3$-competitive deterministic solution for two-point metric (the competitive ratio is best possible for such metric).

1.3. Our contribution

In this paper, we give the first deterministic algorithm for any metric space, whose competitive ratio is $O(m^{\log_{2}5.5})=O(m^{2.46})$, where $2m$ is the number of requests. Typically, for our gaming application, $m$ is smaller than $n$ (although in full generality it can be also larger if multiple requests arrive at the same point of the metric space $\mathcal{X}$). While previous solutions to the MPMD problem [22, 5] required $\mathcal{X}$ to be finite and known a priori (to approximate it first by a random HST tree [24] or a random HST tree with reduced height [8]), our solution works even when $\mathcal{X}$ is revealed in online manner. That is, we require only that, together with any request $r$, an online algorithm learns the distances from $r$ to all previous, not yet matched requests.

Our online algorithm Alg uses a simple, local, semi-greedy scheme to find a suitable matching pair. In the analysis, we fix a final perfect matching of Opt and observe what happens when we gradually add matching edges that Alg creates during its execution. That is, we trace the evolution of alternating paths and cycles in time. To bound the cost of Alg, we charge the cost of an edge that Alg is adding against the cost of already existing matching edges from the same alternating path. Interestingly, our charging argument on alternating cycles bears some resemblance to the analyses of algorithms for the problems that are not directly related to MPMD: online metric (bipartite) matching on line metrics [2] and offline greedy matching [40].

1.4. Related work

Originally, matching problems have been studied in variants where delaying decisions was not permitted. The setting most similar to the MPMD problem is called online metric bipartite matching. In involves $m$ offline points given to an algorithm at the beginning and $m$ requests presented in online manner that need to be matched (immediately after their arrival) to offline points. Both points and requests lie in a common metric space and the goal is to minimize the weight of a perfect matching created by an algorithm. For general metric spaces, the best randomized solution is $O(\log m)$-competitive [7, 26, 37], and the deterministic algorithms achieve the optimal competitive ratio of $2m-1$ [27, 32]. Interestingly, even for line metrics [2, 25, 33], the best known deterministic algorithm attains a competitive ratio that is polynomial in $m$ [2].

In comparison, in the MPMD problem considered in this paper, all $2m$ requests appear in online manner, $m$ is not known to an algorithm, and we allow to match any pair of them. That said, there is also a bipartite variant of the MPMD problem, in which all requests appear online, but $m$ of them are negative and $m$ are positive. An algorithm may then only match pairs of requests of different polarities [4, 3].

The MPMD problem can be cast as augmenting min-cost perfect matching with a time axis, allowing the algorithm to delay its decisions, but penalizing the delays. There are many other problems that use this paradigm: most notably the ski-rental problem and its continuous counterpart, the spin-block problem [29], where a purchase decision can be delayed until renting cost becomes sufficiently large. Such rent-or-buy (wait-or-act) trade-offs are also found in other areas, for example in aggregating messages in computer networks [1, 11, 21, 28, 31, 39], in aggregating orders in supply-chain management [9, 10, 14, 15, 17, 18] or in some scheduling variants [6].

Finally, there is a vast amount of work devoted to other online matching variant, where offline points and online requests are connected by graph edges and the goal is to maximize the weight or the cardinality of the produced matching. These types of matching problems have been studied since the seminal work of Karp et al. [30] and are motivated by applications to online auctions [12, 16, 19, 20, 30, 34, 36, 38]. They were also studied under stochastic assumptions on the input, see, e.g., a survey by Mehta [35].

2. Algorithm

We will identify requests with the points at which they arrive. To this end, we assume that all requested points are different, but we allow distances between different metric points to be zero. For any request $p$, we denote the time of its arrival by $\textsf{atime}(p)$.

Our algorithm is parameterized with real numbers $\alpha>0$ and $\beta>1$, whose exact values will be optimized later. For any request $p$, we define its waiting time at time $\tau\geq\textsf{atime}(p)$ as

[TABLE]

and its budget at time $\tau$ as

[TABLE]

Our online algorithm Alg matches two requests $p$ and $q$ at time $\tau$ as soon as the following two conditions are satisfied.

• •

Budget sufficiency: $\textsf{budget}_{\tau}(p)+\textsf{budget}_{\tau}(q)\geq\textsf{dist}(p,q)$.

• •

Budget balance: $\textsf{budget}_{\tau}(p)\leq\beta\cdot\textsf{budget}_{\tau}(q)$ and $\textsf{budget}_{\tau}(q)\leq\beta\cdot\textsf{budget}_{\tau}(p)$.

Note that the budget balance condition is equivalent to relations on waiting times, i.e., $\textsf{wait}_{\tau}(p)\leq\beta\cdot\textsf{wait}_{\tau}(q)$ and $\textsf{wait}_{\tau}(q)\leq\beta\cdot\textsf{wait}_{\tau}(p)$.

If the conditions above are met simultaneously for many point pairs, we break ties arbitrarily, and process them in any order. Note that at the time when $p$ and $q$ become matched, the sum of their budgets may exceed $\textsf{dist}(p,q)$. For example, this occurs when $q$ appears at time strictly larger than $\textsf{atime}(p)+\textsf{dist}(p,q)$: they are then matched by Alg as soon as the budget balance condition becomes true.

The observation below follows immediately by the definition of Alg.

Observation \thetheorem.

Fix time $\tau$ and two requests $p$ and $q$, such that $\textsf{atime}(p)\leq\tau$ and $\textsf{atime}(q)\leq\tau$. Assume that neither $p$ nor $q$ has been matched by Alg strictly before time $\tau$. Then exactly one of the following conditions holds:

• •

$\alpha\cdot(\textsf{wait}_{\tau}(p)+\textsf{wait}_{\tau}(q))\leq\textsf{dist}(p,q)$,

• •

$\alpha\cdot(\textsf{wait}_{\tau}(p)+\textsf{wait}_{\tau}(q))>\textsf{dist}(p,q)$ and $\textsf{wait}_{\tau}(p)\geq\beta\cdot\textsf{wait}_{\tau}(q)$,

• •

$\alpha\cdot(\textsf{wait}_{\tau}(p)+\textsf{wait}_{\tau}(q))>\textsf{dist}(p,q)$ and $\textsf{wait}_{\tau}(q)\geq\beta\cdot\textsf{wait}_{\tau}(p)$.

3. Analysis

To analyze the performance of Alg, we look at matchings generated by Alg and by an optimal offline algorithm Opt. If points $p$ and $q$ were matched at time $\tau$ by Alg, then we say that Alg creates a (matching) edge $e=(p,q)$. Its cost is

[TABLE]

We call $e$ an Alg-edge. The $\textsf{cost}_{\mathrm{OPT}}$ of an edge in the solution of Opt (an Opt-edge) is defined analogously. In an optimal solution, however, the matching time is always equal to the arrival time of the later of two matched requests.

We now consider a dynamically changing graph consisting of requested points, Opt-edges and Alg-edges. For the analysis, we assume that it changes in the following way: all requested points and all Opt-edges are present in the graph from the beginning, but the Alg-edges are added to the graph in $m$ steps, in the order they are created by Alg.

At all times, the matching edges present in the graph form alternating paths or cycles (i.e., paths or cycles whose edges are interleaved Alg-edges and Opt-edges). Furthermore, any node-maximal alternating path starts and ends with Opt-edges. Assume now that a matching edge $e$ created by Alg is added to the graph. It may either connect the ends of two different alternating paths, thus creating a single longer alternating path or connect the ends of one alternating path, generating an alternating cycle. In the former case, we call edge $e$ non-final, in the latter case — final. Note that at the end of the Alg execution, when $m$ Alg-edges are added, the graph contains only alternating cycles.

We extend the notion of cost to alternating path and cycles. For any cycle $C$, $\textsf{cost}(C)$ is simply the sum of costs of its edges: the cost of an Opt-edge on such cycle is the cost paid by Opt and the cost of an Alg-edge is that of Alg. We also define $\textsf{cost}_{\mathrm{OPT}}(C)$, $\textsf{cost}_{\mathrm{ALG}}(C)$ and $\textsf{cost}_{\mathrm{ALG-NF}}(C)$ as the costs of Opt-edges, Alg-edges and non-final Alg-edges on cycle $C$, respectively. Clearly, $\textsf{cost}_{\mathrm{ALG}}(C)+\textsf{cost}_{\mathrm{OPT}}(C)=\textsf{cost}(C)$. We define the same notions for alternating paths; as a path $P$ does not contain final Alg-edges, $\textsf{cost}_{\mathrm{ALG-NF}}(P)=\textsf{cost}_{\mathrm{ALG}}(P)$.

An alternating path is called $\kappa$-step maximal alternating path if it exists in the graph after Alg matched $\kappa$ pairs and it cannot be extended, i.e., it ends with two requests that are not yet matched by the first $\kappa$ Alg-edges.

3.1. Tree construction

To facilitate the analysis, along with the graph, we create a dynamically changing forest $F$ of binary trees, where each leaf of $F$ corresponds to an Opt-edge and each internal (non-leaf) node of $F$ to a non-final Alg-edge (and vice versa). After Alg matched $\kappa$ pairs, each subtree of $F$ corresponds to a $\kappa$-step maximal alternating path or to an alternating cycle. More precisely, at the beginning, $F$ consists of $m$ single nodes representing Opt-edges. Afterwards, whenever an Alg-edge is created, we perform the following operation on $F$.

• •

When a non-final Alg-edge $e=(p,q)$ is added to the graph, we look at the two alternating paths $P$ and $Q$ that end with $p$ and $q$, respectively. We take the corresponding trees $T(P)$ and $T(Q)$ of $F$. We add a node $v(e)$ (representing edge $e$) to $F$ and make $T(P)$ and $T(Q)$ its subtrees.

• •

When a final Alg-edge $e=(p,q)$ is added to the graph, it turns an alternating path $P$ into an alternating cycle $C$. We then simply say that the tree $T(P)$ that corresponded to $P$, now corresponds to $C$.

An example of the graph and the associated forest $F$ is presented in Figure 1.

For any tree node $w$, we define its weight $\textsf{weight}(w)$ as the cost of the corresponding matching edge, i.e., the cost of an Opt-edge for a leaf and the cost of a non-final Alg-edge for a non-leaf node. For any node $w$, by $T_{w}$ we denote the tree rooted at $w$. We extend the notion of weight in a natural manner to all subtrees of $F$. In these terms, the weight of a tree $T$ in $F$ is equal to the total cost of the corresponding alternating path. (If $T$ represents an alternating cycle $C$, then its weight is equal to the cost of $C$ minus the cost of the final Alg-edge from $C$.)

Note that we consistently used terms “points” and “edges” for objects that Alg and Opt are operating on in the metric space $\mathcal{X}$. On the other hand, the term “nodes” will always refer to tree nodes in $F$ and we will not use the term “edge” to denote an edge in $F$.

3.2. Outline of the analysis

Our approach to bounding the cost of Alg is now as follows. We look at the forest $F$ at the end of Alg execution. The corresponding graph contains only alternating cycles. The cost of non-final Alg-edges is then, by the definition, equal to the total weight of internal (non-leaf) nodes of $F$, while the cost of Opt-edges is equal to the total weight of leaves of $F$. Hence, our goal is to relate the total weight of any tree to the weight of its leaves.

The central piece of our analysis is showing that for any internal node $w$ with children $u$ and $v$, it holds that $\textsf{weight}(w)\leq\xi\cdot\min\{\textsf{weight}(T_{u}),\textsf{weight}(T_{v})\}$, where $\xi$ is a constant depending on parameters $\alpha$ and $\beta$ (see Corollary 3.5). Using this relation, we will bound the total weight of any tree by $O(m^{\log_{2}{(\xi+2)-1}})$ times the total weight of its leaves. This implies the same bound on the ratio between non-final Alg-edges and Opt-edges on each alternating cycle.

Finally, we show that the cost of final Alg-edges incurs at most an additional constant factor in the total cost of Alg.

3.3. Cost of non-final ALG-edges

As described in Section 3.1, when Alg adds a $\kappa$-th Alg-edge $e$ to the graph, and this edge is non-final, $e$ joins two $(\kappa-1)$-step maximal alternating paths $P$ and $Q$. We will bound $\textsf{cost}_{\mathrm{ALG}}(e)$ by a constant (depending on $\alpha$ and $\beta$) times $\min\{\textsf{cost}(P),\textsf{cost}(Q)\}$. We start with bounding the waiting cost of Alg related to one endpoint of $e$.

Lemma 3.1**.**

Let $e=(p,q)$ be the $\kappa$-th Alg-edge added at time $\tau$, such that $e$ is non-final. Let $P=(a_{1},a_{2},\ldots,a_{\ell}$) be the $(\kappa-1)$-step maximal alternating path ending at $p=a_{1}$. Then, $\textsf{wait}_{\tau}(p)\leq\max\{\alpha^{-1},{\beta}/{(\beta-1)}\}\cdot\textsf{cost}(P)$.

Proof 3.2**.**

First we lower-bound the cost of an alternating path $P$. We look at any edge $(a_{i},a_{i+1})$ from $P$. Its cost (no matter whether paid by Alg or Opt) is certainly larger than $\textsf{dist}(a_{i},a_{i+1})+|\textsf{atime}(a_{i})-\textsf{atime}(a_{i+1})|$. Therefore, using triangle inequality (on distances and times), we obtain

[TABLE]

Therefore, in our proof we will simply bound $\textsf{wait}_{\tau}(p)=\textsf{wait}_{\tau}(a_{1})$ using either $\textsf{dist}(a_{1},a_{\ell})$ or $|\textsf{atime}(a_{1})-\textsf{atime}(a_{\ell})|$.

Recall that Alg matches $a_{1}$ at time $\tau$. Consider the state of $a_{\ell}$ at time $\tau$. If $a_{\ell}$ has not been presented to Alg yet ($\textsf{atime}(a_{\ell})>\tau$), then $\textsf{wait}_{\tau}(a_{1})=\tau-\textsf{atime}(a_{1})<\textsf{atime}(a_{\ell})-\textsf{atime}(a_{1})<\beta/(\beta-1)\cdot(\textsf{atime}(a_{\ell})-\textsf{atime}(a_{1}))$, and the lemma follows.

In the remaining part of the proof, we assume that $a_{\ell}$ was already presented to the algorithm ($\textsf{atime}(a_{\ell})\leq\tau$). As $P$ is a $(\kappa-1)$-step maximal alternating path, $a_{\ell}$ is not matched by Alg right after Alg creates $(\kappa-1)$-th matching edge. The earliest time when $a_{\ell}$ may become matched is when Alg creates the next, $\kappa$-th matching edge, i.e., at time $\tau$. Therefore $a_{\ell}$ is not matched before time $\tau$.

Now observe that there must be a reason for which requests $a_{1}$ and $a_{\ell}$ have not been matched with each other before time $\tau$. Roughly speaking, either the sum of budgets of requests $a_{1}$ and $a_{\ell}$ does not suffice to cover the cost of $\textsf{dist}(a_{1},a_{\ell})$ or one of them waits significantly longer than the other. Formally, we apply Observation 2 to pair $(a_{1},a_{\ell})$ obtaining three possible cases. In each of the cases we bound $\textsf{wait}_{\tau}(a_{1})$ appropriately.

**Case 1 (insufficient budgets).: **

If $\alpha\cdot(\textsf{wait}_{\tau}(a_{1})+\textsf{wait}_{\tau}(a_{\ell}))\leq\textsf{dist}(a_{1},a_{\ell})$, then by non-negativity of $\textsf{wait}_{\tau}(a_{\ell})$, it follows that $\textsf{wait}_{\tau}(a_{1})\leq\alpha^{-1}\cdot\textsf{dist}(a_{1},a_{\ell})$.

**Case 2 ($a_{1}$ waited much longer than $a_{\ell}$).: **

If $\alpha\cdot(\textsf{wait}_{\tau}(a_{1})+\textsf{wait}_{\tau}(a_{\ell}))>\textsf{dist}(a_{1},a_{\ell})$ and $\textsf{wait}_{\tau}(a_{1})\geq\beta\cdot\textsf{wait}_{\tau}(a_{\ell})$, then $\textsf{atime}(a_{\ell})-\textsf{atime}(a_{1})=\textsf{wait}_{\tau}(a_{1})-\textsf{wait}_{\tau}(a_{\ell})\geq(1-1/\beta)\cdot\textsf{wait}_{\tau}(a_{1})$. Therefore, $\textsf{wait}_{\tau}(a_{1})\leq\beta/(\beta-1)\cdot|\textsf{atime}(a_{1})-\textsf{atime}(a_{\ell})|$.

**Case 3 ($a_{\ell}$ waited much longer than $a_{1}$).: **

If $\alpha\cdot(\textsf{wait}_{\tau}(a_{1})+\textsf{wait}_{\tau}(a_{\ell}))>\textsf{dist}(a_{1},a_{\ell})$ and $\textsf{wait}_{\tau}(a_{\ell})\geq\beta\cdot\textsf{wait}_{\tau}(a_{1})$, then $\textsf{atime}(a_{1})-\textsf{atime}(a_{\ell})=\textsf{wait}_{\tau}(a_{\ell})-\textsf{wait}_{\tau}(a_{1})\geq(\beta-1)\cdot\textsf{wait}_{\tau}(a_{1})$. Thus, $\textsf{wait}_{\tau}(a_{1})\leq 1/(\beta-1)\cdot|\textsf{atime}(a_{1})-\textsf{atime}(a_{\ell})|<\beta/(\beta-1)\cdot|\textsf{atime}(a_{1})-\textsf{atime}(a_{\ell})|$.

Lemma 3.3**.**

Let $e=(p,q)$ be the $\kappa$-th Alg-edge, such that $e$ is non-final. Let $P=(a_{1},a_{2},\ldots,a_{\ell})$ and $Q=(b_{1},b_{2},\ldots,b_{\ell^{\prime}})$ be the $(\kappa-1)$-step maximal alternating path ending at $p=a_{1}$ and $q=b_{1}$, respectively. Then,

[TABLE]

Proof 3.4**.**

Let $\tau$ be the time when $p$ is matched with $q$ by Alg. Using the definition of $\textsf{cost}_{\mathrm{ALG}}$, we obtain

[TABLE]

The first inequality follows by the budget sufficiency condition of Alg and the second one by the budget balance condition.

By Lemma 3.1, $\textsf{wait}_{\tau}(p)\leq\max\{\alpha^{-1},{\beta}/{(\beta-1)}\}\cdot\textsf{cost}(P)$ and $\textsf{wait}_{\tau}(q)\leq\max\{\alpha^{-1},$ ${\beta}/{(\beta-1)}\}\cdot\textsf{cost}(Q)$, which combined with (2) immediately yield the lemma.

Recall now the iterative construction of forest $F$ from Section 3.1: whenever a non-final matching edge $e$ created by Alg joins two alternating paths $P$ and $Q$, we add a new node $w$ to $F$, such that $\textsf{weight}(w)=\textsf{cost}_{\mathrm{ALG}}(e)$ and make trees $T(P)$ and $T(Q)$ its children. These trees correspond to paths $P$ and $Q$, and satisfy $\textsf{weight}(T(P))=\textsf{cost}(P)$ and $\textsf{weight}(T(Q))=\textsf{cost}(Q)$. Therefore, Lemma 3.3 immediately implies the following equivalent relation on tree weights.

Corollary 3.5**.**

Let $w$ be an internal node of the forest $F$ whose children are $u$ and $v$. Then, $\textsf{weight}(w)\leq(1+\alpha)\cdot(\beta+1)\cdot\max\{\alpha^{-1},\beta/(\beta-1)\}\cdot\min\{\textsf{weight}(T_{u}),\textsf{weight}(T_{v})\}$.

This relation can be used to express the total weight of a tree of $F$ in terms of the total weight of its leaves. The proof of the following technical lemma is deferred to Section 4. Here, we present how to use it to bound the cost of Alg on non-final edges of a single alternating cycle.

Lemma 3.6**.**

Let $T$ be a weighted full binary tree and $\xi\geq 0$ be any constant. Assume that for each internal node $w$ with children $u$ and $v$, their weights satisfy $\textsf{weight}(w)\leq\xi\cdot\min\{\textsf{weight}(T_{u}),\textsf{weight}(T_{v})\}$. Then,

[TABLE]

where $\textsf{L}(T)$ is the set of leaves of $T$ and $\textsf{weight}(\textsf{L}(T))$ is their total weight.

Lemma 3.7**.**

Let $C$ be an alternating cycle obtained from combining matchings of Alg and Opt. Then $\textsf{cost}_{\mathrm{ALG-NF}}(C)\leq(\xi+2)\cdot m^{\log_{2}(\xi/2+1)}\cdot\textsf{cost}_{\mathrm{OPT}}(C)$, where $\xi=(1+\alpha)\cdot(\beta+1)\cdot\max\{\alpha^{-1},\beta/(\beta-1)\}$.

Proof 3.8**.**

As described in Section 3.1, $C$ is associated with a tree $T$ from forest $F$, such that Opt-edges of $C$ correspond to the set of leaves of $T$ (denoted $L(T)$) and non-final Alg-edges of $C$ correspond to internal (non-leaf) nodes of $T$. Hence, $\textsf{cost}_{\mathrm{OPT}}(C)=\textsf{weight}(\textsf{L}(T))$ and $\textsf{cost}_{\mathrm{ALG-NF}}(C)+\textsf{cost}_{\mathrm{OPT}}(C)=\textsf{weight}(T)$.

By Corollary 3.5, the weight of any internal tree node $w$ with children $u,v$ satisfies $\textsf{weight}(w)\leq\xi\cdot\min\{\textsf{weight}(T_{u}),\textsf{weight}(T_{v})\}$. Therefore, we may apply Lemma 3.6 to tree $T$, obtaining $\textsf{weight}(T)\leq(\xi+2)\cdot|\textsf{L}(T)|^{\log_{2}(\xi/2+1)}\cdot\textsf{weight}(L(T))$, and thus

[TABLE]

The last inequality follows as $|\textsf{L}(T)|$, the number of $T$ leaves, is equal to the number of Opt-edges on cycle $C$, which is clearly at most $m$.

3.4. Cost of final ALG-edges

In the previous section, we derived a bound on the cost of all non-final Alg-edges. The following lemma shows that the cost of final Alg-edges contribute at most a constant factor to the competitive ratio.

Lemma 3.9**.**

Let $e$ be a final Alg-edge matched at time $\tau$ and $C$ be the alternating cycle containing $e$. Then $\textsf{cost}_{\mathrm{ALG}}(e)\leq(1+\alpha)\cdot\max\{\alpha^{-1},(\beta+1)/(\beta-1)\}\cdot(\textsf{cost}_{\mathrm{ALG-NF}}(C)+\textsf{cost}_{\mathrm{OPT}}(C))$.

Proof 3.10**.**

Fix a final Alg-edge $e=(p,q)$, where $\textsf{atime}(q)\geq\textsf{atime}(p)$. By the budget sufficiency condition of Alg,

[TABLE]

Our goal now is to bound $\textsf{wait}_{\tau}(p)+\textsf{wait}_{\tau}(q)$ in terms of $\textsf{dist}(p,q)$ or $\textsf{atime}(q)-\textsf{atime}(p)$. Observe that whenever Alg matches two requests, the budget sufficiency condition of Alg or one of the inequalities of the budget balance condition is satisfied with equality. We apply this observation to pair $(p,q)$.

• •

If the budget sufficiency condition holds with equality, $\alpha\cdot(\textsf{wait}_{\tau}(p)+\textsf{wait}_{\tau}(q))=\textsf{dist}(p,q)$, and therefore $\textsf{wait}_{\tau}(p)+\textsf{wait}_{\tau}(q)=\alpha^{-1}\cdot\textsf{dist}(p,q)$.

• •

If the budget balance condition holds with equality, $\beta\cdot\textsf{wait}_{\tau}(q)=\textsf{wait}_{\tau}(p)$. Then,

[TABLE]

Hence, in either case it holds that

[TABLE]

Finally, we bound $\textsf{dist}(p,q)+|\textsf{atime}(q)-\textsf{atime}(p)|$ in terms of costs of other edges of $C$. These edges form a path $P=(a_{1},a_{2},\ldots,a_{\ell})$, where $a_{1}=p$ and $a_{\ell}=q$. By the triangle inequality applied to distances and time differences (in the same way as in (1)), we obtain that

[TABLE]

The lemma follows immediately by combining (3), (4) and (5).

3.5. The competitive ratio

Finally, we optimize constants $\alpha$ and $\beta$ used throughout the previous sections and bound the competitiveness of Alg.

Theorem 3.11**.**

For $\beta=2$ and $\alpha=1/2$, the competitive ratio of Alg is $O(m^{\log_{2}5.5})=O(m^{2.46})$, where $2m$ is the number of requests in the input sequence.

Proof 3.12**.**

The union of matchings constructed by Alg and Opt can be split into a set $\mathcal{C}$ of disjoint cycles. It is sufficient to show that we have the desired performance guarantee on each cycle from $\mathcal{C}$.

Fix a cycle $C\in\mathcal{C}$. Let $e=(p,q)$ be the final Alg-edge of $C$. By Lemma 3.9, $\textsf{cost}_{\mathrm{ALG}}(e)\leq 4.5\cdot\left(\textsf{cost}_{\mathrm{ALG-NF}}(C)+\textsf{cost}_{\mathrm{OPT}}(C)\right)$. Therefore, the competitive ratio of Alg is at most

[TABLE]

where the second inequality follows by Lemma 3.7.

4. Relating weights in trees (proof of Lemma 3.6)

We start with the following technical claim that will facilitate the inductive proof of Lemma 3.6.

Lemma 4.1**.**

Fix any constant $\xi\geq 0$ and let $f(a)=a^{\log_{2}(\xi+2)}$. Then, $\xi\cdot\min\{f(x),f(y)\}+f(x)+f(y)\leq f(x+y)$ for all $x,y\geq 0$.

Proof 4.2**.**

Fix any $z\geq 0$ and let $g_{z}(a)=(\xi+1)\cdot f(a)+f(z-a)$. We observe that $g_{z}(0)=f(z)$ and $g_{z}(z/2)=(\xi+1)\cdot f(z/2)+f(z/2)=(\xi+2)\cdot(z/2)^{\log_{2}(\xi+2)}=z^{\log_{2}(\xi+2)}=f(z)$. Moreover, the function $g_{z}$ is convex as it is a sum of two convex functions. As $g_{z}(0)=g_{z}(z/2)=f(z)$, by convexity, $g_{z}(a)\leq f(z)$ for any $a\in[0,z/2]$.

To prove the lemma, assume without loss of generality that $x\leq y$. By the monotonicity, $f(x)\leq f(y)$, and therefore

[TABLE]

The last inequality follows as $x\leq(x+y)/2$.

Proof 4.3** (Proof of Lemma 3.6).**

We scale weights of all nodes, so that the average weight of each leaf is $1$, i.e., we define a scaled weight function ws as

[TABLE]

Note that ws also satisfies $\textsf{ws}(w)\leq\xi\cdot\min\{\textsf{ws}(T_{u}),\textsf{ws}(T_{v})\}$. Moreover, since we scaled all weighs in the very same way, ${\textsf{ws}(T)}/{\textsf{ws}(\textsf{L}(T))}={\textsf{weight}(T)}/{\textsf{weight}(\textsf{L}(T))}$, and hence to show the lemma, it suffices to bound the term $\textsf{ws}(T)/\textsf{ws}(\textsf{L}(T))$.

For any node $w\in T$ and the corresponding subtree $T_{w}$ rooted at $w$, we define $\textsf{size}(T_{w})=\textsf{ws}(\textsf{L}(T_{w}))+|\textsf{L}(T_{w})|$. We inductively show that for any node of $w\in T$, it holds that

[TABLE]

For the induction basis, assume that $w$ is a leaf of $T$. Then,

[TABLE]

where the last inequality follows as $\textsf{size}(T_{w})\geq|L(T_{w})|=1$ and $\xi>0$.

For the inductive step, let $w$ be a non-leaf node of $T$ and let $u$ and $v$ be its children. Then,

[TABLE]

The first inequality follows by the lemma assumption and the second one by the inductive assumptions for $T_{u}$ and $T_{v}$. The last inequality is a consequence of Lemma 4.1 and the final equality follows by the additivity of function size.

Recall that we scaled weights so that $\textsf{ws}(\textsf{L}(T))=|\textsf{L}(T)|$. Therefore, applying (6) to the whole tree $T$ yields $\textsf{ws}(T)\leq(\textsf{ws}(\textsf{L}(T))+|\textsf{L}(T)|)^{\log_{2}(\xi+2)}=(2\cdot|\textsf{L}(T)|)^{\log_{2}(\xi+2)}=(\xi+2)\cdot|\textsf{L}(T)|^{\log_{2}(\xi+2)}$. Hence,

[TABLE]

which concludes the proof.

5. Conclusions

We showed a deterministic algorithm Alg for the MPMD problem whose competitive ratio is $O(m^{\log_{2}5.5})$. The currently best lower bound (holding even for randomized solutions) is $\Omega(\log n/\log\log n)$ [3]. A natural research direction would be to narrow this gap.

It is not known whether the analysis of our algorithm is tight. However, one can show that its competitive ratio is at least $\Omega(m^{\log_{2}1.5})=\Omega(m^{0.58})$. To this end, assume that all requests arrive at the same time. For such input, Opt does not pay for delays and simply returns the min-cost perfect matching. On the other hand, Alg computes the same matching as a greedy routine (i.e., it greedily connects two nearest, not yet matched requests). Hence, even if we neglect the delay costs of Alg, its competitive ratio would be at least the approximation ratio of the greedy algorithm for min-cost perfect matching. The latter was shown to be $\Theta(m^{\log_{2}1.5})$ by Reingold and Tarjan [40].

The reasoning above indicates an inherent difficulty of the problem. In order to beat the $\Omega(m^{\log_{2}1.5})$ barrier, an online algorithm has to handle settings when all requests are given simultaneously more effectively. In particular, for such and similar input instances it has to employ a non-local and non-greedy policy of choosing requests to match.