Large Scale Real-time Ridesharing with Service Guarantee on Road Networks

Transcription

1 Large Scae Rea-time Ridesharing with Service Guarantee on Road Networks ABSTRACT Yan Huang University of North Texas Ruoming Jin Computer Science Kent State University Urban traffic gridock is a famiiar scene. At the same time, the mean occupancy rate of persona vehice trips in the United States is ony 1.6 persons per vehice mie. Ridesharing has the potentia to sove many environmenta, congestion, poution, and energy probems. In this paper, we introduce the probem of arge scae rea-time ridesharing with service guarantee on road networks. Trip requests are dynamicay matched to vehices whie trip waiting and service time constraints are satisfied. We first propose two scheduing agorithms: a branch-and-bound agorithm and an integer programing agorithm. However, these agorithms do not adapt we to the dynamic nature of the ridesharing probem. Thus, we propose kinetic tree agorithms which are better suited to efficient scheduing of dynamic requests and adjust routes on-the-fy. We perform experiments on a arge Shanghai taxi dataset. Resuts show that the kinetic tree agorithms outperform other agorithms significanty. 1. INTRODUCTION Urban and metropoitan areas are growing at tremendous rates and aready host more than haf of the entire human popuation. In an urban city ike Shanghai, there are approximatey 120,000 road intersections, 40,000 taxis, and more than 400,000 taxi trips per day (these numbers are derived from our experimenta dataset). Sight changes in weather such as ight rain wi send the city into a gridock. Despite mounting energy, poution, and congestion probems, many vehices continue to trave with empty seats. The mean occupancy rate of persona vehice trips in the United States is ony Work by Huang was partiay supported by the Nationa Science Foundation Under Grant No. IIS Work by Jin is partiay supported by NSF CAREER grant IIS , NIH/NIGMS grant: R01GM103309, and OSC (Ohio Supercomputer Center) grant: PGS0218. Work by Wang is partiay supported by NSFC grant # We woud ike to thank anonymous reviewers for their vauabe comments. This work is icensed under the Creative Commons Attribution- NonCommercia-NoDerivs 3.0 Unported License. To view a copy of this icense, visit Obtain permission prior to any use beyond those covered by the icense. Contact copyright hoder by emaiing info@vdb.org. Artices from this voume were invited to present their resuts at the 40th Internationa Conference on Very Large Data Bases, September 1st - 5th 2014, Hangzhou, China. Proceedings of the VLDB Endowment, Vo. 7, No. 14 Copyright 2014 VLDB Endowment /14/10. Favyen Bastani Massachusetts Institute of Technoogy fbastani@mit.edu Xiaoyang Sean Wang Schoo of Computer Science Shanghai Key Laboratory of Data Science Fudan University xywangcs@fudan.edu.cn 1.6 persons per vehice mie [10]. In 1999, if 4% of drivers had rideshared, it woud have offset the increase in congestion in the 68 examined urban areas competey [8]. Large scae private car or taxi sharing is becoming increasingy popuar. Tickengo [23], founded in 2011, is an open ride system where over 50,000 peope participate in ridesharing. Uber and Lyft aow for peer-to-peer ride matching through mobie-phone appications. Other companies incude Didi, Kuaidi, Avego, PickupPa, Zimride, and Zebigo. For most ridesharing systems today, the main operation modes are: (1) a driver gives/shares ride to/with a passenger; (2) a sma set of trips with same origin or destination, e.g. airport, are pre-arranged. A system where mutipe passengers/trips can be combined in reatime with service guarantees has many chaenges and has not been reaized; this is the focus of our paper. Rea-time ridesharing [23, 11], enabed by ow cost geo-ocating devices, smartphones, wireess networks, and socia networks, is a service that dynamicay arranges ad-hoc shared rides. In a reatime ridesharing with service guarantees on road networks probem (hereafter referred to simpy as ridesharing), a set of servers trave over a road network, cruising when not committed to any service and deivering passengers otherwise. Requests for rides are received over time, each consisting of two points, a source and a destination. Each request aso specifies two constraints, a waiting time, defining the maxima time aowed between making the request and receiving the service, and a service constraint, defining the acceptabe extra detour time from the shortest possibe trip duration. When a new request is received, it is evauated immediatey for server matching and scheduing. In order to be assigned to the request, a server must satisfy a constraints, both those of the new request and those of requests aready assigned to the server. The goa is to schedue requests in rea-time and minimize the servers trave times to compete a committed services whie meeting service guarantees. However, providing ridesharing service at the urban scae is a non-trivia probem. The core issue is to devise a rea-time matching agorithm that can quicky determine the best vehice (taxi, cab, bus) to satisfy incoming service requests. The traditiona dia-aride probem [9] aims to design vehice routes and schedues for sma to medium sized trip and vehice sets, e.g. a few vehices serving tens of requests, focusing on scenarios where requests are known ahead of time and servers originate and finish at known depots. These approaches are not designed to dea with the enormity of modern situations. Additionay, the dynamic and en route nature renders many of these agorithms either inappicabe or inefficient. 2017

