key: cord-025439-3rlvmwce
authors: Christman, Ananya; Chung, Christine; Jaczko, Nicholas; Li, Tianzhi; Westvold, Scott; Xu, Xinyue; Yuen, David
title: New Bounds for Maximizing Revenue in Online Dial-a-Ride
date: 2020-04-30
journal: Combinatorial Algorithms
DOI: 10.1007/978-3-030-48966-3_14
sha: 
doc_id: 25439
cord_uid: 3rlvmwce

In the Online-Dial-a-Ride Problem (OLDARP) a server travels to serve requests for rides. We consider a variant where each request specifies a source, destination, release time, and revenue that is earned for serving the request. The goal is to maximize the total revenue earned within a given time limit. We prove that no non-preemptive deterministic online algorithm for OLDARP can be guaranteed to earn more than half the revenue earned by [Formula: see text]. We then investigate the segmented best path ([Formula: see text]) algorithm of [8] for the general case of weighted graphs. The previously-established lower and upper bounds for the competitive ratio of [Formula: see text] are 4 and 6, respectively, under reasonable assumptions about the input instance. We eliminate the gap by proving that the competitive ratio is 5 (under the same assumptions). We also prove that when revenues are uniform, [Formula: see text] has competitive ratio 4. Finally, we provide a competitive analysis of [Formula: see text] on complete bipartite graphs.

In the On-Line Dial-a-Ride Problem (OLDARP), a server travels through a graph to serve requests for rides. Each request specifies a source, which is the pick-up (or start) location of the ride, a destination, which is the delivery (or end) location, and the release time of the request, which is the earliest time the request may be served. Requests arrive over time; specifically, each arrives at its release time and the server must decide whether to serve the request and at what time, with the goal of meeting some optimality criterion. The server has a capacity that specifies the maximum number of requests it can serve at any time. Common optimality criteria include minimizing the total travel time (i.e. makespan) to satisfy all requests, minimizing the average completion time (i.e. latency), or maximizing the number of served requests within a specified time limit. In many variants preemption is not allowed, so if the server begins to serve a request, it must do so until completion. On-Line Dial-a-Ride Problems have many practical applications in settings where a vehicle is dispatched to satisfy requests involving pick-up and delivery of people or goods. Important examples include ambulance routing, transportation for the elderly and disabled, taxi services including Ride-for-Hire systems (such as Uber and Lyft), and courier services.

We study a variation of OLDARP where in addition to the source, destination and release time, each request also has a priority and there is a time limit within which requests must be served. The server has unit capacity and the goal for the server is to serve requests within the time limit so as to maximize the total priority. A request's priority may simply represent the importance of serving the request in settings such as courier services. In more time-sensitive settings such as ambulance routing, the priority may represent the urgency of a request. In profit-based settings, such as taxi and ride-sharing services, a request's priority may represent the revenue earned from serving the request. For the remainder of this paper, we will refer to the priority as "revenue," and to this variant of the problem as ROLDARP. Note that if revenues are uniform the problem is equivalent to maximizing the number of served requests.

The Online Dial-a-Ride problem was introduced by Feuerstein and Stougie [10] and several variations of the problem have been studied since. For a comprehensive survey on these and many other problems in the general area of vehicle routing see [12] and [16] . Feuerstein and Stougie studied the problem for two different objectives: minimizing completion time and minimizing latency. For minimizing completion time, they showed that any deterministic algorithm must have competitive ratio of at least 2 regardless of the server capacity. They presented algorithms for the cases of finite and infinite capacity with competitive ratios of 2.5 and 2, respectively. For minimizing latency, they proved that any algorithm must have a competitive ratio of at least 3 and presented a 15-competitive algorithm on the real line when the server has infinite capacity. Ascheuer et al. [2] studied OLDARP with multiple servers with the goal of minimizing completion time and presented a 2-competitive algorithm. More recently, Birx et al. [5] studied OLDARP on the real line and presented a new upper bound of 2.67 for the smartstart algorithm [2] , which improves the previous bounds of 3.41 [14] and 2.94 [4] . For OLDARP on the real line, Bjelde et al. [6] present a preemptive algorithm with competitive ratio 2.41. The Online Traveling Salesperson Problem (OLTSP), introduced by Ausiello et al. [3] and also studied by Krumke [15] , is a special case of OLDARP where for each request the source and destination are the same location. There are many studies of variants of OLDARP and OLTSP [3, 11, 13, 15] that differ from the variant that we study which we omit here due to space limitations.

