Slides networks-2017-2

Arthur Charpentier, Master Statistique & Économétrie - Université Rennes 1 - 2017
Arthur Charpentier
arthur.charpentier@univ-rennes1.fr
https://freakonometrics.github.io/
Université Rennes 1, 2017
Graphs, Networks & Flows
@freakonometrics freakonometrics freakonometrics.hypotheses.org 1

Network Flows & Matching
Ahuja, Magnanti & Orlin (1993) Network Flows: Theory, Algorithms, and
Applications. Prentice-Hall
Bazaraa, Jarvis & Sherali (2010) Linear Programming and Network Flows Wiley.
Ford & Fulkerson (1962) Flows in Networks. Princeton University Press.
Goldberg, Tardos & Tarjan Network Flow Algorithms

Traveling Salesman Problem
Consider 5 cities,
1 > v=c("Rennes","Paris","Lyon","Marseille","
Toulouse")
2 > x=c( -1.6742900 ,2.348800 ,4.846710 ,
5.38107 ,1.443670)
3 > y=c(48.1119800 ,48.853410 ,45.748460 ,
43.29695 ,43.6042600)
4 > library(maps)
5 > france <-map(database="france",col="grey")
6 > points(x,y,pch =19, cex=2,col="red")
7 > text(x,y,v,pos=3,col="red")
It can also be seen as a complete weighted graph.

1 > df=data.frame(name=v,lat=y,lon=x,index
=1:5)
2 > D=round( GeoDistanceInMetresMatrix (df)/
1000)
3 > library(igraph)
4 > i=c(rep (1 ,4),rep (2 ,3),rep (3 ,2) ,4)
5 > j=c(2:5 ,3:5 ,4:5 ,5)
6 > df=data.frame(a = i, b=j, w=diag(D[i,j]))
7 > g=graph.data.frame(df , directed=FALSE)
8 > V(g)$label=v
9 > plot(g, edge.label=E(g)$w)
What is the path with minimal cost (length) that goes through all cities (and
returns back home) ?

Can be formulated as an integer linear programming problem. Set xij = Ai,j (x
used since it is the unknown component), ui be some dummy variable, and cij
denote the distance from city i to city j. Consider
min
n
i=1
n
j=i,j=1
cijxij
0 ≤ xij ≤ 1 i, j = 1, . . . , n;
ui ∈ Z i = 1, . . . , n;
n
i=1,i=j
xij = 1 j = 1, . . . , n;
n
j=1,j=i
xij = 1 i = 1, . . . , n;
ui − uj + nxij ≤ n − 1 2 ≤ i = j ≤ n.

Let D = [Di,j] denote the distance matrix, with Di,i = ∞, ci,j otherwise
Rennes Paris Lyon Marseille Toulouse
Rennes ∞ 309 562 766 556
Paris 309 ∞ 393 661 588
Lyon 562 393 ∞ 276 360
Marseille 766 661 276 ∞ 320
Toulouse 556 588 360 320 ∞
5 cities, 5! = 24 possibilities (with assymmetric costs, otherwise 12).

One can use brute force search
1 > library(combinat)
2 > M=matrix(unlist(permn (1:5)),nrow =5)
3 > sM=M[,M[1 ,]==1]
4 > sM=rbind(sM ,1)
5 > traj=function(vi){
6 + s=0
7 + for(i in 1:( length(vi) -1)) s=s+D[vi[i],
vi[i+1]]
8 + return(s) }
9 > d=unlist(lapply (1: ncol(sM),function(x)
traj(sM[,x])))
10 > sM=rbind(sM ,d)
11 > sM[,which.min(d)]
12 d
13 1 2 3 4 5 1 1854

12 cities, 12! = 39, 916, 800 possibilities (with assymmetric costs, otherwise 20
millions).
1 > v2=c(v,"Strasbourg","Angers","Bordeaux","
Dijon","Nancy","Montpellier ", "Nevers")
2 > x2=c(x
,7.75 , -0.55 , -0.566667 ,5.016667 ,6.2 ,3.883333 ,3.166667)
3 > y2=c(y
,48.583333 ,47.466667 ,44.833333 ,47.316667 ,48.683333 ,43.6 ,46.983333
)

Little Algorithm
Branch and bound, Little algorithm, from Little, Murty, Sweeney & Karel (1963)
An algorithm for the traveling salesman problem
Step 1 ﬁnd a lower bound for the total cost
Derive reduced matrix D by removing to each raw the smallest element
Rennes ∞ 0 253 457 247 (-309)
Paris 0 ∞ 84 352 279 (-309)
Lyon 286 117 ∞ 0 84 (-276)
Marseille 490 385 0 ∞ 44 (-276)
Toulouse 236 268 40 0 ∞ (-320)

Little Algorithm
and by removing to each column the smallest element
Rennes ∞ 0 253 457 203 (-309)
Paris 0 ∞ 84 352 235 (-309)
Lyon 286 117 ∞ 0 40 (-276)
Marseille 490 385 0 ∞ 0 (-276)
Toulouse 236 268 40 0 ∞ (-320)
(-44)
Again D can be non-symmetric (and it will be afterwards).
Starting value for the cost: 309+309+276+276+320+44=1534

Little Algorithm
Step 2: compute regrets (min on rows and columns)
Rennes ∞ 0 253 457 203 (203)
Paris 0 ∞ 84 352 235
Lyon 286 117 ∞ 0 40
Marseille 490 385 0 ∞ 0
Toulouse 236 268 40 0 ∞
(117) (320)

Little Algorithm
Rennes ∞ 0 (320) 253 457 203
Paris 0 ∞ 84 352 235 (84)
Lyon 286 117 ∞ 0 40
Marseille 490 385 0 ∞ 0
Toulouse 236 268 40 0 ∞
(236) (320)

Little Algorithm
Rennes ∞ 0 (320) 253 457 203
Paris 0 (320) ∞ 84 352 235
Lyon 286 117 ∞ 0 40 (40)
Marseille 490 385 0 ∞ 0
Toulouse 236 268 40 0 ∞
(0) (40)

Little Algorithm
Rennes ∞ 0 (320) 253 457 203
Paris 0 (320) ∞ 84 352 235
Lyon 286 117 ∞ 0 (40) 40
Marseille 490 385 0 (40) ∞ 0 (40)
Toulouse 236 268 40 0 (40) ∞
Select the maximal regret path (arbitrarily if not unique) : Rennes → Paris (RP).
Consider now two alternatives:
• either we keep (RP)
• either we remove (RP)

Little Algorithm
If we exclude (RP), the cost is known : 1534+320=1854.
If we include, consider the simpliﬁed matrix
Rennes Lyon Marseille Toulouse
Paris ∞ 84 352 235
Lyon 286 ∞ 0 40
Marseille 490 0 ∞ 0
Toulouse 236 40 0 ∞
Here (PR) is ∞ otherwise, it will be a round trip.

Little Algorithm
Then derive the reduced matrix
Paris ∞ 0 268 151 (-84)
Lyon 50 ∞ 0 40 (0)
Marseille 254 0 ∞ 0 (0)
Toulouse 0 40 0 ∞ (0)
(-236)
Total (reduction) cost is 84+236=320.

Little Algorithm
And again, compute regrets
Paris ∞ 0 (151) 268 151
Lyon 50 ∞ 0 (40) 40
Marseille 254 0 (0) ∞ 0 (40)
Toulouse 0 (50) 40 0 (0) ∞
The maximal regret path is Paris → Lyon (PL). Consider now two alternatives:
• either we keep (PL)
• either we remove (PL) : cost will be 1534+320+151=2005
If we include, consider the simpliﬁed matrix (with possibly ∞ for (LP))

Little Algorithm
Rennes Marseille Toulouse
Lyon 50 0 40
Marseille 254 ∞ 0
Toulouse 0 0 ∞
Note that this matrix cannot be simpliﬁed, here.
Lyon 50 0 40 (0)
Marseille 254 ∞ 0 (0)
Toulouse 0 0 ∞ (0)
(0) (0) (0)
So the total cost if we keep (RL) is 1534+320=1854

Little Algorithm
Then compute regrets
Lyon 50 0 (40) 40
Marseille 254 ∞ 0 (294)
Toulouse 0 (50) 0 (0) ∞
The maximal regret path is Marseille → Toulouse (MT)
• either we keep (MT)
• either we remove (MT) : cost will be 1854+294
If we include, consider the simpliﬁed matrix (with ∞ for (TM))

Rennes Marseille
Lyon 50 0
Toulouse 0 ∞
Here again no simpliﬁcation. The regret matrix is
Rennes Marseille
Lyon 50 0 (50)
Toulouse 0 (50) ∞
The maximal regret path is Lyon → Marseille (LM)
• either we keep (MT): cost will be 1854+0
• either we remove (MT) : cost will be 1854+50

Little Algorithm
Here we have constructed a search tree.
click to visualize the construction click to visualize the construction
Remark This is an exact algorithm

Traveling Salesman
Exact algorithms are usually extremely slow. For Little Algorithm, the maximal
number of nodes, with n cities, is of order Nn with Nn = (n − 1)[1 + Nn−1] (with
is of order n!).
1 > library(TSP)
2 > df2=data.frame(name=v2 ,lat=y2 ,lon=x2 ,index
=1:12)
3 > D2=round( GeoDistanceInMetresMatrix (df2)/
1000)
4 > listeFR=TSP(D2 ,v2)
5 > tour=solve_TSP(listeFR , method = "nn")
6 > COORD=df2[as.numeric(tour) ,]
7 > COORD=rbind(COORD ,COORD [1 ,])
9 > lines(COORD$lon ,COORD$lat ,lwd=3,col="blue"
)

Traveling Salesman
5 > lines(COORD$lon ,COORD$lat ,lwd=3,col="blue")
6 >
11 > lines(COORD$lon ,COORD$lat ,lwd=3,col="blue")
It is not stable... local optimization?

Traveling Salesman
Historically, introduced by William Rowan Hamilton
in the context of dodecahedrons.
A Hamiltonian path is a path in agraph that visits each
vertice exactly once
Done with n = 20 cities (regular aglebraic structure)
Dantzig, Fulkerson & Johnson (1954) Solution of a large-scale traveling-salesman
problem with n = 49 cities (US State capitals)
In 2000, it was perfomed on n = 15, 000 cities, nowadays close to 2 million.
See also Applegate et al. (2006) The traveling salesman problem: a computational
study.

Stochastic Algorithm
One can use a Greedy Algorithm
Heuristically, makes locally optimal choices at each stage
with the hope of ﬁnding a global optimum.
nearest neighbour, “at each stage visit an unvisited city
nearest to the current city”
(1) start on an arbitrary vertex as current vertice.
(2) ﬁnd out the shortest edge connecting current vertice
and an unvisited vertice v.
(3) set current vertice to v.
(4) mark v as visited.
(5) if all the vertices in domain are visited, then terminate.
(6) Go to step 2.
click to visualize the construction

Stochastic Algorithm
E.g. descent algorithm, where we start from an initial guess, then consider at
each step one vertice s, and in the neighborhood of s, denoted V (s) search
f(s ) = min
s ∈V (s)
{f(s )}
If f(s ) < f(s) then s = s .
See Lin (1965) with 2 opt or 3 opt, see also Lin & Kernighan
(1973) An Eﬀective Heuristic Algorithm for the Traveling-
Salesman Problem
The pairwise exchange or 2-opt technique involves itera-
tively removing two edges and replacing these with two dif-
ferent edges that reconnect the fragments created by edge
removal into a new and shorter tour.
click to visualize the construction

Spanning Algorithm
Kruskal’s algorithm is a minimum-spanning-tree algorithm, see Kruskal (1956)
On the shortest spanning subtree of a graph and the traveling salesman problem

Spanning Algorithm
Select edge e = (u, v) ∈ E which minimizes ω ,
e = argmin
∈E
{ω }
Then remove e from the set of electible edges
E = E{e}
and mark that edge F = {e}

Spanning Algorithm
e = argmin
∈E
{ω }
E = E{e}
and mark that edge F = F ∪ {e}
If the minima is not unique, choose randomly

Spanning Algorithm
E = E{E1 ∪ E2} where we remove
• all edges E1 such that E ∪ E1 contains a cycle (here Rennes-Paris)
• all edges from a node that appears twice in E (here all edges connected to
Angers)

Spanning Algorithm
As long as there are no cycle, set e = argmin
∈E
{ω } and then remove e from the set
of electible edges E = E{e}, and mark those F = F ∪ {e}

Spanning Algorithm
Here again remove
Angers)

Spanning Algorithm
e = argmin
∈E
{ω }
E = E{e}
and mark it F = F ∪ {e}

Spanning Algorithm
Remove
Angers)

