Problem Set 1

We are given as input a set of $𝑛$ requests (e.g., for the use of an auditorium), with a known start time $𝑠 𝑖$ and finish time $𝑡 𝑖$ for each request $𝑖$ . Assume that all start and finish times are distinct. Two requests conflict if they overlap in time — if one of them starts between the start and finish times of the other. Our goal is to select a maximum-cardinality subset of the given requests that contains no conflicts. (For example, given three requests consuming the intervals [0,3], [2,5], and [4,7], we want to return the first and third requests.) We aim to design a greedy algorithm for this problem with the following form: At each iteration we select a new request $𝑖$ , including it in the solution-so-far and deleting from future consideration all requests that conflict with $𝑖$ .

Which of the following greedy rules is guaranteed to always compute an optimal solution?

At each iteration, pick the remaining request with the earliest finish time.

At each iteration, pick the remaining request which requires the least time (i.e., has the smallest value of $𝑡 𝑖 - 𝑠 𝑖$ ) (breaking ties arbitrarily).

At each iteration, pick the remaining request with the earliest start time.

At each iteration, pick the remaining request with the fewest number of conflicts with other remaining requests (breaking ties arbitrarily).

ANSWER: Consider the following requests:

i | start | finish | duration
-----------------------------
1 | 0     | 3      | 3
2 | 2     | 4      | 2
3 | 3     | 6      | 3

If we pick the request with the smallest $𝑡 𝑖 - 𝑠 𝑖$ , we can only pick $𝑟 1$ , whereas just eyeballing shows that the maximum subset should contain $𝑟 1$ and $𝑟 3$ . Therefore, option 2 is incorrect.

Consider the following requests:

i | start | finish
------------------
1 | 0     | 6
2 | 2     | 4
3 | 3     | 6

If we pick the request with the earliest time ( $𝑟 1$ ), we cannot pick any from the table above, but if we somehow don’t pick $𝑟 1$ , we can pick either one of $𝑟 2$ or $𝑟 3$ . Therefore, option 3 is incorrect.

It is shown here that option 4 is incorrect as well, but I honestly don’t understand how they came up with such an example, so I’m going to refrain from copy-pasting it here.

Option 1 is correct. To prove it, let $𝑆$ be a set of requests and $𝑟 𝑚 \in 𝑆$ a request with the earliest finish time. Let $𝑅 \subseteq 𝑆$ be the maximum subset of mutually compatible requests, and $𝑟 𝑘 \in 𝑅$ a request with the earliest finish time. Clearly, $𝑓 𝑖 𝑛 𝑖 𝑠 ℎ (𝑟 𝑚) \leq 𝑓 𝑖 𝑛 𝑖 𝑠 ℎ (𝑟 𝑘)$ . If they are equal, we are done with the proof. Otherwise, let $𝑅' = 𝑅 - {𝑟 𝑘} \cup {𝑟 𝑚}$ . Since $𝑟 𝑘$ is the request with the earliest finish time in $𝑅$ , and $𝑓 𝑖 𝑛 𝑖 𝑠 ℎ (𝑟 𝑚) < 𝑓 𝑖 𝑛 𝑖 𝑠 ℎ (𝑟 𝑘)$ , therefore, none of the other requests in $𝑅$ conflict with $𝑟 𝑚$ , and hence $| 𝑅' | = | 𝑅 |$ . Therefore, the maximum subset $𝑅$ contains $𝑟 𝑚$ , the request with the earliest finish time.

We are given as input a set of $𝑛$ jobs, where job $𝑗$ has a processing time $𝑝 𝑗$ and a deadline $𝑑 𝑗$ . Recall the definition of completion times $𝐶 𝑗$ from the video lectures. Given a schedule (i.e., an ordering of the jobs), we define the lateness $𝑙 𝑗$ of job $𝑗$ as the amount of time $𝐶 𝑗 - 𝑑 𝑗$ after its deadline that the job completes, or as $0$ if $𝐶 𝑗 \leq 𝑑 𝑗$ . Our goal is to minimize the maximum lateness, $m a x 𝑗 𝑙 𝑗$ .