In this paper, we study OLDARP where each request has a revenue that is earned if the request is served and the goal is to maximize the total revenue earned within a specified time limit; the offline version of the problem was shown to be NP-hard in [8] . More recently, it was shown that even the special case of the offline version with uniform revenues and uniform weights is NP-hard [1] . Christman and Forcier [9] presented a 2-competitive algorithm for OLDARP on graphs with uniform edge weights. Christman et al. [8] showed that if edge weights may be arbitrarily large, then regardless of revenue values, no deterministic algorithm can be competitive. They therefore considered graphs where edge weights are bounded by a fixed fraction of the time limit, and gave a 6competitive algorithm for this problem. Note that this is a natural subclass of inputs since in real-world dial-a-ride systems, drivers would be unlikely to spend a large fraction of their day moving to or serving a single request.

In this work we begin with improved lower and upper bounds for the competitive ratio of the segmented best path (sbp) algorithm that was presented in [8] . We study sbp because it has the best known competitive ratio for ROLDARP and is a relatively straightforward algorithm. In [8] , it was shown that sbp's competitive ratio has lower bound 4 and upper bound 6, provided that the edge weights are bounded by a fixed fraction of the time limit, i.e. T /f where T is the time limit and 1 < f < T, and that the revenue earned by the optimal offline solution (opt) in the last 2T /f time units is bounded by a constant. This assumption is imposed because, as we show in Lemma 1, no non-preememptive deterministic online algorithm can be guaranteed to earn this revenue. We note that as T grows, the significance of the revenue earned by opt in the last two time segments diminishes.

We then close the gap between the upper and lower bounds of sbp by providing an instance where the lower bound is 5 (Sect. 3.1) and a proof for an upper bound of 5 (Sect. 3.2). We note that another interpretation of our result is that under a weakened-adversary model where opt has two fewer time segments available, while sbp has the full time limit T , sbp is 5-competitive. We then investigate the problem for uniform revenues (so the objective is to maximize the total number of requests served) and prove that sbp earns at least 1/4 the revenue of opt, minus an additive term linear in f , the number of time segments (Sect. 4). This variant is useful for settings where all requests have equal priorities such as not-for-profit services that provide transportation to elderly and disabled passengers and courier services where deliveries are not prioritized.

We then consider the problem for complete bipartite graphs; for these graphs every source is from the left-hand side and every destination is from the righthand side (Sect. 5). These graphs model the scenario where only a subset of locations may be source nodes and a disjoint subset may be destinations, e.g. in the delivery of goods from commercial warehouses only the warehouses may be sources and only customer locations may be destinations. We refer to this problem as ROLDARP-B. We first show that if edge weights are not bounded by a minimum value, then ROLDARP on general graphs reduces to ROLDARP-B. We therefore impose a minimum edge weight of kT /f for some constant k such that 0 < k ≤ 1. We show that if revenues are uniform, sbp has competitive ratio 1/k . Finally, we show that if revenues are nonuniform sbp has competitive ratio 1/k , provided that the revenue earned by opt in the last 2T /f time units is bounded by a constant. (This assumption is justified by Lemma 1 which says no non-preemptive deterministic algorithm can be guaranteed to earn any fraction Table 1 . Bounds on the algorithm sbp for ROLDARP variants. † This upper bound assumes the optimal revenue of the last two time segments is bounded by a constant. ‡ This upper bound assumes the number of time segments is constant. § k is a constant where 0 < k ≤ 1 such that the minimum edge weight is kT /f where T is the time limit and 1 < f < T .

Competitive ratio ρ of SBP for ROLDARP Uniform revenue Nonuniform revenue

of what is earned by opt in the last 2T /f time units.) Table 1 summarizes our results.

