Transcript Analysis of Algorithms CS 465/665

Shortest Path
• Generalize distance to weighted setting
• Digraph G = (V,E) with weight function W: E 
R (assigning real values to edges)
• Weight of path p = v1  v2  …  vk is
k 1
w( p)   w(vi , vi 1 )
i 1
• Shortest path = a path of the minimum weight
• Applications
– static/dynamic network routing
– robot motion planning
– map/route generation in traffic
1
Dijkstra's Algorithm
• Non-negative edge weights
• Greedy, similar to Prim's algorithm for MST
• Like breadth-first search (if all weights = 1, one
can simply use BFS)
• Use Q, a priority queue ADT keyed by v.d()
(BFS used FIFO queue, here we use a PQ,
which is re-organized whenever some d
decreases)
• Basic idea
– maintain a set S of solved vertices
– at each step select "closest" vertex u, add it to S, and
relax all edges from u
2
Dijkstra’s Pseudo Code
• Input: Graph G, start vertex s
Dijkstra(G,s)
01
02
03
04
05
06
07
08
09
10
11
12
for each vertex u  G.V()
u.setd()
u.setparent(NIL)
s.setd(0)
S 
// Set S is used to explain the algorithm
Q.init(G.V()) // Q is a priority queue ADT
while not Q.isEmpty()
u  Q.extractMin()
S  S  {u}
for each v  u.adjacent() do
relaxing
Relax(u, v, G)
edges
Q.modifyKey(v)
3
Ex: Dijkstra’s On Directed Graph
u
Dijkstra(G,s)
01
02
03
04
05
06
07
08
09
10
11
12
for each vertex u  G.V()
u.setd()
u.setparent(NIL)
s.setd(0)
S 
Q.init(G.V())
while not Q.isEmpty()
u  Q.extractMin()
S  S  {u}
for each v  u.adjacent() do
Relax(u, v, G)
Q.modifyKey(v)
s
0
1

10
2
3

u
2
3
x
6

y
v

9
7
5
4
1
10
10
5
9
2
x
0

7
5
s
v
2
4
6

y
4
Ex: Dijkstra’s On Directed Graph(2)
u
Dijkstra(G,s)
01
02
03
04
05
06
07
08
09
10
11
12
for each vertex u  G.V()
u.setd()
u.setparent(NIL)
s.setd(0)
S 
Q.init(G.V())
while not Q.isEmpty()
u  Q.extractMin()
S  S  {u}
for each v  u.adjacent() do
Relax(u, v, G)
Q.modifyKey(v)
s
0
1
8
10
2
5
2
3
x
y
v
13
9
7
5
6
7
1
8
10
4
2
u
5
9
3
x
0
14
7
5
s
v
2
4
6
7
y
5
Ex: Dijkstra’s On Directed Graph(3)
u
Dijkstra(G,s)
01
02
03
04
05
06
07
08
09
10
11
12
for each vertex u  G.V()
u.setd()
u.setparent(NIL)
s.setd(0)
S 
Q.init(G.V())
while not Q.isEmpty()
u  Q.extractMin()
S  S  {u}
for each v  u.adjacent() do
Relax(u, v, G)
Q.modifyKey(v)
0
1
8
10
2
9
3
5
u
2
3
x
y
v
9
9
7
5
6
7
1
8
10
4
2
x
5
9
7
5
0
v
2
4
6
7
y
6
Ex: Dijkstra’s On Undirected Graph
7
Ex: Dijkstra’s On Undirected Graph
Node
Step1
Step2
Step3
Step4
Step5
A
0*
0*
0*
0*
0*
B
3
3*
3*
3*
3*
C

7
7
7*
7*
D
7
5
5*
5*
5*
E


9
9
9*
8
Dijkstra’s Running Time
•
•
•
•
Extract-Min executed |V| time
Decrease-Key executed |E| time
Time = |V| TExtract-Min + |E| TDecrease-Key
T depends on different Q implementations
Q
T(ExtractMin)
T(Decrease-Key) Total
array
O(V)
O(lg V)
O(lg V)
O(1)
O(lg V)
O(1) (amort.)
binary heap
Fibonacci heap
O(V 2)
O(E lg V)
O(V lgV + E)
9
Example (BFS)
r
s
t
u

0






v
w
x
y
Q: s
0
10
Example (BFS)
r
s
t
u
1
0