Which of the following greedy rules produces an ordering that minimizes the maximum lateness? You can assume that all processing times and deadlines are distinct.

None of the other answers are correct.

Schedule the requests in increasing order of deadline $𝑑 𝑗$

Schedule the requests in increasing order of processing time $𝑝 𝑗$

Schedule the requests in increasing order of the product $𝑑 𝑗 \times 𝑝 𝑗$

ANSWER: Let $𝑆$ be a sequence in increasing order of processing time $𝑝 𝑗$ . Let the position of the job with the maximum lateness be $𝑗$ . If we swap job at $𝑗$ with the one at $𝑗 - 1$ , since $𝐶 𝑗 - 1 < 𝐶 𝑗$ , we get an even lower value for lateness. Thus, option 3 is incorrect.

By similar argument, option 4 is incorrect.

Let $𝑆$ be a sequence in increasing order of deadline $𝑑 𝑗$ . If we swap job at $𝑗$ with the one at $𝑗 - 1$ , the lateness for the new job at position $𝑗$ increases. Thus, the swap makes the sequence worse, and hence, the sequence is optimal to begin with.

Consider an undirected graph $𝐺 = (𝑉, 𝐸)$ where every edge $𝑒 \in 𝐸$ has a given cost $𝑐 𝑒$ . Assume that all edge costs are positive and distinct. Let $𝑇$ be a minimum spanning tree of $𝐺$ and $𝑃$ a shortest path from the vertex $𝑠$ to the vertex $𝑡$ . Now suppose that the cost of every edge $𝑒$ of $𝐺$ is increased by $1$ and becomes $𝑐 𝑒 + 1$ . Call this new graph $𝐺'$ . Which of the following is true about $𝐺'$ ?

$𝑇$ may not be a minimum spanning tree and $𝑃$ may not be a shortest $𝑠 - 𝑡$ path.

$𝑇$ may not be a minimum spanning tree but $𝑃$ is always a shortest $𝑠 - 𝑡$ path.

$𝑇$ is always a minimum spanning tree and $𝑃$ is always a shortest $𝑠 - 𝑡$ path.

$𝑇$ must be a minimum spanning tree but $𝑃$ may not be a shortest $𝑠 - 𝑡$ path.

ANSWER: Since Prim’s MST algorithm picks the edge with the lowest cost at each iteration, increasing the cost of every edge by $1$ wouldn’t change anything. However, the shortest path may change. Consider the graph $𝐷 7 \leftarrow 𝐴 2 \to 𝐵 2 \to 𝐶 2 \to 𝐷$ . The shortest path from $𝐴$ to $𝐷$ is $𝐴 \to 𝐵 \to 𝐶 \to 𝐷$ . Adding $1$ to every edge gives us the new graph $𝐷 8 \leftarrow 𝐴 3 \to 𝐵 3 \to 𝐶 3 \to 𝐷$ . Now $𝐴 \to 𝐵 \to 𝐶 \to 𝐷$ is no longer the shortest path between $𝐴$ and $𝐷$ . Thus, option 4 is correct, and the other ones are not.

Suppose $𝑇$ is a minimum spanning tree of the connected graph $𝐺$ . Let $𝐻$ be a connected induced subgraph of $𝐺$ . (I.e., $𝐻$ is obtained from $𝐺$ by taking some subset $𝑆 \subseteq 𝑉$ of vertices, and taking all edges of $𝐸$ that have both endpoints in $𝑆$ . Also, assume $𝐻$ is connected.) Which of the following is true about the edges of $𝑇$ that lie in $𝐻$ ? You can assume that edge costs are distinct, if you wish. [Choose the strongest true statement.]

For every $𝐺$ and $𝐻$ , these edges form a minimum spanning tree of $𝐻$

For every $𝐺$ and $𝐻$ , these edges are contained in some minimum spanning tree of $𝐻$

