How Many Passengers Can We Serve with Ride-sharing?

01/22/2019
by   Zeren Tan, et al.
0

Ride-sharing can reduce traffic congestion and thus reduce gas emissions and save travel time. However, transportation system with ride-sharing is currently inefficient due to low occupancy rate, high travel demand and some other factors. Existing literature did not consider ride-sharing with multi-request grouped in one trip. In our paper, we firstly proposed a graph-based algorithm that can obtain an approximation solution in polynomial time and then proposed an exact algorithm to solve this problem with maximizing the number of passenegers served in O(1.2312^|E|) time.

READ FULL TEXT VIEW PDF

Authors

page 1

page 2

page 3

page 4

10/27/2020

GMACO-P: GPU assisted Preemptive MACO algorithm for enabling Smart Transportation

Vehicular Ad-hoc NETworks (VANETs) are developing at a very fast pace to...
01/30/2022

Sharing Behavior in Ride-hailing Trips: A Machine Learning Inference Approach

Ride-hailing is rapidly changing urban and personal transportation. Ride...
12/19/2017

The Merits of Sharing a Ride

The culture of sharing instead of ownership is sharply increasing in ind...
12/24/2018

Graph-Based Algorithm for a User-Aware SaaS Approach: Computing Optimal Distribution

As a tool to exploit economies of scale, Software as a Service cloud mod...
07/06/2020

Approximation algorithms for car-sharing problems

We consider several variants of a car-sharing problem. Given are a numbe...
05/27/2021

A Dynamic Tree Algorithm for Peer-to-Peer Ride-sharing Matching

On-demand peer-to-peer ride-sharing services provide flexible mobility o...
05/04/2022

Constrained Backward Time Travel Planning is in P

We consider transportation networks that are modeled by dynamic graphs, ...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Traffic congestion, air pollution and many other societal and environmental concerns are rising with the rapidly increasing number of vehicles on the road. The cost of congestion in the United States are 1% of its GDP, 5.5 billion hours of time lost to waiting in traffic congestion and 2.9 billion gallon of fuel wasted (Agatz et al., 2012; Alonso-Mora et al., 2017). The greenhouse gas and toxic gas emissions and their negative consequences have not even been taken into account. Traffic congestion is caused in many ways, among which low car occupancy rate is a fatal one. According to European Environment Agency, the average number of passengers in a single vehicle ranges from 1.0 to 1.8. Similar result has also been found in the United States(Santos et al., 2011; Agatz et al., 2012). Together with the high transportation demands, low vehicle occupancy rate leads to longer waiting time of a trip and sometimes longer distance travelled and finally costs the inefficiency of traffic system.

The huge costs brought by these negative effects of traffic congesion stimulate researchers, traffic operation agency as well as some companies to seek for a better solution. Big companies like Uber, Lyft and Didi have led a new transportation mode the so-called Mobility-on-demand (MoD) system, which improves the access to urban mobility with less waiting time and stress. MoD system is a more flexible and public transportation system that allows travelers to have more diverse demands. It is a user-centric approach which leverages emerging mobility services, integrated transit networks and operations, real-time data, connected travelers, cooperative Intelligent Transportation System (ITS) and incorporate shared-use and multimodal integration.

In ride-sharing, travelers with similar itineraries (i.e. similar departure time, similar arrival time, similar origin and destination) are grouped together. With ride-sharing, the driver involved in a trip can get more revenues without driving longer distance and passengers sharing a ride should pay less for this ride as they share their ride with others. The travel expenses are reallocated among ride-share participants but different passengers should benefit differently. Some participant may travel longer distance in order to pick up other participants and sometimes cannot reach his/her destination on time while other participants just share a ride with others without travel more. The way to determine how to reallocate the trips costs is an important problem that some researchers are working on.