Spanning Algorithm
e = argmin
∈E
{ω }
E = E{e}
and mark it F = F ∪ {e}
Here e=Strasbourg-Paris
If the minima is not unique, choose randomly

Spanning Algorithm
Last but not least, remove
Angers)

Spanning Algorithm
The collection of edges that were marked in F is our best cycle.

Christoﬁdes Algorithm
Use a spanning algorithm (as in Kruskal algorithm) G = (V, E) but
allow for vertices to have more than 2 incident edges.
Let V1 denote the set of vertices with odd degree, and let G1 = (V1, E1)
denote the induced subgraph of G = (V, E).
Find a perfect coupling G1 of G1 (discussed in the next course).
Consider graph G with vertices V and edges E ∪ E1.
If there are still vertices v with degree exceeding 2, consider shortcuts
i.e. (u, v) and (v, w) becomes (u, w).

Genetic Algorithm
See Potvin (1996) Genetic algorithms for the traveling salesman problem
Mutation can be used to diversify solutions by alterating (randomly) an
individual (possibly bit string)
Cross-Over is obtained by mixing two individuals (single point or two points)

Traveling Salesman
Can be performed on a (much) larger scale
e.g. 48 State capitals in mainland U.S.
see Cook (2011) In Pursuit of the Traveling Salesman
for a survey.