For every $𝐺$ and $𝐻$ and spanning tree $𝑇 𝐻$ of $𝐻$ , at least one of these edges is missing from $𝑇 𝐻$

For every $𝐺$ and $𝐻$ , these edges form a spanning tree (but not necessary minimum-cost) of $𝐻$

ANSWER: Consider a triangle graph $𝐺 = 𝐶 3 \leftarrow 𝐴 1 \to 𝐵 1 \to 𝐶; ∴ 𝑇 = (𝐴, 𝐵), (𝐵, 𝐶)$ . If $𝐻 = (𝐴, 𝐶), 𝑇 \cap 𝐻 = \emptyset$ , which rules out options 1 and 4.

Option 2 is correct. To prove it, let’s establish the Light-Edge Property of a MST.

Light-Edge Property: Let G = (V, E) be a connected undirected weighted graph with distinct edge weights. For any cut of G, the minimum weight edge that crosses the cut is in the minimum spanning tree T of G.

Proof: Suppose $𝑒 (𝑣, 𝑤) \in 𝐸, 𝑒 \notin 𝑇$ be the minimum weight edge. If we take a cut $(𝐴, 𝐵) s . t . 𝑣 \in 𝐴, 𝑤 \in 𝐵$ , then there must be another edge $𝑒' \in 𝑇, 𝑒' \neq 𝑒$ that connects $𝑣$ and $𝑤$ (since by definition $𝑇$ is a connected subgraph). Let $𝑇' = 𝑇 - {𝑒'} \cup {𝑒}$ ; since, $𝑤 𝑒 𝑖 𝑔 ℎ 𝑡 (𝑒') > 𝑤 𝑒 𝑖 𝑔 ℎ 𝑡 (𝑒), 𝑤 𝑒 𝑖 𝑔 ℎ 𝑡 (𝑇') < 𝑤 𝑒 𝑖 𝑔 ℎ 𝑡 (𝑇)$ . Since $𝑇$ is a MST, this brings us to a contradiction, and hence $𝑒 \notin 𝑇$ cannot be true.

Back to the original question, suppose $𝑇'$ be a MST of $𝐻$ and an edge $𝑒 \in 𝑇 \cap 𝐻, 𝑒 \notin 𝑇'$ . Arguing on the same lines as the Light-Edge Property, we can show that this contradicts the assumption $𝑇$ is a MST, and $𝑒$ must be in $𝑇'$ . Since $𝑒$ is an arbitrary edge, all edges in $𝑇 \cap 𝐻$ must be included in $𝑇'$ .

Since option 2 is correct, option 3 is not.

Consider an undirected graph $𝐺 = (𝑉, 𝐸)$ where edge $𝑒 \in 𝐸$ has cost $𝑐 𝑒$ . A minimum bottleneck spanning tree $𝑇$ is a spanning tree that minimizes the maximum edge cost $m a x 𝑒 \in 𝑇 𝑐 𝑒$ . Which of the following statements is true? Assume that the edge costs are distinct.

A minimum bottleneck spanning tree is not always a minimum spanning tree and a minimum spanning tree is not always a minimum bottleneck spanning tree.

A minimum bottleneck spanning tree is always a minimum spanning tree and a minimum spanning tree is always a minimum bottleneck spanning tree.

A minimum bottleneck spanning tree is always a minimum spanning tree but a minimum spanning tree is not always a minimum bottleneck spanning tree.

A minimum bottleneck spanning tree is not always a minimum spanning tree, but a minimum spanning tree is always a minimum bottleneck spanning tree.

ANSWER: Recall the Light-Edge Property; it implies that every other spanning tree has maximum edge cost at least as large. Therefore, a MST is also a minimum bottleneck spanning tree. But the reverse is not true; to see that, consider the graph $𝐺 = 𝐶 4 \leftarrow 𝐴 4 \to 𝐵 - 1 ⟶ 𝐶; 𝑀 𝑆 𝑇 (𝐺) = {(𝐴, 𝐵), (𝐵, 𝐶)}$ . Consider the spanning tree ${(𝐴, 𝐵), (𝐴, 𝐶)}$ ; it doesn’t increase the bottleneck ( $4$ ), and hence is a minimum bottleneck spanning tree, but isn’t a MST.