Existing studies mainly focus on ride-sahring without pooling requests(Pavone et al., 2012; Spieser et al., 2014; Zhang and Pavone, 2016; Spieser et al., 2016). But they did not consider servicing several travel request into a single trip. The best result we know is (Alonso-Mora et al., 2017). They proposed a near-optimal solution that is tractable in practical application.

2 Problem Statement

2.1 Assumptions

There are several major assumptions related to the following discussion:

  1. The time interval considered is sufficiently small so that there will not be any extra taxis arriving except the taxis we have observed at the beginning.

  2. For each passenger, if the gain he get for sharing a ride is greater than the loss, which is acceptable, he is willing to take the ride.

  3. A taxi driver is willing to give a ride as long as the distance is with his acceptable distance and he can get the mean value of the income he used to get regarding of similar time interval and similar travel distance.

Notation Description
The set of passengers
The set of passengers who are close (see Definition 2.1) to passenger
The set of origins
The set of destinations
The set of expected departure time
The set of latest arrival time
The group of passengers, which contains , who are all close to each other
The set of possible group rides for passenger
The loss of passenger to join the group ride
The final departure location for group ride
The final destination for group ride
The final departure time for group ride
The final arrival time for group ride
The set of all possible trips
The discount passenger gain in ride
The amount of money passenger pays the driver in group ride
The amount of money passenger should pay the driver without sharing a ride
The constant threshold for distance in the definition of close
The constant threshold for time in the definition of close
The average income for driver matched with group ride that he could get without ride-sharing
Passengers who take the ride
An indicator variable, 1 if passenger take the group ride ; 0 otherwise
The acceptable loss for each passenger when sharing a ride
The set of available taxis
The average driving velocity
An indicator variable, 1 if taxi is matched with group ride ; 0 otherwise
The distance taxi should travel in order to start trip
The acceptable distance drivers are willing to travel in order to start a trip
Table 1: Notations
Definition 2.1 (Close).

For passengers , they are close to each other if and only if , and , where stands for the Manhattan distance.

We introduce this definition to ensure each passenger in a reasonable group of two or more passengers does not need to walk a lot and wait for too long in order to start a trip or reach his destination. If it is satisfied, we can simply ask them to meet at the geometric center of their requested origins and depart for the geometric center of their expected destinations. If it is not satisfied, a passenger may not want to share a ride with others and may violate.

(1)
(2)
(3)
(4)
(5)
(6)
(7)
(8)
(9)

where are defined as follows:

The objective function is to maximize the total number passengers served by taxis. Constraint 1 suggests that each passenger can take at most one taxi and it is possible that some passengers may not have taxi to take. Constraint 2 ensures the validity of group ride . Constraint 3 and Constraint 4 state that each taxi can be matched with at most one ride and each ride can be matched with at most one taxi. Constraint 5 and Constraint 7 guarantee that the solution is feasible for taxi drivers. Constraint 6 and Constraint 8 make sure that the rides grouped are feasible for passengers. Constraint 9 illustrates that the optimization problem is a 0-1 integer programming problem (IPP).

3 A Graph-Based Algorithm

3.1 Group Ride and Initial Graph

In order to group passengers, we introduce the definition of stable pair.

Definition 3.1 (Stable Pair).

Two passengers are a stable pair if and only if they are close to each other and .

Definition 3.2 (Stable Group).

A group of passengers is a stable group if and only if each two of them form a stable pair.

From the definition of stable group, it can be concluded that passengers can form a stable group ride are indifferent to their partners. We further assume that passengers in different stable groups cannot form any stable group. That is, we can divide passengers into several groups based on with regard to stable groups. Passengers in different stable group can never share a ride.

While this condition is somewhat restrictive, there are some practical applications that meet this condition. For instance, in the international airport, passenger in Terminal 1 may not want to go to Terminal 2 or other terminals to take a taxi. Passenger in the same terminal can form a stable group while passengers in different terminal cannot. Passengers are naturally divided into several stable groups in this example.