1


v
w
x
y
Q: w r
1 1
11
Example (BFS)
r
s
t
u
1
0
2


1
2

v
w
x
y
Q: r t x
1 2 2
12
Example (BFS)
r
s
t
u
1
0
2

2
1
2

v
w
x
y
Q: t x v
2 2 2
13
Example (BFS)
r
s
t
u
1
0
2
3
2
1
2

v
w
x
y
Q: x v u
2 2 3
14
Example (BFS)
r
s
t
u
1
0
2
3
2
1
2
3
v
w
x
y
Q: v u y
2 3 3
15
Example (BFS)
r
s
t
u
1
0
2
3
2
1
2
3
v
w
x
y
Q: u y
3 3
16
Example (BFS)
r
s
t
u
1
0
2
3
2
1
2
3
v
w
x
y
Q: y
3
17
Example (BFS)
r
s
t
u
1
0
2
3
2
1
2
3
v
w
x
y
Q: 
18
Example (BFS)
r
s
t
u
1
0
2
3
2
1
2
3
v
w
x
y
BF Tree
19
Analysis of BFS
• Initialization takes O(V).
• Traversal Loop
– After initialization, each vertex is enqueued and dequeued
at most once, and each operation takes O(1). So, total
time for queuing is O(V).
– The adjacency list of each vertex is scanned at most once.
The sum of lengths of all adjacency lists is (E).
• Summing up over all vertices => total running time of
BFS is O(V+E), linear in the size of the adjacency list
representation of graph.
20
Example (DFS)
u
v
w
y
z
1/
x
21
Example (DFS)
u
v
1/
2/
x
y
w
z
22
Example (DFS)
u
v
1/
2/
w
3/
x
y
z
23
Example (DFS)
u
v
1/
2/
4/
3/
x
y
w
z
24
Example (DFS)
u
v
1/
2/
w
B
4/
3/
x
y
z
25
Example (DFS)
u
v
1/
2/
w
B
4/5
3/
x
y
z
26
Example (DFS)
u
v
1/
2/
w
B
4/5
3/6
x
y
z
27
Example (DFS)
u
v
1/
w
2/7
B
4/5
3/6
x
y
z
28
Example (DFS)
u
v
1/
w
2/7
B
F
4/5
3/6
x
y
z
29
Example (DFS)
u
v
1/8
2/7
w
B
F
4/5
3/6
x
y
z
30
Example (DFS)
u
v
w
1/8
2/7
9/
B
F
4/5
3/6
x
y
z
31
Example (DFS)
u
v
w
1/8
2/7
9/
B
F
C
4/5
3/6
x
y
z
32
Example (DFS)
u
v
w
1/8
2/7
9/
B
F
C
4/5
3/6
10/
x
y
z
33
Example (DFS)
u
v
w
1/8
2/7
9/
B
F
C
4/5
3/6
10/
x
y
z
B
34
Example (DFS)
u
v
w
1/8
2/7
9/
B
F
C
4/5
3/6
10/11
x
y
z
B
35
Example (DFS)
u
v
w
1/8
2/7
9/12
B
F
C
4/5
3/6
10/11
x
y
z
B
36
Analysis of DFS
• Loops on lines 1-2 & 5-7 take (V) time, excluding
time to execute DFS-Visit.
• DFS-Visit is called once for each white vertex vV
when it’s painted gray the first time. Lines 3-6 of
DFS-Visit is executed |Adj[v]| times. The total cost
of executing DFS-Visit is vV|Adj[v]| = (E)
• Total running time of DFS is (V+E).
37
Elementary Graph Algorithms in
External Memory:
38
Introduction
• main memory of size M
• external memory consisting of D disks
• Data is moved in blocks of size B consecutive
words
• scan(x) := O(x/(D.B))
• sort(x) := O(x/(D.B).logM/B(x/B))
• perm(x) := O(min{x/D, sort(x)}
39
Graph-Traversal Problems: BFS, DFS, SSSP
In IM algorithms for BFS,DFS,SSSP to visited next
vertex need to:
– Queue for BFS
– Stack for DFS
– Priority queue for SSSP
40
Graph-Traversal Problems: BFS, DFS, SSSP
• The Key Problems
(a)Unstructured indexed access to adjacency lists.
(b)Remembering visited nodes.
(c) (The lack of) Decrease Key operations in external
priority-queues.
41
Problem (a)
• if a list contains k edges then it takes Θ(1 + k/B)
I/Os to retrieve all its edges.
– fine if k = Ω(B),
– wasteful if k = O(1).
• so there is no general solution for (a) on sparse
graphs.
– Hence, we will mainly focus on methods to avoid
spending one I/O for each edge on general graphs.
42
Problem (b)
• solving in multiple phases
– a dictionary DI of maximum capacity |DI| < M is kept
in internal memory(DI serves to remember visited
nodes)
– Whenever the capacity of DI is exhausted, all edges
pointing to visited nodes are discarded and the
remaining edges are compacted into new adjacency
lists. Then DI is emptied
• This phase-approach is most efficient if the
quotient |V|/|DI| is small
• O(|V |/|DI|.scan(|V | + |E|)) I/Os for graph
compactions
43
Problem (c) first solution
• instead of actually performing Decrease Key
operations, several priorities may be kept for
each node in the external priority-queue;
• after a node v is dequeued for the first time (with
the smallest key) any further appearance of v in
Q will be ignored.
• In order to make this work, superfluous elements
still kept in the EM data structure of Q are
marked obsolete right before DI is emptied at
the end of a phase; the marking can be done by
scanning Q.
44
Problem (c) second solution
• Problems (b) and (c) usually disappear in the
semi-external memory (SEM) setting where it is
assumed that M = c.|V | < |E| for some
appropriately chosen positive constant c.
– keep a boolean array for (b) in internal memory
– a node priority queue with Decrease Key operation for
(c) could reside completely in IM.
• SEM algorithms for BFS, DFS and SSSP require
Ω(|V |+|E|/B) I/Os on general directed graphs.
45
Undirected Breadth-First Search
BFS Numbers → BFS Tree → BFS Levels
→BFS Numbers
• Each of the transformations can be done using
O(sort(|V | + |E|)) I/Os.
46
Undirected Breadth-First Search
BFS Numbers → BFS Tree:
• BFS numbers:order of the nodes in a level.
– for each node v ∈ V,the parent of v in the BFS
tree is the node v’ with BFS number
bfsnum(v’) = min(v,w)∈E bfsnum(w). The
adjacency lists can be augmented with the
BFS numbers by sorting. Another scan
suffices to extract the BFS tree edges.
47
Undirected Breadth-First Search
BFS Tree → BFS Levels:
– Euler tour around the undirected BFS tree
can be constructed and processed using
scanning and list ranking; Euler tour edges
directed towards the leaves are assigned a
weight +1 whereas edges pointing towards
the root get weight −1.
48
Undirected Breadth-First Search
BFS Levels →BFS Numbers:
• having computed correct numbers for level i, the
order (BFS numbers)of the nodes in level i+1 is
given as follows
• each level-(i+1) node v must be a child (in the
BFS tree) of its adjacent level-i node with least
BFS number. After sorting the nodes of level i
and the edges between levels i and i + 1,a scan
provides the adjacency lists of level-(i + 1) nodes
with the required information.
49
The Algorithm of Munagala and Ranade(MR-BFS)
L(t):set of nodes in BFS level t.
|L(t)| :number of nodes in L(t).
N(L(t)):multi-set of neighbor vertices of nodes in
L(t){created by |L(t)| accesses to the adjacency
lists,one for each node in L(t).
• MR-BFS builds L(t) as follows:
1)A(t) := N(L(t−1))
2) A’(t):=removes duplicates from the multi-set A
3) L(t) := A’(t)\{L(t−1)∪L(t−2)}
50
The Algorithm MR-BFS
51
The Algorithm MR-BFS
1)O (|L(t − 1)| + |N(L(t − 1))|/B) I/Os
2) O(sort(|A(t)|) I/Os
3) O(sort(|N(L(t−1))|)+ scan(|L(t−1)| + |L(t−2)|)I/Os
∑t|N(L(t))| = O(|E|)
∑t|L(t)| = O(|V |)
So: O(|V | + sort(|E|)) I/Os
Theorem:BFS on arbitrary undirected graphs can
be solved using O(|V |+ sort(|V |+|E|)) I/Os.
52
Improved BFS Algorithm [MM-BFS]
MM-BFS operates in two phases:
 Preprocessing
 Perform BFS
Preprocessing:
 partitions the graph into disjoint connected subgraphs si
0≤i≤K, with small expected diameter.[also partitions the
adjacency lists accordingly].
 partition is built by choosing master nodes independently
and uniformly at random with probability μ and running a
local BFS from all master nodes“in parallel”
  min{1, (|V |  | E |) /(B. | V |)}
53
Improved BFS Algorithm [MM-BFS]
• in each round, each master node si tries to
capture all unvisited neighbors of its current subgraph Si; this is done by first sorting the nodes of
the active fringes of all Si (the nodes that have
been captured in the previous round) and then
scanning the dynamically shrinking adjacencylists representation of the yet unexplored graph.
54
Improved BFS Algorithm [MM-BFS]
 Expected number of master nodes is K=O(1+μ.n).
 Expected number of edges between any two nodes
of a subgraph is at most 2/μ.
 Expected total amount of data being scanned from
the adjacency-lists representation during the
“parallel partition growing” is bounded by:
X  O(1 / .(1  deg ree(v)))  O((|V |  | E |) /  )
vV
 Total nodes sorted and scanned during the
partitioning is at most Y := O(|V |+|E|).
55
Improved BFS Algorithm [MM-BFS]
Therefore,the partitioning requires:
O(scan(X)+sort(Y))=O(scan(|V|+|E|)/μ+sort(|V|+|E|))
56
Improved BFS Algorithm [MM-BFS]
• F0F1 . . .Fi . . .F|S|−1,where Fi contains the
adjacency lists of the nodes in partition Si;an entry
(v,w, S(w), fS(w)) from the adjacency list of v∈Fi
stands for the edge (v,w) and provides the
additional information that w belongs to subgraph
S(w) whose subfile FS(w) starts at position fS(w)
within F.
57
Improved BFS Algorithm [MM-BFS]
• Fast-BFS keep an external file H(hot adjacency lists).
• H comprises unused parts of subfiles Fi that
contain a node in the current level L(t − 1).
• Fast-BFS initializes H with F0.
• creating level L(t) based on L(t−1) and L(t−2).
performs a parallel scan of the sorted lists L(t−1)
and H and extracts N(L(t − 1)).
58
Improved BFS Algorithm [MM-BFS]
59
Improved BFS Algorithm [MM-BFS]
• After an adjacency list was copied to H, it will be
used only for O(1/μ) expected steps.
• Expected total data volume for scanning H is
O(1/μ.(|V |+|E|)).
• Expected total number of I/Os to handle H and Fi
is O(μ .|V |+sort(|V |+|E|)+1/μ.scan(|V | + |E|)).
  min{1, scan(|V |  | E |) / | V |}
60
Improved BFS Algorithm [MM-BFS]
Theorem: External memory BFS on undirected
graphs can be solving using expected I/Os:
O( | V | .scan(| V |  | E |  sort(| V |  | E |))
61
Deterministic Variant
• instead of growing subgraphs around randomly
selected master nodes, the deterministic variant
extracts the subfiles Fi from an Euler tour around
a spanning tree for the connected component Cs
that contains the source node s.
62
Deterministic Variant
63
Deterministic Variant
• the reduced subgraphs Si may not be connected
any more.
• this does not matter as our approach only
requires that any two nodes in a subgraph are
relatively close in the original input graph.
64
Deterministic Variant
• the modified preprocessing, however,
guarantees that each adjacency-list will be part
of the external set H for at most 2/μ BFS levels:
if a subfile Fi is merged with H for BFS level L(t),
then the BFS level of any node v in Si is at most
L(t) + 2/μ − 1.
• Therefore, the adjacency list of v in Fi will be
kept in H for at most 2/μ BFS levels.
65
Deterministic Variant
• Theorem :External memory BFS on undirected
graphs can besolved using
O( | V | .scan(|V |  | E |  sort(|V |  | E |))
in the worst case.
66
I/O-Efficient Tournament Tree
• Tournament tree is a complete binary tree, where
some rightmost leaves may be missing.
• works as a priority queue with the Decrease Key
operation.
• static I/O-TT can host at most |V | elements with
pairwise disjoint indices in {1, . . . , |V |}. Besides
its index x, each element also has a key k(priority).
An element <x1,k1> is called smaller than <x2,k2> if
k 1 < k 2.
67
I/O-Efficient Tournament Tree
• The I/O-TT supports the following operations:
1)Deletemin
2)delete(x)
3)Update(x,newkey)
• Deletemin:extract the element <x,k> with smallest key k
and replace it by the new entry <x,+∞>.
• Delete(x):replace <x,oldkey> by<x,+∞>.
• Update<x,newkey>:replace <x,oldkey> by <x,newkey>
if newkey<oldkey.
68
I/O-Efficient Tournament Tree
 I/O-TTs rely on the batched processing.
 Let M’= c.M for some positive constant c<1; the