2 In this paper, we focus on deveoping fast matching agorithms for arge scae rea-time ridesharing. Our agorithms are appicabe to existing services incuding taxi services, private vehice sharing, eevator systems, minibus services, and courier services. We have a demo of our ridesharing system [22] (a demo is avaiabe at: and this paper describes the core agorithms of the system. We acknowedge that there are other important factors which need to be considered for arge scae rea-time ridesharing, such as inter-persona, safety, socia discomfort, and pricing concerns. Possibe soutions incude rea-name profiing, reputation, or socia network trust buiding systems [10]. However, those are beyond the scope of this paper. 1.1 Probem Definition A road network G = V, E, W consists of a vertex set V and an edge set E. Each edge (u, v) E (u, v V ) is associated with a weight W (u, v) indicating the traveing cost aong the edge (u, v); this traveing cost may be a time or distance measure. Assuming driving speeds are avaiabe, time and distance can typicay be converted from one to the other, and here they are used interchangeaby. Given two nodes s and e in the road network, a path p between them is a vertex sequence (v 0, v 1,, v k ), where (v i, v i+1) is an edge in E, v 0 = s, and v k = e. The path cost W (p) = W (vi, v i+1) is the sum of a edge costs W (v i, v i+1) aong the path. The shortest path cost d(s, e) is defined as the minima cost for paths inking from s to e, i.e., d(s, e) = min p W (p); the corresponding path with cost d(s, e) is a shortest path from s to e. DEFINITION 1. (Trip Request) A trip request tr = s, e, w, ɛ with respect to a road network G = V, E, W is defined by a source s V, a destination e V, a maxima waiting time w (the maxima time aowed between making the request and receiving the service), and a service constraint ɛ (the extra detour acceptabe in a trip, bounding the overa time from s to e by (1 + ɛ)d(s, e)). We consider a unified waiting time w and service constraint ɛ for a requests specified by the service provider. However, our proposed agorithms can be easiy generaized to request-specific constraints. We further assume that G is static over time (e.g., we do not consider different path costs at different times of the day), but the agorithms we present can hande the case where G changes under a predetermined pattern. An accepted trip request tr has an assigned server (e.g., a taxi or private vehice). The server shoud pick up the rider at s and drop off the rider at e whie satisfying the constraints; the request is competed after the rider is dropped off. To dea with rea-time ride sharing, for each trip tr i = s i, e i, w, ɛ and its assigned server, we further introduce r i, the server s ocation when the request is made; and for each server, the server s trip set T R = {tr 1, tr 2,..., tr m} consists of a trip requests assigned to the server (both competed and uncompeted). Given this, a genera trip schedue S for a server with trip set of size m can be described in a sequence of 3m eements, (x 1, x 2,, x 3m), where an eement x j in the sequence is either a trip source point (s i, where a rider is picked up), a trip destination point (e i, where a rider is dropped off), or a trip request point (r i, where a request is received). Furthermore, a server is assumed to trave aong the shortest path in the road network when moving between two consecutive points in the trip schedue x i and x i+1. Thus, the trip cost d T (x i, x j) between any two points (x i, x j) in the trip schedue is denoted as d T (x i, x j) = d(x i, x i+1) + d(x i+1,i+2) + + d(x j 1, x j). The overa trip cost is simpy d T (x 1, x 3m). Figure 1 iustrates a trip schedue for four trip requests where the four pickups happen to be before any dropoff. Note that each moving server is associated with a trip schedue at any given time. A trip request tr i is active at time t if the request has been accepted but not yet competed. Then, each server is associated with a subset of active trips. For instance, in Figure 1, the active trips are {tr 1, tr 2, tr 3} at time t 1; {tr 1, tr 2, tr 3, tr 4} at time t 2; and {tr 1, tr 2, tr 4} at time t 3. Some trip schedues do not meet the service guarantees for each trip request in the schedue. We thus formay introduce the concept of a vaid trip schedue. DEFINITION 2. (Vaid Trip Schedue) A vaid trip schedue S = (x 1, x 2,, x 3m) for a trip set T R satisfies three conditions: 1. Point order For any trip tr i, et x i1 = r i, x i2 = s i, and x i3 = e i. Then, we must have i 1 < i 2 < i 3 (index represents the position of the points in the trip schedue S), i.e., the requesting point must happen before the pickup point, which must happen before its destination point; 2. Waiting time constraint For any trip tr i, the distance (waiting time) from the server s ocation when the request is made to the request s pickup point shoud be smaer than the waiting time constraint, i.e., d T (r i, s i) w; 3. Service constraint For any trip tr i, the actua trave distance from the pickup point to the dropoff point d T (s i, e i) shoud not be more than the shortest distance between them mutiped by the service constraint, i.e., d T (s i, e i) (1 + ɛ)d(s i, e i). To formay define the rea-time ridesharing probem, we further introduce the augmented vaid trip schedue: Assuming at time t, there are m active trips for a given server, et the current vaid trip schedue be (x 1, x 2,, x 3m), where t is between x c and x c+1. For a new trip request tr m+1 at time t, the augmented vaid trip schedue is (x 1, x 2,, x 3m+3), where x i = x i for i c, and x c+1 = r m+1. In other words, the augmented vaid trip schedue combines a new request with existing requests and shares the same partia trip schedue before the new request is made at time point t. Aso any augmented vaid trip schedue consists of two parts: the finished schedue (x 1, x 2,, x c, r m+1) and the new unfinished schedue (x c+2,, x 3m+3). The probem of Rea-Time Ridesharing is: Given a set of vehices on the road network G and a new incoming request tr, find the vehice that minimizes the overa trip cost for the augmented vaid trip schedue. The scheduing capacity c is a imit on the number of active trips that can be schedued to a vehice. The scheduing workoad per vehice is the number of active trips that needs to be schedued by the agorithm for a vehice. Note that since the finished schedue cannot be changed (because it has aready been executed), we essentiay need to find the minimum trip cost for the unfinished schedue. We aso observe that the minimum cost is usefu to determine the best match between an incoming trip request and the avaiabe vehices in a rea-time fashion. The minimum cost, then, is greedy in nature: When additiona new requests come in, the past optima matching between a trip request and the server may not be the minimum anymore. However, in rea-time, this type of optimaity tends to be the best we can achieve and can be easiy understood and accepted by riders as the future requests are not avaiabe. We choose not to batch process 2018

3 r1 s1 r2 r3 r4 s4 e4 t1 t2 t3 Figure 1: Trip Schedue. s i: trip starting point; e i: trip ending point; r i server ocation when request of trip tr i comes in. requests at a fixed time interva and prefer instant feedback to the users. The batch processing may achieve better system scheduing but is based on sacrificed user experience, e.g. standing by curbside and waiting for 5 minutes to know the resuts. Furthermore, our system is user-centered and does not try to vioate a user s service constraints in order to improve overa system performance. Finay, we note that the probem of rea-time ridesharing is NPhard as the cassica Hamitonian path probem can be reduced to this probem (assuming a the trips have the same ending points and requested in amost the same time). For simpicity, the detais of NP-hardness proof is omitted here. 1.2 Chaenges The main chaenge in ridesharing is to determine how to hande trip requests as they fow into the system in rea-time. From a server s point of view, for any new request, the server may have aready seected (and be executing) a trip schedue for its existing customers. Given this, how can we quicky hep it to determine whether it can accommodate a new request? Note that in order to respond to such a request, one may have to reshuffe the predefined schedue and the reshuffed one has to be a vaid schedue. Furthermore, in a arge metropoitan area such as Shanghai, the number of requests can be very arge, especiay during rush hours. Ceary, for a trip request tr i, servers that are farther than w from the pickup ocation are unabe to respond to the request. Even though potentia servers can be fitered through a dynamic spatia indexing structure [21, 18, 15] on the moving servers, the existing approaches can sti be very computationay expensive and resut in ow response times. Most current agorithms are designed for offine computation. The approaches that use branch-and-bound [16] or integer programing [5] to schedue new requests do not take the dynamic nature of the probem into consideration. Testing if a new request can be accommodated essentiay invoves a rescheduing of the unfinished trips and the new request without reusing the computations in the previous round. Their cacuation time was measured in minutes or hours whie we require miisecond response time. 1.3 Contributions To dea with the chaenges, our idea is based on a simpe observation. For a new vaid schedue accommodating the new request tr i, if we simpy drop the three points r i, s i, e i from the trip schedue, then the resuting trip schedue is a vaid trip schedue. In other words, ony a vaid trip schedue can be extended to accommodate a new request. Given this, a potentia approach for the ridesharing probem is to simpy materiaize every vaid trip schedue; then, when a new request arrives, we can check if any vaid trip schedues can be extended to hande the new request. This approach is promising because its incrementa nature saves many redundant computations: We do not need to recompute the vaid trip schedue competey from scratch on each new request. However, in order to impement such a strategy, we have to dea with the foowing chaenges: 1) Woud the materiaization incur too much memory cost? In other words, can we store the materiaized schedues compacty? 2) How can we efficienty maintain the materiaization? Note that when the server moves, the materiaization needs to be updated. 3) How can the materiaization hep to test quicky whether a new request can be handed? 4) How can the materiaization be updated when a new request is accepted? This paper makes the foowing contributions: We formuate the ridesharing probem in a way that resembes the scenario enabed by current ocating and communication technoogies; We first propose branch-and-bound and mixed-integer programing agorithms for the probem. We then propose a kinetic tree approach for the probem. The tree structure ends itsef naturay to the dynamic nature of the probem; When the pickup or dropoff ocations are cose to each other, any permutation of the ocations can be vaid, rendering the constraints ineffective and resuting in a arge number of vaid schedues. We propose a hotspot-based agorithm that ignores schedues that are amost dupicates to effectivey reduce the number of vaid schedues whie providing a bound on the error for the soution under certain conditions; We compare our approach to the branch-and-bound and mixed integer programing approaches that are traditionay used, aong with the brute-force agorithm. Experiments on a arge taxi dataset show that the tree approach is severa times to a magnitude faster in response time. We further test tree agorithms on various arger probems to show the performance and effectiveness of the optimizations proposed. 1.4 Outine We describe the overa ridesharing framework in Section 2. We present a branch-and-bound agorithm and a mixed-integer programming agorithm for scheduing a request in Section 3. We then propose the kinetic tree approach in Section 4. In section 5, we dea with the issue of arge trees using a hotspot-based agorithm. Experiment resuts are presented in Section 6 foowed by reated work in Section 7 and concusions in Section FRAMEWORK When a request is submitted to the system, the request is matched with candidate servers. Because most vehices wi be outside the waiting time constraint w of a trip request at the time that the request is received, we wi need a ow maintenance cost indexing method to fiter out servers outside the waiting time constraint. So, we use a simpe grid-based indexing. A grid of uniform ce size gr. is superimposed on the region, and servers are mapped into the ce corresponding to their current ocation (the mapping is updated when a server passes between ces). When a new trip request tr is received in grid ce g, we first cacuate the cost of assigning the request to each server within cei( w D ) grid ces from g aong both axes where D is the speed gr. of server. We then assign tr to the server with the minimum unfinished schedue cost, or permanenty reject the request if no server 2019