3.2 Graph Construction Algorithm

We input the stable groups of passengers and the set of taxis. In each group, passengers are all willing to share the same ride with other people. An example of the initial graph is presented in Figure 1.

1 Initialize ;
2 for  do
3        ;
4        for  do
5               if  is willing to give a ride to  then
6                      ;
7                     
8               end if
9              
10        end for
11       
12 end for
return
Algorithm 1 ConstructGraph()

3.3 Algorithm Design

In order to solve this problem, we choose to abstract this problem as a graph by the following steps.

  • We abstract set of taxis and set of passengers as ”small nodes”.

  • A stable group of passengers is abstracted as a ”super node”.

  • There is an edge between the ”super node” contains passengers and the taxi node if and only if the driver is willing to give the passengers a ride.

  • We construct a graph with these nodes and add a source node and a sink node. The source node has edges with taxis nodes and the sink has edges with nodes contain passengers.

  • Each edge has a capacity which is defined as follows:

Figure 2 and Figure 3 illustrate the abstraction process.

Everyone in the same passenger super node is indifferent to who are going to take the same taxi with him/her as long as they are in the same node. Thus, we are not concerned about the allocation of passengers to taxis. The main problem we are going to discuss is how to develop an algorithm that can determine the most effective distribution of taxis so that the system can serve the most passengers. That is, the algorithm we are going to develop can return how many taxis will be sent to each passenger super node. When taxis arrive, we can use constant time for each taxi to decide the way of assigning passengers. Because the amount of taxis arrive for each passenger super node is less than or equal to and the total number of taxis arrive is not greater than , the running time of assigning passengers is .

Definition 3.3 (Maximum-Flow).

A flow network is a directed graph with a source node , a sink and capacities along each edge. The amount of flow between two vertices is described by a mapping . The flow of a graph has the following properties:

(10)
(11)
(12)

The total flow of a flow network is the amount of flow going out the source (or equivalently going to sink). Specifically, . The maximum-flow of a flow network is the largest possible flow for a given graph .

We can show that the constraints stated above are all satisfied by the maximum-flow problem illustrated in Figure 3.

  1. In the same passenger super node, origins and destinations of all passengers are close and when they are grouped together, their gain is greater than their loss. Thus, Constraint 6 and Constraint 8 are satisfied.

  2. Taxis in the same node are willing to take the same rides. By Step 3.3, Constraint 5 and Constraint 7 are satisfied.

  3. When we get a maximum-flow of , there is a flow for each . We denote the set of taxi nodes as and the set of passenger nodes as . For , denote the set of taxis that have edges with as If and , then indicates that passengers in node have taxis to take. And note that from the way we construct graph , we can observe that can only have one outgoing arc. The number of taxis available for is limited by Property 10 and thus the value is . When have taxis to choose, we assign some passengers to each taxi. In addition, it is important to note that both and the number of passengers assigned to a taxi can be zero. Property 12 and Theorem 3.4 ensure that a taxi is only assigned to one ride and a ride can only be matched with one taxi. Therefore, Constraint 1Constraint 4 are also satisfied.

  4. Theorem 3.4 illustrate that there exist a integral maximum-flow since all capacities are defined as integers. Hence, Constraint 9 is satisfied too.

    Theorem 3.4 (Integral-flow Theorem).

    Given a graph , if , then there is a maximum flow in which all flows are integers.

It is reasonable to assume that the taxi has taken as much passengers as it can in the node it is assigned. We write as a proposition.

Proposition 3.5.

If is assigned to , then takes as much passengers as it can from .