Application of the Traveling Salesman Problem
See Fischetti & Pisinger (2016) Optimizing wind farm cable routing considering
power losses
See Fischetti & Monaci (2016) Proximity search heuristics for wind farm optimal
layout

Networks & Flows : Motivation
Harris & Ross (1955) Fundamentals of a Method for Evaluating Rail Net Capacities

The goal was to study the Soviet ability to transport things from the Asian side
to European side

Also to study minimum cut

Network Flow
A Flow Network with capacities is F = (G, c) where G = (V, E) is a network,
c : E → R is a capacity function, on each edge.
The absence of an edge can be seen equivalently as a 0 capacity: if (u, v) /∈ E, we
assume c(u, v) = 0.
Problem: it is not a cycle, water must come from somewhere (a source) and get
out somewhere else (a sink).
The source node is supposed to have ressources, and the ink node is here
insatiable.
For every vertice v ∈ V , there is a path from the source s to the sink t through v.

Network Flow
Transform the network by adding two vertices to V : a source s and a sink t.

Network Flow
Then add edges to E, e = (s, v) with s ∈ in(v)) and e = (v, t) for t ∈ out(v),

Network Flow
and set values c on those new edges.

Network Flow
A flow in G is a real-valued function f : V × V → R, that satisfies these three
properties:
• Capacity constraint:
For all u, v ∈ V , we require f(u, v) ≤ c(u, v)
Flow from one vertex to another must not exceed given capacity.
• Skew symmetry (convention):
For all u, v ∈ V , we require f(u, v) = −f(v, u).
Flow from vertex u to vertex v is negative of flow in reverse direction.
• Flow conservation:
For all u ∈ V {s, t}, we require
v∈V
f(u, v) = 0.

