accelerated csa

5/24/2018 Accelerated CSA

1/13

Connection Scan Accelerated

Ben Strasser Dorothea Wagner

Abstract

We study the problem of efficiently computing journeys in

timetable networks. Our algorithm optimally answers profile

queries, computing all journeys given a time interval. Our

study demonstrates that queries can be answered optimally

on large country-scale timetable networks within several

milliseconds and fast delay integration is possible. Previous

work either had to drop optimality or only considered

comparatively small timetable networks. Our technique is

a combination of the Connection Scan Algorithm and multi-

level overlay graphs.

1 Introduction

We study the problem of answering queries in timetablenetworks. Efficient algorithms are needed as the founda-tion of complex web services such as the Google Transitor bahn.de - the German national railroad companyswebsite. The user enters his desired departure stop,arrival stop and a vague moment in time and the sys-tem should compute an optimal journey telling the userwhen to take which train. In practice, trains do not ad-here perfectly to the timetable and therefore it is neces-sary to be able to quickly adjust the scheduled timetable

to the actual situation.Formalizing the definition of an optimal query is

non-trivial. The straight forward adaptation of theshortest path problem on graphs yields the earliest ar-rival problem [21]. Given a source time, a source stopand a target stop, the problem consists of finding a jour-ney that departs after the source time and has a mini-mum arrival time. Unfortunately, earliest arrival jour-neys are flawed as the following example shows: Theuser asks forA@8:00B where A is the source stop, Bthe target stop, and 8:00 the source time. Suppose thatthere is a train A@10:00B@11:00 and therefore the

earliest arrival is 11:00. Intuitively the user is only inter-ested in the direct journey A B , but this is not nec-essarily the only earliest arrival journey. Consider addi-tional trains A@8:00C@9:00 and C@9:00A@10:00.Another earliest arrival journey is A C A B.

Partial support by DFG grant WA654/16-2 and EU grant

288094 (eCOMPASS) and Google Focused Research Award.Karlsruhe Institute of Technology, [email protected] Institute of Technology, [email protected]

However, intuitively it is clear that this journey is notthe answer to the users question; i.e. the earliest arrival

journey problem does not model the users expectations.One solution is to additionally minimize the number oftransfers. This results in a bicriteria problem and isoften optimized in the Pareto sense [11], i.e., find all

journeys for which no journey exists that is better inboth criteria. However, Pareto optimization is expen-sive. Therefore we chose an intermediate approach: Weoptimize the arrival time as a primary and the trans-

fers as a secondary criterion, i.e., among all earliest ar-rival journeys we choose one with a minimum numberof transfers. This variant was already proposed in [18].

Often the user is flexible with regard to his depar-ture and/or arrival time. The basic earliest arrival prob-lem does not reflect this flexibility. For this reason webservices propose several journeys with varying depar-ture times. We formalize this concept as profile queries.Given a source stop, a target stop, a source time anda target time compute all optimal journeys that departafter the source time and arrive before the arrival time.However, this formalization is still not perfect as theuser often only wants to specify either the source or the

target time. For this reason we also consider the earliestarrival timeproblem to estimate the target time basedon the source time and vice versa.

Our approach uses the Connection Scan Algorithm(CSA) [9] as its core. CSA is a simple algorithm thatdoes not use a priority queue and does not rely oncomputing auxiliary data in a preprocessing phase. Itsstrength lies in its very low running time constantsallowing it to solve even moderately sized timetablenetworks such as the London urban region in about150ms. However, sublinear running times are necessaryon larger country-scale timetable networks such as theone used by bahn.de. We therefore extend CSA to use

auxiliary data computed in a preprocessing phase. Weadapt the basic ideas of CRP [5, 8] and its multi-leveloverlay predecessors [21, 16] to timetables. Previousstudies [3] have shown that directly applying speed-uptechniques designed for road graphs to timetables doesnot work. It is crucial to adapt the algorithms to thespecial timetable structure. CSAs ability to handlemoderately sized timetable networks efficiently makesthe approach practical even if overlays are not tiny.

125 Copyright 2014.

by the Society for Industrial and Applied Mathematics.

Downloaded06/14/14to115.248.130.148.RedistributionsubjecttoSIAMl

icenseorcopyrig

ht;seehttp://www.siam.org/journals/ojsa.php


2/13

1.1 Related Work. In [18] timetable routing is re-duced to variants of the shortest path problem ingraphs. Time and transfers are optimized. Somespeedup techniques are evaluated, among them goal di-rection using potentials. Only small instances are ex-amined. RAPTOR [7] improves on this approach by

not using graph data-structures. They also consideradditional criteria such as price. In [22] multi-levelgraphs are evaluated on timetables. In [12] contractionhierarchies are adapted to timetables to optimize pro-file queries. However, they do not optimize transfers.In [4] the authors introduce two speedup techniques:SUBITO and k-flags. They optimize transfers in thePareto sense. In [1], Transfer Patterns were introducedand were refined in [2]. This technique was developed inpart by the Google Transit team and is the best com-petitor in our scenario. It is the only technique thathas been shown to be practicable on large country-scale

timetable networks with about 60 000 000 connections.This is slightly larger than our benchmark instance. Un-fortunately, the preprocessing time is prohibitive. Tomake preprocessing feasible, correctness is dropped andeven then multi-core CPU days are needed. Studied arePareto optimization and optimizing a single composedcriterion similar to ours. Profile times are not evaluated.

1.2 Our Contribution. Recent studies [7, 9] haveshown that often algorithms not based on Dijkstras[10] work better on timetable networks. We describethe first preprocessing based speedup technique that atits core is not based on Dijkstras algorithm. We achieve

running times of 8.7 ms for the earliest arrival time prob-lem and of 78 ms for the profile problem on large-scaletimetable networks with secondary transfer optimiza-tion. Depending on the formalization our preprocessingis either very fast (1 min) or fast (30 min). We know ofno provably optimal speedup technique achieving sim-ilar running times for similar optimization criteria onlarge scale timetable networks. Our preprocessing is or-ders of magnitude faster than existing approaches.

2 Basics

In this section we formally define the notions of publictransit network and journey and give a motivation for

the design choices. We further formally define profilesand formulate the precise problems considered in thisstudy.

2.1 Network. A (timetable) network consists ofstops, connections, trips and a transfer graph (definedin the next subsection). A connectionc represents a ve-hicle driving from adeparture stop cdepstopatdeparturetime cdeptime without intermediate halt to an arrival

stop carrstop at arrival time carrtime. Travel times mustbe strictly positive. Connections served successively bythe same vehicle are part of the same trip ctripid.

Following [7], we only consider aperiodictimetables,where vehicles only drive once and are not repeat everyday. To support queries involving overnight trains we