The Revenue-Online-Dial-a-Ride Problem (ROLDARP) is formally defined as follows. The input is an undirected complete graph

there is a weight w u,v > 0, which represents the amount of time it takes to traverse (u, v). 1 One node in the graph, o, is designated as the origin and is where the server is initially located (i.e. at time 0). The input also includes a time limit T and a sequence of requests, σ, that are dynamically issued to the server. Each request is of the form (s, d, t, p) where s is the source node, d is the destination, t is the time the request is released, and p is the revenue (or priority) earned by the server for serving the request. The server does not know about a request until its release time t. To serve a request, the server must move from its current location x to s, then from s to d. The total time for serving the request is equal to the length (i.e. travel time) of the path from x to s to d, and the earliest time a request may be released is at t = 0. For each request, the server must decide whether to serve the request and if so, at what time. A request may not be served earlier than its release time and at most one request may be served at any given time. Once the server decides to serve a request, it must do so until completion. The goal for the server is to serve requests within the time limit so as to maximize the total earned revenue. (The server need not return to the origin and may move freely through the graph at any time, even if it is not traveling to serve a request.)

The algorithm segmented best path (sbp) [8] starts by splitting the total time T into f segments each of length T /f (recall that f is fixed and 1 < f < T ).

Input is complete graph G with time limit T and maximum edge weight T /f. At the start of ti, find the max-revenue-request-set, R. 8:

if R is non-empty then 9:

Move to the source location of the first request in R. 10:

At the start of ti+1, serve request-set R. 11: else 12:

Remain idle for ti and ti+1 13: end if 14:

Let i = i + 2.

At the start of a time segment, the server determines the max-revenue-requestset, i.e. the maximum revenue set of unserved requests that can be served within one time segment, and moves to the source of the first request in this set. During the next time segment, it serves the requests in this set. It continues this way, alternating between moving to the source of first request in the max-revenuerequest-set during one time segment, and serving this request-set in the next time segment. To find the max-revenue-request-set, the algorithm maintains a directed auxiliary graph, G to keep track of unserved requests (an edge between two vertices u,v represents a request with source u and destination v). It finds all paths of length at most T /f between every pair of nodes in G and returns the path that yields the maximum total revenue (please refer to [8] for full details).

It was observed in [8] that no deterministic online algorithm can be guaranteed to serve the requests served by opt during the last time segment and the authors proved that sbp is 6-competitive barring an additive factor equal to the revenue earned by opt during the last two time segments. More formally, let rev(sbp(t j )) and rev(opt(t j )) denote the revenue earned by sbp and opt respectively during the j-th time segment.

It was also shown in [8] that as T grows, the competitive ratio of sbp is at best 4 (again with the additive term equal to rev(opt(t f )) + rev(opt(t f −1 ))), resulting in a gap between the upper and lower bounds.

We first present a general lower bound for this problem and show that no non-preemptive deterministic online algorithm (e.g. sbp) can be better than 2-competitive with respect to the revenue earned by the offline optimal schedule (ignoring the last two time segments; see Lemma 1, below).

can be guaranteed to earn more than half the revenue earned by opt in the first T − 2T /f time units. This is the case whether revenues are uniform or nonuniform.

Proof (Sketch). The adversary repeatedly releases requests such that depending on which request(s) the algorithm serves, other request(s) are released that the algorithm cannot serve in time. This scheme requires carefully constructed edge weights, release times, and revenues so that the optimal offline revenue is always twice that of any online algorithm. Please see the full version of the paper for details [7] .

We now show that no non-preemptive deterministic online algorithm (e.g. sbp) can be competitive with the revenue earned by opt in the last two segments of time. We note that this claim applies to the version of non-preemption where, as in real-world systems like Uber/Lyft, once the server decides to serve a request, it must move there and serve it to completion. Proof (). The adversary releases a request in the last two time segments and if the online algorithm chooses not to serve it, no other requests will be released. If the algorithm chooses to serve it, another batch of requests will be released elsewhere that the algorithm cannot serve in time. Please see the full version of the paper for details [7] .