Network Flow
The value of flow f is defined as the total flow leaving the source (and thus
entering the sink):
|f| =
v∈V
f(s, v)
The total positive flow entering vertice v ∈ V is
u∈V,f(u,v)>0
f(u, v) and the total
positive flow leaving vertice u ∈ V is
v∈V,f(u,v)>0
f(u, v)
The total net flow at a vertice v ∈ V is the total positive flow leaving v minus the
total positive flow entering v
A flow f in flow network G is integer-valued if f(u, v) is an integer for all
u, v ∈ V .

Network Flow
Consider two vertices u, v ∈ V , and a ﬂow f(u, v) = 9 from u to v
One might think of having f(u, v) = 15 and f(v, u) = 6
but keep in mind the skew symmetry f(u, v) = −f(v, u)
Here the 6 from v to u are cancelled.
(cancellation will arise implicity in most algorithms).

Network Flow
For convenience, if V1, V2 ⊂ V , denote f(V1, V2) =
u∈V1,v∈V2
f(u, v)
Thus, ﬂow conservation can be written f(u, V ) = 0 for any u ∈ V {s, t}
Further f(V1, V1) = 0 (because of skew symmetry)
and f(V1, V2) = −f(V2, V1) = 0
Finally, consider V1, V2, V3 ⊂ V with V1 ∩ C2 = ∅, then
f(V1 ∪ V2, V3) = f(V1, V3) + f(V2, V3).

s − t Cuts
An s − t cut is a partitionning of V between two blocks Vs and Vt, sur that
Vt = V Vs, with s ∈ Vs and t ∈ Vt
If f is a flow in G = (V1 ∪ V2, E), then the net flow across the cut (Vs, Vt) is
defined to be f(Vs, Vt), and its capacity is capacity c(Vs, Vt).
Note that it can include negative flows.
A minimum cut is a cut with minimum capacity over all cuts.
Proposition Let f be a flow in a flow network G with source s and sink t, let
(Vs, Vt) be a cut of G. Then the flow across (Vs, Vt) is f(Vs, Vt) = |f|.
Proof f(Vs, Vt) = f(Vs, V ) − f(Vs, Vs) = f(Vs, V ) = f(s, V ) + f(Vs{s}, V ) =
f(s, V ) = |f|.

s − t Cuts
Proposition The value of a ﬂow f in a network G is (upper-)bounded by the
capacity of any cut (Vs, Vt) in G.
Proof |f| = f(Vs, Vt) =
u∈Vs v∈Vt
f(u, v) ≤
u∈Vs v∈Vt
c(u, v) = c(Vs, Vt)
The minimum cut problem is to ﬁnd an s − t cut with minimum capacity.
Example : on each edge e, write “f(e)/c(e)”

s − t Cuts
Flow Value Theorem : Let f be a flow, and (V1, V2) denote any s − t cut, then
the net flow accross the cut is equal to the flow value
e∈out of(V1)
f(e) −
e∈into(V1)
f(e) =
v∈V
f({s, v}) = |f|
As a consequence, |f| ≤
e∈out ofV1
f(e), i.e. the flow value is at most the capacity
of a cut.

s − t Cuts
A cut is a vertice partition V = Vs ∪ Vt with s ∈ Vs and t ∈ Vt. Its capacity is
cap(Vs, Vt) =
u∈Vs,v∈out(u)
c((u, v)) (below, Vs is denoted S).
Capacity = 10 + 5 + 15 = 30

s − t Cuts
Capacity = 30 + 8 + 15 + 9 = 62

s − t Cuts
Capacity = 10 + 5 + 15 = 30

Flows
Keep in mind that we represent f(e) and c(e) on the same edge.

Flows
Below another feasable ﬂow

Flows

Flows & Cuts

Electricity Flow, an Example
See electrical power distribution in Canada
Power is generated in Vancouver (the source s) and all remaining power is
transported to Winnipeg (the sink t).
Each high voltage cable has limited capacity (in MegaWatts).

There a two cables between Edmonton and Calgary, and we care about the net
ﬂow, Edmonton (v1) → Calgary (v2).

What could be the/a maximum flow f ?
The flow out of s is lower than the capacity out, i.e. |f | ≤ 13 + 16 = 29
The flow into t is lower than the capacity into, i.e. |f | ≤ 20 + 4 = 24
Is the maximum flow |f | = 24 ? One can start with the feasible flow, for instance
i.e. |f| = 19... can we go up to 24 ?