unrollthe network one day, i.e., we copy all connectionsand add 24h to the departure times and arrival times.However, queries are only allowed within the first 24h.

At first an aperiodic timetable seems less realisticthan the periodic ones with perfectly repeating connec-tions considered in other papers [18]. However, it is alsounrealistic that schedules are never changed, especiallywhen considering delays, and therefore both are modelsdo not fully capture reality.

A third more realistic model assumes that the inputonly consists of a finite connection subset of an infiniteaperiodic set of actual connections. However with this

realistic model has some severe problems. For exampleone can only decide whether a journey exists that solelyuses input connections. However, if no such journey isfound, it does not mean that no journey exists usingconnections in the infinite set of all connections. It isnot possible to decide whether a journey exists solelybased on the input. We conclude that at some pointperfect realism must be dropped.

In practice the differences between the periodic andaperiodic approaches are small, as the user is rarelyinterested in journeys longer than 24h. It makes no realdifference whether a bogus journey is found or none isfound at all. In both cases the user will look for different

transportation options (such as planes).

2.2 Transfers. While real world datasets tend toagree on the modeling of vehicles, they differ signifi-cantly when it comes to modeling transfers. These dif-ferences are also reflected in the published papers butare rarely discussed.

For example, a widely used format is the GeneralTransit Feed Specification [14]. It only allows forfoot-pathsbetween two stops, i.e., the feed contains a list ofweighted directed arcs that represents a transfer optionfrom one stop to an adjacent one. No change times atstops are specified, allowing the user to instantly trans-

fer between vehicles arriving and departing at the samestop. Many feeds model large train stations not as asingle stop but each railway platform inside the stationas individual stop and connect the platforms using foot-paths.

Another specification is given by HAFAS [15]. Ourbenchmark instance is based on it. Here neighboringplatforms are modeled as a single stop. To assurethat the user is given enough time to transfer from

126 Copyright 2014.



icenseorcopyrig



3/13

one vehicle to another one, every stop is associatedwith a minimum change time min, i.e., the differencebetween the departure time of the connecting vehicleand the arriving one must be at least min. The datasetalso contains a few footpaths to connect neighboringplatform regions. A large train station might for

example be modeled as three stops interconnected byfootpaths: the main platforms, the subway platforms,and the forecourt platforms. HAFAS-based feeds tendto have fewer footpaths than GTFS-based ones.

There are GTFS feeds that contain footpath loops,such as for example the feed of Berlin [13]. These arefootpaths with the same departure stop and arrival stopand a non-zero duration. The idea of these footpathsis to encode the minimum change time but the GTFSspecification does not state whether this formulation isvalid. However, GTFS does not provide a better way toencode this type of information.

At first glance the GTFS approach of modelingplatforms as stops instead of whole stations as stopsseems superior as it is more fine grained. However, insome countries such as France the operator does notplanned in advanced at which platform a vehicle willarrive. Platforms are assigned to trains a few dozenminutes before the arrival of the vehicle. This can notbe modeled without minimum change times.

When mixing footpaths and minimum change timesa couple of questions arise. Let A and B be twostops with minimum change times of 5min and 10minand a connecting footpaths of 3min. Is the transfertime 3, 8, 13, or 18 minutes? We model the most

general case allowing 3min transfers. A footpath canreplace minimum change times. Note that this allowsfor transfers below the minimum change times. Weobserved instances of this actually happing in real data.However, one might argue that this is a data error.

Having motivated the need for both footpaths andminimum change times, we are ready to present ourdefinition of the transfer graph, an abstraction thatavoids the need to distinguish between both. It is adirected weighted graph. The stops are its nodes. Wedenote its directed arcs using AB and refer to themas transfers. Their weight is denoted using d (AB)and referred to as duration. Footpaths are modeled as

interstop transfers and minimum change times as loops.Every stop is required to have a loop. The durationmust be non-negative. Multi-arcs are not allowed. Theuser is by definition required to use at least one transferwhen changing vehicles. To assure that one transfer isalso always enough, we require additional restrictionson the transfer graph. Following [7] we require thatthe transfer graph is transitively closed. An equivalentcharacterization is to say that the transfer graph is a

union of disjoint cliques. We further require that thetriangle inequality is fulfilled, i.e, for every two transfersAB and BC the duration of the transfer AC(which must exist) is never larger than the sum of thedurations of AB and BC. These requirementsassure that all shortest paths are at most one hop

long. If the input transfer graph does not fulfill theserequirements, then it can easily be transformed to do so.In theory this can severely increase the transfer graphssize. However, transfers should not model the userwalking from one station to a neighboring one. Transfergraphs are therefore highly disconnected, which resultsin only a small size increase. For unrestricted multi-modal routing a different approach is needed.

2.3 Journeys. We model journeys as sequence ofconnections and transfers. We first define partial jour-neys that can end and/or depart in the middle of a trip.

Based on these we define complete journeys that are re-quired to depart and arrive at a stop and must use aninitial and final transfer.

A partial journeyis a sequence of connections andtransfers in temporal order, i.e., a connection mustarrive before the next one can depart. Two successiveconnections c and c either share the same trip andcarrstop = c

depstop or are separated by a transfer t withcarrstop = tdepstop and tarrstop = c

depstop. Without looseof generality we can forbid successive transfers, as theycan always be replace by a direct transfer that is notshorter. If a sequence begins (ends) with a transferwe say that it departs (arrives) at the source (target)

stop of the transfer and has a departure (arrival) time.Otherwise it begins (ends) with a connection. Wesay that a partial journey departs (arrives) at thatconnection.

A partial journey is called a complete journey (orjust journey) if it begins and ends with a transfer. Toavoid a border case in the profile definition, we do notconsider journeys consisting of a single transfer to becomplete. This is no real restriction as testing for singletransfer journeys is simple. We say that a (complete)

journey is an A@B-journey, if it departs at A noearlier thanand arrives atB. Partial journeys are onlyused in intermediate steps of our algorithms. Unless

stated otherwise journeys are complete. A completejourney can be represented more compactly by onlystoring the connections adjacent to transfers. Theintermediate connections can easily be inferred.

2.4 Optimization Criteria. We consider differentoptimization criteria. The basic ones consist of minimiz-ing arrival time or the number of transfers. However,these two can also be combined yielding further more

127 Copyright 2014.



icenseorcopyrig



4/13

complex criteria. For example we also consider deter-mining a journey with a minimum number of transfersamong those with a minimum arrival time. To avoidhaving to formulate algorithm variations for each crite-rion, we define an abstract journey cost. Unless statedotherwise, our non-accelerated profile algorithms can

minimize any cost that fulfills a short set of axioms. Allthe afore mentioned criteria fulfill these requirements.

A cost is a function that maps partial and com-plete journeys onto values that can be totally ordered.A A@B-journey is optimal, if no other A@B-