The only problem of maximum-flow algorithm is that the solution can be optimal but sometimes it can also be very bad. The situation leads to bad solution is that sometimes a taxi is assigned to a passengers super node and there is only say 2 people take this taxi but in another passenger super node, which has an edge with the same taxi node, there are three or more people need this taxi. (Note that if the node that the waiting passengers are in does not have an edge with this kind of taxi node, the node contains these passengers must either have no edge with any taxis node or the solution is optimal. The first possibility means that these passengers cannot take any taxi. This is not what we are focusing on.) Because of situations like this, the maximum-flow algorithm sometimes is not optimal for the taxis can take more passengers if assigned to another node. This problem often arises when there is not enough taxis and some passengers may not have taxi to take at that moment. We assert that if we can avoid this situation, we can get the optimal solution.

Assertion 3.6.

If we can avoid the situation stated above, the solution found by maximum-flow algorithm is optimal.

Proof.

The proof is obvious. If the situation does not happen in the solution found by our algorithm, it means that each taxi takes as many passengers as possible. Therefore, the total amount of passengers is as large as possible. That is to say, the solution serves the most passengers and thus is optimal. ∎

We design an algorithm based on Ford-Fulkerson method. We add a score to each flow pass through node . The value of the score is defined as following: when there is a taxi assigned to node , the score this flow get from is , where is the number of passengers in . The taxi will get the score if it is assigned to the node . In order to get the optimal solution, we just augment 1 to flow value along a path . The path has the property that when we augment 1 to flow value along it, we can get the most score compared to other augmenting paths. This strategy ensure that the aforementioned bad situation would not exist. The rigorous proof will be illustrated in Proof 3.3. Th proposed algorithms are Algorithm LABEL:alg:a2 and Algorithm LABEL:alg:a3.

1 for edge  do
2        tail of ;
3        head of ;
4        if  then
5               if  then
6                      ;
7                      ;
8                      ;
9                     
10               end if
11              ;
12              
13       else
14               if  then
15                      ;
16                     
17               end if
18              ;
19              
20        end if
21       
22 end for
return and
Algorithm 2 OneAugment()
1 for edge  do
2        ;
3       
4 end for
5while there exists some augmenting path in  do
6        OneAugment();
7        Update ;
8       
9 end while
10while there exist a passenger node for from which can get more scores do
11        the node is now sent to;
12        ;
13        Update ;
14       
15 end while
return
Algorithm 3 Modified-Ford-Fulkerson()

We assert that Algorithm 3 can terminate in finite time.

Assertion 3.7.

Algorithm 3 will terminate in finite steps.

Proof.

Because we only augment flow value by 1 per time and one upper bound for the maximum flow is , the first while loop will definitely stop in times. Since each time when the second while loop runs, the score for taxi will increase by 1, for each taxi, the while loop will only run 4 times. Therefore, the second while loop will run times. ∎

Assertion 3.8.

The solution found by Algorithm LABEL:alg:a2 and Algorithm LABEL:alg:a3 is optimal.

Proof.

The meaning of the score a taxi get is the number of passengers it takes and thus the total score represents the total number of passengers the assignment of taxis can serve. From Algorithm 2 and the augmenting step of Algorithm 3, we can observe that and the score of a taxi are both non-decreasing with respect to the augmenting step. In addition, note that each node if ever matched, it would be always matched even though the set of taxis match with might change.

Assertion 3.9.

After each augmenting step, the total score the flow obtain is non-decreasing.

Proof.

We assume that the score before augmenting is . From Algorithm 2, along an augmenting path , we have three cases to discuss:

  • If there exist an edge , then there must exist which is the tail of and which is the head of . When augmenting, we assume that is an edge of the augmenting path. Then, . Assuming is an edge of the augmenting path. We further assume that was not assigned any taxi before augmenting. There must exist this kind of node, otherwise, there will not have any augmenting path. Therefore, the total score .

  • If there does not exist in augmenting path, then it is obvious that the flow value increase 1 and the score increase as well.

  • If there is no augmenting path regarding of flow, then in the last for loop of Algorithm 3, we can easily find that is non-decreasig.

To summarize, total score is non-decreasing. ∎