4 can feasiby hande it. Because the user gets instant feedback, the user may decide to resubmit the request, possiby with reaxed service constraints. We can aso aow progressivey reaxing the constraints unti the request is satisfied. To cacuate the minimum unfinished schedue cost, an instance of the scheduing agorithm is associated with each server. An agorithm instance maintains the corresponding data structure as the server moves aong its route in the road network through shortest paths between consecutive points. The shortest paths are cacuated and recorded for each server. Computing shortest path on road networks has been widey studied (see [6] for an extensive review). Recenty, Abraham et a. [2] discovered that severa of the fastest distance computation agorithms need the underying graphs to have sma highway dimension. Furthermore, they demonstrate the method with the best time bounds is actuay a abeing agorithm [2]. We choose to use the state-of-art hubabeing agorithm - a fast and practica agorithm to heuristicay construct the distance abeing on arge road networks. After the abeing process, each vertex records a set of intermediate vertices (and distances to them) for the shortest path computation [1]; and they are packed and stored in an array. To answer the distance query from one vertex to another, we perform a inear scan of the abeing arrays of both vertices, and seect the minima distance using a the intermediate vertices existing in both arrays. The most chaenging probem now is: for a given request and a candidate server, find the augmented vaid trip schedues in order to find the server with minimum unfinished schedue cost. The agorithms for this probem wi be described in the next three section. 3. BRANCH-AND-BOUND AND MIXED IN- TEGER PROGRAMMING ALGORITHMS The brute-force agorithm to find the augmented vaid trip schedues is straightforward. We enumerate a of the permutations and then check the constraints. However, this can be expensive. Two approaches that are often used in soving the reated dia-a-ride probem [9] can increase execution speed: branch-and-bound agorithm [4] and integer programming approach [5]. We first propose a modified branch-and-bound agorithm for our probem, and then formuate the probem as a mixed-integer programming probem. 3.1 Branch and Bound Agorithm The branch-and-bound agorithm systematicay enumerates a candidate schedues and organizes the candidates into a schedue tree. It estimates and maintains a ower bound of each partiay constructed schedue and stops buiding candidate schedues that have ower bounds greater than the best soution found so far. The agorithm first expands the partia candidate with the owest ower bound (best-first search). Assume at time t, there are m active trips for the given server. Let the current vaid trip schedue be (x 1, x 2,, x 3m), where t is between x c and x c+1. For a new trip request tr m+1, we need to re-schedue the pickup and dropoff points N = {x c+1, x c+2,, x 3m, r m+1, s m+1, e m+1}. Points in N form a compete graph with edge weights being the shortest path distances between nodes. We attempt to find the schedue through the graph that passes through each node once but, unike a tour, does not return to the first node. The schedue aso has to begin at the ocation of the server when request r m+1 is submitted. In Figure 2 (a), when request r 2 comes in, s 1 is aready picked up. So, ony N = {e 1, s 2, e 2} needs to be schedued and the schedue must start from r 2. We start with the initia schedue tree ST =< r m+1 >, and initiaize the cost of the optima schedue to. We then iterativey r1 s1 r (a) (b) 4 r2 1 (3,5) (5,6) (6,6) r2 (5,8) (10,11) (c) (4,7) Figure 2: Iustration of Branch-and-Bound Agorithm. (a) When request r 2 comes, ony {e 1, s 2, e 2} need to be schedued; (b) Road network distance and minima incident edge cost; (c) When (r 2, e 1, e 2, s 2) with cost 6 is found, partia schedues with estimated costs above 6 are terminated. perform a best-first-search to expand the partia schedue S =< r m+1, x c+1, x c+2,, x k > with the minimum ower bound. The ower bound we use is d T (r m+1, x k) pus the sum of the costs of the minimum-cost-edges incident to each of the nodes that are not yet in the partia schedue S. Figure 2 (b) shows road network costs between two nodes. The minima incident edge cost is abeed beside each node. In Figure 2 (c), for each node x, the two numbers in parentheses indicate the cost d T (r 2, x) of the partia schedue and the ower bound of the schedue containing the partia schedue as prefix. For (r 2, e 1), d T (r 2, e 1) = 3. Ony e 2 and s 2, both with minima incident edge cost of 1, need to be added to the schedue. The minima incident edge cost of e 1 is min(2, 7, 3) = 2, so the ower bound of a schedue containing (r 2, e 1) is d T (r 2, e 1) + 2 = 5. We attempt to expand the partia schedue S with minimum ower bound by another new node to construct S. If S is not vaid or resuts in a bound greater than the current minimum schedue cost, we terminate S. If S is a compete schedue, we compare its cost to that of the best schedue and update if necessary. Once the schedue of cost 6 is found, schedues with ower bounds above 6 can be pruned (abeed by a gray circe). Note that in the figure we do not iustrate vaidity constraints. The compexity of the branch-andbound agorithm in the worst case is sti exponentia. 3.2 Mixed-integer Programming Approach Mixed integer programing is a popuar aternative. In this section, we formuate our augmented vaid trip schedue probem into a mixed integer programming probem. Then, we appy traditiona sovers to find the soution. As in the branch-and-bound agorithm, we are rescheduing N = {x c+1, x c+2,, x 3m, r m+1, s m+1, e m+1}. The schedue must start from r m+1. We divide N into subsets: (1) dropoff ocations of those aready picked up but not dropped off; et the size of this set be k; (2) pickup ocations of trips not started yet; et the size of this set be n; and (3) dropoff ocations of trips not started yet; the size of this set is aso n. The probem can be defined on a compete directed graph G = (N, A) where N = D P D {0}, D = {1, 2,..., k}, P = {k + 1, k + 2,..., k + n}, D = {k + n + 1, k + n + 2,..., k + 2n}. Because of the nature of the probem formuation of integer programing, we abuse the notation of N here: We reshuffe the points in N and assign an integer to each point in N whie node 0 represents the current position r i+1 of the server. For a pickup i in P, its matching dropoff in D is i + n. Each arc (i, j) A is associated with a shortest path routing cost d ij. For each arc (i, j), et y ij = 1 if the server traves from 2020