journey with lower costs exists. We require that the costfunction fulfills thesuffix exchangeabilitycondition: Lets1s2. . . sn denote an optimal A@B-journey. Con-sider any suffix si. . . sn that is a complete journey de-parting at stop Cat time . Replacing the suffix withany optimal C@B-journey must yield another opti-mal A@B-journey.

The combined criteria can be realized using a costfunction that maps journeys onto lexicographically or-dered pairs, consisting of the arrival time and the num-ber of transfers. What component is compared first de-cides what criteria is more important. As optimizationwe encode these pairs as single integer where the im-portant criterion is encoded within the higher bits andthe unimportant criterion in the lower bits. This allowsto perform a lexicographical comparison using a singleinteger comparison.

It is straight forward to additionally define pre-fix exchangeability: Let s1s2. . . sn denote an optimalA@B-journey. Consider any prefix s1. . . si that is

a complete journey arriving at C. Replacing the prefixwith any optimal A@C-journey must yield anotheroptimal A@B-journey. However, only the earliestarrival criterion fulfills this property. Minimizing thenumber of transfers does not and therefore the combinedcriteria do not either. For example suppose that theprefixs1. . . si contains 2 transfers and that a A@C-

journey with 1 transfer exists that arrives later. It isimpossible to guarantee that exchanging the prefix doesnot invalidate the transfer connecting the prefix to therest of the journey sequence. Transfer minimization notfulfilling prefix exchangeability severely limits the con-cepts usefulness. We therefore only exploit postfix ex-

changeability in our profile algorithms. This is the rea-son why we constructs journeys backward starting atthe target stop.

2.5 Profile. Profiles are functions that map depar-ture times onto arrival times (or generalized costs).Given two stops A and B we define a AB-profile tobe the function that maps onto the costs of an op-timal complete A@B-journey (or +if no journey

exists). As by definition all journeys must contain atleast one connection and there are only finitely manyconnections, there may only be a finite number ofval-ues, where the function changes its value. The profilefunctions are therefore always step functions. Furtheras aA@B-journey is also aA@B-journey for all

< , the profile functions are non-decreasing. Profilescan be identified by a sequence of (i, Ci)-pairs, wherethe function changes its value. In each pair i is thedeparture time and Ci the cost. The sequence is simul-taneously ordered by i andCi. These pairs correspondto departing vehicles.

To compute actual journeys (instead of just profiles)we tag every pair with two connection IDs. Theserepresent the connections, where the user enters the firstvehicle and exits the first vehicle of the journey. Thisallows to extract the first part of an optimal journey.The remaining parts can be extracted by iteratively

repeating the process at intermediate stops. We referto these connection IDs as journey pointers.

2.6 Problems. The input to theearliest arrival timeproblemconsists of a network, a source stop ps, a sourcetime s, and a target stop pt. The goal is to computethe minimum arrival time over all [email protected] the latest departure time problem consistsof maximizing the departure time among all journeysarriving not later than a given target time t.

In the profile problem, one is given a network, asource stop ps, and a target stop pt. The objective isto compute the sequence of (i, Ci)-pairs corresponding

to the pspt-profile. Note that source and target timesare not restricted. The problem consists of computingfull profiles.

Therange profile problemtakes as additional inputa source time s and a target time t. All pairs in the

pspt-profile sequence should be computed that departno earlier than s and arrive no later than t.

Note that the (range) profile problems areparametrized on the cost function used. First optimiz-ing arrival time and then optimizing transfers as a sec-ondary criterion is the cost function we want to solve.As an intermediate step in the preprocessing we willalso need to solve profile problems that solely optimize

transfers.Further note that the earliest arrival time and

latest departure time problems are basically equivalent.Solving one on a networkNconsists of solving the otheron a transformed network N constructed as following:The stops are the same. The transfer arcs have theirdirection inverted. All connections have exchangeddeparture and arrival stops. The departure and arrivaltimes are negated. The range profile problem can be

128 Copyright 2014.



icenseorcopyrig



5/13

reduced to the profile problem by removing connectionswith departure time or arrival times outside of therange.

In our envisioned websystem the user is firstprompted for a source stop and a target stop. He mustadditionally enter a source time or a target time (or

both). If he enters both then the query consists of solv-ing the range profile problem. If only one is given, thesystem must estimate a sensible value for the other one.If he indicates only a source times, the system solves anintermediate earliest arrival time problem, to determinethe minimum travel time . The system then suggestst = s+ a , where a is some tuning parameter. Weseta = 2. Analogously, if only a target time t is given,the system solves the latest arrival time problem andsuggestss= t a .

2.7 SIMD. Many modern processor architectures

support single instruction multiple data (SIMD). Theseare special hardware registers that store fixed lengthvectors of scalars. The processors contain special in-structions, that can apply operations componentwise tothe vectors. These special instructions are as fast astheir single scalar counterparts. Using bitmasks sim-ple conditional operations can be done componentwise.However, most algorithms have to be adjusted to exploitsuch SIMD parallelism, because they contain branchesthat diverge too much to be done using bitmasks. A cur-rent x86 processor supports integer vectors of width 4containing 32-bit integers. Next generation processorsare planned to support vectors of 8 integers. Using ac-

celerator cards widths of 16 integers are possible.

3 Connection Scan without Auxiliary Data

In this section we recapitulate the basic ConnectionScan approach to journey planning introduced in [9].We extend the profile algorithm to minimize generalizedcost functions and parallelize it using SIMD.

All algorithms are based on dynamic programming.We maintain a solution that only considers the scannedconnections. (The solution, however, always contains allstops and trips. The trips initial contain no connectionsthough.) Initially no connection was scanned, whichallows for a trivial initial solution. We then iteratively

introduce connections ordered by their departure time.At each step we modify the solution to incorporatethe new connection c. For this it is sufficient to onlyconsider journeys containing c, as the other journeyscan not be modified by introducing a new connection.As the connections are scanned ordered by departuretime, the new connection c can only appear at the endof a journey (or beginning if scanned by decreasingdeparture time). Our objective is to compute journeys

A B

C

6 4

3 3

Figure 1: The capital letters denote stops. The arrowsrepresent transfers and are annotated with their dura-tion. A first vehicle arriving at A@1 sets (B) = 4 and(C) = 7. A second vehicle arriving at B@2 can im-prove (C) but not (B).

between a source stoppsand a target stoppt. However,during the algorithm we do not maintain such a one-to-one solution but a one-to-all solution, i.e., for a fixedsource stop ps and all possible target stops pt. (Whenscanning the connection decreasing by departure time,we maintain an all-to-one solution.)