In this section we improve the lower and upper bounds for the competitive ratio of the segmented best path algorithm [8] . In particular, we eliminate the gap between the lower and upper bounds of 4 and 6, respectively, from [8] , by providing an instance where the lower bound is 5 and a proof for an upper bound of 5. Note that throughout this section we assume the revenue earned by opt in the last two time segments is bounded by some constant. We must impose this restriction on the opt revenue of the last two time segments because, as we showed in Lemma 1, no non-preemptive deterministic online algorithm can be guaranteed to earn any constant fraction of this revenue.

Theorem 2. If the revenue earned by opt in the last two time segments is bounded by some constant, and sbp is γ-competitive, then γ ≥ 5. Proof (Sketch). For the formal details, please refer to the proof of Theorem 2 in the full version [7] . Consider the instance depicted in Fig. 1 . Since T = 2hf in this instance, h represents "half" the length of one time segment, so only one request of length h + 1 fits within a single time segment for sbp. The general idea of the instance is that while sbp is serving every other request across the top row of requests (since the other half across the top are not released until after sbp has already passed them by), opt is serving the entire bottom row in one long chain, then also has time to serve the top row as one long chain.

We now show that sbp is 5-competitive by creating a modified, hypothetical sbp schedule that has additional copies of requests. First, we note that sbp loses a factor of 2 due to the fact that it serves requests during only every other time segment. Then, we lose another factor of two to cover requests in opt that overlap between time segments. Finally, by adding at most one more copy of the requests served by sbp to make up for requests that sbp "incorrectly" serves prior to when they are served by opt, we end up with 5 copies of sbp being sufficient for bounding the total revenue of opt. Note that while this proof uses some of the techniques of the proof of the 6-competitive upper bound in [8] , it reduces the competitive ratio from 6 to 5 by cleverly extracting the set of requests that sbp serves prior to opt before making the additional copies.

Let rev(opt) and rev(sbp) denote the total revenue earned by opt and sbp over all time segments t j from j = 1 . . . f. Theorem 3. If the revenue earned by opt in the last two time segments is bounded by some constant c, then sbp is 5-competitive, i.e., if rev(opt(t f )) + rev(opt(t f −1 )) ≤ c, then f j=1 rev(opt(t j )) ≤ 5 f j=1 rev(sbp(t j )) + c. Note that another interpretation of this result is that under a resource augmentation model where sbp has two more time segments available than opt, sbp is 5competitive.

Proof. We analyze the revenue earned by sbp by considering the time segments in pairs (recall that the length of a time segment is T /f for some 1 < f < T ). We refer to each pair of consecutive time segments as a time window, so if there are f time segments, there are f/2 time windows. Note that the last time window may have only one time segment.

For notational convenience we consider a modified version of the sbp schedule, that we refer to as sbp , which serves exactly the same set of requests as sbp, but does so one time window earlier. Specifically, if sbp serves a set of requests during time window i ≥ 2, sbp serves this set during time window i − 1 (so sbp ignores the set served by sbp in window 1). We note that the schedule of requests served by sbp may be infeasible, and that it will earn at most the amount of revenue earned by sbp.

Let B i denote the set of requests served by opt in window i that sbp already served before in some window j < i. And let B be the set of all requests that have already been served by sbp in a previous window by the time they are served in the opt schedule. Formally, B = Let opt(t j ) denote the set of requests served by opt in time segment t j . Let opt i denote the set of requests served by opt in the time segment of window i with greater revenue, i.e. opt i = arg max{rev(opt(t 2i−1 )), rev(opt(t 2i ))}. Note this set may include a request that was started in the prior time segment, as long as it was completed in the time segment of opt i . Let rev(opt i ) denote the revenue earned in opt i .