5 node i to node j. For each drop point i D D, et L i be the ride time of the request in this partia route. Then, the probem is, r1 s1 r2 r3 r4 s4 e4 subject to: Min i N j N d ijy ij y ij {0, 1}, i N, j N (1) j N yji = 1, i N {0} (2) j N y0j = 1 (3) B 0 = 0 (4) B j (B i + d ij)y ij, i N, j N (5) L i = B i B i n, i D (6) B i w i, i P (7) B i o i, i D (8) d i n,i L i ɛ i, i D (9) where w i is the waiting time eft for i P and o i is the maxima riding time eft for i D. Here d ii is set to a positive number to make sure y ii = 0. The objective is to find the schedue that minimizes the tota cost whie satisfying the constraints. Constraint (1) simpy enforces the binary nature of y ij. Constraint (2) aows exacty one node preceding another for a nodes but 0. Constraint (3) aows exact one node foowing node 0. These two effectivey enforce the schedue structure so that each node is visited exacty once and the schedue starts from node 0. Constraints (4) and (5) set the eariest time at which a node can be reached. Constraints (6) define L i for dropoff nodes, the service distance. Constraints (7) and (8) enforce the waiting time and service constraints for pickup and dropoff nodes where the passenger has aready been picked up. These are grouped together because both w i and o i are measured from the root node. Constraint (9) enforces the service constraint for dropoff nodes where the passenger has not yet been picked up, so that the service time does not exceed ɛ i. The constraint (5) is not inear. It can be inearized by introducing constants M ij, an approach simiar to that in [7]. B j B i + d ij M ij(1 y ij), i N, j N (1) The vaidity of these constraints are ensured by setting M ij max{0, i + d ij e j} where i is the atest time that i needs to be served and e j is the eariest time that j needs to be served. For i P, [e i, i] = [d 0i, w i]. For i D, [e i, i] = [d 0,i n + d in,i, w i + d i n,i(1 + ɛ)]. For i D, [e i, i] = [d 0i, o i]. Let v be the number of variabes in the mixed-integer programming probem, and c be the number of constraints. Then, v = O(m 2 ) and c = O(m), where m is the tota number of requests that we are optimizing. 4. KINETIC TREE APPROACH The two approaches above both suffer from one fundamenta probem: they reschedue unfinished pickups and dropoffs with the new request from scratch, ignoring previous computations. The structures of the two agorithms make it difficut to adapt them to the dynamic nature of the probem. In this section, we introduce a kinetic tree structure that maintains the cacuations performed upto-now and uses them effectivey for new requests. However, when there are severa pickup or dropoff ocations cose to each other, the number of feasibe schedues increases exponentiay. Thus, we propose a hotspot-based approach in Section 5 that reduces the search space and approximates the soution with bounds. r1 s1 (b) r1 (a) s1 r3 r2 r2 r1 s1 r2 r3 r4 r1 s1 r2 r3 r4 (c) Figure 3: Kinetic Tree for Trip Schedues. Darkened path: seected schedue to be executed; Dark circed/squared nodes: finished nodes. 4.1 Basic Tree Structure We introduce a kinetic tree structure to maintain a the vaid trip schedues with respect to the server s current ocation. When the server moves, a portion of the schedue becomes obsoete. The root of the tree tracks the current ocation of the server. The rest of the tree records portions of a vaid schedues (from the current ocation onwards). For a given w and ɛ, Figure 3 iustrates the kinetic tree structure corresponding to the compete trip schedue in Figure 1. The darkened path represents the seected (optima) schedue to be executed by the server. Initiay, for the first trip request, there is ony one vaid trip schedue (Figure 3 (a)). When the second request arrives, the first customer has aready been picked up by the server. Now assuming the option which drops the first passenger before picking up the second one is invaid, there are ony two vaid options for the server to accept the new request: it needs to first pick up the second customer, but it can be fexibe in dropping off either of the two passengers. Let us assume it decides to choose the shorter one which is (, s 2, e 1, e 2), to drop off the first customer first. However, on its way to pick up the second customer, the third request arrives. The server now has the option to pick up either the second customer or the third one. Suppose, based on w and ɛ, that there are five possibe vaid trip schedues for the server to hande the three trip requests (the first trip is aready in progress, shown in Figure 1(c)). Assuming the server decides to move aong the shortest route (, s 2, s 3, e 2, e 3, e 1) for now and picks up the second customer first, then when the fourth request arrives after the pickup of the second customer, the entire right sub-tree of r 3 in Figure 1(c) becomes inactive. Let us now assume there are ony two possibe schedues to accommodate the remaining trips of a four customers as shown in Figure 1(d). Why is such a kinetic tree usefu in maintaining the vaid trip schedues? Its advantage is based on the the foowing key observation: LEMMA 1 s4 e4 (d) (VALID SCHEDULES UNDER MOVEMENT). When s4 e4 2021