Assuming that the solution found by Algorithm LABEL:alg:a2 and Algorithm LABEL:alg:a3 is not optimal. Then, from Assertion 3.6 and Proposition 3.5, we can conclude that the aforementioned situation must exist. That is, there exist one taxi that has edges with two passenger super nodes and is assigned to one node that passengers in take but in another node there is passengers waiting for a taxi.

If we think about why finally choose to take , it turns out that when takes , it can get more scores as how Algorithm 3 is implemented. The scores it has represent the number of passengers it takes. Therefore, . This is a contradiction. ∎

Figure 1: The initial graph
Figure 2: First Step of Graph Construction
Figure 3: Super nodes Abstraction

4 Running Time

4.1 Running Time of Algorithm 1

In this section, we analyze the total running time of our algorithm.

In Algorithm 1, all the steps take . Therefore, the total running time is .

4.2 Running Time of Algorithm 2

It is easy to observe that each path in has only edges. The step looking up if is in takes on average. So the average running time for Algorithm 2 is .

4.3 Running Time of Algorithm 3

The running time for the initialization step is . Since for OneAugment(), the steps in the first while loop take . And this is the most expensive step in the first while loop. To compute the running time for the first while loop, we need to figure out the times this first while loop will run. Since we only augment 1 flow value per time, the first while loop will run at most times. Therefore, the total running time is .

The second while loop will run for at most taxis and as stated in Proof 3.3, it will run at most 4 times for each taxi and per time. Thus, the total running time for the second while loop is .

4.4 Total Running Time of Algorithms

By summarizing the running time analysis of the above three subsections, we can conclude that the total running time is .

5 Proof of NP-Hard

We reduce our problem into a NP-Complete problem–Complete Coloring. In the language of graph theory, the decision problem of complete coloring can be phrased as following:

Given a graph and an integer , find the answer that if there exist a partition of into or more disjoint subsets such that each is an independent set of and for each pair of is not an independent set of .

Proof.

Given an instance of Complete Coloring problem, we can create an instance of our problem by the following method.

Denote as the set of passengers and a passenger as a node. For each pair of passengers who cannot form a stable pair, we attach an edge with them. Assuming that for all vehicles , it can take either of these passengers and the capacity of vehicle is large enough.

The mapping can be constructed as following: let each vertex in be vertex and let independent set be vehicle . It can be observed that passengers that can form a stable trip can be collected as an independent set. So the nodes have the same color form a stable trip and are assigned into a vehicle. The set of passengers a vehicle contains is an independent set of the graph. It is obvious that if there is a solution for our problem, that is, if there exist an assignment of vehicles and passengers, the Complete coloring problem can be solved. If there is a partition of satisfies the aforementioned property, there is a assignment of vehicles and passengers. ∎

6 A Branch and Bound Based Algorithm

6.1 Graph Construction Algorithm

Algorithm 4

1 ; ;
2 for  from 1 to  do
3        ;
4       
5 end for
6for  do
7        ;
8        ;
9       
10 end for
11for  and  do
12        ;
13        ;
14        ;
15        if  then
16               ;
17              
18        end if
19       
20 end for
21for  from to  do
22        for  and  do
23               Denote ;
24               if  then
25                      ;
26                      for  from 1 to  do
27                             ;
28                            
29                      end for
30                     if  can take trip  then
31                             ;
32                             ;
33                            
34                      end if
35                     
36               end if
37              
38        end for
39       
40 end for
41;
42 for each vehicle  do
43        for  do
44               if  is able to take trip  then
45                     
46               end if
47              
48        end for
49       
50 end for
Algorithm 4 VTG()

6.2 Proof of Correctness