3.1 Earliest Arrival Time Algorithm. We solvethe earliest arrival time problem by scanning the con-nections increasingly by departure time. We fix a sourcestopps and maintain a one-to-all solution, that consistsof a tentative arrival time (p) for every possible targetstopp. We further store at every tripqa reachability bitr (q) that indicates whether a partial journey exists thatends in a connection of this trip. Initially no r (q)-bit isset. All(p) are + except if a transferpspexists. Inthis case we set(p) = s + d (psp). When scanning aconnectionc we first determine, whether r (ctripid) mustbe updated and then adjust the tentative arrival times.

If r (ctripid) is set, a partial journey ending in a con-nection of trip ctripid must exist. This partial journeycan be extended by appending c, resulting in a partial

journey ending in c. If it is not set then c can only bepart of a journey, if the user can enter at cdepstop. Thiscan be checked using (pt) cdeptime and if it is thecase, r (ctripid) must be set. If the updated r (ctripid) isset, a partial journey ending in c must exist. By ap-pending a transfer departing at carrstop the journey canbe completed. We do this by iterating over all outgoingtransferscarrstoppand decreasing the tentative arrivaltime (p) if a better journey is found.

As basic optimizations the scan can be started atthe first connection c with cdeptime s and abortedonce (pt) cdeptime holds. A further more complexoptimization is called limited propagation. It consists ofonly iterating over the outgoing transfers, if carrtime (carrstop). Intuitively the idea behind limited propa-gation is, that if we can not ameliorate the solution atcarrstop, we can not do it anywhere, as the better jour-ney ending incarrstopcan be append with another trans-fer resulting in a better journey everywhere. However,

129 Copyright 2014.



icenseorcopyrig



6/13

note that the afore mentioned test is not equivalent with(carrstop) being decreased as the situation in Figure 1demonstrates.

3.2 Profile Algorithm. The profile algorithm usesa very similar approach. The main difference is that

the connections are scanned decreasing by departuretime to exploit suffix exchangeability. We fix a targetstopptand maintain an all-to-one instead of a one-to-allsolution. Further storing full profiles is more complex,which reflects in more complex data structures. We firstintroduce the data structures used, then describe howthey relate to the profiles and what their counterpartsin the basic earliest arrival case are. We then describehow a new connection c can be introduced and whatmodifications in the data structure are necessary.

Our datastructure consists of: the tentative costfunctions Fp, the tentative trip costs Cq, and the

transfer-to-target durationsw

p. The tentative cost func-tions Fp replace the tentative arrival times of the basealgorithm. They are profile functions that map the de-parture time at the stop p onto the minimum cost overall journeys with target pt. The tentative trip costsCqreplace the trip reachability bit of the base algorithm.These are values that store the minimum cost over allpartial journeys that depart in a connection of this tripand arrive at pt. Finally the transfer-to-target dura-tionswphave no real counterpart in the base algorithm.If a transfer ppt exists thenwp is set tod (ppt) and+otherwise.

We initially set the wp to + at the beginning

of the program and before and after each query weiterate over all incoming transfers of pt. By definitioneach complete journey must contain a connection andtherefore initially no journey can exist. This allows us toinitially let each tentative cost function map every valueonto + and also set all tentative trip costs to +.

Let c be the currently processed connection. Wefirst compute the minimum cost over all journeys de-parting in c to update Cctripid . To do this consider alloptions the user has upon the arrival of c: Sometimeshe can directly transfer to the target, or he can remainseated, or use a transfer and enter another vehicle. Thecosts of the first two cases can be computed using wp

and Cq. The last one requires evaluating Fcarrstop . Thecorrectness of the later can be seen as following: Sup-pose an optimal journey did exit upon the arrival ofc.The suffix exchangeability allows us to exchange the

journey suffix afterc, with the journey that caused thevalue of Fcarrstop . After updating Cctripid we prefix thecorresponding partial journey with all incoming trans-ferspcdepstop and adjust Fp if needed. Limited prop-agation can be applied: It is sufficient to only iterate

over the transfers, if inserting a (cdeptime, Cctripid) wouldnot modify the function.

3.3 Tentative Cost Function Operations. Recallthat profile functions can be identified by an orderedsequence of (i, Ci)-pairs. We store these in dynamic

arrays that can be enlarged at the front. A functionis evaluated at by sequentially iterating over all pairsstarting at lower values. In theory this evaluation loopcan have many iterations. However, experiments in Sec-tion 6 show that the contrary is the case: The loopnearly always aborts directly. The newly introducedconnection c has a minimum departure time. It there-fore tends to only change profiles for small values ofi,i.e., precisely those stored at the front of the array. Newpairs are also inserted using a sequential scan. We callthis loop theinsertion loop. The same effect can be ob-served. In essence all operations require quasi constant

running time, giving the whole profile algorithm a run-ning time quasi proportional to the number of scannedconnections. In [9] we have shown, that if no interstoptransfers (i.e., footpaths) exist, the algorithm can bemodified such that amortized constant worst case run-ning time bounds for the cost function operations canbe proven.

3.4 Multi-Query Connection Scan. The profilealgorithm can be parallelized using SIMD, resulting inlower amortized times. Denote by n the width of theSIMD vectors. Our algorithm can compute profiles forn different target stops in parallel. This is useful in

preprocessing. A different scenario involves a serverwith many simultaneous requests. It can answer severalqueries in parallel using a single thread, resulting in ahigher throughput.

We replaceCq and wcarrstop by SIMD-vectors and alloperations on them by SIMD-instructions in a straight-forward way. The varying lengths of the dynamic arraysunderlying the tentative cost functions result in diverg-ing code paths prohibiting a direct parallelization. Weobserve that these arrays may contain duplicated entrieswithout producing incorrect results. We store a singlearray that is used by all n queries. It contains (i, Ci)-pairs, where i is a non-vectorized departure time and

Ci is a SIMD-vector of costs. A pair is inserted if isnot dominated in every query. Dominated cost vectorcomponents are replaced by the dominating cost. Thearrays are longer but SIMD-parallelization is possible.

4 Accelerating Connection Scan

We utilize the core idea from CRP [5, 8]. It consists ofsubdividing a road graph into cells and computing foreach cell a replacement graph that preserves shortest

130 Copyright 2014.



icenseorcopyrig



7/13

A

B

C

D

(a) The solid black connectionsare transit connections.

ps

pt

(b) The transit connection setsparticipating in a normal query.

ps

pt

(c) The transit connection setsparticipating in a local query.

Figure 2: Boxes represent cells. In the right two figures every cell is subdivided into 4 subcells. Curved linesare journey parts consisting of several connections. Arrows denote single connections. Letters denote stops. Theshade of a cell indicates the density of a cell. A darker shade signals a denser set.