6 a server reaches a new pickup or dropoff ocation in the trip schedue, ony those vaid schedues which contain unfinished trips and share the same prefix so far (from the first pickup point of a the unfinished schedues to the current ocation in the trip schedue) need to be materiaized. A other schedues become inactive and can be pruned from the tree. In Figure 3(c), once the server picks up the second customer, ony the schedues in the eft sub-tree rooted at s 2 remain active. 4.2 Handing a New Request Now, we consider how to hande a new request tr k = (r k, s k, e k ). We assume that we aready have a materiaized prefix tree of a vaid and active schedues of unfinished trips. We need to extend a vaid and active schedues in the prefix tree to a new vaid schedue to incude tr k if possibe. We do this by generating a new prefix tree based on the existing one. To dea with the new request, we wi first dea with the pickup ocation s k and then the dropoff ocation e k. Essentiay, we need to scan the tree to determine where s k can be inserted, i.e., which edges of the tree can accommodate the insertion of a new pickup node. A schedues that share the prefix from the root of the tree to the inserted edge wi be inserted into the new tree. Then we insert e k after s k in the new tree. Furthermore, if s k or e k can be inserted at a given ocation (an edge in the tree), then we have to find out which trip schedues containing that edge with an additiona node wi become invaid (due to constraint vioation) and thus shoud be pruned. The probem is how to determine 1) at which edge s k or e k can be inserted, and 2) how to quicky prune the invaid trip schedues foowing that insertion. Inserting Pickup Location: Here, we focus on whether s k can be inserted first and e k can be inserted in a simiar way ater. In order to insert s k in a tree edge, say (x i, x i+1), we need to dea with the foowing situations: (a) ony when the distance from the current ocation (recorded in the root node ) to the pickup ocation s k satisfies d T (, s k ) = d(, x 1) + d(x 1, x 2) + + d(x i, s k ) w, then s k may be inserted; (b) the additiona trave distance (time) introduced by the detour to s k may invaidate some existing trip schedue in the sub-tree containing this tree edge (x i, x i+1), i.e., d(x i, s k ) + d(s k, x i+1) d(x i, x i+1) shoud not be too arge. These schedues shoud be pruned from the sub-tree. Note that condition (a) is easy to be tested in the existing tree structure. LEMMA 2. (d T (, s k ) w) The shortest distance from the current ocation to the requested pickup ocation s k is no greater than w. Furthermore, given a prefix (partia) trip schedue from the root node to a node x j, i.e., (, x 1, x 2,, x j), if d T (, s k ) = d(, x 1)+d(x 1, x 2)+ +d(x j, s k ) > w, then, any edge incident to any descendant of x j in the tree cannot accommodate s k, i.e., the customer cannot wait for the server to finish x j before being picked up at s k. This emma suggests that we can perform either a depth first search (DFS) or breadth first search (BFS) starting from the root node of the tree to generate a the candidate edge (x i, x i+1) to insert s k. Specificay, during the traversa the visiting wi return once certain depth is reached, i.e., a node has the property that d T (, x j) > w, in which case we either wi not expand that nodes (in BFS) or trace back (in DFS). Now the key probem is how to hande condition (b). The straightforward way to perform pruning is to expicity maintain and check constraints for each trip request in the subtree of x i. Specificay, for a trip tr j in the sub-tree rooted at x i, there are two criteria: waiting constraint [r j, s j, w] (d T (r j, s j) w) and trip toerance constraint [s j, e j, ɛ] (d T (s j, e j) (1 + ɛ)d(s j, e j)). At any given time point t, ceary if we need to test whether the detour meets the criteria of trip tr j, then the request is aready issued and responded, and the entire trip is not yet competed. Furthermore, ony one of the criteria needs to be tested: if the server has not picked up the customer, then, we need to test the pickup waiting constraint [r j, s j, w]; once the customer is picked up, we need to test the trip toerance constraint [s j, e j, ɛ]. Thus, at any given point, the active customers can be partitioned into two sets: S 1 records those customers who need to be picked up and S 2 records the on-board customers who need to be dropped off. When a new ocation is reached, we may move customers from S 1 to S 2 and/or remove customers from S 2. For trip j in S 1, we test the first criterion [r j, s j, w] and in S 2, we test the second one: [s j, e j, ɛ]. Given this, for the sub-tree rooted at x i, the simpe way is to first generate these two sets S 1 and S 2. Then, when we insert s k, we need to ensure each condition associated with S 1 and S 2 are aso satisfied. Agorithm 1 insertnodes agorithm. Parameter: root node, request points P = (x 1, x 2,...), current depth depth if feasibe(, x 1, depth + d(, x 1)) then Initiaize fai = 0 n = create(, x 1) {Copy feasibe chid branches under n} for each c such that edge (, c) exists do copynodes(n, {c}, d(, n) + d(n, c) d(, c)) If copy faied, set fai = 1 end for{insert remaining request points to n} if fai = 0 and P > 1 then {Detour now begins negative because we haven t inserted x 2 yet} insertnodes(n, {x 2,...}, d(x 1, x 2)) If insert faied, set fai = 1 end if{now insert request points into chidren} for each c such that edge (, c) exists do insertnodes(c, P, detour + d(, c)) If insert faied, deete (, c) end for if fai = 0 then Add edge (, n) ese if No nodes c with edge (, c) exist then Insert faied, notify caer that this sub-tree is infeasibe ese Insert succeeded end if ese Insert faied, notify caer that this sub-tree is infeasibe end if Agorithm 1 impements the insertion of a new request tr k = (s k, e k ) into the tree recursivey. The insertion is competed by a ca, insertnodes(root, {s k, e k }, 0). The ca to feasibe(parent, node, detour) returns whether or not it is feasibe to insert node as a chid under parent in the tree. First, this ensures that the pickup or service constraint of node is not vioated. If min-max fitering is in pace (wi be discussed), this wi confirm that the detour (third argument) is toerabe for node. The copynodes(node, source, detour) function recursivey copies nodes from a set of nodes, source, to the target node, node. Here, toerance of the root s chidren in insertnodes is impemented through cas to feasibe with detour of detour. copynodes wi fai if a of the chidren of node are aong infeasibe paths. In this case, these branches and node wi be deeted. In Figure 4 (a), we use the insertion agorithm to insert the pickup ocation s 3 into an existing tree, thereby generating a new tree. s 3 wi first be inserted directy beow. Then, the branch with root at s 2 wi be copied underneath this new s 3 node, forming 2022