Figure 4: VTG
1 Find the set of connected components ;
2 if  then
3        ;
4        ;
5        for  do
6               ;
7               ;
8               ;
9              
10        end for
11       
12else
13        Enumerate all edges in from to if needed;
14        the first edge of ;
15        removing ;
16        removing , all outgoing arcs of and all incoming arcs of and its neighbors;
17        for  do
18               if  then
19                      Remove and its incoming edges from ;
20                     
21               end if
22              
23        end for
24       ; ;
25        if  then
26               return ;
27              
28       else
29               return ;
30              
31        end if
32       
33 end if
Algorithm 5 BranchBound()
Assertion 6.1.

The algorithm can return the optimal solution for the original ILP.

Proof.

    1. When a vehicle is selected in the process, that is for one of its outgoing arc ,, it will not be selected in the upcoming process since all of its outgoing edges will be deleted once it is selected. This indicates that each vehicle is only matched with one trip.

    2. As long as for an edge , , the incoming arcs of the matched trip and its neighbors will be removed from graph . So a trip will be only matched with one vehicle.

    3. When deleting all the incoming arcs of a trip, the scanning process is going to detect which trip is incompatible with the selected trip and those trip will be remove from in the end of the scanning process. Hence, all passengers will be assigned to exactly one trip in the final solution.

  • We prove this by contradiction.

    Suppose that there is an optimal solution of the ILP that can not be returned by the algorithm. Assuming that the selected edges of the optimal solution are , this is should be returned by a correct algorithm. Then go back to see what the algorithm does. In the first step, or is determined by the algorithm. If is assigned as 0, only one arc will be deleted and the algorithm will see what should equal to. If , then the algorithm will go on to see which value should be assigned to . The process goes on. When the algorithm reach the point of deciding the value of , either 0 or 1 is the possible choice. The algorithm will explore the two choices in the whole process. When is going to be explored, the algorithm will go on to determine the value of . The assignment that is included in the search space of the algorithm. As long as the algorithm set all of to be 0 when exploring, this assignment will be returned. And then the algorithm will determine the value of . When it is going to exploring the solutions when , the process goes on. Until the algorithm is going to find what will happen if , the process ends since all the arcs are removed and this branch is done.

    From the above statement, it can be observed that the assignment is included in the search space of the algorithm. Hence, if the solution is optimal, it will certainly be returned by the algorithm.

6.3 An Example for Algorithm Implementation

Consider the Vehicle-Trip graph in Figure 4, the steps for Algorithm 5 is shown in Figure 5.

  • Enumerate all edges as from top to down.

  • When , vehicle is matched with trip one that contains passenger number one. Then arcs associated with , node , node , node and node .

  • Then it comes to the point of . If , then it is done.

  • If , then the algorithm will see the assignment of . If is assigned, then it is done.

  • If , then the value of will be determined. If , then this path is finished.

  • If , in this example, the solution is not optimal at all. Actually, it should be categorized as infeasible solution since is not matched with any trip while it really could.

  • The steps go on like the above process. The algorithm will terminate when all possibilities are explored. The solution(s) with maximum passengers is returned as the result. For the final result, the comparison among these passenger-optimal solutions will be made in terms of the weight and the one with maximum weight will be returned in the end. This can be done in polynomial time.

Figure 5: Example

6.4 Running Time of Algorithm 5

From the algorithm, it can be implied that the running time of Algorithm 5 can be obtain by solving this following equation.

(13)

where represent the outgoing, incoming degree and the number of neighbors of selected node, respectively, and are the current edges, trip nodes, vehicles nodes, respectively.

Next, the method of solving this equation is presented as following.

  • If , it means the trip only contains one passenger. then the problem can be reduced to a maximum weight bipartite matching problem. It can be solved in polynomial time by Hungarian method.

  • If a vehicle only has edges with trips formed by a stable group, then we can simply match a vehicle with the node, which it connects with, contains the most passengers. This can be done in polynomial time too.

  • If neither of the above cases exist, an approximation of can be given. Since , and , then . In worst case, .

    In this case, the original problem of solving Equation 13 except the last term becomes solving the polynomial equation

    (14)

    A real-value root of this equation is . Since the last term of Equation 13 is added only when the current edge the algorithm explores is assigned as 1, and in the final solution, the number of edges assigned as 1 is no more than the number of vehicles. In addition, the incidental term decreased when of one edge is assigned as 1. Therefore, the incidental running time of scanning is . Hence, the running time of Algorithm 13 is in terms of the worst case.

