$ \def\opt{ {\mathrm{opt}} } $

- HW 05 Due this Friday
- Midterm 2 Wednesday 11/16
- in class
- focus on material since last midterm up to this Friday
- algorithmic paradigms:
- divide and conquer
- greedy
- dynamic programming
- network flow

- mixture of computational and algorithm design questions
- details forthcoming

**Adjacency List**

- $v$’s neighbors are
*outgoing*neighbors

**Input:**

- (Directed) graph $G = (V, E)$, edge weights $w$
- Starting vertex $u$

**Output:**

- $d(v) = $ distance from $u$ to $v$ for every vertex $v$
- distance is length of shortest
*directed*path from $u$ to $v$ - length is sum of edge weights of path

- distance is length of shortest

- Breadth-first Search (BFS)
- solves SSSP when all edge weights are $1$

- Dijkstra’s Algorithm
- solves SSSP when all edge weights are $\geq 0$

**Question.** What if edge weights can be negative?

**Question 1.** Why can Dijkstra fail when edge weights can be negative?

**Question 2.** Why might shortest paths not exist when edge weights can be negative?

**Assume.** $G$ does not contain any *negative weight cycles.*

**Claim.** $G$ a graph with $n$ vertices, $u, v$ vertices in $G$. If $G$ does not contain negative weight cycles, then the shortest (weighted) path from $u$ to $v$ contains at most $n-1$ edges.

*Why?*

Suppose shortest path from $u$ to $x$ contains $j$ hops.

- $v$ is $x$’s “parent” along path
- $d(u, x) = d(u, v) + w(v, x)$
- shortest path from $u$ to $v$ has $j-1$ hops

**Idea.** For each vertex $v$ and each $j = 1, 2, \ldots, n-1$ compute $d_j(u, v) = $ length of shortest path from $u$ to $v$ with at most $j$ hops.

- Note $d(u, v) = d_{n-1}(u, v)$.

**Question 1.** How to initialize $d_0(u, v)$?

**Question 2.** Given $d_j(u, v)$ for all v, how to find $d_{j+1}(u, v)$?

```
Bellman-Ford(V, E, w, u)
d <- 2d array [0..n-1, 1..n]
for v = 1 to n do d[0, v] <- infinity
d[0, u] <- 0
for j = 1 to n-1 do
for each vertex v in V set d[j, v] <- d[j-1,v]
for each vertex v in V
for each neighbor x of v
d[j, x] <- Min(d[j, x], d[j-1, v] + w[v, x])
return d[n-1]
```

Running time?

**Claim.** For all $j = 0, 1, \ldots, n-1$ and for all vertices $v$, $d[j, v]$ stores length of shortest path from $u$ to $v$ with $j$ or fewer hops. I.e., $d[j, v] = d_j(v)$

**Proof.** Induction on $j$.

*Base case*, $j = 0$.

- suppose $d[j-1, v] = d_{j-1}(v)$ for all $v$
- consider shortest path $P$ of $j$ hops from $u$ to $v$
- let $x$ be penultimate vertex in $P$
- then $d_j(v) = d_{j-1}(x) + w(x, v)$
- by inductive hypothesis, $d_{j-1}(x) = d[j-1,x]$
- therefore in iteration $j$, get $d[j, v] \leq d[j-1,x] + w(x, v) = d_{j-1}(x) + w(x, v) = d_j(v)$
- also have $d[j, v] \geq d_j(v)$ (why?)
- so $d[j, v] = d_j(v)$

If $G$ has no negative weight cycles, then Bellman-Ford solves single source shortest paths in $O(m n)$ time.

Running times:

- Dijkstra: $O(m \log n)$
- Bellman-Ford: $O(m n)$

Why pick Bellman-Ford over Dijkstra?

- Why might Bellman-Ford be preferable even if graph has no negative weight edges?

```
Bellman-Ford(V, E, w, u)
d <- 2d array [0..n-1, 1..n]
for v = 1 to n do d[0, v] <- infinity
d[0, u] <- 0
for j = 1 to n-1 do
for each vertex v in V set d[j, v] <- d[j-1,v]
for each vertex v in V
for each neighbor x of v
d[j, x] <- Min(d[j, x], d[j-1, v] + w[v, x])
return d[n-1]
```

Modeling the network:

- nodes represent railway junctions
- edges represent rail lines
- weights represent capacities of lines
- capacity indicates tonnage that can cross line per unit time
- proportional to cost of disrupting movement along line

**Question 1.** How much material can the USSR transport to Western Europe per unit time?

**Question 2.** What is the cheapest way to disrupt flow of material?

A new interpretation of directed graphs:

- network of (directional) pipes
- weights are
*capacities*- how much fluid can flow through piper per time

- designated
*source node*$s$- all edges directed away from $s$

- designated
*sink*or*destination node*$t$- all edges directed towards $t$

**Question.** How much fluid be routed from $s$ to $t$ per unit time?