7 c: (a) b: d: (b) (c) (d) (e) Figure 4: Tree Insertion. The insertions of s 3 into each edge in tree of (a) resut in (b), (c), (d), and (e), assuming the ast two insertions were infeasibe. a new tree of (, s 3, s 2, ((e 1, e 2), (e 2, e 1))). Let us assume route (, s 3, s 2, e 1, e 2) is not feasibe; then, the branch is pruned from the tree starting at the eaf node unti we reach s 2, where we have an aternate path (, s 3, s 2, e 2, e 1) that is feasibe. This pruning occurs in the copynodes agorithm, which wi succeed because s 3 fas aong at east one (in this case, exacty one) feasibe path. The resuting tree is shown in Figure 4 (b). Then, the insertion agorithm moves down to s 2 and attempts to insert the pickup ocation after it. Two paths are formed: (, s 2, s 3, e 1, e 2) and (, s 2, s 3, e 2, e 1), as a resut of the insertion between s 2 and e 2 and between s 2 and e 1. Suppose (, s 2, s 3, e 2, e 1) is infeasibe. The resuting tree is shown in Figure 4 (c). Suppose inserting s 3 between e 1 and e 2 or between e 2 and e 1 is infeasibe. Then, we have the tree in Figure 4 (d). To compete the insertion of the (s 3, e 3), we now try to insert e 3 in the sub-trees that root at a s 3 foowing the same insertion agorithm. Once this competes, we arrive at the tree shown in Figure 4 (e). Min-max Fitering using Sack time: Though the above test for condition (b) is conceptuay simpe, it is rather computationay expensive. Now, we introduce a fast approach to simpify and speedup such test. For any node j, if j is in S 1, et δ j = w d T (r j, s j); otherwise (j is in S 2), et δ j = (1 + ɛ)d(s j, e j) d T (s j, e j). Then, for the node x j, we associate sack time xj = min(δ j, max i xj.chidren i). Note that xj essentiay represents the minima aowed detour on the most enient route of the subtree routed at x j. Here enient means the route can toerate the most detour compared to other routes. Given this, we introduce the foowing Theorem to describe the simpe condition to determine whether s k can be inserted at a given edge. THEOREM 1. For a trip request tr k, if edge (x i, x i+1) does not satisfy either of the foowing condition: (a) d T (, s k ) = d(, x 1)+ d(x 1, x 2) + + d(x i, s k ) w; or (b) d(x i, s k ) + d(s k, x i+1) d(x i, x i+1) (xi,x i+1 ), then, we can not add the pickup s k between ocation x i and x i+1. After insertion in (x i, x i+1), a nodes under x i of the new tree wi be tested for the constraint δ i d(x i, s k ) + d(s k, x i+1) d(x i, x i+1). A branch is pruned from the sub-tree if the constraint is not satisfied. Updating and Tree: After we try to insert a request to a possibe servers, we get a set of new trees. For each tree, we can find the shortest route and choose the tree that provides the shortest route among a trees. Ony the chosen tree needs to have its updated. This can be done through one tree traversa. When a server is moving, the tree needs to be updated as we. However, the vaues are quiescent to server movement and do not need to be updated. The tree is updated when a vehice reaches a new pickup or dropoff ocation; the server drops the inactive portion of the tree accordingy. Practica concerns: In practice, customers may occasionay wish to cance a trip after it has been schedued. To dea with this, we can reconstruct the tree from scratch without the canceed trip request to derive an optima soution. Aternativey, we can derive an approximate soution by simpy deeting a instances of the canceed pickup and dropoff ocation from the current tree, and seecting the shortest resuting route; whie this ignores branches that become feasibe foowing the deetion, it sti produces better soutions than simpy deeting the customer from ony the current route. Another practica issue is unexpected traffic conditions. If a vehice runs into unexpected deay, then athough it does sti have to drop off on-board passengers regardess of service constraints, we can cance and possiby re-assign the trips that have not started yet to another vehice. To determine if constraints are vioated, we simpy compare the additiona deay encountered to the sack time aong the optima branch. The trips with waiting time constraint being vioated wi be iterativey canceed and re-assigned which may aso ead to better service for on-board passengers. 5. HOTSPOT BASED OPTIMIZATION The main probem with the basic tree agorithm is the exponentia exposion of the size of the tree when there are mutipe pickup or dropoff ocations cose to each other. For exampe, if 8 pickups occur in spatia-tempora proximity, e.g an airport after a fight ands, any permutation of the pickups may resut in a vaid schedue. This yieds 8! = 40, 320 possibiities, even before considering dropoff points. We propose an approximation approach with bound to reduce the search space. The idea is that when the time and space requirements of computing the best schedue are too high, a server may decide to reduce the oad by ony maintaining a representative subset of the schedues. Since the number of eaves of the kinetic tree is determined by the number of possibe routes, the tree size is effectivey controed by the approximation and the service constraints. We propose the foowing hotspot custering agorithm to dea with this situation. When we insert a pickup point s k to an edge (x i, x i+1), we check if d(x i+1, s k ) θ for sma θ. If so, s k is inserted into the node of x i+1. s k and x i+1 are treated as one point caed a hotspot in the tree, and an arbitrary schedue is chosen between the points in a hotspot. When a hotspot contains more than one point, a newy inserted point must be within θ to a points of 2023