static I/O-TT for |V| entries only has [|V |/M’]
leaves(instead of |V| leaves in the standard TT).
 There are O(log2(|V|/M)) levels.
 Elements with indices in the range
{(i−1).M’+1,...,i.M’} are mapped to the ith leaf.
 The index range of internal nodes of the I/O-TT
is given by the union of the index ranges of their
children.
69
I/O-Efficient Tournament Tree
 Internal nodes of the I/O-TT keep a list of at
least M’/2 and at most M’ elements each (sorted
according to their priorities).
 Initially, the I/O-TT stores the elements <1,+∞>,
<2,+∞>, ...,<|V |,+∞>.
70
I/O-Efficient Tournament Tree
71
I/O-Efficient Tournament Tree
 The operations(1)–(3)generate signals which
serve to propagate information down the tree.
 signals are inserted into the root node,which is
kept in internal memory.
 Non-discarded signals are stored until the
capacity of the node’s buffer is exceeded;then
they are sent down the tree towards the unique
leaf node its associated element is mapped to.
 When a signal arrives in a node it may create,
delete or modify an element kept in this node.
72
I/O-Efficient Tournament Tree
• Deletemin removes<x,k> with smallest key k from
the root node (in case there are no elements in the
root it is recursively refilled from its children)
Then a signal is sent on the path towards the leaf
associated with x in order to reinsert<x,+∞>.
The reinsertion takes place at the first tree node on the path
with free capacity whose descendents are either empty or
exclusively host elements with key infinity.
73
I/O-Efficient Tournament Tree
• Delete(x) send a delete signal towards the leaf
node that index x is mapped to,then a signal to
reinsert <x,+∞>.
• Update(x,newkey) replace <x,oldkey> by
<x,newkey> if newkey < oldkey.
74
I/O-Efficient Tournament Tree
Theorem:
On an I/O-efficient tournament tree with |V|
elements,any sequence of z
delete/deletemin/update operations requires at
most O(z/B.log2(|V|/B)) I/Os.
75
Undirected SSSP with Tournament Trees
• The basic idea is replace the data structure Q in
IM traversal-algorithms by the EM tournament
tree.
• The SSSP algorithm with Tournament Tree:
constructs an I/O-TT for the |V | vertices of the graph and
sets all keys to infinity Then the key of the source node
is updated to zero.
algorithm operates in |V | iterations:
iteration i first performs a deletemin in order to extract an
element<vi,ki>,Then the algorithm issues
update(wj,dist(vi)+c(vi,wj)) on the I/O-TT for each
adjacent edge (vi,wj),vi ≠wj,having weight c(vi,wj).
76
Undirected SSSP with Tournament Trees
Problem:
• consider an edge(u,v) where dist(u)<dist(v).after
removing u, the I/O-TT replaces the extracted
entry <u,dist(u)> by <u,+∞>. Thus, performing
update(u,dist(v)+c(v,u)<∞) for the edge (v,u)
after the extraction of v.
77
Undirected SSSP with Tournament Trees
Soulition:
• A second EM priority-queue(SPQ), supporting a
sequence of z deletemin and insert operations with
(amortized) O(z/B.log2(z/B)) I/Os(in order to remember
settled nodes).
• Initially SPQ is empty.
• At the beginning of iteration i,the modified algorithm
additionally checks the smallest element <u’i,k’i> from
SPQ and compares its key k’i with the key ki of the
smallest element <ui,ki> in I/O-TT.
78
Undirected SSSP with Tournament Trees
Compare key:
• k'i=ki: the element in the I/O-TT is processed.
• k'i<ki: delete(u’i) operation is performed on I/O-TT
as well and a new phase start.
• k'i>ki:the algorithm proceeds as described previous
,for each update(v,dist(u)+c(u,v)) on the I/O-TT it
additionally inserts (u,dist(u)+c(u,v)) into the SPQ.
79
Undirected SSSP with Tournament Trees
• O(|E|) operations on the I/O-TT.
• O(|E|/B.log2(|E|/B)) I/O for SPQ operations.
• Theorem:SSSP on undirected graphs can be
solved using O((|V |+ |E|)/B.log2(|E|/B))I/Os.
80
Data structure BRT for BFS in Directed
Graphs
• Problem:The key difference is that it becomes
much more complicated to keep track of
previously visited nodes of the graph; the nice
trick of checking a constant number of previous
levels for visited nodes as discussed for
undirected BFS does not work for directed
graphs. Therefore we store edges that point to
previously seen nodes in a so-called buffered
repository tree (BRT).
81
BRT introduction
• A BRT maintains |E| elements with keys in {1,...,
|V |}and supports the operations insert(edge,key)
and extract-all(key).
• A BRT can be built as a height-balanced static
binary tree with |V | leaves and buffers of size B
for each internal tree node, leaf i is associated
with graph node vi and stores up to degree(vi)
edges.
82
Operations BRT
• insert(edge,key): Insertions into the BRT happen at
the root,in case of buffer overflow an inserted
element (e,i) is flushed down towards the i-th leaf.
an insert operation requires amortized
O(1/B.log2|V|)I/Os.
• extract-all(key): reports and deletes all edges in
the BRT that are associated with the specified key.
reports x edges then it needs to read O(log2|V|)
buffers on the path,another O(x/B) disk blocks
may have to be read at the leaf itself.
This accounts for O(x/B+log2|V|) I/Os.
83
external stack S for DFS in Directed
Graphs
• External stack S is used to store the vertices on
the path from the root node of the DFS tree to the
currently visited vertex.
• DFS algorithm checks the previously unexplored
outgoing edges of the topmost vertex u from S:
If the target node v of such an edge (u,v) has not
been visited before then u is the father of v in the
DFS tree,then v is pushed on the stack.
if v has already been visited before,the next
unexplored outgoing edge of u will be checked(if all
outgoing edges of the u visited, popped u)
84
implemented I/O efficiently of DFS procedure
implemented I/O efficiently of DFS procedure:
 when a node v is visited for the first time,then for each
