Transcript [ppt]

Nondecreasing Paths in
Weighted Graphs
Or: How to optimally read a
train schedule
Virginia Vassilevska
SODA 2008
Carnegie Mellon University
Traveling?
Tomorrow after 8am
As early as possible!
Routes with Multiple Stops
Los Angeles
Chicago
Las Vegas
BWI
4pm – 8:30pm
1:30pm – 6:00pm
Scheduling



You might need to make several
connections.
There are multiple possible stopover
points, and multiple possible
schedules.
How do you choose which segments
to combine?
Graph-Theoretic Abstraction
…
Los Angeles
Chicago
12:35am
9:30pm
8:30pm
Las Vegas
BWI
Nondecreasing
Graph:
(Origin,
(flight,
arrival
departure
A
vertex
Destination)
path
time
flight)
for
time
with
weight;
each
edges;
weight;
minimum
city/airport;
flight;
edges; last edge?
Versions of the problem
Single source – single destination
Single source (every destination) – SSNP
All pairs – APNP
S
T
History

G. Minty 1958: graph abstraction and
first algorithm for SSNP – polytime

E. F. Moore 1959: a new algorithm for
shortest paths, and SSNP – cubic time
History


Dijkstra 1959
Fredman and Tarjan 1987 – Fibonacci
Heaps implementation of Dijkstra’s; until
now asymptotically fastest algorithm for
SSNP. O(m+n log n) m – number of edges
n – number of vertices

Nowadays – experimental research on
improving Dijkstra’s algorithm
implementation
Our contributions

Linear time algorithm for SSNP in the
word-RAM model, O(m log log n) in
comparison based model

First truly subcubic algorithm for APNP
Talk Outline

SSNP:




Two known algorithms
A new O(m log log n) algorithm
Linear time algorithm (on a RAM)
APNP:

Brief outline of our approach
SSNP - Dijkstra’s algorithm




Set U = V and T = { }. Iterate:
At each iteration, pick u from U
minimizing d[u].
T
d[u]
T = T U {u}, U = U \ {u}.
For all edges (u, v),
 If w(u,v) ≥ d[u],
set d[v] = min (d[v], w(u,v))
w(u,v)
min d[u]
S u
v
U
Running time of Dijkstra

Using Fibonacci Heaps, Dijkstra can be
implemented in O(m+n log n) time.

Optimal for Dijkstra’s algorithm – nodes
visited in sorted order of their distance.

The bottleneck are the n extract-mins.
More on Dijkstra’s

Suppose we only maintain F vertices in the
Fibonacci heaps. The rest we maintain in
some other way.
N(F)
F

Then the runtime due to the Fibonacci heaps
would be O(F log F + N(F)) where N(F) is the
number of edges pointing to the F vertices.

For F = m/log n, this is O(m)!
ALG2: Depth First Search - Like
DFS(v, d[v]):
For all (v, u) with w(v, u) ≥ d[v]:
Remove (v, u) from graph.
d[u] = min (d[u], w(v,u))
DFS(u, d[u])
d[v]=2
v
1
3
3
u
d[u]=3
d[u]=4
d[S] = - ∞, start with DFS(S, d[S]).
Naive Runtime of DFS

The number of times we call
DFS(v, d[v]) for any particular v is at
most indegree(v).

Every such time we might have to
check all outedges (w(v,u)≥?d[v]).

Worst case running time: O(mn).
More on DFS

Suppose for a node v and weight d[v] we can
access each edge (v, u) with w(v, u)≥ d[v]
in O(t) time.

As each edge is accessed at most once, the
runtime is O(m t).

For each node, store its neighbors in a
binary search tree w.r.t. outgoing weights.
Combine Dijkstra with DFS

Recall:
If F nodes used in Fibonacci heaps, then
the Dijkstra runtime due to the heaps is
O(F log F + N(F)) ◄ O(m+n) for F = m/log n

{v | degout(v) ≥ log n}

If DFS with binary search trees is run on a
set of nodes T, the runtime is
O(Σv  T { degin(v) log (degout(v)) })
O(m log log n) for T = {v | degout(v)<log n}
Idea Summary

Run DFS on vertices of low degree < log n:
O(m log log n) time.

Put the O(m/log n) high degree nodes in
Fibonacci heaps and run Dijkstra on them.
Time due to Fibonacci heaps: O(m).

We get O(m log log n). Better than
O(m+n log n) for m = o(n log n/log log n).
But we wanted linear time…
Fredman and Willard atomic heaps:
 After O(n) preprocessing, a collection
of O(n) sets of O(log n) size can be
maintained so that the following are in
constant time:

Insert

Delete

Given w, return an element of weight ≥ w.
Linear runtime



Replace binary trees by atomic heaps.
Time due to Dijkstra with Fibonacci Heaps
on O(m/log n) elements is still O(m).
Time due to DFS with atomic heaps:



inserting outedges into atomic heaps takes
constant time per edge;
given d[v], accessing an edge with w(v,u) ≥ d[v]
takes constant time.
O(m+n) time overall!
Linear Time Algorithm

Stage 1: Initialize

Find all vertices v of degree ≥ log n and
insert into Fibonacci Heaps with d[v] = ∞;
Insert S with d[S] = - ∞