8 xi xi+1 a a' p xj-1 b c' d' c q xk-1 xj xj+1 xk xk+1 (a) Figure 5: Bound for Hotspot. x i, x j, and x k are in one hotspot. Back ines: optima schedue S best. We can convert S best by connecting x i, x j, x k consecutivey first and then thread the other ocations (represented by ovas). The new schedue has a bounded cost. b' the hotspot. A simiar procedure can be foowed for dropoff points and mixtures of pickup and dropoffs. Once a point is combined with any hotspot, we stop trying to insert it to any other edges. Let us first assume the service constraints are sufficienty arge that a schedues are possibe. For a trip set T R, et S best be the optima schedue. Suppose there is a hotspot hp among the pickup and dropoff ocations of T R. Our hotspot-based method chooses an arbitrary schedue T hs that goes through the points of the hotspot in a consecutive manner. We want to prove that the cost of T hs is bounded. THEOREM 2. cost(t hs ) cost(s best ) + (2m + 1) θ where m is the number of points in the hotspot without considering constraints. Proof Sketch:We prove when m = 3 by iustration. For genera m, the proof is mainy the same. In Figure 5 (a), assume {x i, x j, x k } has pairwise distance of no greater than θ. The optima schedue S best is abeed by back soid and dashed ines. We can convert S best into T hs by connecting x i, x j, x k consecutivey first and then thread the other ocations (represented by ovas) in S best as shown by the red ines and back dashed ines. We prove that (1) cost(t hs ) cost(s best )+3θ which is equivaent to prove a + b + c + d + e a + b + c + d + e + 3 θ since the dashed ines are common in both schedues. We know d b + c, e < d + e. Now we ony need to show a + b + c a + 3 θ. As shown in 5 (b), we can easiy prove that c a + θ because the shortest path between x k and x i+1 is no onger than than the schedue x k, x i, x i+1. Because a θ and b θ, we know a + b + c a + 3 θ. However, the hotspot agorithm may not use the same order of x i, x j, x k as in the optima soution as it is an arbitrary order, we now prove that (2) for any two hotspot-based schedue S hs and S hs, cost(s hs ) cost(s hs ) + (m + 1)θ where m = 3. Without oss of generaity, et S hs =..., x i 1, x i, x j, x k, x k+1... and S hs =..., x i 1, x j, x k, x i, x k It is obvious that d(x i 1, x i) d(x i 1, x j) + θ and d(x k, x k+1 ) d(x i, x k+1 ) + θ. Aso d(x i, x j) d(x j, x k ) + θ and d(x j, x k ) d(x k, x i) + θ. Adding the inequaities together, we have cost(s hs ) cost(s hs ) + 4θ Putting (1) and (2) together, we have cost(s hs ) cost(s best )+ (2m + 1) θ where m = 3. Because after we buid the whoe tree, we seect the shortest schedue with hotspot cost(s hsbest ) and it is obvious that cost(s hsbest ) cost(s best ) + (2m + 1) θ. When we consider the constraints, for S best the corresponding hotspot-based schedue with constraint may vioate some constraints and thus does not exist. However, when the constraints of points of the best schedue are reaxed, the corresponding hotspot-based schedue wi be found. We have the foowing theorem. d e' e a xi xk a' (b) xj b' c' xi+1 THEOREM 3. cost(s hs ) cost(s best ) + (2m + 1) θ where m is the number of points in the hotspot when constraints of a points in S best is arger than mθ. Proof Sketch:Again we prove for m = 3 because of the ease of iustration. In Figure 5 (a), if (a, p, b, c, q, d, e) is a vaid partia schedue with each node having at east 3θ sack time, then (a, b, c, p, d, q, e ) is a vaid partia schedue. For any point on p, the extra deay is a + b + c a 3 θ. For any point on q, the extra deay a + b + c a + d (b + c) a + b + c 3 θ. For x i+1, the extra deay is a + b + c + d + p + q (a + b + c + d + p + q) which is proven in Theorem 2 as no arger than 3 θ. When θ is sufficienty sma, we wi ikey to find a schedue that is upper bounded by the best schedue with a sma additiona time. 6. EXPERIMENTAL DESIGN We evauate the agorithms using a arge scae taxi dataset containing 432,327 trips made by 17,000 Shanghai taxis over one day (May 29, 2009). A trip tp in the dataset has starting time tp.st, starting ocation tp.s, ending time tp.et, and ending ocation tp.e. A simuator generates trip requests from the actua 432,327 trips and submits them to the scheduing system in reatime. Specificay, for each trip tp, a trip request tr is initiaized as tr = tp.s, tp.e, w, ɛ, and tr is submitted at time tp.st. The Shanghai road network is represented by an undirected and weighted graph containing 122,319 vertices and 188,426 edges. The starting and ending trip coordinates are pre-mapped to the cosest vertex in the graph. The road network is stored in memory in a simpe weighted adjacency ist structure. A vehice is initiaized to a random vertex in the road network. Vehices foow a given route when customers are on board or, otherwise, foow the current road segment, choosing a random segment to foow at intersections. We assume a constant speed D; specificay, based on the data, we set D to 48 km/hr. Time-distance conversion is accompished by mutipying or dividing by D. In our experiments, the superimposed grid size gr. is 500 m. For arge scae ridesharing, the shortest path agorithm is caed very frequenty. We observe the repeated caing from scheduing agorithms foows a pattern that preserves ocaity. We impement two LRU caches: one storing up to ten miion shortest distances and the other storing up to ten thousand shortest paths. A new shortest distance/path is cacuated when there is a cache miss and wi repace the east recenty used one. Both caches are indexed ony by the starting and ending points in a distance or path computation ca; this is accompished by defining the index for two vertices s and e as i = id(s) V + id(e), where V is the tota number of vertices and id returns an integer representation for a vertex. The simuation framework is impemented in C++. We run the experiments on custer nodes with an Inte Xeon X5550 (2.67GHz) processor. The simuation impementation is singe-threaded, and memory usage is imited to three gigabytes. Parameter Tested settings Scheduing Capacity 4 Constraints 5 min / 10%; 10 min / 20%; 15 min / 30%; 20 min / 40%; 25 min / 50% Number of Servers 1,000; 2,000; 5,000; 10,000; 20,000 Tabe 1: Parameters for four-agorithm comparison. 2024

