You are on page 1of 4

Introduction to Algorithms - Ex1

October 16, 2010

Question 1
Let G be a circular directed weighted graph with n nodes (n being the amount
of gas stations), s.t. the sum of all weights is exactly 0.
We can correspond each gas station to a node such that:

• each two nodes are neighbours i their matching gas stations are neigh-
bours

• the weight of a node is the distance which could be travelled with the gas
in the station less the length of the road to the next station

Thus, reducing the original problem to proving that

X
∃e ∈ G s.t. ∀e0 ∈ G : w (e? ) ≥ 0
e? ∈[e,e0 ]

where w is the weight function and [e, e0 ] is the (unanimously dened) simple
0
line between e and e.
Let us assume that no such e exists, thus that

X
∀e ∈ G : ∃e0 ∈ G s.t w (e? ) < 0
e? ∈[e,e0 ]

For the simplicity of the proof well say that e is negatively distant from e0 .
Let e0 ∈ G be any node, according to our assumption there is an e1 which is
negatively distant from e0 , and an e2 which is negatively distant from e1 and
so on.

Let us create a succession of n+1 such nodes, since there are only n gas stations,
we know that ∃i, j s.t. i 6= j and ei = ej .

1
Thus the succession (ei , ..., ej ) starts and ends at the same place, and let us
assume it goes over the entire circle k times, thus, the total weight traversed
along this succession is
X
k w(e)
e∈G

thus, according to our assumption

X X X X
k w(e) = w (e? ) + ... + w (e? ) < 0 =⇒ w(e) < 0
e∈G e? ∈[ei ,ei+1 ] e? ∈[ej−1 ,ej ] e∈G

Thus such a node e exists which proves the hypothesis.

Question 2
I suggest this algorithm (which I like to call a reverse Kruskal):

• Sort the edges from the heaviest to the lightest

• Go over the edges in that order, and remove it from the graph i it doesn't
divide it into two connectivity components (could be checked in o(|E|))

Correctness proof :
First we must prove that RK indeed returns a tree. The constraints promise
that the output graph is simply connected.

Let us assume that the output contains a circle, and let us denote vj as the
heaviest edge in the circle. Since vj is the rst edge traversed by RK, it's still
containt in a circle, which means removing it will not divide the graph into
two connectivity components, thus having the algorithm remove it, which is a

This proves the output is indeed a spanning tree, let us prove that it has a
minimal maximal edge.

The correctness is trivial in case removing a1 (or any ai s.t. w(ai ) = w(a1 ))
divides the graph into two connectivity components, as a1 (or one of it's dopel-
gangers) must stay thus making any spanning tree a solution.

Assuming that is not the case, let us denote a solution as the ordered set of
edges removed from the graph, and denote the output of our algorithm as RK .
Let B be the set of optimal solutions and let S ∈ B , there is a maximal j s.t.
∀j ≤ i : vj ∈ S , assuming that RK is not optimal means that there exists a
minimal j ≤ i s.t. vj ∈
/ RK .

2
But since S is a solution we know that after removing v1 , ..., vj−1 from G, we get
a connected graph, and furthermore, since vj ∈ S we know that G − {v1 , ..., vj }
is still connected.

Hence, after removing the edges {v1 , ..., vj−1 } RK would remove vj , proving
that vj ∈ RK , in contradiction.

Thus it's proved that RK ∈ S .

Question 3
Let us consider a spanning tree of G, and let v∈G be a leaf in that tree.

That means, that ∀u1 , u2 6= v ∈ G there exists a (u1, u2)−trail in G which

doesn't contain v , and by proxy it doesn't contain any of the edges it's connected
to.

Thus, removing v and all if it's edges, doesn't harm the connectivity of the
graph.

Question 4
• Go over each of the numbers in the array from x1 to xn , if the current
number isn't contained in any segment add it to the output set.

Proof of correctness:
Since the algorithm will add any number not yet covered it's obvious that the
output covers all numbers in the array.

Let us denote our output as A = {y1 , ..., yk }.

Let B be a set of optimal solutions, and let us assume that A∈
/ B.
The assumption implies that the optimal solution is of size m < k.
Let j be the maximal value such that ∃S ∈ B s.t. {y1 , ..., yj } ⊂ S , thus S =
{y1 , ..., yj , cj+1 , ..., cm }.
Let us denote by xl the minimal element of the input which isn't contained in
any of the segments described by {y1 , ..., yj }.
From the correctness of the algorithms we know that xl ∈ [cj+1 , cj+1 + 1] and
xl ∈ [yj+1 , yj+1 + 1].
But if we examine the elements larger than xl which are contained in the same
segments, we realize that in case of A they are all contained in [xi , yj+1 + 1] and
in case of S they are all contained in [xi , cj+1 + 1].

But from the denition of our algorithm we get that xi = cj+1 thus [xi , yj+1 +
1] ⊆ [xi , cj+1 + 1] (as the length of the rightmost segment is 1, which is the
maximal length, and they both have the same starting point).

3
This proves that {y1 , ..., yj+1 , cj+2 , ..., cm } as also a solution, in contradiction
with j being maximal.