Let sbp i denote the set of requests served by sbp in window i and let rev(sbp i ) denote the revenue earned by sbp i . Let H denote the chronologically ordered set of time windows w where rev(opt w ) > rev(sbp w ), and let h j denote the jth time window in H. We refer to each window of H as a window with a "hole," in reference to the fact that sbp does not earn as much revenue as opt in these windows. In each window h j there is some amount of revenue that opt earns that sbp does not. In particular, there must be a set of requests that opt serves in window h j that sbp does not serve in h j . Note that this set must be available for sbp in h j since opt does not include the set B.

Let opt hj = A j ∪ C * j , where A j is the subset of requests served by both opt and sbp in h j and C * j is the subset of opt requests available for sbp to serve in h j but sbp chooses not to serve. Let us refer to the set of requests served by sbp in h j as sbp hj = A j ∪ C j for some set of requests C j . Note that if opt hj = A j ∪ C * j can be executed within a single time segment, then rev(C j ) ≥ rev(C * j ) by the greediness of sbp . However, since h j is a hole we know that the set opt hj cannot be served within one time segment.

Our plan is to build an infeasible schedule sbp that will be similar to sbp but contain additional "copies" of some requests such that no windows of sbp contain holes. We first initialize sbp to have the same schedule of requests as sbp . We then add additional requests to h j for each j = 1 . . . |H|, based on opt hj .

Consider one such window with a hole h j , and let k be the index of the time segment corresponding to opt hj . We know opt must have begun serving a request of opt hj in time segment t k−1 and completed this request in time segment t k . Let us use r * to denote this request that "straddles" the two time segments.

After the initialization of sbp = sbp , recall that the set of requests served by sbp in h j is sbp hj = A j ∪ C j for some set of requests C j . We add to sbp a copy of a set of requests. There are two sub-cases depending on whether r * ∈ C * j or not.

Case r * ∈ C * j . In this case, by the greediness of sbp, and the fact that both r * alone and C * j \{r * } can separately be completed within a single time segment, we have: rev(C j ) ≥ max{rev(r * ), rev(C * j \ {r * })} ≥ 1 2 rev(C * j ). We then add a copy of the set C j to the sbp schedule, so there are two copies of C j in h j . Note that for sbp, h j will no longer be a hole since: rev(opt hj ) = rev(A j )+rev(C * j ) ≤ rev(A j ) + 2 · rev(C j ) = rev(sbp hj ).

Case r * / ∈ C * j . In this case C * j can be served within one time segment but sbp chooses to serve A j ∪ C j instead. So we have rev(A j ) + rev(C j ) ≥ rev(C * j ), therefore we know either rev(A j ) ≥ 1 2 rev(C * j ) or rev(C j ) ≥ 1 2 rev(C * j ). In the latter case, we can do as we did in the first case above and add a copy of the set C j to the sbp schedule in window h j , to get rev(opt hj ) ≤ rev(sbp hj ), as above. In the former case, we instead add a copy of A j to the sbp schedule in window h j . Then again, for sbp, h j will no longer be a hole, since this time: rev(opt hj ) = rev(A j ) + rev(C * j ) ≤ 2 · rev(A j ) + rev(C j ) = rev(sbp hj ). Note that for all windows w / ∈ H that are not holes, we already have rev(sbp w ) ≥ rev(opt w ). So we have

where the second inequality is because sbp contains no more than two instances of every request in sbp . Combining (1) with the fact that sbp earns at most what sbp does yields

Since sbp serves in only one of two time segments per window, we have

). Hence, by the definition of opt, and by (2) we can say

rev(sbp(t j )) + rev(opt(t f −1 )) + rev(opt(t f )). (3) Now we must add in any request in B, such that opt serves the request in a time window after sbp serves that request. By definition of B (as the set of all requests that have been served by sbp in a previous window) B may contain at most the same set of requests served by sbp . Therefore rev(B) ≤ rev(sbp ), so rev(B) ≤ rev(sbp). By the definition of opt, opt = opt + B, so

And by combining (3)-(4) with the fact that rev(B) ≤ rev(sbp), we have