For all vertices u of degree < log n, add
outedges into atomic heap sorted by
weights.
This stage takes O(m+n) time.

Linear Time Algorithm Cont.

Stage 2: Repeat:
1.
2.
3.
Extract vertex v from Fibonacci
heaps with minimum d[v]
For all neighbors u of v, if
w(u,v) ≥ d[v]:
1.
Update d[u] if w(v,u) < d[u]
2.
Run DFS(u, d[u]) on the graph
spanned by low degree vertices
until no more can be reached
If Fib.heaps nonempty, go to 1.
Fibonacci Heaps
2
3
4
1
5
4
4
All Pairs Nondecreasing Paths (APNP)

(min, ≤ )-matrix product C = A • B:
C[i, j] = mink { B[k, j] | A[i, k] ≤ B[k, j] }
4
7
i
0
A

9
4
5
j
B
Say W is the adjacency matrix:
W[i, i] = -  and
W[i ,j] = w(i, j) for i ≠ j.
(( W • W) • W) … • W) - min nondecreasing
k times
paths of length ≤ k
All Pairs Nondecreasing Paths cont.




We give an algorithm for (min, ≤ )product of n x n matrices running in
O(n2.8) time.
Hence, APNP for paths of length at
most k can be done in O(k n2.8) time.
We show how to find APNP for paths
of length at least k in Õ(n3 / k) time.
→ O(n2.9) Algorithm for APNP.
Summary

We gave the first linear time algorithm
for the single source nondecreasing
paths problem, and the first subcubic
algorithm for APNP.

Now you can read a train schedule
optimally!
Directions for future work

Single source shortest paths?
Our degree approach fails – finding a linear time
algorithm is hardest on low degree graphs

w1
d’
d
wd
w1
w’1
0
wd

0 d’
d 0
w’d’
w’1
0
w’d’
Shortest Nondecreasing Paths? o(m log n)?
The End.
THANK YOU!
Example
U - Fibonacci Heap:
S: -infinity
P: infinity
Q: infinity
2
S
c
1
5
a
3
3
4
3
b
2
Q
3
2 P
2
5
d
3
Other Distances:
a: infinity
b: infinity
c: infinity
d: infinity
Example
U - Fibonacci Heap:
P: infinity
Q: infinity
2
S
c
1
5
a
3
3
4
3
b
2
Q
3
2 P
2
5
d
Other Distances:
a: 5
b: 1
c: 3
d: infinity
S: -infinity
3
S – extract min from U
Example
U - Fibonacci Heap:
P: 2
Q: infinity
2
S
c
1
5
a
3
3
4
3
b
2
Q
3
2 P
2
5
d
Other Distances:
a: 5
b: 1
c: 3
d: infinity
S: -infinity
3
DFS(b, 1)
Example
U - Fibonacci Heap:
P: 2
Q: infinity
2
S
c
1
5
a
3
3
4
3
b
2
Q
3
2 P
2
5
d
Other Distances:
a: 5
b: 1
c: 3
d: infinity
S: -infinity
3
DFS(a, 3)
DFS(c,
5)
Example
U - Fibonacci Heap:
Q: 3
2
S
c
1
5
a
3
3
4
3
b
2
Q
3
2 P
2
5
d
Other Distances:
a: 3
b: 1
c: 3
d: 2
S: -infinity
P: 2
3
P – extract min from U
Example
U - Fibonacci Heap:
Q: 3
2
S
c
1
5
a
3
b
3
4
3
2
Q
3
2 P
2
5
d
Other Distances:
a: 2
b: 1
c: 3
d: 2
S: -infinity
P: 2
3
DFS(d, 2)
Example
U - Fibonacci Heap:
Q: 3
2
S
c
1
5
a
3
b
3
4
3
2
Q
3
2 P
2
5
d
Other Distances:
a: 2
b: 1
c: 2
d: 2
S: -infinity
P: 2
3
DFS(a, 2)
Example
U - Fibonacci Heap:
Q: 3
2
S
c
1
5
a
3
b
3
4
3
2
Q
3
2 P
2
5
d
Other Distances:
a: 2
b: 1
c: 2
d: 2
S: -infinity
P: 2
3
DFS(c, 2)
DFS(a,
3)
Example
U - Fibonacci Heap:
2
S
c
1
5
a
3
3
b
3
4
2
Q
3
2 P
2
5
d
Other Distances:
a: 2
b: 1
c: 2
d: 2
S: -infinity
P: 2
Q: 3
3
Q – extract min from U
DFS Algorithm
Dijkstra Algorithm
A linear time hybrid
New York
London
Atlanta
Paris
Newark
Frankfurt
7pm – 1:20pm
5:30pm – 10:40am

∞∞
Graph-Theoretic Abstraction




City vertices and Train vertices
Edges between origin and train and
train and destination
Weight on origin -> train edge is
departure time
Weight on train -> destination edge is
arrival time
Fibonacci Heaps

Inserting n vertices initially takes O(n) time.

Updating the distance d[v] of a vertex v
takes constant time.

Returning the vertex u minimizing d[u] takes
logarithmic time.