paths. Translated into the timetable setting, we recur-sively partition the stop set into k cells over levels.The top cell is the full stop set. We define a connectionto be interior (exterior) to a cell z, if it (does not) de-part in z. An entry (exit) connection of a z is departs(arrives) outside ofz but arrives (departs) inside.

4.1 Partitioning. The stops are partitioned by run-ning a graph partitioner [17] on the following graph:Stops are mapped onto the same node if there is atransfer between them. This prohibits transfers fromcrossing cell borders. An edge exists if a correspondingconnection exists and is weighted by the number of suchconnections.

4.2 Transit Connection SetT(z). For every cell zwe store a set of transit connections T(z). The transitconnections are interior connections and every optimal

journey that goes through the cell can be replaced bya journey, that only changes vehicles at connectionsin T(z) (or are exterior to z). Consider the examplein Figure 2a. Suppose that the journeys ABDand ACD are both optimal. It is sufficient toadd one of them (in the example the one through B)into the transit connection set, because any subjourney

though C can be replaced by the one through Bwithout modifying the cost. Note that several transitconnection sets are valid, as we could have includedthe journeys through C. Our algorithm computes somesmall valid sets but not necessarily a smallest one. Theset only contains the connections adjacent to a transferin the journey. The intermediate connections are notcontained. We do this because the base algorithmsintroduced in Section 3 successfully find the journeys

traversing the cell, even if only those connections arescanned. Also note that connections that depart outsideofz are not part of the transit set ofz , but of the set ofits neighboring cell.

Transit connections are computed using the algo-rithms in Section 5. In this section we assume that ablackbox is available that does this. The input of theblackbox is the set of entry and exit connections of zand a set of connections to scan.

4.3 Long Distance Connection Set D (z). Forevery cell z we additionally define a set oflong distanceconnections D (z) as following: If z is at the bottomlevel thenD (z) is the set of all interior connections, andotherwise it is the union of the transit connection sets ofall direct children cells ofz, i.e.,D (z) =

T(zchild). At

query time we merge all D (z) of cells z containing thesource stop or the target stop (or both) resulting in onelarge connection subset Q. The set Q is illustrated inFigure 2b. Let the dotted journey j be optimal. We cannot guarantee that our algorithms will find j . However,one can iteratively replace the subjourneys in each celland obtain the solid line journey j. We can guaranteethat j is optimal and our algorithms find j. We runthe algorithms from Section 3 but only scanning the

connections in Q.

4.4 Improving Local Queries. Local queries,where the source stop and the target stop are nearby, arecommon and therefore we optimize them. We achievethis by not merging all sets up to the top level but onlyup to the lowest common ancestor cell zlca. Considerthe situation in Figure 2c. The top shaded cell is zlca.Most journeys will be fully contained withinzlcaand will

131 Copyright 2014.



icenseorcopyrig



8/13

therefore be found. However a few journeys exist thatexit zlca and reenter it (possibly multiple times such asthe solid journey). We therefore store an additional setof loop connections L (zlca) at every cell, that containsall connections necessary to find journeys that exit andreenter zlca. The set Q is the union of the long distance

connection set of all sets containing either ps orpt (butnot both), and D (zlca) and L (zlca).

The loop connection set of a cell z can be com-puted by passing zs entry and exit connections to theblackbox and letting it scan every connection (includingthose outside ofz ). The connections not needed for theextremely rare journeys that enter and exit z multipletimes and are inside ofD (z) can be removed fromL (z).

4.5 Efficiently ComputingT(z), D (z)and L (z).Computing the connection sets by considering the wholenetwork is too slow. We therefore exploit the hierar-

chy already during their construction and restrict theconnections scanned by the blackbox. In a first phasewe compute T(z) and D (z) in an alternating bottomup fashion. In the second phase L (z) is computedtop down. The main idea of the first phase is thattransit connections are long distance connections, i.e.,T(z) D (z). It is therefore sufficient if the blackboxscans D (z). Long distance connections are computedusing using D (z) =

T(zchild), with the exception of

the lowest level where D (z) is the set of interior con-nections. The second phase exploits that loop connec-tions are either loop or long distance connection of theparent cell, i.e., L (z) D (zparent) L (zparent). The

exception is the top cell where the loop set is empty. Toimprove locality we remove stops without connectionsor transfers before running the blackbox. Operationson the same level can be parallelized but we found thatparallelizing the blackbox is more effective because ofunbalanced workloads per cell. Recall that we scan theconnections ordered by departure time. We thereforeassign ids to the connections in this order. All com-puted sets are stored as ordered connection ID arrays.This allows efficient merging without loading any con-nection details. If a time range is given, we first discardthe connections outside of the range and then merge theremaining connections.

4.6 Tailored for the Earliest Arrival Problem.We can solve the earliest arrival problem by first com-puting Q and then running the basic CSA algorithm.However, we can accelerate the base algorithm by notexplicitly merging the connection sets and processingthe connections out of order.

To achieve this we must first modify the basealgorithm to support the scanning of connections in

a

bc

d

e

A B

tme

Figure 3: The vertical lines are stops and the arrowsconnections. The upper case letters denote stops andthe lower case letters connections. The connections c, dande are part of the same trip.

arbitrary order and not only by increasing departuretime. Consider the situation depicted in Figure 3.Suppose that initially only b is reachable, i.e., only apartial journey ending in b exists. The connectionsare scanned in following order: b, e, c, a. Afterscanning b the stop B is reached. After processing e,the reachability bit of the trip etripidis set. As etripid=

ctripid the next connection c is considered reachableas r (ctripid) is set, even though no partial journeyexists that ends in c. As c is considered reachable thestopA is reached and thus the next connection a is alsoerroneously considered reachable. This problem can befixed by replacing r (q) by an integer representing theposition of the first reachable connection inside trip q.When scanning a connection c the algorithm does nottest whether the bit is set, but whether r (ctripid) issmaller than cs position.

Consider a query with source cell zs, target cell ztand source time s. If a journey exists then an optimal

journey exists that first uses connections from D (zs),

then fromD (zparents ),. . .,D (zlca),L (zlca),D (zlca),. . .,D

zparentt

, and finally from D (zt). Instead of merging

those sets we guess that an earliest arrival journeyarrives before s+ c for some constant c. Next we tryto verify if we guessed correctly and if not increase cand repeat. We verify our guess by iterating over thesets in the order given above. For each set Swe scanthe connections in S departing before s+ c increasingdeparture time. If a journey arriving before s+cexists,it is found this way. As optimization, we do not processconnections multiple times and ignore those departingbefore s by running a binary search on each set.

5 Computing Transit Connections

In this section we implement the blackbox from Section3. Given a set of entry and exit connections and a set ofconnections to scan, the blackbox computes the transitconnections. We describe two constructions Ta(z)and Tt(z) with different properties. Thearrival timetransit set Ta(z) can be computed quickly but onlyguarantees that an earliest arrival journey is found. Ithas no guarantees with respect to transfers. Further