In this problem you are given as input a graph $𝑇 = (𝑉, 𝐸)$ that is a tree (that is, $𝑇$ is undirected, connected, and acyclic). A perfect matching of $𝑇$ is a subset $𝐹 \subset 𝐸$ of edges such that every vertex $𝑣 \in 𝑉$ is the endpoint of exactly one edge of $𝐹$ . Equivalently, $𝐹$ matches each vertex of $𝑇$ with exactly one other vertex of $𝑇$ . For example, a path graph has a perfect matching if and only if it has an even number of vertices.

Consider the following two algorithms that attempt to decide whether or not a given tree has a perfect matching. The degree of a vertex in a graph is the number of edges incident to it. (The two algorithms differ only in the choice of $𝑣$ in line 5.)

Algorithm A:

While T has at least one vertex:
 If T has no edges:
   halt and output "T has no perfect matching."
 Else:
   Let v be a vertex of T with maximum degree.
   Choose an arbitrary edge e incident to v.
   Delete e and its two endpoints from T.
[end of while loop]
Halt and output "T has a perfect matching."

Algorithm B:

While T has at least one vertex:
 If T has no edges:
   halt and output "T has no perfect matching."
 Else:
   Let v be a vertex of T with minimum non-zero degree.
   Choose an arbitrary edge e incident to v.
   Delete e and its two endpoints from T.
[end of while loop]
Halt and output "T has a perfect matching."

Is either algorithm correct?

Algorithm A always correctly determines whether or not a given tree graph has a perfect matching; algorithm B does not.

Neither algorithm always correctly determines whether or not a given tree graph has a perfect matching.

Both algorithms always correctly determine whether or not a given tree graph has a perfect matching.

Algorithm B always correctly determines whether or not a given tree graph has a perfect matching; algorithm A does not.

ANSWER: The algorithms are understated: When a vertex is deleted, all edges incident to that vertex are also deleted, otherwise we’re left with dangling edges.

Consider the path tree $𝐴 - 𝐵 - 𝐶 - 𝐷$ . Algo A chooses vertex $𝐵$ , and say, edge $(𝐵, 𝐶)$ . After deleting vertices $𝐵$ and $𝐶$ , and all the edges, we’re left with vertices $𝐴$ and $𝐷$ with no edges. Algo A halts, and incorrectly declares that $𝑇$ doesn’t have perfect matching (it does, ${(𝐴, 𝐵), (𝐶, 𝐷)}$ ).

Lets prove the correctness of algo B by induction. For $| 𝑉 | = 1$ , it correctly identifies that $𝑇$ doesn’t have perfect matching. For $| 𝑉 | = 2$ , it correctly identifies that $𝑇$ has perfect matching. Clearly, for $𝑇$ to have perfect matching, $| 𝑉 |$ must be even. Assume algo B works for $| 𝑉 | = 𝑘$ . Let us add a new vertex $𝑣$ and a new edge $(𝑣, 𝑤)$ to $𝑇$ , where $𝑤$ is some existing vertex in $𝑇$ . Clearly, for $𝑇$ to have perfect matching, it must include edge $(𝑣, 𝑤)$ (since that’s the only way to match vertex $𝑣$ ). By construction, algo B picks $𝑣$ and removes edge $(𝑣, 𝑤)$ in some iteration, leaving $| 𝑉 | = 𝑘 - 1$ , which by inductive hypothesis, is correctly solved by algo B.

Therefore, algo B is correct.

Share on

X Facebook LinkedIn Bluesky

Problem Set 1

Share on

Leave a comment

You may also enjoy

Signing Artifacts for Publishing to Maven Central Repository

grPC Health Checks on Kubernetes with Spring Boot Actuator

Task Scheduling

Couchbase on Kubernetes