9 Figure 6: Four agorithm Comparison. (a) Average RHT with respect to number of servers; (b) Average RHT with respect to constraints; (c) Average VST with respect to scheduing workoad per vehice. Defaut parameters are 10 min / 20% for the constraints, 10,000 servers, and a scheduing capacity of Four Agorithm Comparison We first compare kinetic tree agorithm with the branch-andbound, brute-force, and mixed-integer programming agorithms. We choose three important parameters: scheduing capacity, waiting time and service constraints, and number of servers. We first estabish reasonabe defauts for the parameters, and then proceed to modify the parameters one at a time to evauate their effect. The defauts (boded) and other tested settings are shown in Tabe 1. Because ony our kinetic tree agorithms respond in rea-time for higher scheduing capacities, the defaut scheduing capacity is set at 4 for experiments (which aso mimic rea-word taxi system) in this section. We test much arger scheduing capacities for kinetic tree agorithms in section 6.2. Note that a waiting time constraint of 10 minutes corresponds to 8,000 meters. To vaidate our settings for the number of servers, we run the simuation first with different numbers of servers and evauate the drop rate (i.e., the number of trip requests that are rejected by the system as a percentage of tota requests) at each setting. These resuts are shown in Tabe 2. As can be seen, there is a steep decrease in the drop rate from 2,000 to 5,000 and again from 5,000 to 10,000 servers, making either 5,000 or 10,000 a good choice for this data (assuming we want to satisfy most requests). It is aso interesting that drop rates are simiar between the two scheduing capacities; this is because most servers are not fied to capacity. #servers Scheduing capacity 4 Scheduing capacity % 84.2% % 72.1% % 51.3% % 7.02% < 0.01% < 0.01% % 0% Tabe 2: Drop rate evauation. The percentage of unsatisfied customers (customers whose requests were denied because no server was avaiabe) is shown for constraints of 10 minutes and 20%, and variabe number of servers and scheduing capacity. To evauate performance, we measure the vehice scheduing time (VST): the time needed to attempt to schedue a trip request to a vehice given its current state, i.e., to cacuate the minimum schedue cost for the active trips and the new request. Depending on the scheduing workoad, the VST can change significanty (for exampe, a taxi with twenty active requests woud have forty more points to be schedued than one with no assigned requests). Thus, we show average VST for different scheduing workoad. Because a request wi need to be matched to a vehices within w to pick the best, we aso measure the request handing time (RHT): the time required to search for and assign the new request to the vehice with minimum cost or to reject it (RHT incudes VST for each vehice searched). Figure 6 (a) and (b) show the average RHT with varying feet size and constraints and Figure 6 (c) shows the average VST with respect to different scheduing workoad per vehice. Generay, the brute-force and branch-and-bound agorithms exhibit roughy the same performance. The mixed-integer programming approach takes significanty more time, probaby because of significant execution time used to initiaize and preprocess each mixed-integer programming probem. The tree agorithm outperforms the other agorithms for a test cases often by orders of magnitude, due to its incrementa approach. For a sma number of taxis and a arge scheduing workoad, branch-and-bound outperforms brute-force. The reason is most ikey that the pruning effect of branch-and-bound is more important when scheduing more requests. When the probem size is sma, the fast initiaization of the brute-force agorithm is preferabe. For the defaut parameters, the execution time of the branchand-bound and brute-force agorithms are amost identica, whie the mixed-integer programming is approximatey 20 times sower. The tree agorithm, on the other hand, is amost two times faster than the branch-and-bound agorithm. Simiar magnitude execution time differences are seen for other parameters.when examining the vehice scheduing time ony for computations where the scheduing workoad is 4 (at the capacity), the tree agorithm becomes 5 times to severa orders of magnitude faster than the other three agorithms. 6.2 Comparing Tree Agorithms We further evauate different versions of our tree agorithm on parameters that the other agorithms cannot efficienty hande: basic tree agorithm, the sack time agorithm, and the hotspot custering agorithm (which aso uses sack time). 2025