Deﬁne a so-called residual network and ﬁnd an augmenting path from s to t.
The residual capacity of this path is 4.

The new ﬂow is the following

The associated residual network is the following
There are no augmenting path...

Let us start again with the same network, with capacities

We can start with a path, from s to t
The maximal capactity of this ﬂow is 4

The ﬂow network f is here, and |f| = 4

Consider the residual network, and pick an augmenting path from s to t
The maximal capactity of this ﬂow is 7.

The ﬂow network f is here, and |f| = 4 + 7 = 11

The ﬂow network f is below, and |f| = 4 + 7 + 8 = 19

The ﬂow network f is below, and |f| = 4 + 7 + 8 + 4 = 23

Consider the residual network, and there is no augmenting path from s to t

Max-flow min-cut
Max-flow min-cut theorem: If f is a flow in a flow network G = (V, E) with
source s and sink t, then the following conditions are equivalent:
• f is a maximum flow in G
• residual network Gf contains no augmenting path
• there is a cut (Vs, Vt) such that c(Vs, Vt) = |f|
How to compute the maximum flow, in practice ?

Ford-Fulkerson
A first idea is the Ford-Fulkerson method, from Flows in Networks
• start with some feasible flow
• get the residual flow network (a graph that shows where extra capacity is
available)
• augment paths (where extra capacity is available)
• look also at cuts, that provide an upper bound for the maximum flow
The residual flow network is the network flow F = ((V, E), cf ) where
cf (e) = c(e) − f(e), ∀e ∈ E.

Ford-Fulkerson
Define the residual capacity between u and v, with respect to some flow f as
cf (u, v) =



c(u, v) − f(u, v) if (u, v) ∈ E
f(v, u) if (v, u) ∈ E
0 otherwise
because the flow either goes from u to v, or from v to u.
The residual network of f has the same vertices as G, but u and v are connected
(edge u → v) if cf (u, v) > 0, and the weight of that edge is cf (u, v).
We can actually restrict ourself to Ef where Ef = {e ∈ E, cf (e) > 0}.

Residual Capacity
The residual capacity cp(f) of an augmenting path p is the maximum additional
ﬂow we can allow along that path,
cp(f) = min{cf (e), e ∈ path p}.
The Ford-Fulkerson algorithm is the following. Consider a network G with nodes
s, t and capacity c.
• for each edge (u, v) ∈ E , set f(u, v) = f(v, u) = 0
• while there is a path p from s to t in the residual network Gf do
• set cf (p) = min{cf (u, v) for (u, v) ∈ p}
• for each edge (u, v) ∈ p do
• f(u, v) = f(u, v) + cf (p) while f(v, u) = −f(u, v)

Ford-Fulkerson
If chosen poorly, algorithm can be extremely long, see

Edmonds-Karp to improve Ford-Fulkerson
The Ford-Fulkerson algorithm is a greedy algorithm that computes the maximum
ﬂow in a ﬂow network, also called Edmonds–Karp algorithm.
See Ford & Fulkerson (1962) Flows in Networks
The Ford–Fulkerson algorithm can be implemented to solve the bipartite
matching problem in O(mn) time.
The Hopcroft–Karp 1973 algorithm solves in O(mn1/2
) time, as the Even–Tarjan
1975, see also wikipedia
The Mądry 2013 solves in O(m10/7
) time.
For non-bipartite graph matching, Blossom algorithm from (Edmonds 1965) is :
O(n4
) but the Micali–Vazirani 1980 algorithm solves in in O(mn1/2
) time (see
wikipedia)

Linear Programming
A linear program is a collection of linear constraints on some real-valued
variables, with come linear objective function.
A polytope is an n-dimensional body, with ﬂat faces
A polytope is a convex polytope if for any point in the polytope, the line segment
joining the two points lies within the polytope.
The feaseable region of a linear program is a convex polytope.
An extremal point is a corner point of the feasible region. Note that it cannot be
expressed as the convex co,bination of two (or more) in the polytope
A general program is either 


max
x∈Rd
+
cT
x
s.t. Ax ≤ b
for some k × d matrix A,

Linear Programming
or 


min
x∈Rd
+
cT
x
s.t. Ax ≥ b
There are three possible cases
• the feasible region is empty: there are no optimal values
• the feasible region is unbounded: the optimal value is unbounded
• the feasible region is a bounded convex polytope: an optimal value exist

Linear Programming
Maximal Flow problems can be expressed as a Linear Programming problem



max
E
(u,v)∈E
f(u, v)
s.t.
(u,v)∈E
f(u, v) =
(u,v)∈E
f(v, u) ∀u, v ∈ V (conservation)
s.t. f(u, v) ≤ c(u, v) ∀(u, v) ∈ E (capacity constraint)
s.t. f(u, v) ≥ 0 ∀(u, v) ∈ E

Simplex & Interior Point Methods
Simplex Method (see wikipedia)
Consider a standard linear program
max
x
cT
· x subject to Ax ≤ b and x ≥ 0
The linear program can be represented as a tableau of the form


1 −cT
0
0 A b