We now consider the setting where revenues are uniform among all requests, so the goal is to maximize the total number of requests served. This variant is useful for settings where all requests have equal priorities, for example for notfor-profit services that provide transportation to elderly and disabled passengers. The proof strategy is to carefully consider the requests served by sbp in each window and track how they differ from that of opt. The final result is achieved through a clever accounting of the differences between the two schedules, and bounding the revenue of the requests that are "missing" from sbp.

We note that the lower bound instance of Theorem 2 can be modified to become a uniform-revenue instance that has ratio 5 − 14/f. We further note that the lower bound instance provided in [8] immediately establishes a lower bound instance for sbp that has a ratio of 4. We now show that opt earns at most 4 times the revenue of sbp in this setting if we assume the revenue earned by opt in the last two time segments is bounded by a constant, and allow sbp an additive bonus of f . Note that even when revenues are uniform, no nonpreemptive deterministic online algorithm can earn the revenue earned by opt in the last two time segments (see Lemma 1) . We begin with several definitions and lemmas.

As in the proof of Theorem 3, we consider a modified version of the sbp schedule, that we refer to as sbp , which serves exactly the same set of requests as sbp, but does so one time window earlier. For all windows i = 1, 2, ..., m, where m = f/2 − 1, we let S i denote the set of requests served by sbp in window i and S * 2. The set S * i cannot be served within one time segment. This means there must be one request in S * i that opt started serving in the previous time segment. We refer to this straddling request as r * . There are three sub-cases based on where r * appears. (a) If r * ∈ Y * i , then due to the greediness of sbp , we know that

since otherwise sbp would have chosen to serve r * . We also know

since otherwise sbp would have chosen to serve Y * i \{r * }. From (5), we have |X i | + |Y i | ≥ 1 and from (6) 

Then r * is served by both opt and sbp . We know that A i ∪ Y * i \{r * } can be served within one time segment since r * is the only request that causes S * i to straddle between two time segments. Again by the greediness of sbp , we have rev

Therefore, for all cases, for window i, we have

Now we will build an infeasible schedule sbp that will be similar to sbp but contain additional "copies" of some requests such that no windows of sbp contain holes, i.e. such that rev(sbp) ≥ m i=1 rev(S * i ). We define a modified opt schedule which we refer to as opt such that