132 Copyright 2014.



icenseorcopyrig



9/13

A B C ptps

cell z

me

Figure 4: The vertical lines are stops. The arrows areconnections. The vertical position is the time. Con-nections arriving and departure at the same momentare part of the same trip. Stops A and B are part ofthe same cell z . Stop Ais an interior border stop ofz,whereas C is an exterior border stop. Only the thick

connections are in Ta(z), whereas all interior connec-tions are in Tt(z).

ps A B

pt

36

45

7812

z

Figure 5: The capital letters represent stops. Thearrows are connections. The solid arrows are part ofthe same trip. The dashed one is in its own trip. Thecircle represents a cellz containing only the stopA. Thestop A is an interior border stop and B is an exterior

one. The connections are annotated with departure andarrival times. Only the dashed connection is in Ta(z).

non-zero duration transfer loops, i.e. minimum changetimes, are not supported. On the other hand, thetransfer transit set Tt(z) needs more preprocessing timebut does not have these limitations. The transit setsare constructed such that the subjourney between anentry and exit connection pair can be replaced with anequivalent subjourney found in the transit set. Bothconstructions are parallelized using threads and SIMD.

5.1 Arrival Time Transit SetTa(z). We first iden-tify all interior (exterior) border stops as the arrivalstops of entry (exit) connections. Note that there aresignificantly less border stops than border connections.In the next step we compute profiles from every inte-rior border to every exterior border stop. We optimizearrival time for correctness. We optimize transfers sec-ondarily to heuristically improve the results. Figure 4depicts an example Ta(z).

This construction is only correct if all transfer loopshave zero-duration. Consider the situation in Figure 5.As the dashed connection dominates the solid one, onlythe dashed one is included in Ta(z). If B has a zerotransfer loop an earliest arrival journey between ps and

ptis found, as the user can transfer atBfrom the dashed

vehicle back into the solid one. However, if the transferduration of the loop at B is greater than 2, no journeyis found at all.

5.2 Transfer Transit Sets Tt(z). To com-pute Tt(z) we compute for each pair of entry andexit connections a journey with a minimum numberof transfers. Note that for a specific pair all journeysare required to end in the same connection. All valid

journeys therefore have the same arrival time and thusit is sufficient to optimize transfers. We do this bycomputing profiles between every pair of entry and exit

connections. As profiles can only be computed betweenstops, we split each entry and exit connection into twoand add a dummy stop in the middle. We compute theprofiles between pairs of dummy stops.

5.3 Parallelization. Both transit sets are computedby enumerating all profiles between a set of sourcestops Sand a set of target stops T. For each pt Twe compute an all-to-one profile solution and extract foreachps Sthe corresponding journeys by following the

journey pointers. We parallelize this operation by sub-dividingTinto work packages ofn elements, where n isthe width of the SIMD vector. A thread then processes

a work package by computing all profiles simultaneouslyusing SIMD. However, the journey extraction can notbe done using SIMD.

5.4 Intermediate Transit Sets. The transfer tran-sit set Tt(z) is constructed such that it conserves allPareto optimal journeys. However we do not exploitthis property afterwards. We only compute a journeywith a minimum amount of transfers among all earli-est arrival journeys. Is it possible to design a transitset larger than the arrival time transit set Ta(z) butsmaller than Tt(z) that only conserves these journeys?We can not give a definitive answer about its existence

but it is very unlikely that it could be computed fasterthanTt(z) and would therefore be useless. Consider thesituation in Figure 4. Every transit set must contain thethick connections because otherwise the earliest arrival

journey from ps to C is not conserved. The questiontherefore is: Which of the thin interior connections aresuperfluous? For an efficient transit set computation, itis necessary that we only use information depending onthe interior of the cell. We therefore can not tell which

133 Copyright 2014.



icenseorcopyrig



10/13

transfer

SIMD

extra inserted pairs average averagerun. time for pair earliest insert evaluationtime journey count when loop loop[ms] pointers /106 inserted iterations iterations

2 640 509 4.3 97.5% 1.006 1.013 3 361 812 5.7 97.6% 1.009 1.021

1 468 405 11.6 97.1% 1.023 1.055

Table 1: Details of the all-to-one profile algorithm on the full network. The time range is not restricted.

of the dashed connections exist. We have to computeone transit connection set, that is correct for each com-bination of dashed connections existing. If both of themexist, all thin connections must be transit connections.We conclude that it is not possible to conserve fewerthan all Pareto optimal journeys, without looking atthe outside of the cell.

6 ExperimentsWe ran experiments on a dual 8-core Intel Xeon E5-2670processor clocked at 2.6 GHz, with 64 GiB of DDR3-1600 RAM, 20 MiB of L3 and 256 KiB of L2 cache. Weuse g++ 4.7.1 with -O3. In the tables an enabled featureis marked by a and a disabled one by a . SIMDis done using SSE with registers containing 4 integersof 32 bits. We ran 104 queries with random source andtarget stops and a random source time within the first24 hours.

#stops 252 374#connections 46 218 148#trips 2 395 656#footpaths 103 535#FIFO-routes 229 666#TE-nodes 82 017 803#TE-arcs 202 073 458

Table 2: Instance size

6.1 Instance.

Our test instance isbased on the dataof bahn.de duringwinter 2011/2012.The data containsEuropean longdistance trains,German local trains,many buses inside ofGermany and evenmore exotic vehicles such as rack railways in the Alps.To obtain an instance comparable in size with [1] weextracted all trips regardless of their day of operation

and consider two successive identical days. We removeddata noise such as exactly duplicated trips, vehiclesdriving at more than 300 km/h or footpaths at morethan 50 km/h. More than half of the connectionsare buses. Minimum change times are modeled astransfer loops and footpaths as interstop transfer arcs.We transitively closed the transfers and obtain thesizes reported in Table 2. For comparison with [7]we indicate the number of FIFO-routes, i.e., into how

many parts the set of trips has to be partitioned (atmost) such that all trips in one part have the samestop sequence and do not overtake eachother. Forcomparison with [1] the time-expanded (TE) graph sizeis indicated.

6.2 Reference Times. We ran a reasonably tunedversion of Dijkstras algorithm with a binary heap. The

advanced optimizations from [18] were not included. Onaverage it settled 10 554 570 nodes and needed 2 960msfor a one-to-one query optimizing only arrival time. Anon-profile one-to-one CSA as described in Section 3needed on average 298.6ms.