Interior Point Method (see wikipedia)
In contrast to the simplex algorithm (which ﬁnds an optimal solution by
traversing the edges between vertices on a polyhedral set) interior-point methods
move through the interior of the feasible region.

Networks & Flows : Extensions
Let us get back to the initial Soviet Railway example.
Note that there are several sources and several sinks.
How to find the maximum flow in the standard network ?
Consider a super source S that is connected to all sources, with infinite capacities
Consider a super sink T that is connected to all sinks, with infinite capacities

Consider a super source S that is connected to all sources, with inﬁnite capacities
Consider a super sink T that is connected to all sinks, with inﬁnite capacities

Other problems were mentioned in that example, like find edge-disjoint paths, or
vertice-disjoint paths: what is the minimum number of train tracks needed to be
destroyed to prevent any transportation from the Asian side to the European
side?
Given a graph G = (V, E), with a source s and a sink t, what is the maximum
number of edge-disjoint paths from s to t ?
This can be solve easily with flow networks, defining a flow network with unit
capacities, for every edges. It is a 0-1 network (here, maximum flow can be
computed efficiently)

Theorem Given a 0-1 flow network with a maximum flow f and maximum
number of edge-disjoint paths k , then |f | = k .
Proof: (1) By having a flow of 1 through every disjoint path, we obtain a flow of
size k so |f | ≥ k .
(2) The converse is obtained by induction (starting with the case |f | = 0)
Consider a maximum flow (of size m ).
Remove every edge with 0 flow through it.
Find a path from s to t (it exists since |f | > 0).
Remove the edges of the path, to obtain a network with a flow of size m − 1
By the induction hypothesis , there are m − 1 edge-disjoint paths in this network.
Bring back the removed path, to obtain at least m edge-disjoint paths

Given a graph G = (V, E), with a source s and a sink t, what is the minimum
number of edges needed to be removed so that no path from s to t remains
Again, consider some 0 − 1 network, and find a maximum flow in this network.
Theorem Given a 0-1 flow network with a maximum flow f and minimum
number of edges needed to disconnect s from t k , then |f | = k .
Proof We have seen that f was actually the maximum number of edge-disjoint
paths
|f | ≤ k since there are |f | edge-disjoint paths, and we need to remove at least
one edge from each
|f | ≥ k since the minum cut is a set of disconnecting edges. And by the
max-flow/ min-cut theorem, there are |f | edges in the min-cut.
Menger Theorem (1927) the minimum number of disconnecting edges is equal
to the maximum number of edge-disjoint paths

Optimal Matching
Consider a transport company, with three plants {A, B, C} and three
construction sites {L, M, N}
Plants can supply (capacity), per week {sA, sB, sC}, {300, 300, 100}
Site can demand (requirement), per week {dL, dM , dN }, {200, 200, 300}
and costs of transportation are given in the following matrix
L M N
A 4 3 8
B 7 5 9
C 4 5 5
Let x(i, j) denote the number of units to be transported from source i to
destination j

Optimal Matching
Let si denote the supply and dj denote the demand, and c(i, j) the cost per unit,
from source i to destination j
Here total supply = total demand, i.e.
i
si =
j
dj
Hence, it is called a balanced problem.
Optimisation program is
min



i j
x(i, j)c(i, j)



subject to
j
x(i, j) = si, ∀i,
i
x(i, j) = dj, ∀j, x(i, j) ≥ 0, ∀i, j.

Optimal Matching
Initial solution - Northwest Corner Rule
1. Start by selecting the cell in the most “North-West” corner of the table.
2. Assign the maximum amount to this cell that is allowable based on the
requirements and the capacity constraints.
3. Exhaust the capacity from each row before moving down to another row.
4. Exhaust the requirement from each column before moving right to another
column.
5. Check to make sure that the capacity and requirements are met

Optimal Matching
Stepping Stone Method
1. Select an unused square to be evaluated.
2. Beginning at this square, trace a closed path back to the original square via
squares that are currently being used (only horizontal or vertical moves allowed).
You can only change directions at occupied cells.
3. Beginning with a plus (+) sign at the unused square, place alternative minus
(-) signs and plus signs on each corner square of the closed path just traced.
4. Calculate an improvement index, Iij by adding together the unit cost ﬁgures
found in each square containing a plus sign and then subtracting the unit costs in
each square containing a minus sign.
5. Repeat steps 1 to 4 until an improvement index has been calculated for all
unused squares.

Optimal Matching
• If all indices computed are greater than or equal to zero, an optimal solution
has been reached.
• If not, it is possible to improve the current solution and decrease total shipping
costs.

Optimal Matching with Ranks
A matching is stable if no unmatched man and woman each prefers the other to
his or her spouse.
The problem is to ﬁnd a stable matching for any dating pool.
Iterative Process
(0) each individual ranks the opposite sex
(1) each man proposes to his top choice
each woman rejects all but her top suitor
(k) each man rejected on day (k − 1) proposes to his top remaining choice
each woman rejects all but her top remaining suitor