By Lemma 2 and Eq. (7), we can say rev(opt

This tells us that to form an sbp whose revenue is at least that of opt , we must "compensate" sbp by adding to it at most copies of all requests in the set Y i for all i = 1, 2, ..., m, plus m "dummy requests." In other words,

We know the total revenue of all Y i can not exceed the total revenue of sbp , hence we have

Combining (8) and (9), we get rev(opt ) ≤ 2 rev(sbp ) + m, which means

Recall that S * i is the set of requests served by opt during the time segment of window i with greater revenue. In other words,

, which, combined with (10), gives us

We assumed that the total revenue of requests served in the last two time segments by opt is bounded by c. From (11), we get

We also know that the total revenue of requests served by sbp during the first m windows is less than or equal to the total revenue of sbp. Therefore, from (12) , we have f j=1 rev(S * (t j )) ≤ 4 f j=1 rev(S(t j )) + 2m + c.

In this section, we consider ROLDARP for complete bipartite graphs G = (V = V 1 ∪ V 2 , E), where only nodes in V 1 maybe be source nodes and only nodes in V 2 may be destination nodes. One node is designated as the origin and there is an edge from this node to every node in V 1 (so the origin is a node in V 2 ). Due strictly to space limitations, most proofs of theorems in this section are deferred to the full version of the paper [7] .

We refer to this problem as ROLDARP-B and the offline version as RDARP-B. We first show that if edge weights of the bipartite graph are not bounded by a minimum value, then the offline version of ROLDARP on general graphs, which we refer to as RDARP, reduces to RDARP-B. Since RDARP has been show in [1, 8] to be NP-hard (even if revenues are uniform), this means RDARP-B is NP-hard as well.

Theorem 5. The problem RDARP is poly-time reducible to RDARP-B. Also, RDARP with uniform revenues is poly-time reducible to RDARP-B with uniform revenues.

Proof (Sketch) . The idea of the reduction is to split each node into two nodes connected by an edge in the bipartite graph with a distance of . Then we turn each edge in the original graph into two edges in the bipartite graph. Please see the full version for details [7] .

We show that for bipartite graph instances, if revenues are uniform, we can guarantee that sbp earns a fraction of opt equal to the ratio between the minimum and maximum edge-length. Proof (Sketch). The proof idea is akin to that of Theorem 7 below. Please see the full version of the paper for details [7] .

In this section we show that even if revenues are nonuniform, we can still guarantee that sbp earns a fraction of opt equal to the ratio between the minimum and maximum edge-length, minus the revenue earned by opt in the last window. Recall that we refer to each pair of consecutive time segments as a time window. Note that no non-preemptive deterministic online algorithm can be competitive with any fraction of the revenue earned by opt in the last 2T /f time units (i.e. Lemma 1 also holds for ROLDARP-B with nonuniform revenues). Due space limitations, please refer to the full version of this work [7] for the proof of the following theorem. 

Maximizing the number of rides served for dial-a-ride

Online dial-a-ride problems: minimizing the completion time

Algorithms for the on-line travelling salesman 1

Tight analysis of the smartstart algorithm for online dial-a-ride on the line

Improved bounds for open online dial-a-ride on the line

Tight bounds for online TSP on the line

New bounds for maximizing revenue in online dial-a-ride

Revenue maximization in online dial-a-ride

Maximizing revenues for on-line dial-a-ride

On-line single-server dial-a-ride problems

Generalized online routing: new competitive ratios, resource augmentation, and asymptotic analyses

Online vehicle routing problems: a survey

Online travelling salesman problem on a circle

Online optimization: competitive analysis and beyond

On minimizing the maximum flow time in the online dial-a-ride problem

Typology and literature review for dial-aride problems

i denote the set of requests served by opt during the time segment of window i with greater revenue, i.e. S * i = arg max{rev(opt(t 2i−1 ), rev(opt(t 2i ))} where rev(opt(t j )) denotes the revenue earned by opt in time segment t j . We define a new set J * i as the set of requests served by opt during the time segment of window i with less revenue, i.e. J * i = arg min{rev(opt(t 2i−1 ), rev(opt(t 2i ))}.(1) A i is the set of requests that appear in both S * i and S i ; (2) X * i is the set of requests that appear in S w for some w = 1, 2, ..., i − 1. Note there is only one possible w for each individual request r ∈ X * i , because each request can be served only once; (3) Y * i is the set of requests such that no request from Y * i appears in S w for any w = 1, 2, ..., i − 1, i; (4) X i is the set of requests that appear in S * w for some w = 1, 2, ..., i − 1. Note there is only one possible w for each individual request r ∈ X i , because each request can be served only once; (5) Y i is the set of requests such that no request from Y i appears in S * w for any w = 1, 2, ...., m, or may not appear in any other sets. Also note that since each request can be served at most once, we have:Given the above definitions, we have the following lemma whose proof has been deferred to the full version of the paper [7] . It states that at any given time window, the cumulative requests of opt that were earlier served by sbp are no more than the number that have been served by sbp but not yet by opt. Proof. Note that since revenues are uniform, the revenue of a request-set U is equal to the size of the set U , i.e., rev(U ) = |U |. Consider each window i where rev(S * i ) > rev(S i ). Note that the set S * i may not fit within a single time segment. We consider two cases based on S * i . 1. The set S * i can be served within one time segment. Note that within S * i = A i ∪X * i ∪Y * i , X * i is not available for sbp to serve because sbp has served the requests in X * i prior to window i. Among requests that are available to sbp , sbp greedily chooses to serve the maximum revenue set that can be served within one time segment. Therefore, we have rev(X i ) + rev(Y i ) ≥ rev(Y * i ). Since revenues are uniform, we also have |X i | + |Y i | ≥ |Y * i |. If this is not the case, then sbp would have chosen to serve Y * i instead of X i ∪Y i since it is feasible for sbp to do so because the entire S * i can be served within one time segment.