incoming edge ei=(ui,v) the algorithm performs
insert(ei,ui) in BRT.
 If at some later point ui is visited then extract-all(ui)
provides a list of all edges out of ui that should not be
traversed again.
 If the (ordered) adjacency list of ui is kept in some EM
priority-queue P(ui) then all superfluous edges can be
deleted from P(ui) in an I/O-efficient way.
 Then the next edge to follow is given by extracting the
minimum element from P(ui).
85
implemented I/O efficiently of DFS procedure
• O(|V |+|E|/B) I/Os to access adjacency lists.
• O(|E|) operations on the n priority queues P(.).
– O(sort(|E|)) I/Os to deleted superfluous edges.
– O(|V |) I/Os to extracting minimum.
O(|V | + sort(|E|)) I/Os on all P(.).
• O(|E|) insert in BRT.(for each insert O(1/B.log2|V|)I/Os)
• O(|V|) extract-all from BRT.(for each key and x edges
O(x/B+log2|V|) I/Os)
 Theorem: BFS and DFS on directed graphs
can be solved using O((|V|+|E|/B).log2|V|) I/Os.
86
Undirected CC,CCL problem
• Connected Components(CC) problem is to create, for a
graph G=(V,E),a list of the nodes of the graph,sorted
by component, with a special record marking the end
of each component.
• The Connected Components Labeling(CCL) problem is to
create a vector L of size |V | such that for every i,j∈{1,…,|V|},
L[i]=L[j] iff nodes i and j are in the same component of G.
 A solution to CCL can be converted into a CC output in
O(sort(|V |))I/Os, by sorting the nodes according to their
component label and adding the separators.
87
Undirected BCC,MSF problem
• Biconnected Components (BCC) is the problem
of finding subsets of the nodes such that u and v
are in the same subset iff there are two nodedisjoint paths between u and v.
• Minimum Spanning Forest(MSF) is the problem
of finding a subgraph F of the input graph G
such that every connected component in G is
connected in F and the total weight of the edges
of F is minimal.
88
89