It is a deferred-acceptance algorithm.
Ana Luke Matthew Norman
Beatrice Matthew Norman Luke
Clara Norman Matthew Luke
Luke Beatrice Clara Ana
Matthew Ana Clara Beatrice
Norman Ana Beatrice Clara
Run the algorithm
[(1.1)] {M, N} → A and L → B

Run the algorithm
[(1.2)] A → M and B → L : couples (A, M) and (B, L) are engaged
Run the algorithm
[(2.1)] N → B

Run the algorithm
[(2.2)] B → N : couples (A, M) and (B, N) are engaged
Run the algorithm
[(3.1)] L → C

Run the algorithm
[(3.2)] C → L : couples (A, M), (B, N) and (C, L) are engaged

Theorem The deferred-acceptance algorithm arranges stable marriages.
Heuristically, each of the women that a given man prefers to his wife rejected him
in favor of a suitor she preferred.
Theorem (Gale-Shapley) In the solution found by the deferred-acceptance
algorithm, every man gets his best possible match
Theorem (Conway) In the stable matching found by the male-proposing
algorithm, every woman gets her worst possible match
Corrolary Waiting to receive proposals is a bad strategy.
Should people lie to improve the result ?
Theorem (Dubins-Freedman) No man (or group of men) can improve their
results in the male-proposing algorithm by submitting false preferences.

Circulation with Supply and Demand
Flows with supply and demand corresponds to multiple sources and sinks
Each source has a certain amount of ﬂow to give (its supply).
Each sink wants to get a certain amount of ﬂow (its demand).

We want to find a flow f such that ∀e ∈ E, f(e) ∈ [0, c(e)]
and for each v ∈ V ,
uin
f(u, v) −
uout
f(u, v) = d(v)
The demand d(v) is the excess flow that should come into node.
Let S be the set of nodes with negative demands (supply). Let T be the set of
nodes with positive demands (demand).
In order for there to be a feasible ow, we must have
s∈S
d(s) +
t∈T
d(t) = 0
Define D =
t∈T
d(t)

To get back to a maximum flow problem, introduce a super source s with edges
to every vertice in S and a super sink t with edges to every vertice in T
Capacity of edge (s , s) is −d(s) while capacity of edge (t, t ) is d(t) .
Now we can use nax-flow algorithms to find a flow f.

More on Matching
Consider a set of vertices V , a matching is a set of edges E that do not have a set
of common vertices : a matching is a graph (V, E) where each node has either
zero or one edge incident to it (see brilliant.org)

More on Matching
A maximal matching is a matching to which no more edges can be added without
increasing the degree of one vertices to two (it is locally optimal)
A maximum matching is a matching with the largest possible number of edges (it
is globally optimal)
A bipartite graph is a graph whose vertices can be divided into two disjoint and
independent sets V1 and V2, with V1 ∩ V2 = ∅, such that every edge connects a
vertex in V1 to one in V2 (called A and B in the pictures).
Consider directed graphs, with edges from V1 to V2.
Assume further that all edges have unit capacity.

More on Matching
For a bipartite matching, with value k
• there are no node in V1 which has more than one outgoing edge, where there is
a flow
• there are no node in V2 which has more than one incoming edge, where there is
a flow
• the number of edges between V1 and V2 carrying flow is equal to k
A perfect matching is a matching in which each node has exactly one edge
incident on it
König’s theorem states that, in bipartite graphs, the maximum matching is equal
in size to the minimum vertex cover.
Hall’s marriage theorem provides a characterization of bipartite graphs which
have a perfect matching and the Tutte theorem provides a characterization for
arbitrary graphs.

Bipartite Matching (0/1 weights)
See the Task Assignment Problem
A set of tasks that need to be complete.
A set of people , each qualified to do a different subset of tasks.
Each person can perform at most one task. Each task is performed by at most
one person.
Assign as many tasks as possible to people
Consider the bipartite graph, (V, E), where V = V1 ∪ Var2, with V1 is the set of
people, V2 is the set of tasks. And there is an edge between every person and
every task that the person is qualified to do
A matching in an undirected graph is a set of vertice - disjoint edges.
The size of a matching is the number of edges in it.
A matching is possible on any kind of graph
A maximum matching of G is a matching of maximum size.

How can we find such a matching?
Recall that on G = (V1 ∪ V2, E),
v∈V1
d(v) =
v∈V2
d(v) = nE = |E|,
since every edge of E contributes 1 to the sum of the degrees in each side
Simple case: assume that
• Each person is qualified to do exactly k of the jobs.
• Every job has exactly k people that are qualified for it

Since each person is qualiﬁed to do exactly k of the tasks
v∈V1
d(v) = k|V1|
Since each task has exactly k people that are qualiﬁed to do it
v∈V2
d(v) = k|V2|
Thus k|V1| = k|V2|, i.e. necessarily |V1| = |V2|
A perfect matching of a graph G = (V, E) is a matching of size |V |/2.
So, a perfect matching for a bipartite graph can be obtained only when both
sides have the same size.
Consider a bipartite graph (V1 ∪ V2, E), and a vertice v ∈ V1, then the neighbor
set of v is
N(v) = {u ∈ V2 such that (v, u) ∈ E}.
and for a subset A1 ∈ V1,
N(A1) = {u ∈ V2 such that (v, u) ∈ E for some v ∈ A1}.