6.3 Profile Queries. In Table 1 we evaluate the un-accelerated CSA described in Section 3. We report run-ning times with and without journey pointers. SIMDrunning times are divided by the number of simultane-ous queries. We report the number of inserted pairs andhow many were inserted at the front of the array (i.e.have an earliest departure time when inserted). We fur-ther report how many iterations the insertion and theevaluation loops needed. Computing pointers increasesrunning times by 25%. Optimizing transfers inserts ad-ditional pairs which costs in time. SIMD halves therunning time. The two loops nearly always terminateright away. SIMD increases the number of iterations butthey remain negligible. Unsurprisingly a near constantinsertion loop implies most pairs being inserted at thearrays front.

SIMD

t

ransfer

running

time [s] 45.4 49.2 2007.8 1794.7

Table 4: Parallelizedrunning time neededto compute overlays.

6.4 Computing Overlays.In Table 4 we report the times

needed to compute the transitsets introduced in Section 5.To compute the Ta(z) we setall transfer loops to zero in thisexperiment. transfer indi-cates whether Tt(z) or Ta(z)is computed. All 16 cores areused. We recursively subdi-vide the stops 5 times into 3

134 Copyright 2014.



icenseorcopyrig



11/13

(a) Computing Tt(z). (b) Computing Ta(z).

Figure 6: Running times needed to compute the transit connections against their border size. The data pointsare annotated with the geographical regions that they belong to. Thread parallelization was used. SIMD was notactive.

only time Ta(z) with transfers Tt(z)level |D (z)| |L (z)| |D (z)| |L (z)|

0 193 029 11 232 193 029 11 1091 70 781 15 204 115 660 14 0422 93 933 20 046 138 036 18 8363 125 642 24 046 181 689 24 065

4 154 790 25 155 222 143 24 5965 168 080 0 277 454 0

Table 3: Number of long distance and loop connectionsaveraged over all cells on the same level. Level 5 is thetop.

partitions. Ta(z) can be computed in under a minuteenabling real time updates. The alternative Tt(z) canbe computed in half an hour, which should be fastenough for most applications. SIMD-speedup is smallerthan in the base query case because following jour-

ney pointers is sequential. Further interleaving pointersfrom different queries destroys cache locality, which ex-plains the slight slowdown for Ta(z). We use Tt(z) inall query experiments.

Table 3 shows the sizes of the connection setscorresponding to Table 4. A first observation is thatthe arrival time transit sets Ta(z) are smaller, thanthe transfer transit sets Tt(z). This is a direct resultof the effect illustrated in Figure 4. As expected thenumber of loop connections is significantly smaller than

the number of long distance connections. With theexception of the bottom level the average size of eachlong distance connection set increases with each level.The size of the bottom level suggests that a furthersubdivision might be useful to decrease query runningtimes. We decided against it after doing some quick

preliminary experiments. The higher levels dominatethe amount of scanned connections and therefore themaximum impact on the query running times is small.However, an additional level exponentially increasesthe number cells, which resulted in significantly longerpreprocessing times.

In Table 4 we observed that computing Tt(z) issignificantly more expensive than computing Ta(z).We therefore analyzed the running times per cell ingreater detail in Figure 6. Figure 6a shows thatthe running times needed to compute the Tt(z) isquadratic in the number of entry connections of z.This was to be expected, given that there are about

as many exit connections as entry connections and weconsider all pairs of exit and entry connections. A moredetailed investigation reveals that computing Tt(z) forthe metropolitan areas on the lowest levels are by farthe most expensive cells. Figure 6b depicts similarinformation for Ta(z). A first observation is that thesquare of the interior border stops only is a lower boundson the running time. The interior of the cells has alsoa significant influence on performance. For both transit

135 Copyright 2014.



icenseorcopyrig



12/13

4 5 6 7 8 9 10 11 12 13 14 15 16 17

0.5

1.

0

2.

0

5.0

10.0

20.0

50.

0

geo rank

runningtime[ms]

Figure 7: Geo-rank showing the running times of thetailored EA query

range

accel.

merge scan processed[ms] [ms] conn /106

4 173 46.2 12 159 1.2 6 72 0.6

Table 5: Running times for the accelerated algorithmsplit up into the merge and scan phases and the numberof processed connections.

set types the same Berlin cell needs the most time.

6.5 Earliest Arrival Time and Local Queries.We examine in Figure 7 the speedup of local queries.

We use a geo-rank instead of the common Dijkstra-rankused for road networks. With the later it is unclear whatsource time to use. Further, especially in rural areas,travel times between neighboring villages can be huge.A Dijkstra-rank [19] does not recognize these queriesas being local. A geo-rank picks a random source stopand orders all other stops by geographical distance. Itruns queries towards the 2r-th stop. The geo-rank ofthe query is r . Local queries are on average by a factorof 6 faster than long distance connections. The figurealso shows that the running times have a lot of variance.The largest outliers are queries where no journey exists.

With random source and target stops our query averagesat 8.66ms, which is about the running time of query withmaximum geo-rank. This is the case because pickingstops uniformly at random nearly never picks sourceand target stops that are close.

6.6 Accelerated Profile Queries. We evaluate inTable 5 the speedup of our technique. We assumethat a earliest arrival time query ( 8.66ms) was runto compute a minimum travel time while the user

selects the time interval. As = + is easy to test,we assume that a journey exists. Journey pointers werecomputed. accel indicates whether transit sets wereused. range indicates whether a source and targettime restricted the scan. The source time s is chosenat random and the target time t is set to s + 2.

Using transit connections achieves a speedup of 24. Thisis less than the ratio of processed connections becausethe relevant connection data is no longer adjacent inmemory. Restricting the time interval yields anotherfactor 2 totaling in a speedup of 49 over a CSAprofile baseline. Interestingly the number of processedconnections is still large, which explains why the scanphase dominates.

6.7 Comparison with Transfer Pattern [1]. Faircomparisons are hard because the problem formulationsand instances differ. Further their algorithm is heuristic.

However, no detailed error study was published makingthe gain of optimality hard to quantify. The TE-node ratio between our instance and their largest NorthAmerica instance is 0.72. The instances are roughlycomparable in size. Their processor is probably a bitslower than ours but they publish no details. The fastest(non-adjusted) reported running time for a one-to-oneearliest arrival variant is 7ms compared to our 9ms.Because of the various differences in setup the numberscan not directly be compared. We conclude that theorder of magnitude is the same. However, we haveprovable correctness. Further there is a huge differencein preprocessing time. We need 8 hours single core.

They report 2632h + 571h 4 months single core.

6.8 Comparison with RAPTOR [7]. In [9] wecompared RAPTOR with the non-accelerated CSAand concluded that it is slower than our profile CSAbaseline. Further the London instance used in [9, 7]has significantly more trips per route. A higher ratiobenefits RAPTOR. We expect the running time gap tobe larger. They compute full Pareto sets optimally.

7 Conclusion.

We showed that profile queries can be solved optimallyon country-sized timetable networks within 78ms. Our