If the algorithm is expected to detect the infeasible solutions, then it needs more space to remember how many vehicles and stable groups left for each path. If the algorithm does not remove infeasible solutions and do not go on the detecting process , then it needs more space to remember the states of each edge.

7 Experiments

7.1 Data

The datasets from NYC TLC are used to evaluate the performance of the proposed algorithms. The datasets include the pickup and dropoff location and time of a recorded trip. We choose the data in a relatively small area of Manhattan and use trips detected in that place. To be specific, trips served in the rectangle area formed by () and (). Trips during 8:15-8:30 a.m. are extracted to verify the feasibility of our algorithms.

8 Conclusion

In this paper, we introduced a reactive anytime optimal method with scalable real-time performance for assigning passenger requests to a fleet of vehicles of varying capacity. We quantify experimentally the tradeoff between fleet size, capacity, waiting time, travel delay, and operational costs for low- and mediumcapacity vehicles, such as taxis or vans in a large-scale city dataset.Under the assumption of one person per ride, we show that 98% of the taxi rides currently served by over 13,000 taxis could be served with just 3,000 taxis of capacity four. We observe that a vehicle capacity of two is sufficient for ride-sharing when a small trip delay of 2 min is imposed. If a maximum delay of 5 min or more (comparable to the time spent retrieving a car from parking) is allowed, higher-capacity vehicles (i) increase the service rate significantly, (ii) reduce the waiting time, and (iii) reduce the distance traveled by each vehicle. Our analysis shows that a ride-pooling service can provide a substantial improvement in urban transportation systems and that the system parameters such as vehicle capacity and fleet size depend on quality of service requirements and demand.

References

  • Agatz et al. [2012] Niels Agatz, Alan Erera, Martin Savelsbergh, and Xing Wang. Optimization for dynamic ride-sharing: A review. European Journal of Operational Research, 223(2):295–303, 2012.
  • Alonso-Mora et al. [2017] Javier Alonso-Mora, Samitha Samaranayake, Alex Wallar, Emilio Frazzoli, and Daniela Rus. On-demand high-capacity ride-sharing via dynamic trip-vehicle assignment. Proceedings of the National Academy of Sciences, 114(3):462–467, 2017.
  • Pavone et al. [2012] Marco Pavone, Stephen L Smith, Emilio Frazzoli, and Daniela Rus. Robotic load balancing for mobility-on-demand systems. The International Journal of Robotics Research, 31(7):839–854, 2012.
  • Santos et al. [2011] Adella Santos, Nancy McGuckin, Hikari Yukiko Nakamoto, Danielle Gray, and Susan Liss. Summary of travel trends: 2009 national household travel survey. Technical report, 2011.
  • Spieser et al. [2014] Kevin Spieser, Kyle Treleaven, Rick Zhang, Emilio Frazzoli, Daniel Morton, and Marco Pavone. Toward a systematic approach to the design and evaluation of automated mobility-on-demand systems: A case study in singapore. In Road vehicle automation, pages 229–245. Springer, 2014.
  • Spieser et al. [2016] Kevin Spieser, Samitha Samaranayake, Wolfgang Gruel, and Emilio Frazzoli. Shared-vehicle mobility-on-demand systems: a fleet operator’s guide to rebalancing empty vehicles. In Transportation Research Board 95th Annual Meeting, number 16-5987, 2016.
  • Zhang and Pavone [2016] Rick Zhang and Marco Pavone. Control of robotic mobility-on-demand systems: a queueing-theoretical perspective. The International Journal of Robotics Research, 35(1-3):186–203, 2016.