If there is a subset A1 ⊂ V1 such that |A1| > |N(A1)| ten there is no perfect
matching in G.

Hall’s (Marriage) Theorem Consider a bipartite graph (V1 ∪ V2, E) with
|V1| = |V2|, there exists a perfect matching in G if and only if for every A1 ⊂ V1,
|A1| ≤ |N(A1)|
Hall’s (Marriage) Theorem Consider a bipartite graph (V1 ∪ V2, E), there
exists a perfect matching in G if and only if for every A1 ⊂ V1, |A1| ≤ |N(A1)|
Consider a bipartite graph G = (V1 ∪ V2, E), the deﬁciency of G is
def(G) = max
A1⊂V1
|A1| − |N(A1)|
E.g. on the graph on the right def(G) = 1
Note that def(G) ≥ 0

Theorem Consider a bipartite graph G = (V1 ∪ V2, E), then
the size of the maximum matching is V1 − def(G).
In a bipartite graph G = (V1 ∪ V2, E), and let M denote a
matchin. A path is alternating for M if it starts with an un-
matched vertice of V1 and every other edge of it is in M.

An alternating path is augmenting for M if it also ends with
an unmatched vertice.
Let M denote an an augmenting path, then by switching the
edges that are in M with the edges that are not, we obtain a
larger matching.
Theorem If a matching M in a bipartite graph G = (V1 ∪
V2, E) is not a maximum matching, then there exists an aug-
menting path for M.

This can be used to set up an algorithm to find a maximum matching
Consider a bipartite graph G = (V1 ∪ V2, E), start with any maching M (even a
single edge)
Repeatedly find an augmenting path for M, and use it to find a larger matching

Bipartite Matchings and Network Flows
Given a bipartite graph G = (V1 ∪ V2, E), why not use a max-flow algorithm to
find a maximum matching of G ?
Add a source s and edges to every vertice of V1, and a sink t and edges to every
vertice of V2
Direct edges from s to vertices of V1, then to vertices of V2 and finally to t.
Set capacities to 1.
There is a bijection between the matchings of G and the flows of the network.
Theorem A max-matching corresponds to a max-flow.

Try the following one

Bipartite Matching (general weights)
Consider now the case where non-negative weights w(e) are assigned to each edge
e ∈ E, see as a cost matrix w
Example : you want to send three sales managers to three cities. They are
incities {A, B, C} and they need to visit {D, E, F}
Here are the cost of airplane ticksts
D E F
A
B
C
250 400 350
400 600 350
200 400 250
Where should you send each of your salespeople in order to minimize airfare?

Bipartite Matching (general weights)
One possible assignment/matching is {A, D}, {B, E},{C, F}, and the total cost
is 1100
One possible assignment/matching is {A, D}, {B, F},{C, E}, and the total cost
is 1000
There are n! ways of assigning n resources to n tasks.
Theorem: If a number is added to or subtracted from all of the entries of any
one row or column of a cost matrix, then on optimal assignment for the resulting
cost matrix is also an optimal assignment for the original cost matrix.

Hungarian Algorithm (Kuhn-Munkres)
Step 1. Subtract the smallest entry in each row from all entries of its row.
Step 2. Subtract the smallest entry in each column from all entries of its column.
Step 3. Draw lines through appropriate rows and columns so that all zero
entries of the cost matrix are covered and minimum number of such lines is used.
Step 4. Test for Optimality:
(i) If the minimum number of covering lines is n, an optimal assignment of zeros
is possible and we are ﬁnished.
(ii) If the minimum number of covering lines is less than n, an optimal
assignment of zeros is not yet possible. In that case, proceed to Step 5.
Step 5. Determine the smallest entry not covered by any line. Subtract this
entry from each uncovered row, and then add it to each covered column. Return
to Step 3 (see hrefhttps://brilliant.org/wiki/hungarian-matching/brilliant.org)

In our previous example
Step 1:
D E F
A 250 400 350
B 400 600 350
C 200 400 250
∼
D E F
A 0 150 100
B 50 250 0
C 0 200 50
Step 2:
D E F
A 0 150 100
B 50 250 0
C 0 200 50
∼
D E F
A 0 0 100
B 50 100 0
C 0 50 50

Step 3. Cover all the zeros of the matrix with the minimum number of horizontal
or vertical lines
D E F
A 0 0 100
B 50 100 0
C 0 50 50

Step 4. Since the minimal number of lines is 3, an optimal assignment of zeros is
possible and we are ﬁnished
Since the total cost for this assignment is 0, it must be an optimal assignment.
D E F
A 0 0 100
B 50 100 0
C 0 50 50
∼
D E F
A 250 400 350
B 400 600 350
C 200 400 250
(we keep the same assignment to the original cost matrix)

Slides networks-2017-2

More Related Content

What's hot (20)

Viewers also liked (7)

Similar to Slides networks-2017-2 (20)

More from Arthur Charpentier (20)

Recently uploaded (20)

Slides networks-2017-2