algorithm optimizes realistic transfers and has reason-able preprocessing times. We equate Transfer Pattern,the fastest competitor, in terms of query times withoutdropping optimality. But we are significantly better interms of preprocessing time.

Directions for future research include: (1) Eval-uating the impact of other graph partitioner thanMETIS [17], such as PUNCH [6] or KaHip [20]; (2) Bet-ter algorithms to compute transfer transit sets in dense

136 Copyright 2014.



icenseorcopyrig



13/13

metropolitan areas; (3) Solving more complex queriessuch as MEAT [9] or complex Pareto queries.

References

[1] Hannah Bast, Erik Carlsson, Arno Eigenwillig, Robert

Geisberger, Chris Harrelson, Veselin Raychev, andFabien Viger. Fast Routing in Very Large PublicTransportation Networks using Transfer Patterns. InProceedings of the 18th Annual European Symposiumon Algorithms (ESA10), volume 6346 ofLecture Notesin Computer Science, pages 290301. Springer, 2010.

[2] Hannah Bast, Jonas Sternisko, and Sabine Storandt.Delay-Robustness of Transfer Patterns in Public Trans-portation Route Planning. In Proceedings of the13th Workshop on Algorithmic Approaches for Trans-portation Modeling, Optimization, and Systems (AT-MOS13), OpenAccess Series in Informatics (OASIcs),pages 4254, September 2013.

[3] Annabell Berger, Daniel Delling, Andreas Gebhardt,

and Matthias MullerHannemann. Accelerating Time-Dependent Multi-Criteria Timetable Information isHarder Than Expected. In Proceedings of the9th Workshop on Algorithmic Approaches for Trans-portation Modeling, Optimization, and Systems (AT-MOS09), OpenAccess Series in Informatics (OASIcs),2009.

[4] Annabell Berger, Martin Grimmer, and MatthiasMullerHannemann. Fully Dynamic Speed-Up Tech-niques for Multi-criteria Shortest Path Searches inTime-Dependent Networks. In Proceedings of the 9thInternational Symposium on Experimental Algorithms(SEA10), volume 6049 ofLecture Notes in ComputerScience, pages 3546. Springer, May 2010.

[5] Daniel Delling, Andrew V. Goldberg, Thomas Pajor,and Renato F. Werneck. Customizable Route Plan-ning. In Proceedings of the 10th International Sym-posium on Experimental Algorithms (SEA11), volume6630 ofLecture Notes in Computer Science, pages 376387. Springer, 2011.

[6] Daniel Delling, Andrew V. Goldberg, Ilya Razen-shteyn, and Renato F. Werneck. Graph Partitioningwith Natural Cuts. In25th International Parallel andDistributed Processing Symposium (IPDPS11), pages11351146. IEEE Computer Society, 2011.

[7] Daniel Delling, Thomas Pajor, and Renato F. Werneck.Round-Based Public Transit Routing. In Proceedingsof the 14th Meeting on Algorithm Engineering andExperiments (ALENEX12), pages 130140. SIAM,2012.

[8] Daniel Delling and Renato F. Werneck. Faster Cus-tomization of Road Networks. In Proceedings of the12th International Symposium on Experimental Algo-rithms (SEA13), volume 7933 of Lecture Notes inComputer Science, pages 3042. Springer, 2013.

[9] Julian Dibbelt, Thomas Pajor, Ben Strasser, andDorothea Wagner. Intriguingly Simple and Fast Tran-sit Routing. In Proceedings of the 12th International

Symposium on Experimental Algorithms (SEA13), vol-ume 7933 ofLecture Notes in Computer Science, pages4354. Springer, 2013.

[10] Edsger W. Dijkstra. A Note on Two Problems inConnexion with Graphs. Numerische Mathematik,1:269271, 1959.

[11] Yann Disser, Matthias MullerHannemann, and Math-ias Schnee. Multi-Criteria Shortest Paths in Time-Dependent Train Networks. In Proceedings of the 7thWorkshop on Experimental Algorithms (WEA08), vol-ume 5038 ofLecture Notes in Computer Science, pages347361. Springer, June 2008.

[12] Robert Geisberger. Contraction of Timetable Net-works with Realistic Transfers. In Proceedings of the9th International Symposium on Experimental Algo-rithms (SEA10), volume 6049 of Lecture Notes inComputer Science, pages 7182. Springer, May 2010.

[13] VBB Verkehrsverbund Berlin-BrandenburgGmbH. http://daten.berlin.de/datensaetze/vbb-gtfs-daten-jun-dez-2013 , 2013.

[14] GTFS. https://developers.google.com/transit/gtfs/reference, 2013.

[15] HAFAS. http://www.hacon.de/hafas, 2013.[16] Martin Holzer, Frank Schulz, and Dorothea Wagner.

Engineering Multilevel Overlay Graphs for Shortest-Path Queries. ACM Journal of Experimental Algorith-mics, 13(2.5):126, December 2008.

[17] Dominique LaSalle and George Karypis. Multi-Threaded Graph Partitioning. In 27th Interna-tional Parallel and Distributed Processing Symposium(IPDPS13). IEEE Computer Society, 2013.

[18] Evangelia Pyrga, Frank Schulz, Dorothea Wagner, andChristos Zaroliagis. Efficient Models for TimetableInformation in Public Transportation Systems. ACM

Journal of Experimental Algorithmics, 12(2.4):139,2008.

[19] Peter Sanders and Dominik Schultes. Highway Hier-archies Hasten Exact Shortest Path Queries. In Pro-ceedings of the 13th Annual European Symposium onAlgorithms (ESA05), volume 3669 ofLecture Notes inComputer Science, pages 568579. Springer, 2005.

[20] Peter Sanders and Christian Schulz. Think Locally,Act Globally: Highly Balanced Graph Partitioning.In Proceedings of the 12th International Symposiumon Experimental Algorithms (SEA13), volume 7933ofLecture Notes in Computer Science, pages 164175.Springer, 2013.

[21] Frank Schulz, Dorothea Wagner, and Karsten Weihe.

Dijkstras Algorithm On-Line: An Empirical CaseStudy from Public Railroad Transport. ACM Journalof Experimental Algorithmics, 5(12):123, 2000.

[22] Frank Schulz, Dorothea Wagner, and Christos Zaro-liagis. Using Multi-Level Graphs for Timetable Infor-mation in Railway Systems. InProceedings of the 4thWorkshop on Algorithm Engineering and Experiments(ALENEX02), volume 2409 ofLecture Notes in Com-puter Science, pages 4359. Springer, 2002.

137 Copyright 2014.



icenseorcopyrig


accelerated csa

Documents

earliest arrival journey

source time

theearliest arrival

minimum arrival time

earliest arrival journeys

earliest arrival problem

time interval

departure andor arrival