Solutions to Kleinberg & Tardos’s Algorithm Design

False. Take \(n = 2\) with

\begin{equation*} \begin{aligned} m_1 &: w_1 \succ w_2, & \qquad w_1 &: m_2 \succ m_1,\\ m_2 &: w_2 \succ w_1, & \qquad w_2 &: m_1 \succ m_2. \end{aligned} \end{equation*}

The first choices of the men are \(m_1 \to w_1\), \(m_2 \to w_2\), and the first choices of the women are \(w_1 \to m_2\), \(w_2 \to m_1\); no man and woman rank each other first, so no matching, stable or not, contains such a pair.

True. Let \(S\) be a perfect matching with \((m,w) \notin S\), say \((m,w^{\prime}), (m^{\prime},w) \in S\) with \(w^{\prime} \ne w\) and \(m^{\prime} \ne m\). Since \(w\) is first on \(m\)’s list and \(m\) is first on \(w\)’s list,

\begin{equation*} w \succ_m w^{\prime} \quad\text{and}\quad m \succ_w m^{\prime}, \end{equation*}

so \((m,w)\) is an instability with respect to \(S\) and \(S\) is not stable. Hence every stable matching contains \((m,w)\).

(b): take \(n = 2\), network \(\mathcal{A}\) with shows of ratings \(1\) and \(3\), network \(\mathcal{B}\) with shows of ratings \(2\) and \(4\).

A pair \((S,T)\) only matters through which show of \(\mathcal{A}\) faces which show of \(\mathcal{B}\), and with \(n = 2\) there are two such pairings; either network, by swapping its own two shows, switches to the other pairing.

(i) \(3\) vs \(2\) and \(1\) vs \(4\): each network wins one slot. Network \(\mathcal{B}\) swaps, giving \(3\) vs \(4\) and \(1\) vs \(2\), and wins \(2 > 1\) slots. Not stable.

(ii) \(3\) vs \(4\) and \(1\) vs \(2\): \(\mathcal{A}\) wins \(0\) slots. Network \(\mathcal{A}\) swaps, giving \(3\) vs \(2\) and \(1\) vs \(4\), and wins \(1 > 0\) slots. Not stable.

Run Gale-Shapley with the hospitals proposing: a hospital with an open position offers it to the best student it has not yet offered to, and a student holds the best offer received so far. Let hospital \(h\) have \(c_h \ge 1\) positions, with \(\sum_h c_h < n\).

all students unassigned; every hospital has all positions open
while some hospital h has an open position
      and has not yet offered to every student:
    s = highest-ranked student on h's list not yet offered by h
    h offers to s
    if s is unassigned: assign s to h
    else if s prefers h to current hospital h2:
        assign s to h   (h2 regains one open position)
    else: s rejects h
return the assignment

Termination. Each iteration is an offer of some \(h\) to some \(s\), and no pair repeats, so there are at most \(mn\) iterations.

As in (1.1), once a student receives an offer she stays assigned and her hospital only improves; each hospital offers in decreasing order of its list.

All positions filled. Suppose \(h\) has an open position at the end. The loop stopped, so \(h\) has offered to all \(n\) students, and then all \(n\) students are assigned. That needs \(n \le \sum_h c_h\) positions, contradicting \(\sum_h c_h < n\).

No instability of the first type. Suppose \(s\) is at \(h\), \(s^{\prime}\) is unassigned, and \(h\) prefers \(s^{\prime}\) to \(s\). Then \(h\) offered to \(s\), so it offered to \(s^{\prime}\) earlier. After that \(s^{\prime}\) is assigned forever, a contradiction.

No instability of the second type. Suppose \(s\) is at \(h\), \(s^{\prime}\) is at \(h^{\prime} \ne h\), \(h\) prefers \(s^{\prime}\) to \(s\), and \(s^{\prime}\) prefers \(h\) to \(h^{\prime}\). As before, \(h\) offered to \(s^{\prime}\). From then on, the hospital \(s^{\prime}\) holds is \(h\) or one she prefers to \(h\). So her final hospital \(h^{\prime}\) is not worse than \(h\), a contradiction.

Running time. Store the students’ rankings as inverse arrays \(\mathrm{rank}_s[h]\) and keep a list of hospitals with open positions, as in Section 2.3. Each iteration then costs \(O(1)\), so the algorithm takes \(O(mn)\) time after \(O(mn)\) preprocessing.

(a) Yes. Break every tie arbitrarily, which gives strict preference lists, and run Gale-Shapley on the resulting instance. By (1.5) and (1.6) it returns a perfect matching \(S\) that is stable for the strict lists. Suppose \((m,w)\) were a strong instability in \(S\), with partners \(w^{\prime}\) and \(m^{\prime}\). Then \(m\) strictly prefers \(w\) to \(w^{\prime}\) and \(w\) strictly prefers \(m\) to \(m^{\prime}\) in the original lists. Breaking ties keeps every strict preference, so the same holds in the strict lists, and \((m,w)\) is an instability there. This contradicts (1.6). The running time is that of Gale-Shapley, \(O(n^2)\) (Section 2.3), plus \(O(n^2)\) for breaking ties.

(b) No. Take \(n = 2\) with

\begin{equation*} m_1, m_2 : w_1 \succ w_2, \qquad w_1, w_2 : m_1 \sim m_2, \end{equation*}

where \(\sim\) means indifferent: both men strictly prefer \(w_1\), and both women are indifferent. There are two perfect matchings:

(i) \(\{(m_1,w_1),(m_2,w_2)\}\): \(m_2\) prefers \(w_1\) to \(w_2\), and \(w_1\) is indifferent between \(m_2\) and \(m_1\). So \((m_2,w_1)\) is a weak instability.

(ii) \(\{(m_1,w_2),(m_2,w_1)\}\): \(m_1\) prefers \(w_1\) to \(w_2\), and \(w_1\) is indifferent between \(m_1\) and \(m_2\). So \((m_1,w_1)\) is a weak instability.

Run Gale-Shapley with ships as the proposing side and ports as the other: each ship ranks the ports in the order it visits them (earliest first), and each port ranks the ships in reverse order of their visits (latest visitor first); if ship \(S\) is matched to port \(P\), it stops at \(P\) on the day \(d(S,P)\) it is scheduled there.

By (1.5) and (1.6) this produces a perfect, stable matching, so every ship gets a distinct stopping port. Suppose two ships are in the same port \(P\) on day \(t\) in the truncated schedules.

(i) Both are moving: then both are following their original schedules on day \(t\), contradicting the original \((\dagger)\).

(ii) Both are stopped: then both are matched to \(P\), impossible in a matching.

(iii) Ship \(S\) is stopped at \(P\) (so \(d(S,P)\le t\)) and ship \(S^{\prime}\), matched to \(P^{\prime}\ne P\), is still moving and visits \(P\) on day \(t=d(S^{\prime},P)\). By \((\dagger)\), \(d(S^{\prime},P)\ne d(S,P)\), so

\begin{equation*} \begin{aligned} d(S^{\prime},P) &> d(S,P) &&\Rightarrow\ P \text{ prefers } S^{\prime} \text{ to } S,\\ d(S^{\prime},P) &< d(S^{\prime},P^{\prime}) &&\Rightarrow\ S^{\prime} \text{ prefers } P \text{ to } P^{\prime}, \end{aligned} \end{equation*}

the second because \(S^{\prime}\) has not yet reached its stop. So \((S^{\prime},P)\) is an instability, contradicting (1.6).

Hence the truncations satisfy \((\dagger)\), and in particular they always exist. Building the preference lists takes one scan of the schedules, \(O(mn)\) (sorting each ship’s ports and each port’s visitors by day is a bucket pass over the \(m\) days), and Gale-Shapley runs in \(O(n^2)\) (Section 2.3), for \(O(mn)\) total.

Run Gale-Shapley with inputs proposing to outputs: each input ranks the outputs in the order it meets them (most upstream first), and each output ranks the inputs in reverse order of meeting them (most downstream first); switch input \(i\) onto its partner output at their common junction box \(B_{ij}\).

By (1.5) and (1.6) the result is a perfect, stable matching, so each input goes to a different output. A box \(B_{ij^{\prime}}\) lies on exactly one input and one output, so two streams can meet there only if one arrives along Input \(i\) and the other along Output \(j^{\prime}\). Thus suppose \(i\) is switched onto \(j\ne j^{\prime}\) with \(B_{ij^{\prime}}\) upstream of \(B_{ij}\) on Input \(i\), and \(i^{\prime}\ne i\) is switched onto \(j^{\prime}\) with \(B_{ij^{\prime}}\) downstream of \(B_{i^{\prime}j^{\prime}}\) on Output \(j^{\prime}\). Then

\begin{equation*} \begin{aligned} B_{ij^{\prime}} \text{ upstream of } B_{ij} \text{ on Input } i &\Rightarrow\ i \text{ prefers } j^{\prime} \text{ to } j,\\ B_{ij^{\prime}} \text{ downstream of } B_{i^{\prime}j^{\prime}} \text{ on Output } j^{\prime} &\Rightarrow\ j^{\prime} \text{ prefers } i \text{ to } i^{\prime}, \end{aligned} \end{equation*}

so \((i,j^{\prime})\) is an instability, contradicting (1.6). Hence no junction box carries two streams, and a valid switching always exists.

Reading off the \(2n\) preference lists from the wiring takes \(O(n^2)\), and Gale-Shapley runs in \(O(n^2)\) (Section 2.3), so the algorithm runs in \(O(n^2)\) time.

(b) holds: a woman can do better by lying. Take three men and three women with these preference lists:

Here \(w=w_1\), \(m=m_1\), \(m^{\prime}=m_2\), \(m^{\prime\prime}=m_3\). By (1.7) every execution of Gale-Shapley gives the same matching, so any proposal order may be used.

Truthful lists. \(m_1\) gets \(w_1\); \(m_2\) is rejected by \(w_1\) and gets \(w_2\); \(m_3\) proposes to \(w_2\), who trades \(m_2\) for \(m_3\); \(m_2\) goes to \(w_3\). The output is

\begin{equation*} \{(m_1,w_1),\ (m_3,w_2),\ (m_2,w_3)\}, \end{equation*}

so \(w_1\) gets \(m_1\).

\(w_1\) claims \(m_3 > m_2 > m_1\). \(m_1\) gets \(w_1\); \(m_2\) proposes to \(w_1\), who now trades \(m_1\) for \(m_2\); \(m_1\) gets \(w_2\); \(m_3\) is rejected by \(w_2\) (she holds \(m_1\)) and proposes to \(w_1\), who trades \(m_2\) for \(m_3\); \(m_2\) is rejected by \(w_2\) and gets \(w_3\). The output is

\begin{equation*} \{(m_3,w_1),\ (m_1,w_2),\ (m_2,w_3)\}, \end{equation*}

so \(w_1\) gets \(m_3\), whom she truly prefers to both \(m_1\) and \(m_2\).

Doubling multiplies the polynomial times by a constant and squares the exponential; adding one multiplies only the exponential by a constant. Writing \(T(n)\) for the running time (\(\log\) to base 2):

Each entry is a direct expansion, e.g.

\begin{equation*} \begin{aligned} (2n)\log(2n) &= 2n(\log n + 1) = 2\,n\log n + 2n,\\ 2^{2n} &= (2^n)^2, \qquad 2^{n+1} = 2\cdot 2^n . \end{aligned} \end{equation*}

So under doubling, (a) and (c) become 4 times slower, (b) 8 times slower, (d) slightly more than twice as slow (by the factor \(2(1 + 1/\log n)\)), and (e) becomes \(2^n\) times slower, i.e. its running time is squared. Under \(n \mapsto n+1\), (a)-(d) slow down by the additive amounts in the table (a factor tending to 1), and (e) becomes twice as slow.

The budget is \(N = 3600 \cdot 10^{10} = 3.6\times 10^{13}\) operations, and each answer is the largest \(n\) with \(T(n) \le N\) (taking \(\log = \log_2\)).

(a) \(n^2 \le 3.6\times 10^{13} \iff n \le 6\times 10^6\), so \(n = 6{,}000{,}000\).

(b) \(33019^3 \approx 3.59991\times 10^{13} \le N < 33020^3\), so \(n = 33{,}019\).

(c) \(100n^2 \le N \iff n^2 \le 3.6\times 10^{11} \iff n \le 6\times 10^5\), so \(n = 600{,}000\).

(d) \(n\log_2 n\) is increasing, and

\begin{equation*} \begin{aligned} 906316482853 \cdot \log_2 906316482853 &\approx 3.6\times 10^{13} - 7 \le N,\\ 906316482854 \cdot \log_2 906316482854 &\approx 3.6\times 10^{13} + 34 > N, \end{aligned} \end{equation*}

so \(n = 906{,}316{,}482{,}853 \approx 9.06\times 10^{11}\).

(e) \(2^{45} \approx 3.52\times 10^{13} \le N < 2^{46} \approx 7.04\times 10^{13}\), so \(n = 45\).

(f) \(2^{2^n} \le N \iff 2^n \le \log_2 N \approx 45.03\), and \(2^5 = 32 \le 45.03 < 64 = 2^6\), so \(n = 5\).

The order is \(f_2,\ f_3,\ f_6,\ f_1,\ f_4,\ f_5\), that is,

\begin{equation*} \sqrt{2n},\quad n+10,\quad n^2\log n,\quad n^{2.5},\quad 10^n,\quad 100^n . \end{equation*}

Each consecutive pair is certified as follows (for \(n \ge 2\)):

\begin{equation*} \begin{aligned} \sqrt{2n} &\le 2n \le 2(n+10),\\ n + 10 &\le 11n \le 11\, n^2 \log n,\\ n^2 \log n &= n^2 \cdot O(n^{0.5}) = O(n^{2.5}) &&\text{by (2.8) with } x = 0.5,\\ n^{2.5} &= O(10^n) &&\text{by (2.9) with } r = 10,\ d = 2.5,\\ 10^n &\le 100^n . \end{aligned} \end{equation*}

The order is \(g_1,\ g_3,\ g_4,\ g_5,\ g_2,\ g_7,\ g_6\), that is,

\begin{equation*} 2^{\sqrt{\log n}},\quad n(\log n)^3,\quad n^{4/3},\quad n^{\log n},\quad 2^n,\quad 2^{n^2},\quad 2^{2^n} . \end{equation*}

Write everything with \(\log = \log_2\), so \(n = 2^{\log n}\) and \(n^{\log n} = 2^{(\log n)^2}\). Each consecutive pair is certified as follows:

\begin{equation*} \begin{aligned} 2^{\sqrt{\log n}} &\le 2^{\log n} = n \le n(\log n)^3 &&(n \ge 2,\ \text{as } \log n \ge 1),\\ n(\log n)^3 &= n \cdot O(n^{1/3}) = O(n^{4/3}) &&\text{by (2.8) with } x = 1/9, \text{ cubed},\\ n^{4/3} &= 2^{\frac43 \log n} \le 2^{(\log n)^2} = n^{\log n} &&(n \ge 4,\ \text{as } \log n \ge 2),\\ n^{\log n} &= 2^{(\log n)^2} \le 2^n &&(n \ge 16,\ \text{as } (\log n)^2 \le n),\\ 2^n &\le 2^{n^2} &&(n \ge 1),\\ 2^{n^2} &\le 2^{2^n} &&(n \ge 4,\ \text{as } n^2 \le 2^n). \end{aligned} \end{equation*}

For \((\log n)^2 \le n\), i.e. \(\log_2 x \le \sqrt{x}\) for \(x \ge 16\): equality holds at \(x = 16\), and

\begin{equation*} \frac{d}{dx}\bigl(\sqrt{x} - \log_2 x\bigr) = \frac{1}{2\sqrt{x}} - \frac{1}{x\ln 2} > 0 \iff \sqrt{x} > \frac{2}{\ln 2} \approx 2.89 . \end{equation*}

For \(n^2 \le 2^n\) (\(n \ge 4\)): it holds at \(n = 4\), and \((n+1)^2 \le 2n^2\) for \(n \ge 3\) carries the induction.

(a) False. Take \(f(n) = 2\) and \(g(n) = 1\): then \(f(n) \le 2g(n)\), so \(f = O(g)\), but

\begin{equation*} \log_2 f(n) = 1 \le c \cdot 0 = c\log_2 g(n) \end{equation*}

fails for every \(c\) and every \(n\), so \(\log_2 f\) is not \(O(\log_2 g)\).

(b) False. Take \(f(n) = 2n\) and \(g(n) = n\): then \(f = O(g)\) with \(c = 2\), but

\begin{equation*} \frac{2^{f(n)}}{2^{g(n)}} = \frac{4^n}{2^n} = 2^n \to \infty, \end{equation*}

so no constant \(c\) gives \(2^{2n} \le c\,2^n\) for all large \(n\).

(c) True. There are \(c > 0\) and \(n_0\) with \(0 \le f(n) \le c\,g(n)\) for all \(n \ge n_0\) (running times are nonnegative), and squaring preserves inequalities between nonnegative numbers, so

\begin{equation*} f(n)^2 \le c^2\, g(n)^2 \qquad (n \ge n_0), \end{equation*}

i.e. \(f^2 = O(g^2)\) with constant \(c^2\).

Take \(f(n) = n^3\). Summing \(A[i]\) through \(A[j]\) touches \(j-i+1\) entries, so (up to the constant cost of each read, addition, and store) the pair \((i,j)\) costs \(j-i+1\) steps. Writing \(d = j-i\), there are \(n-d\) pairs with difference \(d\), so the total work is

\begin{equation*} \begin{aligned} T(n) &= \sum_{1 \le i < j \le n} (j-i+1) = \sum_{d=1}^{n-1} (n-d)(d+1) \\ &= \frac{(n-1)\,n\,(n+4)}{6}. \end{aligned} \end{equation*}

(The closed form is a routine sum of \(n\sum d\) and \(\sum d^2\). Check!)

(a) Because \((n-1)(n+4) \le n \cdot 5n\), we get \(T(n) \le \tfrac{5}{6} n^3\), and therefore \(T(n) = O(n^3)\).

(b) For \(n \ge 2\) we have \(3n \ge 4\), so \((n-1)(n+4) = n^2 + 3n - 4 \ge n^2\). Hence \(T(n) \ge \tfrac16 n^3\), and \(T(n) = \Omega(n^3)\). Together with (a), \(T(n) = \Theta(n^3)\).

(c) Reuse the previous sum: \(B[i,j] = B[i,j-1] + A[j]\), which costs one addition per entry.

For i = 1, 2, ..., n
  s = A[i]
  For j = i+1, i+2, ..., n
    s = s + A[j]
    Store s in B[i, j]
  Endfor
Endfor

By induction on \(j\) (starting from \(s = A[i]\), each iteration appends exactly \(A[j]\)), \(s = A[i] + \cdots + A[j]\) when \(B[i,j]\) is stored. For a fixed \(i\) the inner loop does \(O(n-i)\) work, so the total is \(\sum_i O(n-i+1) = O(n^2)\). With \(g(n) = n^2\) we get \(g(n)/f(n) = 1/n \to 0\).

\(f(n) = O(\sqrt{n})\): write each of the \(k\) new lines once, followed by a constant-length singing instruction.

Let the song have \(k\) verses with new lines \(\ell_1, \dots, \ell_k\) of lengths \(1 \le |\ell_i| \le c\), where verse \(j\) is \(\ell_j, \ell_{j-1}, \dots, \ell_1\). The script is

Lines: l_1, l_2, ..., l_k
For j = 1, 2, ..., k:
    sing l_j, l_(j-1), ..., l_1

which reproduces the song exactly, and whose length is \(\sum_i |\ell_i| + O(1) \le ck + O(1)\) (the instruction is a fixed text; even writing the number \(k\) explicitly adds only \(O(\log k)\)). Since every line has at least one word, verse \(j\) has at least \(j\) words, so

\begin{equation*} \begin{aligned} n &= \sum_{j=1}^{k} \sum_{i=1}^{j} |\ell_i| \ \ge\ \sum_{j=1}^{k} j = \frac{k(k+1)}{2} \ \ge\ \frac{k^2}{2}, \\ \text{hence}\quad k &\le \sqrt{2n}. \end{aligned} \end{equation*}

Therefore the script has length at most

\begin{equation*} f(n) = c\sqrt{2n} + O(1) = O(\sqrt{n}). \end{equation*}

This is the best possible in general. Each verse has at most \(cj\) words, so

\begin{equation*} \begin{aligned} n &\le c\,\frac{k(k+1)}{2} \le c\,k^2 \quad (k \ge 1), \\ \text{hence}\quad k &\ge \sqrt{n/c}, \end{aligned} \end{equation*}

and when the \(k\) new lines are arbitrary (distinct, unrelated words) any script that determines the song must spell out each of them at least once, so its length is at least \(k \ge \sqrt{n/c} = \Omega(\sqrt{n})\). Thus the cumulative script achieves the optimal growth rate \(f(n) = \Theta(\sqrt{n})\).

Split the ladder into blocks of size about \(n^{(k-1)/k}\), use the first jar to find the block by dropping from the top rung of each block in turn, and then solve that block recursively with the remaining \(k-1\) jars; this gives \(f_k(n) = \Theta(n^{1/k})\), and in particular \(f_2(n) \le 2\lceil\sqrt n\,\rceil\).

Label the possible answers \(0,1,\dots,n\), where \(0\) means that rung \(1\) already breaks the jar. Fix \(r = \lceil n^{1/k}\rceil\), so \(r^k \ge n\). The strategy \(S_j\) uses \(j\) jars on a stretch of \(m \le r^j\) consecutive unknown rungs \(\ell+1,\dots,\ell+m\), where rung \(\ell\) is already known to be safe:

S_j(l, m):                       # rungs l+1..l+m unknown, rung l safe
  if j = 1: drop at l+1, l+2, ... until a break; answer = last safe rung
  s = r^(j-1);  x = l + s
  while x <= l + m:
      drop at x
      if it breaks: return S_(j-1)(x - s, s - 1)
      x = x + s
  return S_(j-1)(x - s, l + m - (x - s))

The full strategy is \(S_k(0,n)\). For \(k=2\) the first jar is dropped at rungs \(r, 2r, 3r, \dots\) with \(r = \lceil\sqrt n\,\rceil\), and the second jar scans upward one rung at a time inside the single block of fewer than \(r\) rungs that is left.

Correctness and the jar budget. We use induction on \(j\). For \(j=1\) this is the linear scan from the statement: it is correct, takes at most \(m \le r\) drops and breaks at most one jar. For \(j \ge 2\), suppose the first break is at rung \(x\). Then rung \(x-s\) is safe (it is either \(\ell\) or a rung that survived a drop), so the answer lies in \([x-s, x-1]\), and the \(s-1 < r^{j-1}\) rungs \(x-s+1,\dots,x-1\) are handed to \(S_{j-1}\). If there is no break, the answer lies at or above the last rung tested, \(x - s\), and fewer than \(s = r^{j-1}\) rungs remain above it. In both cases the hypothesis of \(S_{j-1}\) holds. The loop breaks at most one jar, because it stops at the first break, and \(S_{j-1}\) breaks at most \(j-1\) by induction. So \(S_k\) is correct and breaks at most \(k\) jars.

Upper bound. The loop tests multiples of \(s = r^{j-1}\) inside a stretch of \(m \le r^j\) rungs, so it makes at most \(m/s \le r\) drops. By induction, \(S_j\) therefore makes at most \(jr\) drops. Using \(\lceil y\rceil \le 2y\) for \(y \ge 1\),

\begin{equation*} f_k(n) \;\le\; k\lceil n^{1/k}\rceil \;\le\; 2k\, n^{1/k}. \end{equation*}

Lower bound. If the answer is \(n\), no jar ever breaks, and the top-level loop drops at every multiple of \(s = r^{k-1} \le (2n^{1/k})^{k-1}\) up to \(n\). Hence

\begin{equation*} f_k(n) \;\ge\; \Big\lfloor \frac{n}{s} \Big\rfloor \;\ge\; \frac{n^{1/k}}{2^{k-1}} - 1 . \end{equation*}

For \(k=1\) we have \(r=n\) and \(S_1\) is the plain scan, so \(f_1(n) = n\).

(a) For \(k=2\) the upper bound gives \(f_2(n) \le 2\lceil\sqrt n\,\rceil\), so \(f_2(n)/n \le 2(\sqrt n + 1)/n \to 0\).

(b) For \(k \ge 2\), combining the upper bound on \(f_k\) with the lower bound on \(f_{k-1}\) (for \(k=2\), use \(f_1(n)=n\) directly) gives

\begin{equation*} \begin{aligned} \frac{f_k(n)}{f_{k-1}(n)} &\le \frac{2k\, n^{1/k}}{n^{1/(k-1)}/2^{k-2} - 1} \\ &= \frac{2^{k-1} k\, n^{1/k - 1/(k-1)}}{1 - 2^{k-2} n^{-1/(k-1)}} \;\longrightarrow\; 0, \end{aligned} \end{equation*}

because \(1/k - 1/(k-1) < 0\) and the denominator tends to \(1\). So each \(f_k\) grows strictly more slowly than \(f_{k-1}\).

Six.

The only node with no incoming edge is \(a\) and the only node with no outgoing edge is \(f\), so every topological ordering starts with \(a\) and ends with \(f\). The four middle positions hold \(b,c,d,e\), subject only to \(b\) before \(c\) and \(d\) before \(e\) (there are no edges between \(\{b,c\}\) and \(\{d,e\}\)). Such an ordering is determined by choosing which two of the four middle positions hold \(b\) and \(c\), so the count is

\begin{equation*} \binom{4}{2}=6 : \end{equation*}

\begin{equation*} \begin{aligned} &a\,b\,c\,d\,e\,f, \quad a\,b\,d\,c\,e\,f, \quad a\,b\,d\,e\,c\,f,\\ &a\,d\,b\,c\,e\,f, \quad a\,d\,b\,e\,c\,f, \quad a\,d\,e\,b\,c\,f. \end{aligned} \end{equation*}

Run BFS from every undiscovered node, recording parents and layer numbers; the first time an edge \((u,v)\) is scanned with \(v\) already discovered and \(v\ne \mathrm{parent}(u)\), that edge is not a tree edge, and it closes the cycle formed with the two tree paths up to the lowest common ancestor of \(u\) and \(v\).

for each node s not yet discovered:
    discover s; layer(s) = 0; parent(s) = none; Q = [s]
    while Q nonempty:
        u = dequeue(Q)
        for each edge (u, v):
            if v not discovered:
                discover v; parent(v) = u; layer(v) = layer(u) + 1
                enqueue(Q, v)
            else if v != parent(u):
                x = u; y = v; P = [u]; R = [v]
                while layer(x) > layer(y): x = parent(x); append x to P
                while layer(y) > layer(x): y = parent(y); append y to R
                while x != y:
                    x = parent(x); append x to P
                    y = parent(y); append y to R
                output P followed by R reversed (without its last node w = x = y)
                stop
output "no cycle"

Correctness. (We take \(G\) simple, as in the book.) Every node is dequeued once, so every edge is scanned. Suppose the algorithm outputs “no cycle”. Then each scan of an edge \((u,v)\) found either \(v\) undiscovered, making \((u,v)\) a tree edge, or \(v=\mathrm{parent}(u)\), so \((u,v)\) is again a tree edge. Hence every edge of \(G\) lies in the BFS forest, so \(G\) is a forest and has no cycle.

Suppose the algorithm stops at edge \((u,v)\). This edge is not in the BFS forest: \(v\ne\mathrm{parent}(u)\) by the test, and \(u\ne\mathrm{parent}(v)\) because a child of \(u\) is discovered during the scan of its unique edge to \(u\), whereas \(v\) was already discovered when this edge was scanned. The parent pointers from \(u\) and \(v\) climb to the same BFS root, so the climb reaches their lowest common ancestor \(w\) (the first two loops equalize layers, the third climbs in lockstep until the pointers meet). The tree paths \(u\to w\) and \(v\to w\) share only \(w\), so

\begin{equation*} u \to \cdots \to w \to \cdots \to v \to u \end{equation*}

is a simple cycle; it has at least three nodes, since a cycle on two nodes would need \((u,v)\) to be a tree edge.

Running time. The BFS over all components takes \(O(m+n)\) by (3.11), and the cycle extraction runs once and climbs each tree path at most once, costing \(O(n)\). The total is \(O(m+n)\).

Run the \(O(m+n)\) implementation of Section 3.6 until the set \(S\) of active nodes with no active in-neighbours is empty; if all \(n\) nodes were deleted, output the deletion order, and otherwise walk backward along edges among the still-active nodes, exactly as in the proof of (3.19), until a node repeats, and output the cycle between the two visits.

build in-lists and out-lists; count(w) = indegree(w); S = {w : count(w) = 0}
while S nonempty:
    remove v from S; mark v deleted; append v to ORDER
    for each edge (v, w):
        count(w) = count(w) - 1; if count(w) = 0: add w to S
if |ORDER| = n: output ORDER
else:
    v = any active node; i = 0
    while v has no index:
        index(v) = i; WALK[i] = v; i = i + 1
        v = an active u with (u, v) an edge     (scan in-list of v)
    output WALK[index(v)], ..., WALK[i-1] in reverse order

Correctness. If \(|\mathrm{ORDER}|=n\), every node \(v\) was deleted while it had no edge from an active node, so every edge into \(v\) comes from a node deleted earlier; thus every edge points forward in ORDER and it is a topological ordering, certifying by (3.18) that \(G\) is a DAG.

Otherwise the set \(A\) of active nodes is nonempty and \(S=\emptyset\), so every \(v\in A\) has \(\mathrm{count}(v)\ge 1\), i.e. an incoming edge from a node of \(A\). Hence the backward walk never gets stuck and stays inside \(A\); since \(A\) is finite, some node \(v\) is reached a second time. If \(v=\mathrm{WALK}[j]\), the walk gives edges

\begin{equation*} \mathrm{WALK}[k+1]\to\mathrm{WALK}[k]\ \ (j\le k<i-1), \qquad \mathrm{WALK}[j]=v\to\mathrm{WALK}[i-1], \end{equation*}

so

\begin{equation*} \mathrm{WALK}[i-1]\to\mathrm{WALK}[i-2]\to\cdots\to\mathrm{WALK}[j]\to\mathrm{WALK}[i-1] \end{equation*}

is a directed cycle on the distinct nodes \(\mathrm{WALK}[j],\dots,\mathrm{WALK}[i-1]\) (a self-loop when \(j=i-1\)).

Running time. The first phase is the book’s \(O(m+n)\) implementation from Section 3.6. In the walk each node receives an index at most once, so each in-list is scanned at most once, costing \(O(m+n)\) in total; building the in-lists and outputting the cycle are also \(O(m+n)\).

Build the graph \(G\) on the \(n\) specimens with one edge per judgment, propagate labels by BFS from an arbitrary root of each component (a “same” edge copies the label, a “different” edge flips it), and then check every judgment against the labels: they are consistent if and only if every check passes.

for each specimen s not yet labeled:
    label(s) = A; Q = [s]
    while Q nonempty:
        u = dequeue(Q)
        for each judgment (u, v) with v not yet labeled:
            label(v) = label(u)        if (u, v) is "same"
            label(v) = other(label(u)) if (u, v) is "different"
            enqueue(Q, v)
for each judgment (i, j):
    if it is violated by label(i), label(j): output "inconsistent"; stop
output "consistent"

Correctness. If every check passes, the computed labeling satisfies all \(m\) judgments, so they are consistent. Conversely suppose some labeling \(L\) satisfies all judgments, and let \(C\) be a component of \(G\) with BFS root \(s\). Swapping \(A\) and \(B\) on \(C\) preserves every judgment (each judgment lies inside one component and depends only on whether its two labels agree), so we may assume \(L(s)=A=\mathrm{label}(s)\). Each node \(v\ne s\) of \(C\) receives its label from its BFS parent \(u\) across the judgment \((u,v)\), and \(L\) satisfies that judgment, so by induction on the BFS layer

\begin{equation*} L(u)=\mathrm{label}(u)\ \Rightarrow\ L(v)=\mathrm{label}(v). \end{equation*}

Hence \(\mathrm{label}=L\) on every component, so every check passes. The algorithm therefore reports “consistent” exactly when the judgments are consistent.

Running time. The labeling phase is BFS over all components of a graph with \(n\) nodes and \(m\) edges, \(O(m+n)\) by (3.11), and the check costs \(O(1)\) per judgment, for \(O(m+n)\) in total.

Induct on the number of nodes \(n\ge 1\): write \(t(T)\) for the number of nodes of \(T\) with two children and \(\ell(T)\) for its number of leaves; we show \(t(T)=\ell(T)-1\).

For \(n=1\) the root is a leaf, so \(t(T)=0=\ell(T)-1\). Let \(n\ge 2\), assume the claim for all binary trees with fewer than \(n\) nodes, and let \(r\) be the root of \(T\), which has one or two children. Every node other than \(r\) has the same children in \(T\) as in the subtree containing it, and \(r\) is not a leaf.

(i) \(r\) has one child, rooting a subtree \(T^{\prime}\) with \(n-1\) nodes. Since \(r\) has neither zero nor two children,

\begin{equation*} t(T)=t(T^{\prime})=\ell(T^{\prime})-1=\ell(T)-1. \end{equation*}

(ii) \(r\) has two children, rooting subtrees \(T_1,T_2\) with fewer than \(n\) nodes each. Then \(r\) is counted in \(t(T)\) and

\begin{equation*} \begin{aligned} t(T)&=t(T_1)+t(T_2)+1=(\ell(T_1)-1)+(\ell(T_2)-1)+1\\ &=\ell(T_1)+\ell(T_2)-1=\ell(T)-1. \end{aligned} \end{equation*}

This completes the induction.

A non-tree edge would have to join an ancestor to a descendant at least two levels below it (DFS), yet join nodes in adjacent or equal layers (BFS), which is impossible.

Let \(\mathrm{depth}(x)\) be the depth of \(x\) in \(T\) rooted at \(u\); since \(T\) is a BFS tree, \(x\) lies in layer \(L_{\mathrm{depth}(x)}\). Suppose \((x,y) \in E\) is not an edge of \(T\). Since \(T\) is a DFS tree, (3.7) says one endpoint, say \(x\), is an ancestor of \(y\); as \((x,y) \notin T\), \(y\) is not a child of \(x\), so \[ \mathrm{depth}(y) \ge \mathrm{depth}(x) + 2 . \] But since \(T\) is a BFS tree, (3.4) gives \(|\mathrm{depth}(x) - \mathrm{depth}(y)| \le 1\), a contradiction. Hence every edge of \(G\) is in \(T\), i.e. \(G = T\).

True.

Suppose \(G\) is not connected. Its connected components partition \(V\) (3.8) into at least two parts, so some component \(C\) has \(|C| \le n/2\). Take any \(x \in C\); every neighbour of \(x\) lies in \(C \setminus \{x\}\), so \[ \deg(x) \le |C| - 1 \le \tfrac{n}{2} - 1 < \tfrac{n}{2}, \] contradicting the hypothesis. Hence \(G\) is connected.

False: a huge clique with a long path hanging off it has \(\mathrm{apd} \le 2\) but arbitrarily large diameter.

For \(k \ge 1\) let \(N = 16k^2\) and let \(G_k\) consist of a complete graph on nodes \(a = c_1, c_2, \dots, c_N\) together with a path \(a, p_1, p_2, \dots, p_k\); so \(n = N + k\) and \(G_k\) is connected. Then \(\mathrm{dist}(p_k, c_2) = k + 1\) and no distance exceeds this, so \(\mathrm{diam}(G_k) = k+1\).

The \(\binom{N}{2}\) clique pairs have distance \(1\). The remaining pairs each contain some \(p_i\), so there are at most \(k n \le 2kN\) of them, each at distance at most \(k+1 \le 2k\). Using \(\binom{n}{2} \ge \binom{N}{2} = N(N-1)/2 \ge N^2/4\),

\begin{equation*} \begin{aligned} \mathrm{apd}(G_k) &\le \frac{\binom{N}{2}}{\binom{n}{2}} + \frac{2kN \cdot 2k}{\binom{n}{2}} \le 1 + \frac{4k^2 N}{N^2/4} \\ &= 1 + \frac{16k^2}{N} = 2 . \end{aligned} \end{equation*}

Hence \(\mathrm{diam}(G_k)/\mathrm{apd}(G_k) \ge (k+1)/2\), which exceeds any fixed \(c\) once \(k \ge 2c\).

Run BFS from \(s\); some layer strictly between \(s\) and \(t\) consists of a single node \(v\), and \(v\) is the required cut node.

If \(t\) is unreachable from \(s\), any \(v \ne s, t\) works; otherwise let \(d = \mathrm{dist}(s,t) > n/2\) and let \(L_0 = \{s\}, L_1, \dots\) be the BFS layers, so \(t \in L_d\) by (3.3). Each of \(L_1, \dots, L_{d-1}\) is nonempty (the \(i\)-th node of a shortest \(s\)-\(t\) path is at distance \(i\), hence in \(L_i\)). If each had at least two nodes, then \[ n \ge |L_0| + |L_d| + \sum_{i=1}^{d-1} |L_i| \ge 2 + 2(d-1) = 2d > n , \] a contradiction; so some \(L_i\) with \(1 \le i \le d-1\) equals \(\{v\}\), and \(v \ne s, t\).

Every node of an \(s\)-\(t\) path \(s = x_0, x_1, \dots, x_r = t\) lies in the component of \(s\), hence in some layer (3.3), and by (3.4) consecutive layer indices differ by at most \(1\). The indices go from \(0\) to \(d\) in steps of size at most \(1\), so some \(x_j \in L_i\), i.e. \(x_j = v\). Thus every \(s\)-\(t\) path uses \(v\), and \(G - v\) has no \(s\)-\(t\) path.

Algorithm. Run BFS from \(s\) recording each node’s layer (if \(t\) is unreached, return any \(v \ne s,t\)), count \(|L_i|\) for every \(i\), and return the unique node of any layer \(L_i\) with \(1 \le i \le d-1\) and \(|L_i| = 1\). BFS takes \(O(m+n)\) by (3.11), and the counting and scan take \(O(n)\).

Run BFS from \(v\) and set \(N(v) = 1\) and, for \(x \in L_j\) with \(j \ge 1\), \(N(x) = \sum N(y)\) over the neighbours \(y\) of \(x\) in \(L_{j-1}\); output \(N(w)\) (and \(0\) if \(w\) is never reached).

for each node x: layer[x] = undefined, N[x] = 0
layer[v] = 0; N[v] = 1; Q = queue containing v
while Q is not empty:
    x = Q.dequeue()
    for each neighbour y of x:
        if layer[y] is undefined:
            layer[y] = layer[x] + 1; Q.enqueue(y)
        if layer[y] == layer[x] + 1:
            N[y] = N[y] + N[x]
return N[w]

Correctness. Let \(P(x)\) be the number of shortest \(v\)-\(x\) paths. If \(x \in L_j\), \(j \ge 1\), the node of a shortest \(v\)-\(x\) path just before \(x\) is at distance exactly \(j-1\) from \(v\), so it is a neighbour \(y \in L_{j-1}\) of \(x\) (3.3), and the path minus \(x\) is a shortest \(v\)-\(y\) path; conversely a shortest \(v\)-\(y\) path followed by the edge \((y,x)\) is a \(v\)-\(x\) path of length \(j\). This bijection gives \[ P(x) = \sum_{y \in L_{j-1},\ (x,y) \in E} P(y), \qquad P(v) = 1, \] so \(N = P\) by induction on \(j\), provided each \(N[y]\) is final when \(y\) is dequeued. It is: the queue dequeues all of \(L_{j-1}\) before any node of \(L_j\) (BFS processes layers in order), and \(N[x]\) for \(x \in L_j\) only receives contributions from dequeued nodes of \(L_{j-1}\), one per edge.

Running time. This is BFS with \(O(1)\) extra work per edge scan, so \(O(m+n)\) by (3.11), counting each addition as one step.

Sweep the triples in time order, one block of equal timestamps at a time, and inside each block run BFS over that block’s communications starting from the machines already infected. (Equal timestamps need a whole block at once: the first example still infects \(C_3\) even if \((C_3, C_4, 8)\) is listed before \((C_2, C_4, 8)\).)

if x > y: return false
infected[1..n] = false; infected[a] = true
for each maximal block B of triples sharing one time t, in order:
    if t > y: stop
    if t < x: skip B
    H = graph on the endpoints of B, one edge per triple of B
    Q = endpoints of B that are infected
    BFS in H from all of Q; mark every node reached infected
return infected[b]

Correctness. Say \(C_c\) is infected by time \(t\) if there are computers \(C_a = C_{c_0}, C_{c_1}, \dots, C_{c_k} = C_c\) (\(k \ge 0\)) and triples joining \(C_{c_{l-1}}\) to \(C_{c_l}\) at times \(t_l\) with \[ x \le t_1 \le t_2 \le \dots \le t_k \le t . \] We show by induction over the blocks that, once all blocks with time at most \(t\) (and at least \(x\)) are processed, \(\text{infected}[c]\) holds exactly when \(C_c\) is infected by time \(t\). Before the first block only \(C_a\) is marked, which is the case \(k = 0\). Now take the block \(B\) at time \(t\), and let \(t^- < t\) be the previous processed time.

(i) Soundness. Each node newly marked in \(B\) is reached in \(H\) by a path \(u = v_0, v_1, \dots, v_r\) from some \(u\) that was already infected by time \(t^-\). Adding the \(r\) steps, all at time \(t \ge t^-\), to \(u\)’s sequence gives a valid sequence for \(v_r\).

(ii) Completeness. Take a valid sequence for \(C_c\) with \(t_k \le t\). If \(t_k < t\), then \(C_c\) is infected by time \(t^-\) and was already marked. Otherwise let \(l\) be the first index with \(t_l = t\). The prefix ending at \(C_{c_{l-1}}\) uses only times below \(t\), so \(C_{c_{l-1}}\) was marked before \(B\) (if \(l = 1\), it is \(C_a\)). The steps \(l, \dots, k\) all happen at time \(t\), so they are edges of \(H\), and \(C_{c_{l-1}}, \dots, C_{c_k}\) is a path in \(H\) from a node of \(Q\). BFS therefore reaches \(C_c\) by (3.5).

The sweep stops before the first block with time above \(y\), so the answer is \(\text{infected}[b]\) at time \(y\), which is exactly the question asked (for \(x > y\) the virus is not yet present at time \(y\), so the answer is no).

Running time. The array takes \(O(n)\) to initialize. A block with \(m_B\) triples has at most \(2m_B\) endpoints, so its adjacency lists can be built in \(O(m_B)\), using arrays of length \(n\) allocated once and reset through the list of touched endpoints. Its BFS also takes \(O(m_B)\) by (3.11). Since \(\sum_B m_B \le m\), the total is \[ O\Big(n + \sum_B m_B\Big) = O(m + n). \]

Build a directed graph \(G\) whose \(2n\) nodes are the events \(b_i\) (birth of \(P_i\)) and \(d_i\) (death of \(P_i\)), with an edge for each forced “earlier than”. The facts are consistent if and only if \(G\) is a DAG, and in that case a topological ordering gives the dates.

The edges, with \(m\) the number of facts, are:

• \((b_i, d_i)\) for every \(i\);
• \((d_i, b_j)\) for each fact “\(P_i\) died before \(P_j\) was born”;
• \((b_i, d_j)\) and \((b_j, d_i)\) for each fact “\(P_i\) and \(P_j\) overlapped”.

So \(G\) has \(2n\) nodes and at most \(n + 2m\) edges. Run the \(O(m+n)\) topological-ordering algorithm of Section 3.6 on \(G\). If it deletes all \(2n\) nodes and produces the ordering \(v_1, \dots, v_{2n}\), give the event \(v_k\) the date \(k\). If it gets stuck with active nodes left over, report that the facts are inconsistent.

Dates output are valid. A topological ordering sends every edge forward, so every edge \((u, v)\) gets \(\text{date}(u) < \text{date}(v)\). In particular each \(b_i < d_i\). Each “died before” fact gets \(d_i < b_j\). Each overlap fact gets \(b_i < d_j\) and \(b_j < d_i\), which is precisely the condition that the intervals \([b_i, d_i]\) and \([b_j, d_j]\) share a nonempty open interval: \[ \max(b_i, b_j) < \min(d_i, d_j). \]

Reported inconsistency is correct. If the algorithm gets stuck, then the remaining subgraph has no source, so by (3.19) it is not a DAG and \(G\) contains a cycle \(C\). Suppose some dates satisfied all the facts. Even reading lives and overlaps weakly (\(b_i \le d_i\), and \(b_i \le d_j\), \(b_j \le d_i\) for an overlap), every edge \((u, v)\) would satisfy \(\text{date}(u) \le \text{date}(v)\). Also, every edge out of a death node is a “died before” edge, which forces a strict inequality \(d_i < b_j\). Edges out of birth nodes all go to death nodes, so \(C\) must enter a death node and then leave it along a strict edge. Going around \(C\) then gives \[ \text{date}(u) < \text{date}(u) \] for any node \(u\) of \(C\), which is impossible. So no consistent dates exist.

Running time. Building \(G\) takes \(O(n + m)\). The topological ordering, done with active-in-degree counts and the set \(S\) of active sources, runs in \(O(|V| + |E|) = O(n + m)\) (Section 3.6). Detecting a failure is the case where \(S\) empties before all nodes are deleted. In total the algorithm runs in \[ O(n + m). \]

True. Write \(e^* = (v,w)\) and take \(S = \{v\}\), which is neither empty nor all of \(V\) (since \(w \notin S\)). The edge \(e^*\) has one end in \(S\) and the other in \(V - S\), and it is cheaper than every other edge of \(G\), so in particular it is the cheapest edge with one end in \(S\) and the other in \(V-S\). The costs are distinct, so the Cut Property (4.17) applies: every minimum spanning tree of \(G\) contains \(e^*\). Since \(G\) is connected, a minimum spanning tree exists, and any one of them is the required \(T\).

(a) True. Let \(K\) be the tree Kruskal’s Algorithm outputs for the costs \(c_e\). The proof of (4.18) shows that each edge Kruskal adds is the cheapest edge crossing some cut, so by the Cut Property (4.17) (costs distinct) it lies in every minimum spanning tree. Hence \(K \subseteq T\), and since both have \(n-1\) edges, \(T = K\).

Kruskal’s Algorithm only compares costs, and \(x \mapsto x^2\) is strictly increasing on positive numbers:

\begin{equation*} c_e < c_f \iff c_e^2 < c_f^2 \qquad (c_e, c_f > 0). \end{equation*}

So on the squared costs (still distinct) Kruskal considers the edges in the same order, makes the same decisions, and outputs the same tree \(K = T\), which is a minimum spanning tree for the new instance by (4.18).

(b) False. Take nodes \(s, a, t\) and directed edges

\begin{equation*} c_{(s,t)} = 4, \qquad c_{(s,a)} = 2, \qquad c_{(a,t)} = 3 . \end{equation*}

The only \(s\)-\(t\) paths are \(P = s \to t\) and \(Q = s \to a \to t\). Originally \(P\) is the unique minimum, since \(c(P) = 4 < 5 = 2 + 3 = c(Q)\). After squaring,

\begin{equation*} c^2(P) = 16 > 13 = 4 + 9 = c^2(Q), \end{equation*}

so \(P\) is no longer a minimum-cost \(s\)-\(t\) path.

The measure is the number of boxes shipped by the first \(r\) trucks: greedy’s first \(r\) trucks always carry at least as many boxes as the first \(r\) trucks of any other valid packing.

Number the boxes \(1, \dots, n\) in arrival order (each \(w_i \le W\), else no packing exists). Because boxes ship in order, any packing with \(k\) trucks is described by indices \(0 = b_0 < b_1 < \dots < b_k = n\), truck \(r\) carrying boxes \(b_{r-1}+1, \dots, b_r\), with \(\sum_{i=b_{r-1}+1}^{b_r} w_i \le W\). Let greedy’s indices be \(0 = g_0 < g_1 < \dots < g_q = n\); since greedy dispatches a truck only when the next box does not fit,

\begin{equation*} g_r = \max\Big\{ j : \sum_{i=g_{r-1}+1}^{j} w_i \le W \Big\}. \end{equation*}

Claim: \(g_r \ge b_r\) for every \(r \le \min(k,q)\) (with \(g_r := n\) once greedy has finished). Induction, as in (4.2): \(g_0 = b_0\). Suppose \(g_{r-1} \ge b_{r-1}\). (i) If \(b_r \le g_{r-1}\), then \(g_r \ge g_{r-1} \ge b_r\). (ii) If \(b_r > g_{r-1}\), the boxes \(g_{r-1}+1, \dots, b_r\) are a subset of truck \(r\)’s load \(b_{r-1}+1, \dots, b_r\), so

\begin{equation*} \sum_{i=g_{r-1}+1}^{b_r} w_i \le \sum_{i=b_{r-1}+1}^{b_r} w_i \le W, \end{equation*}

and the maximality of \(g_r\) gives \(g_r \ge b_r\).

Now let the packing \(b\) be optimal with \(k\) trucks and suppose \(q > k\). Then \(g_k < n\) (greedy needs truck \(k+1\)), yet the claim gives \(g_k \ge b_k = n\), a contradiction. Hence \(q \le k\): greedy uses the minimum number of trucks.

Scan \(S\) once from left to right, matching each event of \(S^{\prime}\) to its earliest possible occurrence in \(S\) after the previous match.

i = 1
for j = 1 to n:
    if i <= m and S[j] = S'[i]:
        i = i + 1        (S'[i] is matched to position j)
return (i > m)

If the algorithm answers yes, the matched positions \(g_1 < g_2 < \dots < g_m\) satisfy \(S[g_r] = S^{\prime}[r]\), so deleting all other events of \(S\) leaves \(S^{\prime}\). Conversely, suppose \(S^{\prime}\) is a subsequence of \(S\) via positions \(k_1 < \dots < k_m\) with \(S[k_r] = S^{\prime}[r]\). The greedy match stays ahead: we claim it matches \(S^{\prime}[r]\) at some \(g_r \le k_r\). For \(r = 1\), \(g_1\) is the first occurrence of \(S^{\prime}[1]\) in \(S\), so \(g_1 \le k_1\). If \(g_{r-1} \le k_{r-1}\), then position \(k_r\) satisfies

\begin{equation*} k_r > k_{r-1} \ge g_{r-1}, \qquad S[k_r] = S^{\prime}[r], \end{equation*}

so the scan, which looks for \(S^{\prime}[r]\) from position \(g_{r-1}+1\) onward, meets it at some \(g_r \le k_r \le n\). By induction all \(m\) events are matched and the algorithm answers yes.

Running time: the loop runs \(n\) times with \(O(1)\) work per iteration (one comparison of events), and the index \(i\) only increases up to \(m+1\); reading the inputs costs \(O(m+n)\), so the total is \(O(m+n)\).

Sweep from west to east; whenever a house is not yet covered, place a station four miles east of it.

Measure positions in miles from the western endpoint and sort the houses, \(x_1 \le x_2 \le \dots \le x_n\).

covered = -infinity
for i = 1 to n:
    if x[i] > covered:
        place a station at s = x[i] + 4
        covered = x[i] + 8

(If \(x_i + 4\) lies beyond the eastern endpoint \(E\), the station goes at \(E\) instead, still covering \([x_i, E]\).) Each house is either covered when examined, or becomes covered by the station placed for it, so the output is valid.

Let greedy place stations \(s_1 < \dots < s_q\), triggered by houses \(y_1 < \dots < y_q\), so \(s_r = \min(y_r + 4, E)\), and let \(t_1 \le \dots \le t_k\) be any valid placement. Claim: for every \(r \le q\) we have \(k \ge r\) and \(t_r \le s_r\). Suppose it holds for \(r-1\) (vacuous for \(r = 1\)). By construction \(y_r\) is not covered by \(s_{r-1}\), i.e. \(y_r > s_{r-1} + 4\), and therefore, for \(j \le r-1\),

\begin{equation*} y_r - t_j \ \ge\ y_r - t_{r-1} \ \ge\ y_r - s_{r-1} \ >\ 4 . \end{equation*}

So \(y_r\) is covered by none of \(t_1, \dots, t_{r-1}\), but by some \(t_j\) with \(j \ge r\); hence \(k \ge r\) and

\begin{equation*} t_r \le t_j \le \min(y_r + 4, E) = s_r . \end{equation*}

Taking \(r = q\) gives \(k \ge q\): no valid placement uses fewer stations than greedy.

Running time: \(O(n \log n)\) to sort the houses, then \(O(n)\) for the sweep (constant work per house).

Send the contestants out in decreasing order of biking time plus running time.

Write \(s_i, b_i, r_i\) for contestant \(i\)’s three times and \(t_i = b_i + r_i\). Sort the contestants so that \(t_{i_1} \ge t_{i_2} \ge \dots \ge t_{i_n}\) and start them in that order, each entering the pool the moment the previous swimmer leaves.

Correctness. There is never a reason to leave the pool idle, so in the order \(i_1, \dots, i_n\) contestant \(i_k\) finishes at time \(S_k + t_{i_k}\), where \(S_k = s_{i_1} + \dots + s_{i_k}\), and the completion time is \(\max_k (S_k + t_{i_k})\). Call a pair an inversion if \(i\) goes before \(j\) but \(t_i < t_j\); as in the proof of (4.9), an order with an inversion has an adjacent inversion. Swapping an adjacent inversion \(i, j\) that starts swimming at time \(S\) leaves everyone else’s finishing time unchanged, and replaces the two finishing times

\begin{equation*} \begin{aligned} &\text{before: } S + s_i + t_i, \quad S + s_i + s_j + t_j, \\ &\text{after: } S + s_j + t_j, \quad S + s_i + s_j + t_i, \end{aligned} \end{equation*}

and both “after” values are at most \(S + s_i + s_j + t_j\) (using \(t_i < t_j\)). So the swap does not increase the completion time and strictly decreases the number of inversions. Starting from an optimal order and swapping repeatedly therefore reaches an order with no inversions and completion time no larger. All orders with no inversions differ only in the arrangement of contestants with equal \(t\), and these have the same completion time (swapping an adjacent pair with \(t_i = t_j\) leaves the larger of the two finishing times at \(S + s_i + s_j + t_i\), by the display). Hence the greedy order is optimal.

Running time. \(O(n \log n)\), for sorting by \(t_i\).

Feed the jobs to the supercomputer in decreasing order of finishing time \(f_i\).

This is Exercise 4.6 with the pool replaced by the supercomputer (\(s_i = p_i\)) and the bike-plus-run time replaced by the PC time (\(t_i = f_i\)): in the order \(i_1, \dots, i_n\) job \(J_{i_k}\) is done at \(P_k + f_{i_k}\), where \(P_k = p_{i_1} + \dots + p_{i_k}\), and the completion time is \(\max_k (P_k + f_{i_k})\). Swapping an adjacent pair \(i, j\) with \(f_i < f_j\) that starts on the supercomputer at time \(P\) changes only their two completion times,

\begin{equation*} \begin{aligned} \max(P + p_i + f_i,\; P + p_i + p_j + f_j) &\ge P + p_i + p_j + f_j \\ &\ge \max(P + p_j + f_j,\; P + p_i + p_j + f_i), \end{aligned} \end{equation*}

so it never increases the completion time, and swaps between equal \(f\)’s leave it unchanged. Removing the inversions of an optimal order one adjacent swap at a time, as in the proof of (4.9), reaches the sorted order with no larger completion time, so the sorted order is optimal.

Running time. \(O(n \log n)\), for the sort.

Every edge of a minimum spanning tree \(T\) lies in every minimum spanning tree, so all minimum spanning trees coincide with \(T\).

A minimum spanning tree exists since \(G\) is connected. Fix one, \(T\), and an edge \(e = (v,w) \in T\). Deleting \(e\) splits \(T\) into two components; let \(S\) be the node set of the one containing \(v\), so \(w \in V - S\). If some edge \(f \ne e\) with one end in \(S\) and the other in \(V - S\) had \(c_f < c_e\), then \(T - \{e\} + \{f\}\) would be connected (as \(f\) joins the two components), have \(n - 1\) edges, and so be a spanning tree with

\begin{equation*} c(T - \{e\} + \{f\}) = c(T) - c_e + c_f < c(T), \end{equation*}

contradicting the minimality of \(T\). Hence \(e\) is the cheapest edge with one end in \(S\) and the other in \(V - S\) (strictly, by distinctness), and the Cut Property (4.17) says \(e\) belongs to every minimum spanning tree. Thus \(T \subseteq T^{\prime}\) for every minimum spanning tree \(T^{\prime}\), and since both have \(n - 1\) edges, \(T^{\prime} = T\).

(a) No. Take nodes \(a, b, c, d\) and edges

\begin{equation*} c_{ab} = 1, \qquad c_{bc} = 2, \qquad c_{ac} = 3, \qquad c_{cd} = 4 . \end{equation*}

Every spanning tree contains the only edge \(cd\) at \(d\), so every spanning tree has bottleneck cost \(4\) and every spanning tree is a minimum-bottleneck tree. In particular \(T = \{ab, ac, cd\}\) is one, but it costs \(8\), while \(\{ab, bc, cd\}\) costs \(7\); so \(T\) is not a minimum spanning tree.

(b) Yes. Let \(T\) be a minimum spanning tree with bottleneck edge \(e\), and suppose some spanning tree \(T^{\prime}\) has every edge cheaper than \(c_e\). Deleting \(e\) from \(T\) splits it into two components with node sets \(S\) and \(V - S\). Since \(T^{\prime}\) is connected, it has an edge \(f\) with one end in \(S\) and the other in \(V - S\), and \(c_f < c_e\). Then \(T - \{e\} + \{f\}\) is connected with \(n - 1\) edges, hence a spanning tree, and

\begin{equation*} c(T - \{e\} + \{f\}) = c(T) - c_e + c_f < c(T), \end{equation*}

contradicting the minimality of \(T\). So no spanning tree has a cheaper bottleneck edge than \(T\).

(a) \(T\) remains a minimum spanning tree if and only if \(c \ge c_f\), where \(f\) is the most expensive edge on the \(v\)-\(w\) path \(P\) in \(T\); this is testable in \(O(|V|)\) time.

Assumption. \(T\) is stored as adjacency lists, each entry carrying the edge’s cost (the representation of \(G\) is never used). Run DFS (or BFS) in \(T\) from \(v\), recording for each discovered node its parent edge; when \(w\) is found, walk the parent pointers back to \(v\), which traverses \(P\), and keep the most expensive edge \(f\). Answer “yes” iff \(c \ge c_f\). Since \(T\) has \(|V| - 1\) edges, DFS takes \(O(|V|)\) time (3.13), and the walk back \(O(|V|)\); this is \(O(|E|)\) as well, since \(G\) is connected.

Correctness. Write \(e\) for the new edge and \(G^{\prime} = G + e\). (i) If \(c < c_f\): \(T - \{f\} + \{e\}\) is connected (deleting \(f\) splits \(T\) into two components separating \(v\) from \(w\), and \(e\) rejoins them) with \(|V| - 1\) edges, so it is a spanning tree of \(G^{\prime}\) of cost \(c(T) - c_f + c < c(T)\), and \(T\) is not minimum. (ii) If \(c \ge c_f\), so \(c \ge c_g\) for every \(g \in P\): let \(T^*\) be a minimum spanning tree of \(G^{\prime}\). If \(e \notin T^*\), then \(T^*\) is a spanning tree of \(G\) and \(c(T) \le c(T^*)\). If \(e \in T^*\), deleting \(e\) splits \(T^*\) into components with node sets \(S \ni v\) and \(V - S \ni w\); the path \(P\) runs from \(S\) to \(V - S\), so some \(g \in P\) has one end in each, and \(T^* - \{e\} + \{g\}\) is a spanning tree of \(G\), whence

\begin{equation*} c(T) \le c(T^*) - c + c_g \le c(T^*). \end{equation*}

Either way \(c(T) \le c(T^*)\), so \(T\) is a minimum spanning tree of \(G^{\prime}\).

(b) Replace \(T\) by \(T^{\prime} = T - \{f\} + \{e\}\), where \(f\) is the edge found in (a).

Correctness. Here \(c < c_f\). \(T^{\prime}\) is a spanning tree of \(G^{\prime}\) by (a)(i), of cost \(c(T^{\prime}) = c(T) - c_f + c\). Let \(T^{\prime\prime}\) be any spanning tree of \(G^{\prime}\). (i) If \(e \notin T^{\prime\prime}\): \(c(T^{\prime\prime}) \ge c(T) > c(T^{\prime})\). (ii) If \(e \in T^{\prime\prime}\): let \(\hat G\) be \(G\) plus a copy \(\hat e\) of the edge \((v,w)\) with cost \(c_f\) instead of \(c\). Since \(c_f\) is the largest cost on \(P\), part (a)(ii) shows \(T\) is a minimum spanning tree of \(\hat G\). The tree \(\hat T^{\prime\prime}\) obtained from \(T^{\prime\prime}\) by using \(\hat e\) in place of \(e\) is a spanning tree of \(\hat G\), so

\begin{equation*} c(T^{\prime\prime}) - c + c_f = c(\hat T^{\prime\prime}) \ge c(T) = c(T^{\prime}) - c + c_f , \end{equation*}

i.e. \(c(T^{\prime\prime}) \ge c(T^{\prime})\). So \(T^{\prime}\) is a minimum spanning tree of \(G^{\prime}\).

Running time. Finding \(f\) is the \(O(|V|)\) search of (a); deleting \(f\) from the two adjacency lists of its ends and inserting \(e\) take \(O(|V|)\) more. The total \(O(|V|) \subseteq O(|E|)\).

Yes: sort the edges by cost and, among edges of equal cost, put the edges of \(T\) before the edges not in \(T\). This ordering is valid; we show Kruskal’s Algorithm run on it accepts exactly the edges of \(T\).

Suppose not, and look at the first edge on which the run deviates from \(T\) (accepting an edge outside \(T\) or rejecting an edge of \(T\)). Up to that point the accepted edges are exactly the edges of \(T\) processed so far.

(i) An edge \(e \in T\) is rejected. Then \(e\) closes a cycle with the accepted edges, which all lie in \(T\); but \(T\) is acyclic. Contradiction.

(ii) An edge \(f = (u,v) \notin T\) is accepted. Adding \(f\) to \(T\) creates a cycle \(C\). For each \(e \in C - f\), the graph \(T - e + f\) is again a spanning tree, so minimality of \(T\) gives

\begin{equation*} c(T) \le c(T) - c_e + c_f, \qquad\text{i.e.}\qquad c_e \le c_f . \end{equation*}

So every edge of the \(u\)-\(v\) path \(C - f\) in \(T\) has cost at most \(c_f\), and by the tie-breaking rule it comes before \(f\) in the ordering; by the choice of \(f\) as the first deviation, all of these edges were accepted. Hence \(u\) and \(v\) were already connected by accepted edges, and Kruskal’s Algorithm rejects \(f\). Contradiction.

So the run accepts every edge of \(T\) and no other edge, and its output is \(T\).

(a) False. Take \(n = 2\), \(r = 2\), \((b_1, t_1) = (1, 1)\) and \((b_2, t_2) = (3, 1)\). The order \(1, 2\) sends

\begin{equation*} 1 \le 2 \cdot 1 \quad (t = 1), \qquad 1 + 3 = 4 \le 2 \cdot 2 \quad (t = 2), \end{equation*}

and nothing more is sent for \(t \ge 2\), so the schedule is valid; yet \(b_2 = 3 > 2 = r t_2\).

(b) A valid schedule exists if and only if

\begin{equation*} \sum_{i=1}^n b_i \le r \sum_{i=1}^n t_i , \end{equation*}

and then sending the streams in increasing order of rate \(b_i / t_i\) is valid. So the algorithm computes the two sums and compares them.

Necessity: put \(T = \sum_i t_i\), a natural number \(> 0\). Every schedule has sent all \(\sum_i b_i\) bits by time \(T\), so (\(*\)) at \(t = T\) is exactly the inequality.

Sufficiency: let \(B(t)\) be the number of bits sent by time \(t\) in the increasing-rate schedule. It is piecewise linear with \(B(0) = 0\), and its slope on successive pieces is \(b_i/t_i\) in nondecreasing order, so \(B\) is convex on \([0, T]\). For \(0 < t \le T\), convexity between the points \(0\) and \(T\) gives

\begin{equation*} B(t) \le \Bigl(1 - \frac{t}{T}\Bigr) B(0) + \frac{t}{T} B(T) = \frac{t}{T} \sum_i b_i \le \frac{t}{T} \cdot rT = rt , \end{equation*}

and for \(t > T\) we have \(B(t) = B(T) \le rT < rt\). So (\(*\)) holds for every \(t > 0\).

The test takes \(O(n)\) time (producing the schedule itself means sorting by rate, \(O(n \log n)\)).

Do the jobs in increasing order of the ratio \(t_i / w_i\) (weights positive), breaking ties arbitrarily.

Call a pair \(i, j\) an inversion of a schedule if \(i\) is done before \(j\) but \(t_i / w_i > t_j / w_j\). Swapping two adjacent jobs \(i, j\) (with \(i\) first, starting at time \(S\)) changes only \(C_i\) and \(C_j\), and

\begin{equation*} \begin{aligned} &\bigl[w_i(S + t_i) + w_j(S + t_i + t_j)\bigr] \\ &\qquad - \bigl[w_j(S + t_j) + w_i(S + t_j + t_i)\bigr] \\ &\qquad = w_j t_i - w_i t_j = w_i w_j \Bigl(\frac{t_i}{w_i} - \frac{t_j}{w_j}\Bigr). \end{aligned} \end{equation*}

So swapping an adjacent inversion strictly lowers the cost, and swapping two adjacent jobs of equal ratio leaves it unchanged.

Take an optimal schedule \(O\). If it has an inversion, then (exactly as in the proof of (4.9)) it has an adjacent one, and swapping it would strictly lower the cost, contradicting optimality; so \(O\) has no inversions. Any two schedules without inversions differ only in the order of jobs with equal ratio, which form a contiguous block in each (as in the proof of (4.8)), and one is turned into the other by adjacent swaps within these blocks, each of cost change \(0\). Hence the greedy schedule has the same cost as \(O\) and is optimal.

Sorting takes \(O(n \log n)\) time and computing the \(C_i\) takes \(O(n)\).

(a) Scan the processes in order of finish time, and whenever a process is not yet covered, invoke status_check at its finish time. Process \(P\) runs over the closed interval \([s_P, f_P]\).

sort processes so that f(1) <= f(2) <= ... <= f(n)
p = -infinity;  times = empty
for j = 1 to n:
    if s(j) > p:           (process j not yet covered)
        add f(j) to times;  p = f(j)
return times

The output covers every process: when \(j\) is reached either \(s_j > p\) and \(f_j\) is added, or \(s_j \le p \le f_j\) (as \(p\) is the finish time of an earlier process in the sorted order), so \(p\) lies in \([s_j, f_j]\); and since every invocation time is at most the current \(p\), the test \(s_j > p\) correctly detects that \(j\) is uncovered.

Let \(j_1, \dots, j_k\) be the processes whose finish times were chosen, so \(|\text{times}| = k\). When \(j_{m+1}\) was chosen, the current \(p\) was \(f_{j_m}\), so

\begin{equation*} s_{j_{m+1}} > f_{j_m} \qquad (1 \le m < k), \end{equation*}

i.e. \(j_1, \dots, j_k\) are pairwise never running at the same time. One invocation lies in at most one of them, so every valid set of times has size at least \(k\), and the output is optimal.

The sort costs \(O(n \log n)\) and the scan \(O(n)\).

(b) True. With \(k\) and \(j_1, \dots, j_k\) as in (a), let \(\mathrm{OPT}\) be the minimum number of invocations. By the consultants’ argument and by (a),

\begin{equation*} k \le k^* \le \mathrm{OPT} = k , \end{equation*}

so \(k^* = \mathrm{OPT}\): the \(k^*\) times returned by the algorithm in (a) cover every process.

Repeatedly take the uncovered shift \(I\) that finishes earliest, and put on the committee the student whose shift, among all shifts overlapping \(I\) (including \(I\) itself), finishes latest. Shift \(J = [s_J, f_J]\) covers \(L\) if \(L = J\) or they overlap, i.e. \(s_L \le f_J\) and \(s_J \le f_L\); a shift is uncovered if no committee member covers it.

C = empty
while some shift is uncovered by C:
    I = the uncovered shift with smallest finish time
    K = the shift covering I with largest finish time
    add K to C
return C

Key fact: at a step with \(I, K\) as above, if \(J\) covers \(I\) and \(L\) is uncovered and covered by \(J\), then \(K\) covers \(L\). Indeed \(f_L \ge f_I\) (choice of \(I\)) and \(f_K \ge f_J\) (choice of \(K\), since \(J\) covers \(I\)), so

\begin{equation*} s_K \le f_I \le f_L, \qquad s_L \le f_J \le f_K . \end{equation*}

Let the greedy committee be \(K_1, \dots, K_m\). We show by induction on \(j\) that some minimum complete committee contains \(K_1, \dots, K_j\); the case \(j = 0\) is trivial. Let \(O\) be a minimum complete committee containing \(K_1, \dots, K_{j-1}\), and let \(I\) be the shift chosen at step \(j\). As \(O\) is complete, some \(J \in O\) covers \(I\), and \(J \notin \{K_1, \dots, K_{j-1}\}\) since \(I\) was uncovered. Put \(O^{\prime} = O - J + K_j\), so \(|O^{\prime}| \le |O|\). A shift covered by \(K_1, \dots, K_{j-1}\), or by a member of \(O\) other than \(J\), is still covered in \(O^{\prime}\); any other shift \(L\) (including \(L = J\)) is uncovered at step \(j\) and covered by \(J\), hence covered by \(K_j\) by the key fact. So \(O^{\prime}\) is a minimum complete committee containing \(K_1, \dots, K_j\).

For \(j = m\) this gives a minimum complete committee \(O \supseteq \{K_1, \dots, K_m\}\), so \(m \le |O|\), and the greedy committee (complete when the loop stops) is optimal.

Each round takes \(O(n)\) time and covers at least one new shift, so there are at most \(n\) rounds and the total is \(O(n^2)\).

Process the events in increasing order of time, and give each event the still-unused transaction window that contains it and has the earliest right endpoint. Write \(I_j = [\ell_j, r_j] = [t_j - e_j,\, t_j + e_j]\); event \(x\) may be associated with transaction \(j\) exactly when \(x \in I_j\).

sort the events so that x_1 <= x_2 <= ... <= x_n
mark every window I_j as unused
for i = 1 to n:
    among unused j with l_j <= x_i <= r_j, pick j with the smallest r_j
    if there is no such j: return "no association"
    associate x_i with j; mark j as used
return "association exists"

If the algorithm answers “exists”, it has built an association, so it is right. For the converse, we show by induction on \(k\): if some valid association exists, then some valid association \(M\) agrees with the algorithm’s first \(k\) choices. The case \(k=0\) is immediate. Now let \(M\) agree with the first \(k-1\) choices. Since \(M\) gives \(x_k\) an unused window containing it, the algorithm finds some window at step \(k\). Call it \(I_j\), and say \(M\) gives \(x_k\) the window \(I_{j^{\prime}} \ne I_j\) and gives \(I_j\) to the event \(x_m\). Window \(I_j\) is unused before step \(k\), so \(m > k\) and \(x_m \ge x_k\). The greedy choice gives \(r_j \le r_{j^{\prime}}\), so

\begin{equation*} \ell_{j^{\prime}} \le x_k \le x_m \le r_j \le r_{j^{\prime}} , \end{equation*}

which means \(x_m \in I_{j^{\prime}}\), and of course \(x_k \in I_j\). Swapping the two windows between \(x_k\) and \(x_m\) therefore gives a valid association that agrees with the first \(k\) choices. So when an association exists the algorithm never gets stuck, and it answers “exists”.

Running time: sorting takes \(O(n \log n)\), and each of the \(n\) iterations scans the \(n\) windows in \(O(n)\), for \(O(n^2)\) in total.

Try each job \(J\) in turn as a job that is definitely accepted. Cutting the 24-hour circle open at \(J\) turns the remaining compatible jobs into an ordinary interval scheduling instance, which the earliest-finish-time greedy algorithm of Section 4.1 solves. Return the best of these \(n\) schedules.

best = empty set                       (the answer when n = 0)
for each job J = (s_J, f_J):
    R = jobs that do not overlap J
    lay out the circle as the line from f_J forward to s_J;
        each job in R becomes an ordinary interval on this line
    A = earliest-finish-time greedy schedule on R
    if |A| + 1 > |best|: best = A plus J
return best

The jobs that do not overlap \(J\) occupy arcs inside the arc of the day running from \(f_J\) forward to \(s_J\). Measuring time forward from \(f_J\) makes this arc a line segment, and each such job becomes an interval on it. So \(R\) is an ordinary interval scheduling instance, and every candidate \(A \cup \{J\}\) is a set of pairwise compatible daily jobs. Now let \(O\) be an optimal set, with \(n \ge 1\), and pick any \(J \in O\). Then \(O \setminus \{J\} \subseteq R\) is compatible, so by (4.3) the greedy set has \(|A| \ge |O| - 1\). Hence the candidate for this \(J\) already has size \(|O|\), and the returned set is optimal.

Running time: each of the \(n\) rounds builds \(R\) in \(O(n)\) and runs the greedy algorithm in \(O(n \log n)\), for \(O(n^2 \log n)\) in total. Sorting all jobs once by end time and scanning that circular order starting from \(f_J\) makes each round \(O(n)\), for \(O(n^2)\).

Run Dijkstra’s Algorithm with the label update \(d(u) + \ell_e\) replaced by \(f_e(d(u))\). Here \(d(u)\) is the earliest arrival time at \(u\), and each edge is queried once, at the moment its tail \(u\) is finalized.

S = {s}; d(s) = 0
while some node outside S has an edge into it from S:
    for each v not in S: d'(v) = min of f_e(d(u)) over e = (u, v), u in S
    pick v not in S minimizing d'(v)
    add v to S; d(v) = d'(v); pred(v) = the minimizing edge
return d(dest), with the route read off the pred pointers

We claim, as in (4.14), that for every \(u \in S\) the pred-path \(P_u\) reaches \(u\) at time \(d(u)\), and that every \(s\)-\(u\) path reaches \(u\) no earlier than \(d(u)\). Argue by induction on \(|S|\). The case \(|S| = 1\) holds because times never decrease. Suppose \(v\) is added through \(e = (u, v)\). Then \(P_u\) followed by \(e\) reaches \(v\) at \(f_e(d(u)) = d(v)\). Now take any \(s\)-\(v\) path \(P\), and let \((x, y)\) be its first edge leaving \(S\), so \(x \in S\) and \(y \notin S\). By induction, \(P\) reaches \(x\) at some time \(\tau \ge d(x)\). Monotonicity of \(f_{(x,y)}\) and the choice of \(v\) give

\begin{equation*} \text{arrival}_P(y) = f_{(x,y)}(\tau) \ge f_{(x,y)}(d(x)) \ge d^{\prime}(y) \ge d^{\prime}(v) = d(v), \end{equation*}

and the rest of \(P\), from \(y\) to \(v\), can only increase the time because \(f_e(t) \ge t\). So \(P\) reaches \(v\) no earlier than \(d(v)\). Nodes never added to \(S\) are unreachable from \(s\). In particular, \(P_{\text{dest}}\) is a fastest route.

Running time: implement the algorithm exactly as Dijkstra’s Algorithm with a priority queue (4.15). When \(u\) joins \(S\), query \(f_e(d(u))\) once for each edge \(e\) out of \(u\) and do a ChangeKey. That is \(m\) queries and \(O(m \log n)\) time in total.

Take \(T\) to be a maximum-bandwidth spanning tree, that is, a minimum spanning tree for the costs \(c_e = -b_e\). Kruskal’s Algorithm finds one: by (4.18), together with the tie-breaking perturbation argument at the end of Section 4.5, it returns a minimum spanning tree even when costs repeat.

Fix \(u, v\), let \(P\) be the \(u\)-\(v\) path in \(T\), and let \(e \in P\) have \(b_e = b(P)\). Since \(P\) is itself a \(u\)-\(v\) path in \(G\), \(b(P)\) is at most the best achievable rate. Suppose some \(u\)-\(v\) path \(Q\) in \(G\) had \(b(Q) > b(P)\). Deleting \(e\) splits \(T\) into two components \(S \ni u\) and \(V - S \ni v\), and \(e\) is the only edge of \(T\) between them. The path \(Q\) must cross between \(S\) and \(V - S\) along some edge \(f\), so \(f \notin T\) and

\begin{equation*} b_f \ge b(Q) > b(P) = b_e . \end{equation*}

Then \(T - e + f\) is a spanning tree whose total bandwidth exceeds that of \(T\), contradicting the choice of \(T\). Hence \(b(P)\) equals the best achievable bottleneck rate, for every pair \(u, v\) simultaneously.

Running time: \(O(m \log n)\) by (4.25).

(a) Yes. Let \(T\) be the minimum spanning tree, take towns \(i, j\), let \(P\) be the \(i\)-\(j\) path in \(T\), and let \(e \in P\) be its highest edge. Suppose some \(i\)-\(j\) path \(Q\) in \(G\) had height less than \(a_e\). Deleting \(e\) splits \(T\) into components \(S \ni i\) and \(V - S \ni j\), and \(Q\) crosses between them along some edge \(f \ne e\), with \(f \notin T\) and

\begin{equation*} a_f \le \text{height}(Q) < a_e . \end{equation*}

Then \(T - e + f\) is a spanning tree of smaller total altitude than \(T\), a contradiction. So the \(T\)-path between any two towns is winter-optimal in \(G\), and \((V, T)\) is a minimum-altitude connected subgraph.

(b) Yes. (i) If \(E^{\prime} \supseteq T\), then for every pair \(i, j\) the subgraph \((V, E^{\prime})\) contains the \(T\)-path, whose height is optimal in \(G\) by (a). Also \((V, E^{\prime})\) is connected. So \((V, E^{\prime})\) is a minimum-altitude connected subgraph.

(ii) Conversely, suppose \(E^{\prime}\) misses some tree edge \(e = (i, j) \in T\). The \(T\)-path from \(i\) to \(j\) is the single edge \(e\), so by (a) the winter-optimal height between \(i\) and \(j\) in \(G\) is \(a_e\). Deleting \(e\) splits \(T\) into components \(S \ni i\) and \(V - S \ni j\). Every edge \(f \ne e\) crossing this cut has \(a_f > a_e\), since otherwise \(T - e + f\) would be a cheaper spanning tree (the altitudes are distinct). Any \(i\)-\(j\) path \(Q\) in \((V, E^{\prime})\) avoids \(e\) but must cross the cut along some such \(f\), so

\begin{equation*} \text{height}(Q) \ge a_f > a_e . \end{equation*}

If there is no such path, \((V, E^{\prime})\) is not even connected. Either way, \((V, E^{\prime})\) is not a minimum-altitude connected subgraph, and the second conjecture holds.

Repeatedly find a cycle and delete its most expensive edge, until \(n-1\) edges remain.

while G has more than n - 1 edges:
    run DFS on G to find a cycle C
    delete from G the most expensive edge of C
return G

Correctness. Let \(e\) be the most expensive edge on a cycle \(C\) of the current graph \(H\). Since the costs are distinct, the Cycle Property (4.20) says \(e\) lies in no minimum spanning tree of \(H\); so the (unique) minimum spanning tree \(T\) of \(H\) is a spanning tree of \(H - e\), and since every spanning tree of \(H - e\) is a spanning tree of \(H\), \(T\) is also the minimum spanning tree of \(H - e\). Deleting an edge of a cycle keeps the graph connected, so the loop is well defined: a connected graph with more than \(n-1\) edges has a cycle. Hence the MST is invariant throughout, and at termination \(G\) is connected with \(n-1\) edges, i.e. a tree, so it is its own minimum spanning tree, which is therefore the MST of the input.

Running time. Each iteration deletes one edge, so there are at most \((n+8) - (n-1) = 9\) iterations. Each iteration is a DFS (which finds a cycle via a non-tree edge, or reports none) plus a scan of the cycle, costing \(O(n + m) = O(n + n + 8) = O(n)\). Total \(9 \cdot O(n) = O(n)\).

No. Take the triangle on nodes \(a, b, c\) with

\begin{equation*} c_{(a,b)} = 1, \qquad c_{(b,c)} = 2, \qquad c_{(a,c)} = 2, \end{equation*}

and \(T = \{(b,c), (a,c)\}\). The three spanning trees are the three pairs of edges, with costs

\begin{equation*} c(\{(a,b),(b,c)\}) = 3, \qquad c(\{(a,b),(a,c)\}) = 3, \qquad c(T) = 4 . \end{equation*}

So the minimum spanning trees are exactly \(\{(a,b),(b,c)\}\) and \(\{(a,b),(a,c)\}\). The edge \((b,c) \in T\) lies in the first and \((a,c) \in T\) lies in the second, so \(T\) satisfies the guarantee; yet \(c(T) = 4 > 3\), so \(T\) is not a minimum-cost spanning tree.

Yes. Let \(r\) be the root and, for \(v \ne r\), let \(y_v\) be the minimum cost of an edge entering \(v\).

In a DAG, every set \(F\) consisting of exactly one edge entering each \(v \ne r\) is an arborescence: \((V,F)\) is a subgraph of an acyclic graph, so it has no cycles, and (4.34) applies. In particular, choosing a cheapest entering edge for every \(v \ne r\) gives an arborescence of cost \(\sum_{v \ne r} y_v\), and by (4.34) every arborescence has one entering edge per \(v \ne r\), hence cost at least \(\sum_{v \ne r} y_v\). So the optimum is exactly \(\sum_{v \ne r} y_v\).

Now let \(e = (u,v) \in A\) and let \(A^*\) be a minimum-cost arborescence containing \(e\). If \(c_e > y_v\), replace \(e\) in \(A^*\) by a cheapest edge entering \(v\): the result still has exactly one edge entering each node other than \(r\), so it is an arborescence by the observation above, and it is cheaper than \(A^*\), a contradiction. Hence \(c_e = y_v\) for every \(e = (u,v) \in A\), and since \(A\) has exactly one edge entering each \(v \ne r\) (4.34),

\begin{equation*} c(A) = \sum_{v \ne r} y_v , \end{equation*}

the minimum cost. So \(A\) is a minimum-cost arborescence.

Work bottom-up: at each internal node, lengthen the edge to the shallower child just enough to match the deeper one, and never touch the deeper side.

For a node \(v\) let \(d(v)\) be the (common) distance from \(v\) to the leaves below it after its subtree has been processed; \(d(v) = 0\) at a leaf. For an internal node \(v\) with child edges \(a = (v,u)\) and \(b = (v,w)\), put

\begin{equation*} p = \ell_a + d(u), \qquad q = \ell_b + d(w), \qquad d(v) = \max(p,q), \end{equation*}

and increase \(\ell_a\) by \(d(v) - p\) and \(\ell_b\) by \(d(v) - q\) (one of these is 0). Processing nodes in post-order, the subtree of every node has zero skew with height \(d(v)\), so the whole tree has zero skew. Let \(g(v)\) be the total increase made inside the subtree \(T_v\); then \(g(\text{leaf}) = 0\) and

\begin{equation*} g(v) = g(u) + g(w) + |p - q| . \end{equation*}

Optimality. Claim: any choice of increases \(x_e \ge 0\) that makes \(T_v\) zero-skew with common height \(H\) has \(H \ge d(v)\) and total increase inside \(T_v\) at least \(g(v) + 2(H - d(v))\). At a leaf this reads \(0 \ge 0\). At internal \(v\), the subtrees \(T_u, T_w\) are zero-skew with heights \(H_u, H_w\), where by induction \(H_u \ge d(u)\), \(H_w \ge d(w)\) and

\begin{equation*} H = \ell_a + x_a + H_u = \ell_b + x_b + H_w , \end{equation*}

so \(H \ge \max(p,q) = d(v)\), and the cost is at least

\begin{equation*} \begin{aligned} &g(u) + g(w) + (H_u - d(u)) + (H_w - d(w)) + x_a + x_b \\ &\quad = g(u) + g(w) + (H - p) + (H - q) \\ &\quad = g(u) + g(w) + (2\max(p,q) - p - q) + 2(H - d(v)) \\ &\quad = g(v) + 2(H - d(v)) . \end{aligned} \end{equation*}

At the root this gives total increase \(\ge g(\text{root})\), which the algorithm attains; since the final total length is the original total plus the total increase, the algorithm minimizes it.

Running time. The tree has \(2n - 1\) nodes and each is processed in \(O(1)\) time in a post-order traversal, so \(O(n)\).

Run Kruskal’s Algorithm on the complete graph on \(P\) with edge costs \(d\), and record each merge as a tree node: when an edge of cost \(w\) joins the clusters whose current tree roots are \(x\) and \(y\), create a new node with height \(w\) and children \(x, y\).

Start with each \(p_i\) as a leaf of height 0. Kruskal considers edges in nondecreasing order of cost, so a node created at cost \(w\) has children of height at most \(w\) (they are leaves or were created earlier); thus \(h(\text{parent}) \ge h(\text{child})\), and after \(n-1\) merges we have a rooted tree \(T\) with the points at distinct leaves, i.e. a hierarchical metric \(\tau\). By construction, \(\tau(p_i,p_j)\) is the cost \(w\) of the edge at which the clusters of \(p_i\) and \(p_j\) were merged.

(i) When the edge \((p_i,p_j)\) is considered, either \(p_i, p_j\) are already in one cluster, merged at some cost \(\le d(p_i,p_j)\), or they are merged now at cost \(d(p_i,p_j)\). Either way \(\tau(p_i,p_j) \le d(p_i,p_j)\).

(ii) Every hierarchical metric \(\tau^{\prime}\) (with tree \(T^{\prime}\)) satisfies the ultrametric inequality

\begin{equation*} \tau^{\prime}(x,z) \le \max(\tau^{\prime}(x,y), \tau^{\prime}(y,z)) . \end{equation*}

Indeed \(a = \mathrm{lca}(x,y)\) and \(b = \mathrm{lca}(y,z)\) are both ancestors of \(y\), so one, say \(a\), is an ancestor of the other; then \(a\) is an ancestor of \(x\) and \(z\), so \(\mathrm{lca}(x,z)\) lies on the path from \(a\) down, and monotonicity of heights gives \(h(\mathrm{lca}(x,z)) \le h_a\).

Now fix \(p_i, p_j\) merged at cost \(w = \tau(p_i,p_j)\) via an edge \((q,q^{\prime})\) with \(q\) in the cluster of \(p_i\) and \(q^{\prime}\) in that of \(p_j\). Each cluster is connected by the Kruskal edges already added, all of cost \(\le w\), so there is a path \(p_i = s_0, s_1, \ldots, s_k = p_j\) with \(d(s_{t-1},s_t) \le w\) for all \(t\). Iterating the ultrametric inequality and using consistency of \(\tau^{\prime}\),

\begin{equation*} \tau^{\prime}(p_i,p_j) \le \max_{t} \tau^{\prime}(s_{t-1},s_t) \le \max_t d(s_{t-1},s_t) \le w = \tau(p_i,p_j) . \end{equation*}

Running time. Kruskal’s Algorithm on the \(\binom{n}{2}\) edges takes \(O(n^2 \log n)\) time by (4.25), and creating the \(n-1\) tree nodes is \(O(n)\) extra; reading off all \(\tau(p_i,p_j)\) by LCA queries costs \(O(n)\) each, \(O(n^3)\) in all, which is polynomial.

Cut the time line at the \(O(m^2)\) times where two cost parabolas cross, take the Kruskal tree of each piece, minimize its quadratic cost over the piece, and return the best time found.

P = empty
for each pair e != e' with f_e - f_e' not identically 0:
    add to P the (at most 2) real roots of f_e(t) - f_e'(t)
sort P as t_1 < ... < t_r; set t_0 = -inf, t_(r+1) = +inf
for each piece I_i = [t_i, t_(i+1)], i = 0..r:
    s = an interior point of I_i   (midpoint, or t_1 - 1, t_r + 1, or 0 if r = 0)
    T_i = Kruskal's tree for costs f_e(s), ties broken by edge index
    A, B', C = sums of a_e, b_e, c_e over e in T_i
    tau_i = -B'/(2A) clamped into I_i;  val_i = A tau_i^2 + B' tau_i + C
return the tau_i with the smallest val_i

Correctness. On the interior of a piece \(I_i\), any two edges \(e, e^{\prime}\) either have \(f_e \equiv f_{e^{\prime}}\) or have \(f_e - f_{e^{\prime}}\) continuous with no root, hence of constant sign. So the order of the edges by \((f_e(t), \text{index})\) is the same for every interior \(t\); Kruskal’s Algorithm only compares costs, so it outputs the same tree \(T_i\) for each such \(t\), and \(T_i\) is a minimum spanning tree at time \(t\) by (4.18) (ties allowed, by the perturbation argument of Section 4.5). Writing \(F_T(t) = \sum_{e \in T} f_e(t)\),

\begin{equation*} c_G(t) = \min_{T} F_T(t) = F_{T_i}(t) \qquad (t \in \operatorname{int} I_i). \end{equation*}

Both sides are continuous (\(c_G\) is a minimum of finitely many polynomials), so equality holds on all of \(I_i\). The pieces cover \(\mathbb{R}\), so

\begin{equation*} \min_{t \in \mathbb{R}} c_G(t) = \min_{i} \, \min_{t \in I_i} F_{T_i}(t). \end{equation*}

Each \(F_{T_i}(t) = At^2 + B^{\prime}t + C\) with \(A = \sum_{e \in T_i} a_e > 0\) is a convex parabola, so its minimum over the interval \(I_i\) is attained at the vertex \(-B^{\prime}/(2A)\) clamped into \(I_i\); this is \(\tau_i\). Hence the returned \(\tau_i\) minimizes \(c_G\) (and the minimum exists).

Running time. Each pair contributes at most 2 roots (a quadratic, a linear, or a nonzero constant difference), so \(r \le 2\binom{m}{2} < m^2\); sorting costs \(O(m^2 \log m)\), and the \(r+1 = O(m^2)\) pieces each need one \(O(m \log n)\) run of Kruskal’s Algorithm (Section 4.6), for \(O(m^3 \log n)\) in total (counting a square root as one arithmetic operation).

Yes, \(\mathcal{H}\) is always connected. We show by induction on \(d(T,T^{\prime}) = |T - T^{\prime}|\) that any two spanning trees \(T, T^{\prime}\) are joined by a path in \(\mathcal{H}\) of length \(d(T,T^{\prime})\); the case \(d = 0\) is \(T = T^{\prime}\).

Let \(d(T,T^{\prime}) \ge 1\) and pick \(e \in T^{\prime} - T\). Adding \(e\) to the tree \(T\) creates a unique cycle \(C \subseteq T + e\). Not every edge of \(C\) lies in \(T^{\prime}\), since \(T^{\prime}\) is acyclic; and \(e \in T^{\prime}\), so there is an edge \(f \in C - T^{\prime}\), \(f \ne e\), hence \(f \in T\). Put

\begin{equation*} T_1 = T + e - f . \end{equation*}

Deleting an edge of the cycle \(C\) from the connected graph \(T + e\) leaves it connected, and \(T_1\) has \(n-1\) edges, so \(T_1\) is a spanning tree. It differs from \(T\) exactly in \(e \in T_1 - T\) and \(f \in T - T_1\), so \(T\) and \(T_1\) are neighbors. Since \(e \in T^{\prime}\) and \(f \notin T^{\prime}\),

\begin{equation*} d(T_1, T^{\prime}) = |T - T^{\prime}| - 1 = d(T,T^{\prime}) - 1, \end{equation*}

so by induction \(T_1\) is joined to \(T^{\prime}\) by a path of length \(d(T,T^{\prime})-1\), and prefixing the edge \(T T_1\) of \(\mathcal{H}\) gives the required path from \(T\).

Compute a spanning tree \(T_{\min}\) with the fewest \(X\)-edges and one \(T_{\max}\) with the most, then walk from \(T_{\min}\) to \(T_{\max}\) by single-edge exchanges; each exchange changes the \(X\)-count by at most one, so every value in between is hit.

For a spanning tree \(T\) let \(x(T)\) be its number of \(X\)-edges.

T_min = Kruskal with cost 1 on X-edges, 0 on Y-edges
T_max = Kruskal with cost 0 on X-edges, 1 on Y-edges
if k < x(T_min) or k > x(T_max): report "no such tree"
T = T_min
while x(T) != k:
    pick e in T_max - T; find the cycle C of T + e
    pick f in C - T_max;  T = T + e - f
return T

Correctness. With costs \(1\) on \(X\)-edges and \(0\) on \(Y\)-edges the cost of a tree is exactly \(x(T)\), so by (4.18) (ties handled as in Section 4.5) \(x(T_{\min}) = \min_T x(T)\); symmetrically the cost \(n - 1 - x(T)\) is minimized by \(T_{\max}\), so \(x(T_{\max}) = \max_T x(T)\). Hence if \(k\) lies outside \([x(T_{\min}), x(T_{\max})]\) no tree has \(k\) edges labeled \(X\), and report (ii) is correct.

Otherwise, the loop body is exactly the exchange step in the solution of Exercise 4.27: \(f\) exists, \(T + e - f\) is a spanning tree, and \(|T - T_{\max}|\) drops by one, so after at most \(n-1\) iterations \(T = T_{\max}\). One exchange changes the count by

\begin{equation*} x(T + e - f) - x(T) = [e \in X] - [f \in X] \in \{-1, 0, 1\}. \end{equation*}

The integer sequence \(x(T)\) thus starts at \(x(T_{\min}) \le k\), ends at \(x(T_{\max}) \ge k\), and moves in steps of size at most \(1\), so it equals \(k\) at some iteration, where the loop stops and returns a spanning tree with exactly \(k\) edges labeled \(X\).

Running time. The two runs of Kruskal’s Algorithm take \(O(m \log n)\); each of at most \(n-1\) exchanges finds the cycle (the tree path between the ends of \(e\)) by a BFS of \(T\) in \(O(n)\) time, so the total is \(O(m \log n + n^2)\).

Use the Havel-Hakimi rule: join a node of largest required degree \(d\) to the \(d\) other nodes of largest required degree, delete it, and recurse on the reduced list.

loop:
    sort the list so that d_1 >= d_2 >= ... >= d_n
    if d_1 = 0: answer YES
    if d_1 > (current length of the list) - 1: answer NO
    replace the list by (d_2 - 1, ..., d_(d_1 + 1) - 1, d_(d_1 + 2), ..., d_n)
    if some entry is negative: answer NO

Call a list graphical if some simple graph realizes it. Correctness rests on one claim.

Claim. Let \(d_1 \ge d_2 \ge \cdots \ge d_n\) be graphical and \(S = \{v_2, \ldots, v_{d_1+1}\}\). Then some realization has \(N(v_1) = S\).

Take a realization maximizing \(|N(v_1) \cap S|\), and suppose \(N(v_1) \ne S\). Both sets have size \(d_1\), so there are \(w \in S - N(v_1)\) and \(u \in N(v_1) - S\), with \(d_w \ge d_u\) (every node of \(S\) precedes every node outside \(S \cup \{v_1\}\)). Let \(A = N(w) - \{u\}\) and \(B = N(u) - \{w\}\); then

\begin{equation*} |A| = d_w - [uw \in E] \;\ge\; d_u - [uw \in E] = |B| . \end{equation*}

Since \(v_1 \in B - A\), there is some \(x \in A - B\); so \(x \ne u, w, v_1\), \(wx \in E\) and \(ux \notin E\). Replace the edges \(v_1 u, wx\) by \(v_1 w, ux\): both new pairs were non-edges and are not loops, and every degree is unchanged. This raises \(|N(v_1) \cap S|\) by one, a contradiction. \(\square\)

Now one round is exact: if the list is graphical, then \(d_1 \le n-1\), and deleting \(v_1\) from the realization of the Claim realizes the reduced list (so no entry is negative); conversely, if the reduced list is realized by a graph on \(v_2, \ldots, v_n\), adding \(v_1\) adjacent to \(S\) realizes the original list. Hence each NO is correct, each round preserves graphicality, and the all-zero list (reached after at most \(n\) rounds, since the list shortens by one each round) is realized by the empty graph, so YES is correct.

Running time. At most \(n\) rounds, each a sort and \(O(n)\) updates, for \(O(n^2 \log n)\).

Try every set \(Y \subseteq V - X\) with \(|Y| \le k-2\), take a minimum spanning tree of \(G[X \cup Y]\), and return the lightest one found; this suffices because some optimal Steiner tree uses at most \(k-2\) non-terminals. (For \(k \le 1\) the answer is \(Z = X\) with the empty tree, of weight \(0\).)

Claim. For \(k \ge 2\) some minimum-weight Steiner tree \((Z,T)\) has \(|Z - X| \le k-2\).

Among minimum-weight Steiner trees take one with \(|Z|\) smallest. Every \(v \in Z - X\) has \(\deg_T(v) \ge 3\): (i) if \(\deg_T(v) = 1\), then \((Z - \{v\}, T - v)\) is a Steiner tree of smaller weight (weights are positive), impossible; (ii) if \(\deg_T(v) = 2\) with neighbors \(a, b\), then \(T - va - vb + ab\) spans \(Z - \{v\}\), is a tree, and has weight changed by \(w_{ab} - w_{av} - w_{vb} \le 0\) by the triangle inequality, contradicting minimality of \(|Z|\). So every leaf of \(T\) is a terminal. Let \(T\) have \(L \le k\) leaves, \(r\) nodes of degree \(2\) and \(s\) nodes of degree \(\ge 3\); as \(|Z| \ge k \ge 2\), no node has degree \(0\), and

\begin{equation*} 2(L + r + s - 1) = \sum_{v \in Z} \deg_T(v) \ge L + 2r + 3s \;\Longrightarrow\; s \le L - 2 \le k - 2 . \end{equation*}

Since \(Z - X\) consists of nodes of degree \(\ge 3\), \(|Z - X| \le s \le k-2\). \(\square\)

Correctness. Every candidate (a set \(X \cup Y\) with a spanning tree of \(G[X \cup Y]\), which is complete hence connected) is a Steiner tree, so the output weighs at least the optimum \(\mathrm{OPT}\). Conversely, for the tree \((Z, T)\) of the Claim, \(Y = Z - X\) is enumerated, and \(T\) is a spanning tree of \(G[Z]\), so the minimum spanning tree found for \(Y\) (optimal by (4.19)) weighs at most \(w(T) = \mathrm{OPT}\).

Running time. The number of sets \(Y\) is at most

\begin{equation*} \sum_{j=0}^{k-2} \binom{n}{j} \le \sum_{j=0}^{k-2} n^j \le n^{k-1} \qquad (n \ge 2), \end{equation*}

and Prim’s Algorithm on the complete graph \(G[X \cup Y]\) with at most \(2k - 2\) nodes takes \(O(k^2)\) time with an array in place of the heap. The total is \(O(k^2 n^{k-1}) = O(n^{k+1}) = O(n^{O(k)})\).

(a) Every edge \(e = (u, v) \in E\) satisfies \(d_H(u, v) \le 3\ell_e\): either \(e \in F\), or when \(e\) was considered \(u\) and \(v\) were already joined in \(H\) with \(d_{uv} \le 3\ell_e\), and later additions to \(H\) only shorten distances. Summing over the edges of a shortest \(u\)-\(v\) path \(P = (u = x_0, x_1, \dots, x_k = v)\) in \(G\) and using the triangle inequality for \(d_H\),

\begin{equation*} \begin{aligned} d_H(u, v) &\le \sum_{i=1}^{k} d_H(x_{i-1}, x_i) \\ &\le \sum_{i=1}^{k} 3\ell_{(x_{i-1}, x_i)} = 3\, d_G(u, v). \end{aligned} \end{equation*}

(b) \(H\) has no cycle of length at most 4, and a graph with no 4-cycle has at most \(\frac{n}{2}(1 + \sqrt{n})\) edges.

No short cycles. Let \(C\) be a cycle of \(H\) and \(e = (u, v)\) its longest edge. Edges are scanned in increasing order of (distinct) lengths, so every other edge of \(C\) was already in \(H\) when \(e\) was considered; hence \(C - e\) was a \(u\)-\(v\) path in \(H\), and since \(e\) was nevertheless added,

\begin{equation*} 3\ell_e < d_{uv} \le \ell(C - e) < (|C| - 1)\,\ell_e , \end{equation*}

so \(|C| \ge 5\).

Counting. If two distinct vertices \(u, w\) had two common neighbours \(x \ne x^{\prime}\), then \(u, x, w, x^{\prime}\) would be a 4-cycle of \(H\); so each pair \(\{u, w\}\) is the pair of ends of at most one path of two edges. Counting such paths by their middle vertex, with \(m = |F|\) and average degree \(\bar d = 2m/n\), convexity of \(x \mapsto \binom{x}{2}\) gives

\begin{equation*} n \binom{\bar d}{2} \le \sum_{x \in V} \binom{\deg x}{2} \le \binom{n}{2}, \qquad\text{so}\qquad \bar d(\bar d - 1) \le n - 1 . \end{equation*}

Hence \(\bar d \le 1 + \sqrt{n}\), i.e. \(m \le \frac{n}{2}(1 + \sqrt{n})\). As this holds for every output,

\begin{equation*} 0 \le \frac{f(n)}{n^2} \le \frac{1 + \sqrt{n}}{2n} \longrightarrow 0 . \end{equation*}

Throughout, edges entering \(r\) are deleted (no arborescence uses them), so \(\{r\}\) is a strong component of every subgraph and every nontrivial strong component \(S\) avoids \(r\); write \(Y = \sum_{v \ne r} y_v\) and \(\mathrm{OPT}(G, c)\) for the minimum cost of an arborescence.

(a) Contracting a nontrivial 0-cost strong component \(S\) is the same as contracting 0-cost cycles one at a time, each a legal step of the Section 4.9 algorithm. Indeed \(S\) contains a 0-cost cycle \(C\); if \(C \ne S\), some 0-cost edge of \(S\) enters the contracted node \(C\), so its new \(y\)-value is \(0\) and no cost changes, and \(S/C\) is again strongly connected by 0-cost edges; repeat until \(S\) is one node. By (4.38) and (4.39) every such run returns an optimal arborescence. Moreover a 0-cost subgraph has a cycle if and only if it has a nontrivial strong component, so the algorithm stops at the same moment as before.

(b) Every edge \(e = (u, v) \in T\) has \(c^{\prime\prime}_e = 0\), i.e. \(c_e \le 2y_v\); and every arborescence \(T^*\) uses one edge into each \(v \ne r\), of cost at least \(y_v\). Hence

\begin{equation*} c(T) = \sum_{(u,v) \in T} c_{(u,v)} \le 2\sum_{v \ne r} y_v = 2Y \le 2\,c(T^*). \end{equation*}

(c) The key inequalities are, for every edge \(e\) entering \(v\) (using \(c_e \ge y_v\) in the case \(c_e < 2y_v\)),

\begin{equation*} c_e - 2y_v \le c^{\prime\prime}_e \le c_e - y_v . \end{equation*}

The procedure terminates: every \(v \ne r\) has a \(c^{\prime\prime}\)-zero entering edge (its cheapest one), so if there were no nontrivial 0-cost strong component, one such edge per node would be acyclic and hence a 0-cost arborescence by (4.34). We prove \(c(T) \le 2\,\mathrm{OPT}(G, c)\) by induction on \(|V|\); the base case (a 0-cost arborescence is found) is (b). Otherwise let \(G^{\prime}\) be the contracted graph with costs \(c^{\prime\prime}\), \(T^{\prime}\) the arborescence returned on it, and \(T\) its expansion to \(G\) by 0-cost arborescences inside each contracted component, as in (a), so \(c^{\prime\prime}(T) = c^{\prime\prime}(T^{\prime})\). Contracting any arborescence of \(G\) leaves a subgraph of \(G^{\prime}\) in which \(r\) still reaches every node, which contains an arborescence of no larger \(c^{\prime\prime}\)-cost, so \(\mathrm{OPT}(G^{\prime}, c^{\prime\prime}) \le \mathrm{OPT}(G, c^{\prime\prime})\). With the inductive hypothesis on \(G^{\prime}\),

\begin{equation*} \begin{aligned} c(T) &\le c^{\prime\prime}(T) + 2Y = c^{\prime\prime}(T^{\prime}) + 2Y \le 2\,\mathrm{OPT}(G^{\prime}, c^{\prime\prime}) + 2Y \\ &\le 2\,\mathrm{OPT}(G, c^{\prime\prime}) + 2Y \\ &\le 2\bigl(\mathrm{OPT}(G, c) - Y\bigr) + 2Y = 2\,\mathrm{OPT}(G, c), \end{aligned} \end{equation*}

where the first and last inequalities sum the two bounds on \(c^{\prime\prime}_e\) over an arborescence (one edge into each \(v \ne r\)).

Compute a cheapest arborescence \(T_1\) (cost \(a\)) and a most expensive one \(T_2\) (cost \(b\)); if \(k \notin [a, b]\) report that none exists, and otherwise walk from \(T_1\) to \(T_2\) by changing one parent at a time, stopping when the cost equals \(k\).

Write \(p_T(v)\) for the tail of the edge of \(T\) entering \(v\).

T1 := min-cost arborescence for costs c_e        (Section 4.9)
T2 := min-cost arborescence for costs 1 - c_e    (a max-cost one for c)
a := c(T1);  b := c(T2)
if k < a or k > b: report "no such arborescence"
T := T1
while c(T) != k:
    v := a node with p_T(v) != p_T2(v) of least depth in T2
    replace the edge (p_T(v), v) in T by (p_T2(v), v)
return T

Correctness. The algorithm of Section 4.9 is optimal by (4.39) (all costs are nonnegative, and an arborescence exists by (4.35)); since every arborescence has exactly \(n - 1\) edges, its cost under \(1 - c\) is \(n - 1 - c(T)\), so \(T_2\) maximizes \(c\). Hence \(a \le c(T) \le b\) for every arborescence \(T\), and the report for \(k \notin [a, b]\) is correct.

Each swap keeps \(T\) an arborescence. Every node of \(T_2\)-depth less than that of \(v\) has the same parent in \(T\) as in \(T_2\), so the \(T_2\)-path from \(r\) to \(p_{T_2}(v)\) lies in \(T\) and is the \(T\)-path to \(p_{T_2}(v)\); it avoids \(v\), which has larger \(T_2\)-depth. So \(v\) is not a \(T\)-ancestor of \(p_{T_2}(v)\), the swap creates no cycle, and each node \(\ne r\) still has one entering edge, so the result is an arborescence by (4.34).

Each swap lowers the number of nodes whose parents in \(T\) and \(T_2\) differ by one, so after at most \(n - 1\) swaps \(T = T_2\). One edge leaves and one enters, both of cost \(0\) or \(1\), so consecutive costs satisfy

\begin{equation*} \bigl|c(T_{\text{after}}) - c(T_{\text{before}})\bigr| \le 1 . \end{equation*}

An integer sequence from \(a\) to \(b\) with steps of size at most 1 takes every integer value in \([a, b]\), so the loop stops at an arborescence of cost exactly \(k\).

Running time. Two runs of the Section 4.9 algorithm take \(O(mn)\) time (at most \(n\) contractions, each \(O(m)\)), and the walk does at most \(n - 1\) swaps of \(O(n)\) each (recompute \(T_2\)-depths once; maintain \(c(T)\) incrementally), for \(O(mn)\) in total.

Compare the two databases’ “middle” elements and throw away the lower half of the database whose middle element is smaller together with the upper half of the other one; the median of what remains is still the median.

Write \(A[i]\), \(B[i]\) for the \(i^{\text{th}}\) smallest values of the two databases (each \(A[i]\) or \(B[i]\) costs one query). We maintain offsets \(a, b\) and a size \(m\) such that the median sought is the \(m^{\text{th}}\) smallest element of the \(2m\) values \(A[a+1..a+m] \cup B[b+1..b+m]\); initially \(a = b = 0\), \(m = n\).

a = 0; b = 0; m = n
while m > 1:
    k = ceil(m/2); d = floor(m/2)
    if A[a+k] < B[b+k]:  a = a + d     (drop A[a+1..a+d] and B[b+k+1..b+m])
    else:                b = b + d     (drop B[b+1..b+d] and A[a+k+1..a+m])
    m = m - d
return min(A[a+1], B[b+1])

Correctness. It suffices to show one iteration preserves the invariant. Say \(A[a+k] < B[b+k]\) (the other case is symmetric), and rank elements within the current \(2m\) values. For \(j \le d = m-k < k\), the values below \(A[a+j]\) are at most \(j-1\) elements of \(A\) and the elements of \(B\) below \(A[a+j] < A[a+k] < B[b+k]\), at most \(k-1\) of them; for \(j \ge k+1\), the value \(B[b+j]\) exceeds \(B[b+1..b+k]\) and \(A[a+1..a+k]\). Hence

\begin{equation*} \begin{aligned} \operatorname{rank} A[a+j] &\le (j-1)+(k-1)+1 \le m-1 && (j \le d),\\ \operatorname{rank} B[b+j] &\ge 2k+1 \ge m+1 && (j \ge k+1). \end{aligned} \end{equation*}

So we discard \(d\) elements below the median and \(m-k = d\) elements above it: what remains is \(A[a+d+1..a+m] \cup B[b+1..b+k]\), two blocks of size \(m-d = k\), and the median is its \((m-d)^{\text{th}} = k^{\text{th}}\) smallest element, which is the invariant with \((a+d, b, k)\). When \(m = 1\) the median is the smaller of the two remaining values.

Queries. Each iteration makes \(2\) queries and replaces \(m\) by \(\lceil m/2 \rceil\), so the query count \(Q(m)\) satisfies \(Q(m) \le Q(\lceil m/2\rceil) + 2\), \(Q(1) = 2\); this is recurrence (5.16) of Solved Exercise 1, giving

\begin{equation*} Q(n) \le 2\lceil \log_2 n \rceil + 2 = O(\log n). \end{equation*}

Run Sort-and-Count (Section 5.3), but before each merge of the sorted halves \(A\) (first half) and \(B\) (second half) count the cross pairs \(x \in A\), \(y \in B\) with \(x > 2y\) by a separate two-pointer pass.

Sort-and-Count-Significant(L):
  if |L| <= 1: return (0, L)
  split L into first half and second half
  (rA, A) = Sort-and-Count-Significant(first half)
  (rB, B) = Sort-and-Count-Significant(second half)
  c = 0; p = 1
  for each y in B, in increasing order:
      while p <= |A| and A[p] <= 2y:  p = p + 1
      c = c + (|A| - p + 1)
  L' = Merge(A, B)              (ordinary merge, as in Mergesort)
  return (rA + rB + c, L')

Correctness. By induction on \(|L|\). A significant inversion \((i,j)\) either has both indices in one half, and is counted in \(r_A\) or \(r_B\) by induction, or has \(i\) in the first half and \(j\) in the second; whether \(a_i > 2a_j\) depends only on the two values, so the cross pairs are exactly the pairs \((x, y) \in A \times B\) with \(x > 2y\), regardless of the order inside each half. Since \(A\) is sorted, \(\{x \in A : x \le 2y\}\) is a prefix of \(A\), and since \(2y\) increases as \(y\) runs through \(B\) in increasing order, this prefix only grows; so the pointer \(p\) never moves back, and when \(y\) is processed \(A[p..|A|]\) are exactly the \(x \in A\) with \(x > 2y\). Hence \(c\) is the number of cross significant inversions. The returned list is \(L\) sorted, as in Mergesort, which the parent call needs.

Running time. The counting pass moves \(p\) at most \(|A|\) times and visits each \(y\) once, and the merge is linear, so the combining work is \(O(n)\) and the running time satisfies recurrence (5.1), \(T(n) \le 2T(n/2) + cn\); by (5.2), \(T(n) = O(n \log n)\). (To compare two orderings, relabel as in Section 5.3 so that one ordering is \(1, 2, \ldots, n\) and read off the other as \(a_1, \ldots, a_n\).)

Split the cards into two halves, recursively find a “majority card” of each half (a card whose class contains more than half of that half), and test each of the at most two candidates against all \(n\) cards.

Majority(S):                  returns a card of a class of size > |S|/2, or none
  if |S| = 1: return the card in S
  split S into S1, S2 of sizes floor(|S|/2), ceil(|S|/2)
  for c in {Majority(S1), Majority(S2)} (skip "none"):
      test c against every other card of S
      if more than |S|/2 cards of S are equivalent to c: return c
  return none

The answer to the bank’s question is “yes” if and only if Majority(all \(n\) cards) returns a card.

Correctness. By induction on \(|S|\); the base case is clear. A class of size more than \(|S|/2\) is unique, so it suffices to show that if a class \(K\) has \(|K \cap S| > |S|/2\), then a card of \(K\) is among the candidates. Indeed

\begin{equation*} |K \cap S_1| + |K \cap S_2| = |K \cap S| > \tfrac{|S_1|}{2} + \tfrac{|S_2|}{2}, \end{equation*}

so \(|K \cap S_i| > |S_i|/2\) for some \(i\), and by induction Majority\((S_i)\) returns a card of \(K\), which then passes the count. Conversely, a returned card passed the count, so its class is a majority of \(S\).

Tests. Each call makes at most \(2(|S|-1)\) tests besides its recursive calls, so the number of tests satisfies \(T(n) \le 2T(n/2) + 2n\), recurrence (5.1); by (5.2), \(T(n) = O(n \log n)\).

Each \(F_j\) is \(C q_j\) times one coordinate of the convolution of the charge vector with a fixed vector of signed inverse squares, so one FFT convolution computes them all.

Let

\begin{equation*} g(t) = \begin{cases} 1/t^2, & t > 0,\\ 0, & t = 0,\\ -1/t^2, & t < 0,\end{cases} \end{equation*}

and define vectors indexed from \(0\):

\begin{equation*} \begin{aligned} a &= (a_0, \ldots, a_{n-1}), & a_p &= q_{p+1},\\ b &= (b_0, \ldots, b_{2n-2}), & b_r &= g(r-(n-1)). \end{aligned} \end{equation*}

Then the two sums in \(F_j\) combine into one, \(F_j = C q_j \sum_{i=1}^n q_i\, g(j-i)\). In the convolution \(a * b\) (Section 5.6), \((a*b)_s = \sum_{p+r=s} a_p b_r\); putting \(p = i-1\) forces \(r = s-i+1\), and \(b_{s-i+1} = g(j-i)\) exactly when \(s = j+n-2\), where every \(i \in \{1, \ldots, n\}\) gives a valid index \(r = j-i+n-1 \in [0, 2n-2]\). Hence

\begin{equation*} F_j = C q_j \,(a*b)_{j+n-2}, \qquad j = 1, \ldots, n. \end{equation*}

Algorithm. Build \(b\) in \(O(n)\) time, pad \(a\) with zeros to length \(2n-1\), compute \(a*b\) with the Fast Fourier Transform, and output \(F_j = Cq_j (a*b)_{j+n-2}\) for each \(j\).

Running time. Building the vectors and the final \(n\) multiplications take \(O(n)\); by (5.15) the convolution of two vectors of length \(2n-1\) takes \(O(n \log n)\). Total: \(O(n \log n)\).

Sort the lines by slope and compute the upper envelope by divide and conquer: the envelopes of the low-slope half and the high-slope half cross exactly once, so they merge in linear time.

Preprocessing. Sort the lines by slope. Among lines of equal slope (parallel lines) all but the one with the largest intercept lie strictly below it everywhere and are invisible; delete them in one \(O(n)\) pass (lines are assumed distinct). Now \(a_1 < a_2 < \cdots < a_n\).

Recursion. For a set of lines with consecutive slopes, return its visible lines \(\ell_1, \ldots, \ell_p\) in increasing slope order together with breakpoints \(\beta_1 < \cdots < \beta_{p-1}\) such that \(\ell_i\) is uppermost exactly on the open interval \((\beta_{i-1}, \beta_i)\) (with \(\beta_0 = -\infty\), \(\beta_p = +\infty\)). A single line returns itself with no breakpoints. Otherwise solve the lower-slope half \(\mathcal{L}\), giving \((\ell_i; \beta_i)\) and envelope \(U_L(x) = \max_{L \in \mathcal{L}} (a x + b)\), and the higher-slope half \(\mathcal{R}\), giving \((r_i; \gamma_i)\) and \(U_R\). Merge:

walk the merged sorted list of breakpoints beta and gamma, keeping track
  of the current envelope line of each half (two pointers);
find the elementary interval on which U_R - U_L changes sign;
there l_s and r_t are the current lines; x* = intersection of l_s and r_t;
return lines l_1..l_s, r_t..r_q
  with breakpoints beta_1..beta_(s-1), x*, gamma_t..gamma_(q-1)

Correctness. \(U_L\) and \(U_R\) are convex, piecewise linear, with every slope of \(U_L\) at most \(\max_{\mathcal L} a\) and every slope of \(U_R\) at least \(\min_{\mathcal R} a > \max_{\mathcal L} a\). Hence \(D = U_R - U_L\) is continuous with all one-sided derivatives at least \(\delta = \min_{\mathcal R} a - \max_{\mathcal L} a > 0\), so

\begin{equation*} D(x) \to \mp\infty \ (x \to \mp\infty), \qquad D(x) < 0 \iff x < x^* \end{equation*}

for a unique \(x^*\), which the walk finds (on the elementary interval containing it both envelopes are single lines \(\ell_s\), \(r_t\), and \(x^*\) is their intersection). A line of \(\mathcal L\) is uppermost among all lines at \(x\) iff it is uppermost in \(\mathcal L\) at \(x\) and \(U_L(x) > U_R(x)\), i.e. \(x \in (\beta_{i-1}, \beta_i) \cap (-\infty, x^*)\); this is nonempty iff \(\beta_{i-1} < x^*\), i.e. \(i \le s\), and \(\ell_s\) is then uppermost on \((\beta_{s-1}, x^*)\). Symmetrically \(r_j\) is visible iff \(j \ge t\), with \(r_t\) uppermost on \((x^*, \gamma_t)\). (\(x^*\) is not a breakpoint of either half, since that would make three lines concurrent.) So the returned lines and breakpoints satisfy the specification, and the top-level call returns exactly the visible lines.

Running time. Sorting is \(O(n \log n)\). The merge walks \(O(n)\) breakpoints with two pointers and does \(O(1)\) work at each, so \(T(n) \le 2T(n/2) + cn\), recurrence (5.1), and \(T(n) = O(n \log n)\) by (5.2).

Walk down from the root, always stepping to the smaller child, and stop at the first node smaller than both its children (or at a leaf).

v = root; probe v
while v is not a leaf:
    probe the children c1, c2 of v
    if x_v < x_c1 and x_v < x_c2: return v
    v = the child with the smaller label
return v

Correctness. Every node \(v\) the walk visits satisfies the invariant

\begin{equation*} v = \text{root} \quad\text{or}\quad x_v < x_{\text{parent}(v)} . \end{equation*}

It holds at the root vacuously, and when we step from \(v\) to its smaller child \(c\) we have \(x_c = \min(x_{c_1}, x_{c_2}) < x_v\) (we did not stop at \(v\), and labels are distinct). The neighbours of \(v\) are its parent (if any) and its children (if any). If we return an internal \(v\), it beats both children by the stopping test and its parent by the invariant; if we return a leaf, its only neighbour is its parent, beaten by the invariant. Either way \(v\) is a local minimum.

Probes. The walk visits at most one node per level, and there are \(d\) levels; it probes the root once and two children per non-leaf visited, so

\begin{equation*} \#\text{probes} \le 1 + 2(d-1) = 2\log_2(n+1) - 1 = O(\log n). \end{equation*}

Recurse on a shrinking rectangle \(S\): probe its middle row and middle column (the cross \(C\)), and move into the quadrant that contains a node smaller than everything on the quadrant’s border.

For a rectangle \(S\) of nodes write \(\partial S\) for the set of nodes outside \(S\) adjacent to some node of \(S\). Call \((S, u)\) good if either \(S = G\) (so \(\partial S = \emptyset\)), or \(u \in S\) is a probed node with \(x_u < x_y\) for all \(y \in \partial S\).

S = G, u = none
loop:
    C = middle row and middle column of S;  probe all of C
    w = node of minimum label in C + {u}
    if w == u and u is not in C:  z = u
    else:
        probe the (at most 4) neighbours of w in G
        if w is smaller than all of them: return w
        z = the smallest neighbour of w
    S = the quadrant of S - C containing z;  u = z

Correctness. The four quadrants are the connected pieces of \(S \setminus C\), and for each quadrant \(Q\) every neighbour of \(Q\) lies in \(C\) (if inside \(S\)) or in \(\partial S\) (if outside), i.e. \(\partial Q \subseteq C \cup \partial S\). Assume \((S,u)\) is good. By the choice of \(w\) and goodness,

\begin{equation*} x_w \le x_c \ (c \in C), \qquad x_w \le x_u < x_y \ (y \in \partial S). \end{equation*}

(i) \(w = u \notin C\): then \(u\) lies in a quadrant \(Q\), and \(x_u < x_y\) for every \(y \in C \cup \partial S \supseteq \partial Q\), so \((Q, u)\) is good.

(ii) \(w \in C\) and \(w\) beats all its neighbours: \(w\) is a local minimum of \(G\), and we return it.

(iii) \(w \in C\) with a smaller neighbour \(z\): then \(x_z < x_w\), so \(z \notin C\) and \(z \notin \partial S\) by the display; hence \(z \in S \setminus C\) lies in a quadrant \(Q\), and \(x_z < x_w \le x_y\) for all \(y \in C \cup \partial S \supseteq \partial Q\), so \((Q, z)\) is good.

Goodness is therefore preserved, and \(S\) strictly shrinks each round while staying nonempty (it contains \(u\)), so the loop ends in case (ii) with a local minimum.

Probes. If \(S\) has both sides at most \(m\), the round probes at most \(2m\) nodes of \(C\) plus 4 neighbours (\(u\) was already probed), and each quadrant has both sides at most \(\lfloor m/2 \rfloor\). Starting from \(m = n\),

\begin{equation*} \begin{aligned} P(n) &\le \sum_{k \ge 0,\ n/2^k \ge 1} \Bigl( 2\cdot\frac{n}{2^k} + 4 \Bigr) \\ &\le 4n + 4(\log_2 n + 1) = O(n). \end{aligned} \end{equation*}

(a) Take the path with weights \(2, 3, 2\). Heaviest-first picks \(v_2\) (weight 3), deletes \(v_1, v_3\), and returns \(\{v_2\}\) of weight \(3\), while \(\{v_1, v_3\}\) is independent of weight \(4\).

(b) Take the path with weights \(3, 1, 1, 3\). Then \(w(S_1) = 3 + 1 = 4 = w(S_2)\), so the algorithm returns weight \(4\), while \(\{v_1, v_4\}\) is independent of weight \(6\).

(c) Let \(\mathrm{OPT}(j)\) be the maximum weight of an independent set in the subpath \(v_1, \ldots, v_j\); this is weighted interval scheduling with \(p(j) = j - 2\), so (6.1) gives

\begin{equation*} \mathrm{OPT}(j) = \max\bigl(w_j + \mathrm{OPT}(j-2),\ \mathrm{OPT}(j-1)\bigr), \qquad \mathrm{OPT}(0) = \mathrm{OPT}(-1) = 0 . \end{equation*}

Directly: an optimal set \(S\) for \(v_1, \ldots, v_j\) either omits \(v_j\), and is then an optimal set for \(v_1, \ldots, v_{j-1}\), or contains \(v_j\), hence omits its only earlier neighbour \(v_{j-1}\), and \(S - \{v_j\}\) is an optimal set for \(v_1, \ldots, v_{j-2}\) (any independent set there plus \(v_j\) is independent).

M[-1] = M[0] = 0
for j = 1 to n:  M[j] = max(w_j + M[j-2], M[j-1])
trace back from j = n: if w_j + M[j-2] >= M[j-1]
  then put v_j in S and go to j-2, else go to j-1

By induction on \(j\) (exactly as in (6.3)) \(M[j] = \mathrm{OPT}(j)\), and the traceback returns a set achieving \(M[n]\) as in (6.5). Each of the \(n\) table entries takes \(O(1)\) arithmetic operations and the traceback takes \(O(n)\) steps, so the running time is \(O(n)\), independent of the weights.

(a) Take \(n = 3\) with \((\ell_1, \ell_2, \ell_3) = (2, 2, 2)\) and \((h_1, h_2, h_3) = (1, 5, 10)\). At \(i = 1\) the test \(h_2 = 5 > \ell_1 + \ell_2 = 4\) succeeds, so the algorithm outputs none, high-stress for weeks 1, 2; at \(i = 3\) the test \(h_4 = 0 > \ell_3 + \ell_4 = 2\) fails, so it outputs low-stress for week 3. Its plan has value \(0 + 5 + 2 = 7\). The correct answer is the plan low-stress, none, high-stress, of value \(2 + 0 + 10 = 12\) (optimal by checking all \(3^3\) plans).

(b) Let \(\mathrm{OPT}(i)\) be the maximum value of a plan for weeks \(1, \ldots, i\), with \(\mathrm{OPT}(0) = \mathrm{OPT}(-1) = 0\). Then for \(i \ge 1\)

\begin{equation*} \mathrm{OPT}(i) = \max\bigl(\ell_i + \mathrm{OPT}(i-1),\ h_i + \mathrm{OPT}(i-2)\bigr). \end{equation*}

Compute \(M[i]\) by this recurrence for \(i = 1, \ldots, n\) and return \(M[n]\).

Correctness, by induction on \(i\): consider an optimal plan \(P\) for weeks \(1, \ldots, i\) and its choice in week \(i\). (i) Low-stress: no constraint links week \(i\) to earlier weeks, so \(P\) restricted to weeks \(1, \ldots, i-1\) is an arbitrary plan, and \(\mathrm{OPT}(i) = \ell_i + \mathrm{OPT}(i-1)\). (ii) High-stress: week \(i - 1\) (if it exists) is “none”, and weeks \(1, \ldots, i-2\) form an arbitrary plan, so \(\mathrm{OPT}(i) = h_i + \mathrm{OPT}(i-2)\). (iii) None: replacing “none” by “low-stress” in week \(i\) keeps the plan valid (a low-stress week constrains nothing) and gains \(\ell_i > 0\), so this case never beats (i). Conversely each term in the max is the value of a valid plan (in case (ii), append “none”, “high-stress” to an optimal plan for weeks \(1, \ldots, i-2\); for \(i = 1\), just “high-stress”), so \(\mathrm{OPT}(i)\) equals the max.

Each of the \(n\) entries costs \(O(1)\), so the running time is \(O(n)\).

(a) Take \(n = 5\) with edges \((v_1, v_2)\), \((v_1, v_3)\), \((v_2, v_5)\), \((v_3, v_4)\), \((v_4, v_5)\) (ordered: every edge increases the index and \(v_1, \ldots, v_4\) each have an out-edge). The algorithm walks \(v_1 \to v_2 \to v_5\) and returns \(2\); the correct answer is \(3\), via \(v_1 \to v_3 \to v_4 \to v_5\).

(b) Let \(\mathrm{OPT}(j)\) be the length of the longest path from \(v_1\) to \(v_j\), with \(\mathrm{OPT}(j) = -\infty\) if there is none. Since every edge into \(v_j\) comes from some \(v_i\) with \(i < j\) by (i), the last edge of such a path is some \((v_i, v_j) \in E\) and the rest is a path from \(v_1\) to \(v_i\), which may be taken longest; conversely any \(v_1\)-\(v_i\) path extended by \((v_i, v_j)\) is a \(v_1\)-\(v_j\) path (indices strictly increase, so no node repeats). Hence

\begin{equation*} \mathrm{OPT}(1) = 0, \qquad \mathrm{OPT}(j) = \max_{i < j,\ (v_i, v_j) \in E} \bigl(\mathrm{OPT}(i) + 1\bigr) \quad (j \ge 2), \end{equation*}

with the max of an empty set (or of \(-\infty\) terms) equal to \(-\infty\).

M[1] = 0;  M[j] = -infinity for j = 2..n
for i = 1 to n-1:
  if M[i] > -infinity:
    for each edge (v_i, v_j):  M[j] = max(M[j], M[i] + 1)
return M[n]

When node \(v_i\) is processed, all its in-edges come from \(v_1, \ldots, v_{i-1}\), which were processed earlier, so by induction on \(i\) we have \(M[i] = \mathrm{OPT}(i)\) at that moment, and the loop returns \(\mathrm{OPT}(n)\). This is finite: by (ii) the walk from \(v_1\) that always follows some out-edge strictly increases the index, so it ends at the only node without out-edges, \(v_n\). Each node and each edge is handled once, so the running time is \(O(n + m)\) for \(m = |E|\), with \(G\) given as adjacency lists.

(a) Take \(n = 2\), \(M = 10\), \((N_1, N_2) = (1, 2)\), \((S_1, S_2) = (2, 1)\). The algorithm outputs \([\mathrm{NY}, \mathrm{SF}]\), of cost \(1 + 1 + 10 = 12\). The correct answer is \([\mathrm{NY}, \mathrm{NY}]\) (or \([\mathrm{SF}, \mathrm{SF}]\)), of cost \(3\); the four plans NN, NS, SN, SS cost \(3, 12, 14, 3\).

(b) Take \(n = 4\), \(M = 1\), \((N_1, \ldots, N_4) = (1, 10, 1, 10)\), \((S_1, \ldots, S_4) = (10, 1, 10, 1)\). The plan \([\mathrm{NY}, \mathrm{SF}, \mathrm{NY}, \mathrm{SF}]\) moves three times and costs \(4 \cdot 1 + 3 \cdot 1 = 7\). Every other plan is in the wrong city in some month, since the cheap city alternates, so it costs at least

\begin{equation*} 10 + 3 \cdot 1 = 13 > 7 . \end{equation*}

Hence this plan is the unique optimum, and it moves three times.

(c) Let \(\mathrm{OPT}_N(i)\) and \(\mathrm{OPT}_S(i)\) be the minimum cost of a plan for months \(1, \ldots, i\) that ends in NY, respectively SF. Then \(\mathrm{OPT}_N(1) = N_1\), \(\mathrm{OPT}_S(1) = S_1\), and for \(i \ge 2\)

\begin{equation*} \begin{aligned} \mathrm{OPT}_N(i) &= N_i + \min\bigl(\mathrm{OPT}_N(i-1),\ M + \mathrm{OPT}_S(i-1)\bigr),\\ \mathrm{OPT}_S(i) &= S_i + \min\bigl(\mathrm{OPT}_S(i-1),\ M + \mathrm{OPT}_N(i-1)\bigr). \end{aligned} \end{equation*}

Compute both tables for \(i = 1, \ldots, n\) and return \(\min(\mathrm{OPT}_N(n), \mathrm{OPT}_S(n))\).

Correctness, by induction on \(i\): the cost of a plan for months \(1, \ldots, i\) ending in NY is \(N_i\), plus \(M\) if month \(i - 1\) was SF, plus the cost of its prefix on months \(1, \ldots, i-1\), which is an arbitrary plan ending in the city of month \(i - 1\); minimizing the prefix separately for each of the two possible cities of month \(i - 1\) gives the first line, and symmetrically the second. Every optimal plan ends in one of the two cities, giving the returned value.

There are \(2n\) entries, each computed in \(O(1)\), so the running time is \(O(n)\).

With \(q(i, j) = \mathrm{quality}(y_i y_{i+1} \cdots y_j)\) and \(\mathrm{OPT}(j)\) the maximum total quality of a segmentation of the prefix \(y_1 \cdots y_j\), conditioning on the last block as in (6.6) gives the recurrence below. If the last block of an optimal segmentation of \(y_1 \cdots y_j\) is \(y_i \cdots y_j\), the remaining blocks form a segmentation of \(y_1 \cdots y_{i-1}\), which may be replaced by an optimal one; conversely every such combination is a segmentation of \(y_1 \cdots y_j\). Hence

\begin{equation*} \mathrm{OPT}(0) = 0, \qquad \mathrm{OPT}(j) = \max_{1 \le i \le j} \bigl(q(i, j) + \mathrm{OPT}(i-1)\bigr) \quad (1 \le j \le n). \end{equation*}

M[0] = 0
for j = 1 to n:
  M[j] = max over i = 1..j of quality(y_i..y_j) + M[i-1]
  B[j] = an index i attaining that max
j = n
while j > 0:  output block y_{B[j]}..y_j;  j = B[j] - 1

By induction on \(j\), \(M[j] = \mathrm{OPT}(j)\) (each \(M[i-1]\) used has \(i - 1 < j\)), and the traceback outputs, in reverse order, blocks whose qualities sum to \(M[n] = \mathrm{OPT}(n)\), as in (6.5); quality values may be negative, which does not affect this argument.

Computing \(M[j]\) takes \(j\) black-box calls and \(O(j)\) arithmetic, so the total is \(\sum_{j=1}^{n} O(j) = O(n^2)\) steps, and the traceback is \(O(n)\).

Let \(\mathrm{OPT}(j)\) be the minimum sum of squared slacks over valid formattings of \(w_1, \ldots, w_j\); the last line of such a formatting is some \(w_i, \ldots, w_j\), so

\begin{equation*} \mathrm{OPT}(0) = 0, \qquad \mathrm{OPT}(j) = \min_{\substack{1 \le i \le j \\ S(i,j) \ge 0}} \bigl[\mathrm{OPT}(i-1) + S(i,j)^2\bigr], \end{equation*}

where \(S(i,j) = L - \bigl(\sum_{t=i}^{j} c_t\bigr) - (j - i)\) is the slack of the line \(w_i, \ldots, w_j\) (the line is valid iff \(S(i,j) \ge 0\)). We assume every \(c_i \le L\); otherwise no valid formatting exists at all.

P[0] = 0; for t = 1..n: P[t] = P[t-1] + c_t
OPT[0] = 0
for j = 1..n:
    OPT[j] = infinity
    for i = j down to 1:
        s = L - (P[j] - P[i-1]) - (j - i)
        if s < 0: break
        if OPT[i-1] + s*s < OPT[j]: OPT[j] = OPT[i-1] + s*s; last[j] = i
trace back: the final line is w_last[n] .. w_n, then recurse on n' = last[n] - 1

Correctness, by induction on \(j\). A valid formatting of \(w_1, \ldots, w_j\) is exactly a valid last line \(w_i, \ldots, w_j\) together with a valid formatting of \(w_1, \ldots, w_{i-1}\) (empty when \(i = 1\)), and its cost is \(S(i,j)^2\) plus the cost of that prefix formatting. Minimizing over the prefix first gives \(\mathrm{OPT}(i-1) + S(i,j)^2\) by the induction hypothesis, and minimizing over \(i\) gives the recurrence. The set of \(i\) is nonempty since \(S(j,j) = L - c_j \ge 0\). The inner loop may stop at the first \(i\) with \(S(i,j) < 0\), because \(S(i,j)\) strictly decreases as \(i\) decreases. The answer is \(\mathrm{OPT}(n)\), and the stored \(\mathrm{last}[\cdot]\) pointers recover the lines.

Running time. The prefix sums make each \(S(i,j)\) an \(O(1)\) computation, and there are at most \(n\) choices of \(i\) for each of the \(n\) values of \(j\), so the time is \(O(n^2)\).

Scan the days left to right, maintaining the cheapest day \(m\) seen so far; the best sale on day \(j\) buys on day \(m\), so the best pair is the best of these \(n - 1\) candidates.

m = 1; best = 0; (bi, bj) = none
for j = 2..n:
    if p(j) - p(m) > best: best = p(j) - p(m); (bi, bj) = (m, j)
    if p(j) < p(m): m = j
if best = 0: report that no profit is possible
else: return (bi, bj)

Correctness. Write \(m(j)\) for an index minimizing \(p\) over \(\{1, \ldots, j\}\); it satisfies the one-step recurrence \(m(1) = 1\) and \(m(j) = j\) if \(p(j) < p(m(j-1))\), else \(m(j) = m(j-1)\), which is exactly the update of \(m\), so at the top of iteration \(j\) the variable \(m\) equals \(m(j-1)\). Hence

\begin{equation*} \max_{1 \le i < j \le n} \bigl[p(j) - p(i)\bigr] = \max_{2 \le j \le n} \Bigl[p(j) - \min_{i < j} p(i)\Bigr] = \max_{2 \le j \le n} \bigl[p(j) - p(m(j-1))\bigr], \end{equation*}

and the loop computes the maximum of the right side over \(j\), recording a pair \((m(j-1), j)\) attaining it whenever it is positive. If every candidate is \(\le 0\), no pair makes money and the algorithm says so.

Running time. Each of the \(n - 1\) iterations does \(O(1)\) work, so the time is \(O(n)\).

(a) Take \(n = 2\) with

No \(j \le 2\) has \(f(j) \ge x_2 = 10\), so Schedule-EMP sets \(j = 2\), fires only in second 2 and stops (\(n - j = 0\)), destroying \(\min(10, f(2)) = 3\) robots. The correct answer is 4: firing in seconds 1 and 2 destroys \(\min(2, f(1)) + \min(10, f(1)) = 2 + 2 = 4\) (the other schedules give \(2\), \(3\) and \(0\)).

(b) Let \(\mathrm{OPT}(j)\) be the maximum number of robots destroyed in seconds \(1, \ldots, j\) by a schedule whose last activation is in second \(j\); with the convention that “second 0” is the drained start,

\begin{equation*} \mathrm{OPT}(0) = 0, \qquad \mathrm{OPT}(j) = \max_{0 \le i < j} \bigl[\mathrm{OPT}(i) + \min(x_j, f(j - i))\bigr], \end{equation*}

and the answer is \(\mathrm{OPT}(n)\).

OPT[0] = 0
for j = 1..n:
    OPT[j] = max over i = 0..j-1 of OPT[i] + min(x_j, f(j - i))
return OPT[n]

Correctness. A schedule ending in second \(j\) has a previous activation in some second \(i < j\) (or \(i = 0\) if second \(j\) is the first use), the EMP has charged for \(j - i\) seconds, so second \(j\) contributes \(\min(x_j, f(j-i))\), and the activations up to \(i\) form a schedule ending in second \(i\) whose kills are unaffected by what happens after \(i\). Maximizing over that prefix gives \(\mathrm{OPT}(i)\) by induction on \(j\), and maximizing over \(i\) gives the recurrence. Finally some optimal schedule activates in second \(n\): if a schedule’s last activation is at \(k < n\) (or there is none, \(k = 0\)), adding an activation at \(n\) leaves every earlier kill unchanged and adds \(\min(x_n, f(n-k)) \ge 0\). So the optimum over all schedules is \(\mathrm{OPT}(n)\).

Running time. Entry \(j\) takes \(O(j)\) evaluations of \(f\), so the total is \(\sum_{j=1}^{n} O(j) = O(n^2)\).

(a) Take \(n = 5\), \(x_i = 11\) for every \(i\), and \((s_1, \ldots, s_5) = (10, 4, 3, 2, 1)\). The optimal solution reboots on days 2 and 4, processing

\begin{equation*} 10 + 0 + 10 + 0 + 10 = 30, \end{equation*}

whereas never rebooting gives \(10 + 4 + 3 + 2 + 1 = 20\), and the best single reboot (on day 3) gives \(10 + 4 + 0 + 10 + 4 = 28\).

(b) Let \(\mathrm{OPT}(i, j)\) be the maximum amount processed on days \(i, \ldots, n\) given that day \(i\) is the \(j^{\text{th}}\) day since the last reboot (\(1 \le j \le i\)). On day \(i\) we either process, or reboot and start day \(i+1\) fresh, so

\begin{equation*} \begin{aligned} \mathrm{OPT}(n+1, j) &= 0, \\ \mathrm{OPT}(i, j) &= \max\bigl\{\min(x_i, s_j) + \mathrm{OPT}(i+1, j+1),\ \mathrm{OPT}(i+1, 1)\bigr\}, \end{aligned} \end{equation*}

and the answer is \(\mathrm{OPT}(1, 1)\).

for j = 1..n+1: OPT[n+1][j] = 0
for i = n down to 1:
    for j = 1..i:
        OPT[i][j] = max( min(x_i, s_j) + OPT[i+1][j+1], OPT[i+1][1] )
return OPT[1][1]

Correctness, by downward induction on \(i\). The only state that matters for days \(i, \ldots, n\) is the number \(j\) of days since the last reboot, since it alone fixes the capacity \(s_j\) on day \(i\) if we process. If we process on day \(i\) we gain \(\min(x_i, s_j)\) and day \(i+1\) is day \(j+1\) since the reboot; if we reboot we gain 0 and day \(i+1\) is day 1. In either case the rest of the schedule is an arbitrary schedule for days \(i+1, \ldots, n\) from the resulting state, whose best value is \(\mathrm{OPT}(i+1, j+1)\) or \(\mathrm{OPT}(i+1, 1)\) by induction; the better of the two options is \(\mathrm{OPT}(i, j)\). Day 1 starts freshly rebooted, so the optimum is \(\mathrm{OPT}(1, 1)\). (Indices stay in range: \(j \le i\) forces \(j + 1 \le n + 1\).)

Running time. There are \(\sum_{i=1}^{n} i = O(n^2)\) entries, each filled in \(O(1)\) time, so the time is \(O(n^2)\).

(a) Take \(n = 3\) with

The algorithm picks \(A\) in minute 1 (since \(2 > 1\)); at \(i = 2\) it sees \(b_3 = 10 > a_2 + a_3 = 2\), so it chooses move in minute 2 and \(B\) in minute 3, and stops. Its plan \(A\), move, \(B\) has value \(2 + 0 + 10 = 12\). The correct answer is \(21\), from the plan \(B, B, B\) with value \(1 + 10 + 10\) (no plan can do better, since \(\sum_i \max(a_i, b_i) = 22\) would require \(A\) then \(B\) in consecutive minutes).

(b) Let \(A(i)\), \(B(i)\), \(M(i)\) be the maximum value of a plan for minutes \(1, \ldots, i\) whose minute \(i\) is \(A\), \(B\), move respectively, with \(A(0) = B(0) = M(0) = 0\) standing for the empty plan. Minute \(i\) can be \(A\) only if minute \(i-1\) is \(A\) or move (or absent), likewise for \(B\), and a move may follow anything, so

\begin{equation*} \begin{aligned} A(i) &= a_i + \max\{A(i-1),\ M(i-1)\}, \\ B(i) &= b_i + \max\{B(i-1),\ M(i-1)\}, \\ M(i) &= \max\{A(i-1),\ B(i-1),\ M(i-1)\}, \end{aligned} \end{equation*}

and the optimal value is \(\max\{A(n), B(n), M(n)\}\).

A = B = M = 0
for i = 1..n:
    (A, B, M) = (a_i + max(A, M), b_i + max(B, M), max(A, B, M))
return max(A, B, M)

Correctness, by induction on \(i\). The only constraint on a plan is that \(A\) and \(B\) are never in consecutive minutes, so a sequence ending in \(A\) at minute \(i\) is a plan iff its first \(i - 1\) minutes form a plan whose last choice is not \(B\) (or \(i = 1\)). Its value is \(a_i\) plus the value of that prefix, and the best such prefix has value \(\max\{A(i-1), M(i-1)\}\) by induction (for \(i = 1\) this is \(0\), the empty plan). The same argument gives \(B(i)\), and for \(M(i)\) every plan for minutes \(1, \ldots, i-1\) may be extended by move, contributing \(0\). Every plan for minutes \(1, \ldots, n\) ends in one of the three choices, so the optimum is the largest of the three final values.

Running time. Each of the \(n\) iterations does \(O(1)\) work, so the time is \(O(n)\).

Let \(\mathrm{OPT}(j)\) be the minimum cost of a schedule for weeks \(1, \ldots, j\); week \(j\) is either shipped by A, or it ends a B-block covering weeks \(j-3, \ldots, j\), so

\begin{equation*} \mathrm{OPT}(j) = \min\bigl(\mathrm{OPT}(j-1) + r s_j,\ \mathrm{OPT}(j-4) + 4c\bigr), \qquad \mathrm{OPT}(0) = 0, \end{equation*}

where the second option is present only for \(j \ge 4\).

Algorithm. Fill \(M[0..n]\) by this recurrence for \(j = 1, \ldots, n\), recording which option attained the minimum; then trace back from \(j = n\): if A was chosen, assign A to week \(j\) and go to \(j-1\); otherwise assign B to weeks \(j-3..j\) and go to \(j-4\).

Correctness. By induction on \(j\). In any valid schedule for weeks \(1..j\) the B-weeks split into consecutive blocks of four, so either week \(j\) is an A-week and the rest is a valid schedule for weeks \(1..j-1\), costing at least \(\mathrm{OPT}(j-1)\), or week \(j\) is the last week of a B-block \(\{j-3, \ldots, j\}\) and the rest is a valid schedule for weeks \(1..j-4\), costing at least \(\mathrm{OPT}(j-4)\). Conversely, appending an A-week or a B-block to an optimal shorter schedule gives a valid schedule of the stated cost. Hence the recurrence holds, and the traceback produces a schedule achieving \(\mathrm{OPT}(n)\).

Running time. Each of the \(n\) entries takes \(O(1)\) time, and the traceback is \(O(n)\): total \(O(n)\).

Let \(\mathrm{OPT}(j)\) be the minimum total cost (placement plus access) of servers \(S_1, \ldots, S_j\) over configurations that place a copy at \(S_j\); conditioning on the previous copy \(S_i\) (\(i = 0\) meaning none),

\begin{equation*} \mathrm{OPT}(j) = c_j + \min_{0 \le i < j}\Bigl(\mathrm{OPT}(i) + \binom{j-i}{2}\Bigr), \qquad \mathrm{OPT}(0) = 0, \end{equation*}

and the answer is \(\mathrm{OPT}(n)\).

Algorithm. Compute \(\mathrm{OPT}(1), \ldots, \mathrm{OPT}(n)\) in order by the recurrence, storing the minimizing \(i\) for each \(j\); trace back from \(n\) through the stored indices to list the servers that receive a copy.

Correctness. Since searches only move to higher indices, the access cost of \(S_k\) depends only on the first copy at or after \(S_k\). Fix a configuration of \(S_1..S_j\) with a copy at \(S_j\), and let \(S_i\) be the last copy before \(S_j\) (\(i = 0\) if there is none). Each server \(S_k\) with \(i < k < j\) finds its copy at \(S_j\), at access cost \(j - k\), while servers \(S_1..S_i\) are served within the prefix ending at the copy \(S_i\). So the cost splits as

\begin{equation*} \begin{aligned} \text{cost} &= \bigl[\text{cost of } S_1..S_i\bigr] + c_j + \sum_{k=i+1}^{j-1} (j-k)\\ &= \bigl[\text{cost of } S_1..S_i\bigr] + c_j + \binom{j-i}{2}. \end{aligned} \end{equation*}

The bracket ranges over all configurations of \(S_1..S_i\) with a copy at \(S_i\), independently of the rest, so its minimum is \(\mathrm{OPT}(i)\). Minimizing over \(i\) gives the recurrence, and by induction on \(j\) the traceback yields a configuration of cost \(\mathrm{OPT}(n)\), which is optimal because every configuration has a copy at \(S_n\).

Running time. Entry \(j\) takes a minimum over \(j\) terms, each computed in \(O(1)\), so the total is \(\sum_j O(j) = O(n^2)\).

Give the edge \((i, j)\) of the complete directed graph on the \(n\) companies the cost \(c_{ij} = -\log r_{ij}\); opportunity cycles are then exactly negative cycles, which the negative-cycle algorithm of Section 6.10 finds.

Algorithm. Build the directed graph \(G\) with nodes \(1, \ldots, n\) and an edge \((i,j)\) of cost \(c_{ij} = -\log r_{ij}\) for every \(i \ne j\). Add a sink \(t\) with a cost-\(0\) edge from every node to \(t\), as in (6.29), and run the Bellman-Ford-based negative-cycle detection of Section 6.10 on it. If it reports no negative cycle, report that no opportunity cycle exists; otherwise output the negative cycle \(C\) it returns, which lies in \(G\) because no edge leaves \(t\).

Correctness. For any cycle \(C = i_1 i_2 \cdots i_k i_1\) (write \(i_{k+1} = i_1\)),

\begin{equation*} \sum_{a=1}^{k} c_{i_a i_{a+1}} = -\log \prod_{a=1}^{k} r_{i_a i_{a+1}}, \end{equation*}

so \(C\) has negative cost if and only if the product of its ratios exceeds \(1\), i.e. if and only if \(C\) is an opportunity cycle. By (6.29) the augmented graph has a negative cycle with a path to \(t\) if and only if \(G\) has a negative cycle, and by (6.34) the algorithm finds such a cycle whenever one exists. So it outputs an opportunity cycle if and only if one exists.

Running time. The graph has \(n+1\) nodes and \(m = n(n-1) + n = n^2\) edges, so by (6.34) the running time is \(O(mn) = O(n^3)\).

(a) Run breadth-first search from \(s\) in the intersection graph \(G^{*} = (V, E_0 \cap E_1 \cap \cdots \cap E_b)\) and return the BFS-tree path to \(t\). A path \(P\) is an \(s\)-\(t\) path in every \(G_i\) if and only if every edge of \(P\) lies in every \(E_i\), i.e. if and only if \(P\) is an \(s\)-\(t\) path in \(G^{*}\); so the paths in question are exactly the \(s\)-\(t\) paths of \(G^{*}\), and BFS finds one with the fewest edges (Section 3.2). With \(m = \max_i |E_i|\), the intersection is built in \(O(bm)\) time by marking edges (e.g. in an \(n \times n\) array or a hash table), and BFS takes \(O(m+n)\), for a total of \(O(b(m+n))\).

(b) For \(0 \le i \le j \le b\) let \(\ell(i,j)\) be the length of a shortest \(s\)-\(t\) path in \(G_{i,j} = (V, E_i \cap \cdots \cap E_j)\) (with \(\ell(i,j) = \infty\) if there is none), and let \(\mathrm{OPT}(j)\) be the minimum cost of a sequence \(P_0, \ldots, P_j\). Splitting at the start \(i\) of the last stretch on which the path is constant,

\begin{equation*} \mathrm{OPT}(j) = \min_{0 \le i \le j}\bigl(\mathrm{OPT}(i-1) + K + (j-i+1)\,\ell(i,j)\bigr), \qquad \mathrm{OPT}(-1) = -K, \end{equation*}

and the answer is \(\mathrm{OPT}(b)\); recording the minimizing \(i\) and a shortest path of \(G_{i,j}\) lets us trace back the sequence.

Algorithm. For \(j = 0, 1, \ldots, b\): let \(I = E_j\); for \(i = j, j-1, \ldots, 0\), replace \(I\) by \(I \cap E_i\), compute \(\ell(i,j)\) by BFS in \((V, I)\) (stop the inner loop once it is \(\infty\), since intersections only shrink), and update the minimum above.

Correctness. Write \(D(j)\) for the right-hand side. First, \(D(j) \le \mathrm{OPT}(j)\): in an optimal sequence for \(0..j\), let \(i\) be the first index with \(P_i = P_{i+1} = \cdots = P_j\). This common path \(P\) is an \(s\)-\(t\) path in each of \(G_i, \ldots, G_j\), so in \(G_{i,j}\) by part (a), and \(\ell(P) \ge \ell(i,j)\). If \(i > 0\) then \(P_{i-1} \ne P_i\) contributes one change, and \(P_0..P_{i-1}\) costs at least \(\mathrm{OPT}(i-1)\); if \(i = 0\) there is no change and the convention \(\mathrm{OPT}(-1) + K = 0\) accounts for it. Hence

\begin{equation*} \mathrm{OPT}(j) \ge \mathrm{OPT}(i-1) + K + (j-i+1)\,\ell(i,j) \ge D(j). \end{equation*}

Second, \(D(j) \ge \mathrm{OPT}(j)\): take an optimal sequence for \(0..i-1\) and append \(j-i+1\) copies of a shortest path of \(G_{i,j}\). This adds at most one change, so the new sequence costs at most \(\mathrm{OPT}(i-1) + K + (j-i+1)\ell(i,j)\), which is therefore \(\ge \mathrm{OPT}(j)\). By induction on \(j\), \(\mathrm{OPT}(j) = D(j)\), and the traceback produces a sequence of cost exactly \(\mathrm{OPT}(b)\) (its cost is at most the computed value by the second argument, and at least \(\mathrm{OPT}(b)\) by definition).

Running time. There are \(O(b^2)\) pairs \((i,j)\); for each, one intersection step costs \(O(m)\) with marked edges and one BFS costs \(O(m+n)\). The total is \(O(b^2(m+n))\), polynomial.

(a) Take \(n = 4\) with coordinates

Every event is legal (\(|d_4 - d_j| = 2, 0, 1, 0 \le 4 - j = 3, 2, 1, 0\)). The algorithm takes event \(1\) (reachable since \(|1 - 0| \le 1\)); from coordinate \(1\) at minute \(1\) it cannot reach event \(2\) (\(|-1-1| = 2 > 1\)) or event \(3\) (\(|-2-1| = 3 > 2\)), and it then takes event \(4\) (\(|-1-1| = 2 \le 3\)). So it outputs \(S = \{1, 4\}\), of size \(2\). The correct answer is \(\{2, 3, 4\}\), of size \(3\): the moves \(0 \to -1 \to -2 \to -1\) cover distances \(1, 1, 1\) in times \(2, 1, 1\). (All four events are not viewable, since \(1 \to -1\) in one minute is impossible, so \(3\) is optimal.)

(b) Let \(\mathrm{OPT}(j)\) be the maximum size of a viewable set whose last event is \(j\) (\(-\infty\) if none exists); then

\begin{equation*} \mathrm{OPT}(j) = 1 + \max\Bigl(\{0 : |d_j| \le j\} \cup \bigl\{\mathrm{OPT}(i) : i < j,\ |d_j - d_i| \le j - i\bigr\}\Bigr), \end{equation*}

with \(\max \emptyset = -\infty\), and the algorithm computes \(\mathrm{OPT}(1), \ldots, \mathrm{OPT}(n)\) in order and returns \(\mathrm{OPT}(n)\) (if this is \(-\infty\), i.e. \(|d_n| > n\), no viewable set contains event \(n\)).

Correctness. A set \(S = \{j_1 < \cdots < j_k\}\) is viewable exactly when every hop is fast enough,

\begin{equation*} \begin{aligned} &|d_{j_1} - 0| \le j_1 - 0,\\ &|d_{j_{a+1}} - d_{j_a}| \le j_{a+1} - j_a \quad (1 \le a < k), \end{aligned} \end{equation*}

since moving at full speed toward the next target and then waiting is always possible. Hence if \(S\) ends at \(j\), either \(S = \{j\}\) with \(|d_j| \le j\), or \(S \setminus \{j\}\) is viewable, ends at some \(i < j\) with \(|d_j - d_i| \le j - i\), and has size at most \(\mathrm{OPT}(i)\); conversely, appending \(j\) to an optimal viewable set ending at such an \(i\) (or taking \(\{j\}\) alone) gives a viewable set of size \(\mathrm{OPT}(i) + 1\) (or \(1\)). By induction on \(j\) the recurrence holds, and \(\mathrm{OPT}(n)\) is the size of an optimal solution, since an optimal solution must end at event \(n\).

Running time. Entry \(j\) scans \(j - 1\) earlier entries in \(O(1)\) each, so the total is \(O(n^2)\).

Compute bottom-up \(r(v)\), the minimum number of rounds to notify the subtree \(T_v\) once \(v\) knows, by having every node call its children in decreasing order of \(r\):

\begin{equation*} r(v) = \max_{1 \le j \le d} \bigl( j + r(c_j) \bigr), \qquad r(c_1) \ge r(c_2) \ge \dots \ge r(c_d), \end{equation*}

where \(c_1, \dots, c_d\) are the children of \(v\) (\(r(v) = 0\) for a leaf). The answer is \(r(\text{root})\), and the calls are: each \(v\), from the round after it is informed, calls \(c_1, c_2, \dots, c_d\) in this order.

Correctness. Induction up the tree. Only nodes of \(T_c\) ever call into \(T_c\), so in any scheme, once \(c\) is informed, \(T_c\) needs at least \(r( c)\) further rounds (induction hypothesis), and our scheme inside \(T_c\) achieves exactly \(r( c)\). Waiting idly never helps, so a scheme for \(T_v\) is an order \(c_{\sigma(1)}, \dots, c_{\sigma(d)}\) of calls by \(v\) in rounds \(1, \dots, d\), and the best it can do is \(\max_j (j + r(c_{\sigma(j)}))\). If some adjacent pair has \(a = c_{\sigma(j)}\), \(b = c_{\sigma(j+1)}\) with \(r(a) < r(b)\), swapping them replaces the two terms \(j + r(a)\), \(j+1+r(b)\) by

\begin{equation*} j + r(b) \le j + 1 + r(b), \qquad j + 1 + r(a) < j + 1 + r(b), \end{equation*}

so the maximum does not increase. Repeated swaps reach the decreasing order without increasing the cost, so that order is optimal and gives \(r(v)\).

Running time. Each node sorts its children once, so the total is \(\sum_v O(d_v \log d_v) = O(n \log n)\).

(a) Take \(n = 4\) and prices \(1, 5, 2, 3\). The algorithm jumps to day \(2\) (price \(5\)), after which no later price exceeds \(5\), so it returns \(L = 2\); but days \(1, 3, 4\) give the rising trend \(1 < 2 < 3\), and the true length is \(3\) (all four days do not rise, as \(5 > 2\)).

(b) Let \(\text{OPT}(j)\) be the length of the longest rising trend whose last day is \(j\), with \(\text{OPT}(j) = -\infty\) if none exists. Then

\begin{equation*} \text{OPT}(1) = 1, \qquad \text{OPT}(j) = 1 + \max\{\text{OPT}(i) : 1 \le i < j,\ P[i] < P[j]\} \quad (j \ge 2), \end{equation*}

with \(\max \emptyset = -\infty\), and the answer is \(\max_{1 \le j \le n} \text{OPT}(j)\) (which is at least \(\text{OPT}(1) = 1\)). Fill the array for \(j = 1, 2, \dots, n\).

Correctness. A rising trend ending at day \(j \ge 2\) has at least two days (it starts at day \(1\)); deleting day \(j\) leaves a rising trend ending at some \(i < j\) with \(P[i] < P[j]\), and conversely appending \(j\) to any rising trend ending at such an \(i\) gives a rising trend ending at \(j\). So the recurrence holds, by induction on \(j\).

Running time. Entry \(j\) scans \(j - 1\) earlier entries, so the total is \(\sum_j O(j) = O(n^2)\).

Run the alignment recurrence (6.16) while also counting optimal alignments, with counts capped at \(2\); the proposed alignment \(M\) is the unique optimum iff its cost equals \(\text{OPT}(m,n)\) and the capped count is \(1\).

Counting paths in \(G_{XY}\) would be wrong, since an alignment with consecutive gaps on both sides corresponds to several paths. So split the alignments of \(A_i = a_1 \cdots a_i\) and \(B_j = b_1 \cdots b_j\) into three disjoint classes, exhaustive by (6.14): (i) \((i,j) \in M\); (ii) \(a_i\) unmatched; (iii) \(a_i\) matched but \((i,j) \notin M\), so \(b_j\) unmatched. Keep two tables of pairs (minimum cost, number of alignments attaining it, capped at \(2\)): \(Q(i,j)\) over all alignments of \(A_i, B_j\), and \(P(i,j)\) over those in which \(a_i\) is matched, i.e. classes (i) and (iii). Removing \((i,j)\), resp. \(a_i\), resp. \(b_j\) is a bijection from class (i), (ii), (iii) onto all alignments of \((A_{i-1}, B_{j-1})\), all of \((A_{i-1}, B_j)\), and those of \((A_i, B_{j-1})\) with \(a_i\) matched, so

\begin{equation*} \begin{aligned} P(i,j) &= \operatorname{comb}\bigl(\alpha_{a_i b_j} + Q(i-1,j-1),\ \delta + P(i,j-1)\bigr),\\ Q(i,j) &= \operatorname{comb}\bigl(P(i,j),\ \delta + Q(i-1,j)\bigr), \end{aligned} \end{equation*}

where adding a constant shifts the cost and keeps the count, and \(\operatorname{comb}\) takes the smaller cost with the sum (capped at \(2\)) of the counts of the terms attaining it. The base cases are \(Q(i,0) = (i\delta, 1)\), \(Q(0,j) = (j\delta, 1)\), \(P(i,0) = P(0,j) = (\infty, 0)\). By induction on \(i + j\), the first coordinate of \(Q(i,j)\) is \(\text{OPT}(i,j)\) and the second is \(\min(2, \#\{\text{optimal alignments of } A_i, B_j\})\); capping commutes with addition, since \(\min(2, x+y) = \min(2, \min(2,x) + \min(2,y))\).

Finally, compute \(\text{cost}(M) = \delta(m + n - 2|M|) + \sum_{(i,j) \in M} \alpha_{a_i b_j}\) and answer yes iff \(Q(m,n) = (\text{cost}(M), 1)\): the first coordinate says \(M\) is optimal, the second that no other alignment is.

Running time. There are \(2(m+1)(n+1)\) table entries, each computed in \(O(1)\) from earlier ones, and \(\text{cost}(M)\) takes \(O(m+n)\); the total is \(O(mn)\).

Let \(X_i\) and \(Y_j\) be the length-\(i\) prefix of \(x^\infty\) and the length-\(j\) prefix of \(y^\infty\) (so the repetitions of \(x\) are exactly the \(X_i\)), and fill a Boolean table \(M[i,j]\) = “\(s[1..i+j]\) is an interleaving of \(X_i\) and \(Y_j\)”, i.e. can be split into subsequences equal to \(X_i\) and \(Y_j\). With \(|s| = n\), \(p = |x|\), \(q = |y|\):

\begin{equation*} \begin{aligned} M[0,0] &= \text{true},\\ M[i,j] &= \bigl(i \ge 1 \wedge M[i-1,j] \wedge s[i+j] = x[((i-1) \bmod p) + 1]\bigr)\\ &\quad \vee \bigl(j \ge 1 \wedge M[i,j-1] \wedge s[i+j] = y[((j-1) \bmod q) + 1]\bigr), \end{aligned} \end{equation*}

computed in increasing order of \(i + j \le n\). Then \(s\) is an interleaving of \(x\) and \(y\) iff \(M[i, n-i]\) holds for some \(0 \le i \le n\).

Correctness. Induction on \(i + j\). In any split of \(s[1..i+j]\) into \(X_i\) and \(Y_j\), the last symbol \(s[i+j]\) is either the last symbol of \(X_i\), namely \(x[((i-1) \bmod p)+1]\), and the rest is a split of \(s[1..i+j-1]\) into \(X_{i-1}, Y_j\); or symmetrically the last symbol of \(Y_j\). Conversely each such split of \(s[1..i+j-1]\) extends by putting \(s[i+j]\) on the matching side. So \(M[i,j]\) satisfies the recurrence. Finally \(s\) is an interleaving iff it splits into \(X_i\) and \(Y_{n-i}\) for some \(i\), since the two parts have lengths summing to \(n\).

Running time. There are \(O(n^2)\) entries with \(i + j \le n\), each \(O(1)\), so the total is \(O(n^2)\).

Maximize the total \(\sum_i f_i(h_i)\) (equivalently the average) by a knapsack-style recurrence: let \(\text{OPT}(i, h)\) be the largest total grade on courses \(1, \dots, i\) using at most \(h\) hours in all. Then

\begin{equation*} \text{OPT}(0, h) = 0, \qquad \text{OPT}(i, h) = \max_{0 \le k \le h} \bigl( f_i(k) + \text{OPT}(i-1, h-k) \bigr), \end{equation*}

for \(1 \le i \le n\), \(0 \le h \le H\); the best average is \(\text{OPT}(n, H)/n\). Recording the maximizing \(k\) in each entry and tracing back from \((n, H)\) gives the hours \(h_n, h_{n-1}, \dots, h_1\); adding the unused hours to any project does not lower its grade (the \(f_i\) are nondecreasing), so the allocation can be taken to use exactly \(H\) hours.

Correctness. Induction on \(i\): an allocation for courses \(1, \dots, i\) within \(h\) hours gives some \(k \in \{0, \dots, h\}\) hours to course \(i\) and is an allocation for courses \(1, \dots, i-1\) within \(h - k\) hours on the rest, and every such pair combines into one; so the maximum splits as in the recurrence.

Running time. There are \((n+1)(H+1)\) entries, each a maximum over at most \(H + 1\) terms, so the total is \(O(nH^2)\), polynomial in \(n\) and \(H\) (and independent of \(g\)).

Let \(\mathrm{OPT}(j, i)\) be the largest value of \(\sum (p(s_\ell) - p(b_\ell))\) over strategies with at most \(j\) pairs that use only days \(1, \ldots, i\); condition on whether day \(i\) is the last sell day. The answer is \(1{,}000 \cdot \mathrm{OPT}(k, n)\), with

\begin{equation*} \begin{aligned} \mathrm{OPT}(0, i) &= \mathrm{OPT}(j, 0) = \mathrm{OPT}(j,1) = 0,\\ \mathrm{OPT}(j, i) &= \max\Bigl(\mathrm{OPT}(j, i-1),\; p(i) + \max_{1 \le b < i}\bigl(\mathrm{OPT}(j-1, b-1) - p(b)\bigr)\Bigr). \end{aligned} \end{equation*}

for j = 1..k:
    M = -infinity                       # max over b < i of OPT(j-1,b-1) - p(b)
    for i = 2..n:
        M = max(M, OPT[j-1][i-2] - p(i-1))
        OPT[j][i] = max(OPT[j][i-1], M + p(i))
return 1000 * OPT[k][n]

Correctness. By induction on \((j, i)\). Take an optimal strategy \(\mathcal{S}\) for \((j, i)\). (i) If \(\mathcal{S}\) does not sell on day \(i\), it uses only days \(1, \ldots, i-1\), so its value is \(\mathrm{OPT}(j, i-1)\). (ii) If \(s_m = i\) with buy day \(b = b_m < i\), the other \(m-1 \le j-1\) pairs lie in days \(1, \ldots, b-1\) (since \(s_{m-1} < b_m\)), so they are worth at most \(\mathrm{OPT}(j-1, b-1)\), and conversely any such strategy on days \(1,\ldots,b-1\) extends by \((b, i)\). Hence the recurrence takes the max over exactly the feasible strategies. The variable \(M\) equals \(\max_{1 \le b < i}(\mathrm{OPT}(j-1,b-1) - p(b))\) because each \(i\) adds exactly the term \(b = i-1\). The strategy itself is recovered by the usual traceback, recording for each \((j,i)\) which branch and which \(b\) attained the max.

Running time. Each of the \(kn\) entries costs \(O(1)\) thanks to the running maximum \(M\), so the algorithm runs in \(O(nk)\) time.

Compute the distances \(d(u)\) from every node to \(w\) with Bellman-Ford, keep only the tight edges \((u,x)\) with \(d(u) = c_{ux} + d(x)\), and count \(u\)-\(w\) paths in this tight subgraph, which is a DAG.

run Bellman-Ford with sink w to get d(u) for all u
if d(v) = infinity: return 0
H = edges (u,x) with d(x) finite and d(u) = c_ux + d(x)
N(w) = 1
for u in reverse topological order of H, u != w:
    N(u) = sum of N(x) over edges (u,x) in H
return N(v)

Correctness. There are no negative cycles, so by (6.24)–(6.25) Bellman-Ford returns the true distances \(d(u)\) to \(w\), and by (6.22) these are attained by simple paths. Every edge satisfies \(d(u) \le c_{ux} + d(x)\), so for any \(u\)-\(w\) path \(P = u_0 u_1 \cdots u_r\)

\begin{equation*} \begin{aligned} c(P) = \sum_{i=0}^{r-1} c_{u_i u_{i+1}} &\ge \sum_{i=0}^{r-1} \bigl(d(u_i) - d(u_{i+1})\bigr)\\ &= d(u) - d(w) = d(u), \end{aligned} \end{equation*}

with equality iff every edge of \(P\) is tight. Hence the shortest \(u\)-\(w\) paths are exactly the \(u\)-\(w\) paths of \(H\). The graph \(H\) is acyclic: a cycle \(C\) of tight edges would telescope to \(c( C) = \sum (d(u_i) - d(u_{i+1})) = 0\), contradicting that every cycle has strictly positive cost. So a topological order of \(H\) exists (Section 3.6). Splitting the \(u\)-\(w\) paths of \(H\) (\(u \ne w\)) by their first edge \((u, x) \in H\) gives \(N(u) = \sum_{(u,x) \in H} N(x)\), with \(N(w) = 1\) (the trivial path; no tight path leaves \(w\) and returns, as that would be a tight cycle). By induction along the reverse topological order, \(N(v)\) is the number of shortest \(v\)-\(w\) paths.

Running time. Bellman-Ford takes \(O(mn)\) by (6.25); building \(H\), topologically sorting it (Section 3.6) and the counting pass take \(O(m + n)\) additions. The total is \(O(mn)\) arithmetic operations, on counts of at most \(2^{n-2}\) (a path in the DAG \(H\) is determined by its set of interior nodes), i.e. \(O(n)\)-bit integers.

(a) Accept iff (i) \(d(t) = 0\), (ii) \(d(v) \le c_{vw} + d(w)\) for every edge \((v,w)\), and (iii) every node reaches \(t\) using only tight edges, those with \(d(v) = c_{vw} + d(w)\). (As in Section 6.8, “minimum-cost path” means the minimum over all \(v\)-\(t\) walks, which is finite and attained by a simple path when no negative cycle is reachable, by (6.22).)

if d(t) != 0: reject
for each edge (v,w): if d(v) > c_vw + d(w): reject
R = reverse of the tight edges
search (BFS) from t in R
accept iff every node was reached

Sufficiency. By (ii), for any \(v\)-\(t\) walk \(P = v_0 v_1 \cdots v_r\),

\begin{equation*} c(P) \ge \sum_{i=0}^{r-1} \bigl(d(v_i) - d(v_{i+1})\bigr) = d(v) - d(t) = d(v), \end{equation*}

and the same telescoping gives \(c( C) \ge 0\) for every cycle, so the minimum is well defined; by (iii) some tight \(v\)-\(t\) path exists, and its cost is exactly \(d(v)\). Hence \(d(v)\) is the minimum cost.

Necessity. If the claim holds, (i) holds because the minimum over \(t\)-\(t\) walks is the empty walk (no negative cycles, as all \(d\) are finite); (ii) holds since \(c_{vw}\) plus a cheapest \(w\)-\(t\) path is a \(v\)-\(t\) path; and for (iii), every node has a \(v\)-\(t\) path (all \(d(v)\) are finite), and along a shortest one \(v_0 \cdots v_r\) each suffix is shortest, so \(d(v_i) = c_{v_i v_{i+1}} + d(v_{i+1})\) and every edge is tight.

The test reads each edge a constant number of times and does one BFS (Section 3.2), so it runs in \(O(m + n)\) time; since every node must reach \(t\), an accepted graph has \(m \ge n - 1\), and we may reject at once if \(m < n-1\), giving \(O(m)\).

(b) Run Dijkstra’s Algorithm with the reduced costs \(c^{\prime}\), which are nonnegative, toward \(t^{\prime}\) (on the reversed graph), and correct the answers by \(d^{\prime}(v) = d_{c^{\prime}}(v) + d(v) - d(t^{\prime})\).

By (ii) of part (a), \(c^{\prime}_{vw} = c_{vw} - d(v) + d(w) \ge 0\) for every edge. For any \(u\)-\(t^{\prime}\) path \(P = u_0 \cdots u_r\) the potentials telescope:

\begin{equation*} \begin{aligned} c^{\prime}(P) &= \sum_{i=0}^{r-1} \bigl(c_{u_i u_{i+1}} - d(u_i) + d(u_{i+1})\bigr)\\ &= c(P) - d(u) + d(t^{\prime}). \end{aligned} \end{equation*}

The correction term depends only on the endpoints, so \(P\) minimizes \(c^{\prime}\) among \(u\)-\(t^{\prime}\) paths iff it minimizes \(c\), and \(d^{\prime}(u) = d_{c^{\prime}}(u) + d(u) - d(t^{\prime})\) (both sides \(\infty\) when \(u\) cannot reach \(t^{\prime}\)). Dijkstra’s Algorithm from \(t^{\prime}\) on the reversed graph computes \(d_{c^{\prime}}\) correctly since all costs are nonnegative (4.14), and with a heap-based priority queue it runs in \(O(m \log n)\) by (4.15); computing \(c^{\prime}\) and the corrections is \(O(m + n)\). Total: \(O(m \log n)\).

Compute, by a subset-sum style dynamic program, every value \(s\) that the party-A count of some set of exactly \(n/2\) precincts can take; the precincts are susceptible iff some such \(s\) lies strictly between \(nm/4\) and \(T - nm/4\) (in either order), where \(T = \sum_i a_i\) and \(a_i\) is the party-A count of \(P_i\).

The criterion. Each district has \(nm/2\) voters, so a party has a majority in it iff it has more than \(nm/4\) of them. Let \(S\) be a district with \(A(S) = \sum_{i \in S} a_i\); its complement has \(T - A(S)\) A-voters, and party B holds a majority in \(S\) iff \(A(S) < nm/4\). Hence

\begin{equation*} \begin{aligned} \text{A wins both} &\iff nm/4 < A(S) < T - nm/4,\\ \text{B wins both} &\iff T - nm/4 < A(S) < nm/4 . \end{aligned} \end{equation*}

The DP. Let \(R(j, k, s)\) be true iff some \(k\) of the precincts \(P_1, \ldots, P_j\) have A-total exactly \(s\), for \(0 \le j \le n\), \(0 \le k \le n/2\), \(0 \le s \le nm/2\). Then \(R(0, 0, 0)\) is true, \(R(0, k, s)\) is false otherwise, and

\begin{equation*} \begin{aligned} R(j, k, s) = R(j-1, k, s) \;\vee\; \bigl(&k \ge 1 \wedge s \ge a_j\\ &\wedge R(j-1, k-1, s - a_j)\bigr), \end{aligned} \end{equation*}

by conditioning on whether \(P_j\) is chosen (an induction on \(j\) shows the table is exactly the set of realizable \((k, s)\)). Answer “susceptible” iff \(R(n, n/2, s)\) holds for some \(s\) satisfying one of the two displayed conditions. (A sum over \(n/2\) precincts is at most \(nm/2\), so the range of \(s\) suffices.)

Running time. The table has \((n+1)(n/2+1)(nm/2+1) = O(n^3 m)\) entries, each filled in \(O(1)\), and the final scan is \(O(nm)\): total \(O(n^3 m)\).

Charge each day’s price drop to all the shares still unsold on that day; then the income splits into per-day terms that depend only on \(y_j\) and the number \(r_j = y_j + \cdots + y_n\) of shares left, and a DP over (day, shares left) solves it. Set \(f(0) = 0\) (selling nothing moves no price).

Rewriting the income. Swapping the order of summation,

\begin{equation*} \begin{aligned} \sum_{i=1}^{n} y_i \Bigl(p_i - \sum_{j \le i} f(y_j)\Bigr) &= \sum_{i=1}^n y_i p_i - \sum_{j=1}^{n} f(y_j) \sum_{i \ge j} y_i\\ &= \sum_{j=1}^{n} \bigl(y_j p_j - f(y_j)\, r_j\bigr). \end{aligned} \end{equation*}

The DP. Let \(\mathrm{OPT}(j, r)\) be the maximum of \(\sum_{i \ge j} (y_i p_i - f(y_i) r_i)\) over natural numbers \(y_j, \ldots, y_n\) summing to \(r\) (so \(r_j = r\)). Choosing \(y = y_j\) leaves \(r - y\) shares for days \(j+1, \ldots, n\), and the remaining terms depend only on \(y_{j+1}, \ldots, y_n\), so

\begin{equation*} \begin{aligned} \mathrm{OPT}(n+1, 0) &= 0, \qquad \mathrm{OPT}(n+1, r) = -\infty \ (r > 0),\\ \mathrm{OPT}(j, r) &= \max_{0 \le y \le r} \bigl( y\, p_j - f(y)\, r + \mathrm{OPT}(j+1, r-y) \bigr), \end{aligned} \end{equation*}

and the answer is \(\mathrm{OPT}(1, x)\), with the \(y_j\) recovered by recording the maximizing \(y\) for each \((j, r)\) and tracing forward from \((1, x)\). Correctness is induction on \(j\) downward from \(n+1\), the identity above showing that \(\mathrm{OPT}(1,x)\) is exactly the maximum total income.

Running time. There are \(n(x+1)\) entries, each a max over at most \(x+1\) choices: \(O(n x^2)\) time.

Run a dynamic program over (month, trucks carried into that month): there are only \(S+1\) possible stock levels, and fixing the stock left after month \(i\) fixes how much month \(i\)’s order must be.

Let \(\mathrm{OPT}(i,s)\) be the minimum cost of months \(i, \dots, n\) when \(s \in \{0,\dots,S\}\) trucks are carried into month \(i\), and let \(\mathrm{OPT}(n+1,s) = 0\). In month \(i\) we either place no order, which is allowed only if \(s \ge d_i\) and leaves \(s - d_i\) trucks, or we place one order and choose any leftover \(s^{\prime} \in \{\max(0, s-d_i), \dots, S\}\), which means ordering \(s^{\prime} + d_i - s \ge 0\) trucks. In both cases the leftover \(s^{\prime}\) is stored at cost \(Cs^{\prime}\). So

\begin{equation*} \begin{aligned} \mathrm{OPT}(i,s) = \min\Big\{\, & C(s-d_i) + \mathrm{OPT}(i+1, s-d_i) \quad [\text{only if } s \ge d_i], \\ & \min_{\max(0,s-d_i) \le s^{\prime} \le S} \big( K + Cs^{\prime} + \mathrm{OPT}(i+1, s^{\prime}) \big) \Big\}, \end{aligned} \end{equation*}

and the answer is \(\mathrm{OPT}(1,0)\).

for s = 0..S: M[n+1][s] = 0
for i = n down to 1:
    for s = 0..S:
        M[i][s] = min over s' in [max(0,s-d_i), S] of K + C*s' + M[i+1][s']
        if s >= d_i: M[i][s] = min(M[i][s], C*(s-d_i) + M[i+1][s-d_i])
return M[1][0]   (trace back the argmins to read off the orders)

Correctness. We use induction on \(i\) going downward. The case \(i = n+1\) holds because nothing remains to be paid. A feasible plan for months \(i..n\) that starts with \(s\) trucks makes one decision in month \(i\): order or not, and if it orders, how many trucks. That decision fixes the leftover \(s^{\prime}\), which has to satisfy \(0 \le s^{\prime} \le S\), and \(s^{\prime} = s - d_i\) when there is no order. The plan’s cost for month \(i\) is \(Cs^{\prime}\), plus \(K\) if it ordered. Its remaining decisions form a feasible plan for months \(i+1..n\) that starts with \(s^{\prime}\) trucks, so by induction they cost at least \(\mathrm{OPT}(i+1,s^{\prime})\). Every such pair (month-\(i\) decision, optimal rest) is feasible, so the minimum in the recurrence is attained. A single order per month is enough, since splitting it only adds fees.

Running time. The table has \(n(S+1)\) entries, and each one takes a minimum over at most \(S+2\) terms, so the algorithm runs in \(O(nS^2)\) time.

Some optimal plan orders only on days when the tank is empty, and each such order covers exactly the next run of days, so a segmentation dynamic program like the one for segmented least squares (Section 6.3) finds it.

Model. An order placed on day \(i\) arrives at the start of day \(i\). The tank level after the delivery may not exceed \(L\). Day \(i\)’s \(g_i\) gallons are used during day \(i\). Let \(I_t\) be the level at the end of day \(t\), with \(I_0 = 0\) and \(I_n = 0\). The storage cost is \(c\sum_t I_t\), so a gallon delivered on day \(i\) and used on day \(t\) costs \(c(t-i)\). Every plan buys the same \(\sum_t g_t\) gallons, so the price of the gas itself is a constant. Write

\begin{equation*} G(i,j) = \sum_{t=i}^{j} g_t, \qquad W(i,j) = \sum_{t=i}^{j} (t-i)\, g_t . \end{equation*}

Zero-inventory property: every optimal plan orders only when \(I_{j-1} = 0\). Suppose not. Let \(j\) be the first order day with \(r = I_{j-1} > 0\), and let \(i < j\) be the last order day before \(j\). By the minimality of \(j\) we have \(I_{i-1} = 0\), so the order size is \(q_i \ge I_i \ge r\). Between days \(i\) and \(j-1\) nothing is delivered, so \(I_t \ge I_{j-1} = r\) for \(i \le t \le j-1\). Now move \(r\) gallons from order \(i\) to order \(j\). Each \(I_t\) with \(i \le t < j\) drops by \(r\) and stays \(\ge 0\). The level after delivery on day \(j\) does not change, and on day \(i\) it decreases. No new order is created. The storage cost falls by \(cr(j-i) > 0\) (as \(c > 0\)), which contradicts optimality.

So an optimal plan splits days \(1..n\) into consecutive blocks. Each block \([i,j]\) is served by one order of exactly \(G(i,j)\) gallons on day \(i\), which is feasible iff \(G(i,j) \le L\) and costs \(P + cW(i,j)\). A leading block with \(G(1,j) = 0\) needs no order. Let \(\mathrm{OPT}(j)\) be the minimum cost of days \(1..j\) with \(I_j = 0\). Then \(\mathrm{OPT}(0) = 0\), and

\begin{equation*} \mathrm{OPT}(j) = \begin{cases} 0, & G(1,j) = 0,\\[2pt] \min\limits_{1 \le i \le j,\ G(i,j) \le L} \big(\mathrm{OPT}(i-1) + P + cW(i,j)\big), & \text{otherwise}. \end{cases} \end{equation*}

To see why this holds, look at an optimal plan for days \(1..j\). Let \(i\) be its last order day. By the zero-inventory property we have \(I_{i-1} = 0\), so that order is exactly \(G(i,j)\), and what the plan does on days \(1..i-1\) costs at least \(\mathrm{OPT}(i-1)\). In the other direction, every term of the recurrence is achieved by a feasible plan. The answer is \(\mathrm{OPT}(n)\), and it is infeasible exactly when some \(g_t > L\). To output the plan, trace back the minimizing \(i\)’s; each one is an order day, and the amount ordered is \(G(i,j)\).

Running time. With the prefix sums \(A_j = \sum_{t \le j} g_t\) and \(B_j = \sum_{t \le j} t\,g_t\), which take \(O(n)\) to compute, we get

\begin{equation*} G(i,j) = A_j - A_{i-1}, \qquad W(i,j) = (B_j - B_{i-1}) - i\,(A_j - A_{i-1}), \end{equation*}

each in \(O(1)\). That leaves \(O(n)\) choices of \(i\) for each of the \(n\) values of \(j\), so the total time is \(O(n^2)\).

(a) Take any schedulable set \(J\) of maximum size and schedule it with the greedy Earliest Deadline First rule of Section 4.2. Because \(J\) is schedulable, some schedule of \(J\) has maximum lateness \(0\). By (4.10), applied to the instance made of the jobs in \(J\), the greedy schedule \(A\), which runs \(J\) back to back from \(s\) in increasing order of deadline, has the optimal maximum lateness. Hence

\begin{equation*} \max_{j \in J}\, (f_j - d_j)^+ \text{ in } A \;\le\; 0 , \end{equation*}

so every job of \(J\) meets its deadline in \(A\), and \(A\) is an optimal solution that runs its jobs in increasing order of deadline.

(b) Sort the jobs by deadline and run a knapsack-style dynamic program over (jobs considered, total processing time). We shift time so that \(s = 0\), taking \(s\) to be an integer like the \(d_i\) and \(t_i\). Number the jobs so that \(d_1 \le \dots \le d_n\), and call \(J\) EDF-feasible if running \(J\) back to back from time \(0\) in index order meets every deadline, that is, \(\sum_{l \in J,\, l \le j} t_l \le d_j\) for all \(j \in J\). By (a), a set is schedulable iff it is EDF-feasible. (Index order is an Earliest Deadline First order, and (4.10) holds with ties broken arbitrarily.) For \(0 \le u \le D\), let \(\mathrm{OPT}(i,u)\) be the maximum \(|J|\) over EDF-feasible \(J \subseteq \{1,\dots,i\}\) with \(\sum_{l\in J} t_l \le u\). Then \(\mathrm{OPT}(0,u) = 0\) and

\begin{equation*} \begin{aligned} \mathrm{OPT}(i,u) = \max\big\{ & \mathrm{OPT}(i-1,u), \\ & 1 + \mathrm{OPT}(i-1,\ \min(u,d_i) - t_i) \ \ [\text{only if } \min(u,d_i) \ge t_i] \big\}. \end{aligned} \end{equation*}

The answer is \(\mathrm{OPT}(n,D)\). A traceback recovers \(J\), which we then run back to back in deadline order.

Correctness. Let \(J\) be EDF-feasible with \(J \subseteq \{1..i\}\) and total time at most \(u\).

• (i) If \(i \notin J\), then \(J\) is counted by \(\mathrm{OPT}(i-1,u)\).
• (ii) If \(i \in J\), then \(i\) runs last, finishing at \(\sum_{l\in J} t_l \le \min(u,d_i)\). The jobs of \(J^{\prime} = J \setminus \{i\}\) finish at the same times as before, so \(J^{\prime}\) is EDF-feasible with total time at most \(\min(u,d_i) - t_i\), and \(|J| \le 1 + \mathrm{OPT}(i-1, \min(u,d_i)-t_i)\).

In the other direction, adding job \(i\) to an EDF-feasible \(J^{\prime} \subseteq \{1..i-1\}\) of total time at most \(\min(u,d_i) - t_i\) gives an EDF-feasible set whose new last job finishes by \(\min(u,d_i)\). So both branches are achievable, and induction on \(i\) proves the recurrence. Every EDF-feasible set has total time at most \(D\), so \(\mathrm{OPT}(n,D)\) is the optimum.

Running time. Sorting takes \(O(n\log n)\). The table has \((n+1)(D+1)\) entries, each filled in \(O(1)\), so the total is \(O(n\log n + nD)\).

We can take \(f(k) = 3^k\) and \(p(n) = n^2\), using the Dreyfus-Wagner dynamic program over pairs (set of terminals, one extra node).

For \(D \subseteq X\) and \(v \in V\), let \(S(D,v)\) be the minimum weight of a Steiner tree on \(D \cup \{v\}\), and set \(w_{vv} = 0\). Then \(S(\emptyset, v) = 0\), \(S(\{x\},v) = w_{xv}\), and \(S(D,v) = S(D\setminus\{v\}, v)\) when \(v \in D\). For \(v \notin D\) with \(|D| \ge 2\),

\begin{equation*} \begin{aligned} S(D,v) = \min_{u \in V}\Big( w_{vu} + \min_{\emptyset \ne D_1 \subsetneq D} \big[ S(D_1,u) + S(D \setminus D_1,u) \big] \Big). \end{aligned} \end{equation*}

The answer is \(S(X\setminus\{x\}, x)\) for any \(x \in X\) (and \(0\) if \(k = 0\)). We fill the table in order of increasing \(|D|\) and recover the tree by tracing back.

The recurrence is an upper bound. Take trees achieving \(S(D_1,u)\) and \(S(D\setminus D_1,u)\) and add the edge \((v,u)\). The union is a connected subgraph that contains \(D \cup \{v\}\) and has weight at most the bracketed sum. One of its spanning trees is a Steiner tree on \(D \cup \{v\}\) of no greater weight.

The recurrence is a lower bound. Let \(T\) be an optimal Steiner tree on \(D \cup \{v\}\), where \(v \notin D\) and \(|D| \ge 2\). Every leaf of \(T\) lies in \(D \cup \{v\}\), since a leaf outside that set could be deleted and the weights are positive. For any node \(u\), call a split of a tree containing \(D^{\prime} \cup \{u\}\) at \(u\) the following: break it at \(u\) into two edge-disjoint subtrees through \(u\), each containing a terminal. This needs \(\deg(u) \ge 2\), and each branch ends in a leaf of \(D^{\prime}\). Such a tree then weighs at least \(S(D_1,u) + S(D^{\prime}\setminus D_1,u)\) for some nonempty proper \(D_1 \subset D^{\prime}\).

• (i) \(\deg_T(v) \ge 2\). Split \(T\) at \(u = v\), and use \(w_{vv} = 0\).
• (ii) \(\deg_T(v) = 1\). Walk from \(v\) to the first node \(u \ne v\) that lies in \(D\) or has \(\deg_T(u) \ge 3\). The nodes passed on the way have degree \(2\) and are not terminals. Removing the path \(P\) from \(v\) to \(u\) leaves a tree \(T^{\prime}\) that contains \(D \cup \{u\}\), and \(w(P) \ge w_{vu}\) by the triangle inequality. One of three things holds:
  • (ii-a) \(\deg_{T^{\prime}}(u) \ge 2\), and we split \(T^{\prime}\) at \(u\);
  • (ii-b) \(\deg_{T^{\prime}}(u) = 1\), so \(u \in D\), and we take \(D_1 = \{u\}\), which gives \(S(\{u\},u) = 0\) and \(w(T^{\prime}) \ge S(D\setminus\{u\},u)\);
  • (ii-c) \(\deg_{T^{\prime}}(u) = 0\), which is impossible because \(|D| \ge 2\).

In every case \(w(T)\) is at least one term of the recurrence.

Running time. For each \(D\) and \(u\), precompute \(B(D,u) = \min_{D_1} [S(D_1,u) + S(D\setminus D_1,u)]\). Over all \(D\) this takes \(n\sum_{D} 2^{|D|} = n\,3^{k}\) steps. Then each \(S(D,v) = \min_u (w_{vu} + B(D,u))\) costs \(O(n)\), which adds up to \(n^2 2^k\). The total is

\begin{equation*} O(3^k n + 2^k n^2) = O(3^k \cdot n^2). \end{equation*}

(a) The minimum cuts are \((\{s\},\{u,v,t\})\), \((\{s,v\},\{u,t\})\) and \((\{s,u,v\},\{t\})\), each of capacity \(2\). Writing a cut by its source side \(A\), the four cuts have capacities

\begin{equation*} \begin{aligned} c(\{s\}) &= c_{su}+c_{sv} = 2, & c(\{s,u\}) &= c_{sv}+c_{uv}+c_{ut} = 3,\\ c(\{s,v\}) &= c_{su}+c_{vt} = 2, & c(\{s,u,v\}) &= c_{ut}+c_{vt} = 2, \end{aligned} \end{equation*}

(for \(A=\{s,v\}\) the edge \(u\to v\) enters \(A\) and does not count), so the minimum is \(2\), attained exactly by the three cuts listed.

(b) The minimum capacity is \(4\). The four cuts have capacities

\begin{equation*} \begin{aligned} c(\{s\}) &= 2+4 = 6, & c(\{s,u\}) &= 4+6+4 = 14,\\ c(\{s,v\}) &= 2+2 = 4, & c(\{s,u,v\}) &= 4+2 = 6, \end{aligned} \end{equation*}

and the minimum is \(c(\{s,v\})=4\) (again \(u\to v\) enters \(A\)).

(a) The value is \(\nu(f) = 5+8+5 = 18\), and it is not maximum. In the residual graph \(G_f\) the path

\begin{equation*} s \xrightarrow{\,5\,} a \xrightarrow{\,3\,} c \xrightarrow{\,8\,} b \xrightarrow{\,3\,} d \xrightarrow{\,5\,} t \end{equation*}

exists (\(c\to b\) is the backward edge of \(b\to c\); the labels are residual capacities), so augmenting by its bottleneck \(3\) gives, by (7.3), a flow \(f^{\prime}\) of value \(21\): \(f^{\prime}(s,a)=8\), \(f^{\prime}(a,c)=3\), \(f^{\prime}(b,c)=5\), \(f^{\prime}(b,d)=3\), \(f^{\prime}(d,t)=8\), all other edges unchanged.

(b) A minimum cut is \(A=\{s,a\}\), \(B=\{b,c,d,t\}\), of capacity

\begin{equation*} c(A,B) = c_{sb}+c_{sd}+c_{ac}+c_{at} = 8+5+3+5 = 21 \end{equation*}

(\(b\to a\) enters \(A\) and does not count). Since \(\nu(f^{\prime})=21=c(A,B)\), (7.8) shows that \(f^{\prime}\) is a maximum flow and \((A,B)\) a minimum cut; indeed \(A\) is exactly the set of nodes reachable from \(s\) in \(G_{f^{\prime}}\), as in (7.9).

(a) The value is \(\nu(f) = 6+3+1 = 10\), and it is not maximum. In the residual graph \(G_f\) the path

\begin{equation*} s \xrightarrow{\,4\,} a \xrightarrow{\,2\,} c \xrightarrow{\,5\,} b \xrightarrow{\,1\,} d \xrightarrow{\,10\,} t \end{equation*}

exists (\(c\to b\) and \(b\to d\) are the backward edges of \(b\to c\) and \(d\to b\); the labels are residual capacities), so augmenting by its bottleneck \(1\) gives, by (7.3), a flow \(f^{\prime}\) of value \(11\): \(f^{\prime}(s,a)=7\), \(f^{\prime}(a,c)=1\), \(f^{\prime}(b,c)=4\), \(f^{\prime}(d,b)=0\), \(f^{\prime}(d,t)=1\), all other edges unchanged.

(b) A minimum cut is \(A=\{s,a,b,c\}\), \(B=\{d,t\}\), of capacity

\begin{equation*} c(A,B) = c_{sd}+c_{at}+c_{ct} = 1+5+5 = 11 \end{equation*}

(\(d\to b\) and \(d\to c\) enter \(A\) and do not count). Since \(\nu(f^{\prime})=11=c(A,B)\), (7.8) shows that \(f^{\prime}\) is a maximum flow and \((A,B)\) a minimum cut; \(A\) is exactly the set of nodes reachable from \(s\) in \(G_{f^{\prime}}\), as in (7.9).

False. Take nodes \(s,v,t\) with edges \(s\to v\) of capacity \(c_{sv}=2\) and \(v\to t\) of capacity \(c_{vt}=1\). Conservation at \(v\) and the capacity of \(v\to t\) force every flow to satisfy

\begin{equation*} f(s,v) = f(v,t) \le 1 < 2 = c_{sv}, \end{equation*}

so the maximum flow (value \(1\), matching the cut \((\{s,v\},\{t\})\) of capacity \(1\)) does not saturate the only edge out of \(s\).

False. Adding \(1\) to every capacity raises the capacity of a cut by the number of edges crossing it, so a minimum cut crossed by many edges can lose to one crossed by few. Take nodes \(s,a,b,t\) and edges

\begin{equation*} c_{sa} = 2,\qquad c_{ab} = 1,\qquad c_{at} = 1,\qquad c_{bt} = 1. \end{equation*}

The cuts, by source side, have capacities \(c(\{s\}) = 2\), \(c(\{s,a\}) = c_{ab}+c_{at} = 2\), \(c(\{s,a,b\}) = c_{at}+c_{bt} = 2\), \(c(\{s,b\}) = c_{sa}+c_{bt} = 3\), so \((A,B)=(\{s,a\},\{b,t\})\) is a minimum cut. With capacities \(1+c_e\),

\begin{equation*} c^{\prime}(\{s,a\},\{b,t\}) = 2+2 = 4 > 3 = c^{\prime}(\{s\},\{a,b,t\}), \end{equation*}

so \((A,B)\) is no longer a minimum cut.

Build the bipartite “visibility graph” between switches and fixtures and test it for a perfect matching.

Let \(X=\{p_1,\dots,p_n\}\) be the switches and \(Y=\{q_1,\dots,q_n\}\) the fixtures, and put the edge \((p_i,q_j)\) in \(G\) exactly when the segment \(p_iq_j\) crosses none of the \(m\) walls; this takes \(m\) calls of the crossing subroutine per pair, \(O(n^2m)\) in total. Then compute a maximum matching \(M\) of \(G\) with the Ford-Fulkerson Algorithm as in (7.38), and answer “ergonomic” iff \(|M|=n\).

A wiring in which each switch controls one fixture and each fixture is controlled by one switch is a bijection \(X\to Y\); it is valid iff every pair \((p_i,q_j)\) it uses has \(q_j\) visible from \(p_i\), i.e. iff it is a set of \(n\) edges of \(G\) no two sharing an endpoint. So

\begin{equation*} \text{ergonomic} \iff G \text{ has a perfect matching} \iff |M| = n, \end{equation*}

and by (7.37)-(7.38) Ford-Fulkerson returns a maximum matching, so the test is correct.

Running time: \(G\) has at most \(n^2\) edges and \(2n\) nodes, so (7.38) gives \(O(n^2\cdot n)=O(n^3)\) for the matching, and the total is \(O(n^2m+n^3)\).

Compute a maximum flow in the network: source \(\to\) each client (capacity \(1\)), client \(\to\) each base station within distance \(r\) (capacity \(1\)), each base station \(\to\) sink (capacity \(L\)); the answer is yes iff the maximum flow value is \(n\).

Concretely, \(G\) has nodes \(s\), \(t\), clients \(u_1,\dots,u_n\) and stations \(b_1,\dots,b_k\), edges \((s,u_i)\) with capacity \(1\), \((u_i,b_j)\) with capacity \(1\) whenever \(\|u_i-b_j\|\le r\), and \((b_j,t)\) with capacity \(L\). Run Ford-Fulkerson and answer yes iff \(\nu(f)=n\).

(\(\Rightarrow\)) Given a valid connection, send one unit along \(s\to u_i\to b_j\to t\) for each client \(u_i\) and its station \(b_j\). Each \((s,u_i)\) and \((u_i,b_j)\) carries at most \(1\), each \((b_j,t)\) carries the number of clients at \(b_j\), which is \(\le L\), and conservation holds at every client and station; the value is \(n\).

(\(\Leftarrow\)) If the maximum flow has value \(n\), then by (7.14) there is an integer maximum flow \(f\), and Ford-Fulkerson returns one. Since \(c(\{s\},V-\{s\})=n\), every \((s,u_i)\) carries exactly \(1\); by conservation and integrality each \(u_i\) sends its unit along exactly one edge \((u_i,b_j)\), and we connect \(u_i\) to that \(b_j\). This \(b_j\) is within range by construction of the edges, and the number of clients connected to \(b_j\) is

\begin{equation*} f^{\text{in}}(b_j) = f^{\text{out}}(b_j) = f(b_j,t) \le L . \end{equation*}

Running time: the network has \(n+k+2\) nodes and at most \(nk+n+k\) edges, built in \(O(nk)\) time; the flow value is at most \(C=n\), so by (7.5) Ford-Fulkerson runs in \(O(n(nk+n+k)) = O(n^2k)\) time (using \(k\ge 1\)).

(a) The supply suffices iff the following network has a flow of value \(D=d_O+d_A+d_B+d_{AB}\): a source \(s\), a node \(u_X\) for each blood type \(X\) on hand, a node \(w_Y\) for the patients of each type \(Y\), and a sink \(t\), with edges

\begin{equation*} \begin{aligned} &(s,u_X) \text{ of capacity } s_X, \qquad (w_Y,t) \text{ of capacity } d_Y,\\ &(u_X,w_Y) \text{ of capacity } s_X \text{ whenever}\\ &\qquad \text{type-}Y\text{ patients can receive type-}X\text{ blood}, \end{aligned} \end{equation*}

the compatible pairs being \(O\to O,A,B,AB\); \(A\to A,AB\); \(B\to B,AB\); \(AB\to AB\).

(\(\Rightarrow\)) If \(a_{XY}\) units of type \(X\) go to type-\(Y\) patients in an allocation meeting all demand, the flow \(f(s,u_X)=\sum_Y a_{XY}\le s_X\), \(f(u_X,w_Y)=a_{XY}\le s_X\), \(f(w_Y,t)=\sum_X a_{XY}=d_Y\) is feasible of value \(D\). (\(\Leftarrow\)) If the maximum flow value is \(D\), by (7.14) there is an integer flow \(f\) of value \(D\); since \(c(V-\{t\},\{t\})=D\), every \((w_Y,t)\) is saturated, so giving \(f(u_X,w_Y)\) whole units of type \(X\) to type-\(Y\) patients uses at most \(f^{\text{out}}(u_X)=f(s,u_X)\le s_X\) units of each type, only along compatible pairs, and meets each demand \(d_Y=f^{\text{in}}(w_Y)\).

The network has \(10\) nodes and \(17\) edges, so the Scaling Max-Flow Algorithm runs in \(O(m^2\log_2 C)=O(\log C)\) time by (7.20), where \(C=s_O+s_A+s_B+s_{AB}\) is the capacity out of \(s\); this is polynomial in the input size (the supplies and demands written in binary).

(b) No: at most \(97\) of the \(98\) patients in the table can be served. (The table’s demands sum to \(98\), not \(100\); with the \(10\) percent figure, \(d_B=10\), the same argument gives at most \(99\) of \(100\).) An optimal allocation:

which serves \(45+41+8+3=97\) patients, leaving one type-A patient without blood.

For the cut, take the source side \(A=\{s,u_B,u_{AB},w_B,w_{AB}\}\). The edges out of \(u_B\) and \(u_{AB}\) all end at \(w_B\) or \(w_{AB}\), inside \(A\), so the edges leaving \(A\) are \((s,u_O)\), \((s,u_A)\), \((w_B,t)\), \((w_{AB},t)\), and

\begin{equation*} c(A,V-A) = s_O + s_A + d_B + d_{AB} = 50+36+8+3 = 97 . \end{equation*}

By (7.8) every flow has value at most \(97 < 98\), so the allocation above is optimal and not all patients can be served.

For the administrators: type O and type A patients can only be given type O or type A blood. There are \(45+42=87\) such patients but only \(50+36=86\) units of type O and type A blood in stock, so at least one of them must go without, no matter how the blood is shared out; the surplus type B and AB blood cannot help them.

Compute a maximum flow in the network: source \(\to\) each person (capacity \(1\)), person \(\to\) each hospital within a half-hour’s drive (capacity \(1\)), each hospital \(\to\) sink (capacity \(\lceil n/k\rceil\)); a balanced assignment exists iff the maximum flow value is \(n\).

This is the network of Exercise 7.7 with clients replaced by people, base stations by hospitals, the range condition “within distance \(r\)” by “within a half-hour’s driving time”, and \(L=\lceil n/k\rceil\); the correctness proof there (both directions, with (7.14) giving an integral flow of value \(n\)) applies word for word, the number of people sent to \(h_j\) being \(f(h_j,t)\le\lceil n/k\rceil\).

Running time: the network has \(n+k+2\) nodes and at most \(nk+n+k\) edges, and the flow value is at most \(n\), so by (7.5) Ford-Fulkerson runs in \(O(n(nk+n+k))=O(n^2k)\) time, after \(O(nk)\) time to read off which hospitals are within reach of each person.

If \(e^*\) is not saturated, \(f\) is still maximum; otherwise cancel one unit of flow along an \(s\)-\(t\) path through \(e^*\) and then search once for an augmenting path.

Let \(\nu=\nu(f)\) and write \(G^{\prime}\) for the graph with \(c^{\prime}_{e^*}=c_{e^*}-1\). Every flow in \(G^{\prime}\) is a flow in \(G\), so the maximum flow value \(\nu^{\prime}\) of \(G^{\prime}\) satisfies \(\nu^{\prime}\le\nu\).

(i) \(f_{e^*}<c_{e^*}\). Then \(f_{e^*}\le c^{\prime}_{e^*}\) by integrality, so \(f\) is feasible in \(G^{\prime}\) with value \(\nu\ge\nu^{\prime}\), and \(f\) is maximum in \(G^{\prime}\).

(ii) \(f_{e^*}=c_{e^*}\ge 1\), with \(e^*=(u,v)\). Walk backwards from \(u\): at a node \(x\ne s\) with an outgoing edge of positive flow, conservation gives an entering edge \((y,x)\) with \(f_{(y,x)}>0\); step to \(y\). Since no edge leaves \(t\), every node reached other than \(s\) has positive outflow, and since \(f\) is acyclic no node repeats, so the walk ends at \(s\) and gives a path \(P_1\) from \(s\) to \(u\) of positive-flow edges. Symmetrically, walking forwards from \(v\) (no edge enters \(s\)) gives a path \(P_2\) from \(v\) to \(t\). If \(P_1\) and \(P_2\) shared a node \(x\), then \(x\leadsto u\to v\leadsto x\) would be a cycle of positive-flow edges; hence \(P=P_1\,e^*\,P_2\) is a simple \(s\)-\(t\) path with \(f_e\ge 1\) on each edge. Let \(f^{\prime}=f-1\) on the edges of \(P\). Conservation is preserved at the interior nodes of \(P\), \(0\le f^{\prime}_e\le c^{\prime}_e\) for all \(e\) (in particular \(f^{\prime}_{e^*}=c_{e^*}-1\)), and

\begin{equation*} \nu-1=\nu(f^{\prime})\le\nu^{\prime}\le\nu . \end{equation*}

Now search \(G^{\prime}_{f^{\prime}}\) once for an \(s\)-\(t\) path by breadth-first search. If there is one, augment along it as in (7.3); the bottleneck is a positive integer, so the result has value at least \(\nu\), hence exactly \(\nu=\nu^{\prime}\) and it is maximum. If there is none, \(f^{\prime}\) is maximum in \(G^{\prime}\) by (7.9).

Running time: each walk visits each node at most once and, scanning the edge lists of the nodes it visits, inspects each edge at most once, so \(P\) is found in \(O(m+n)\); updating \(f^{\prime}\), building \(G^{\prime}_{f^{\prime}}\), the breadth-first search and the single augmentation are each \(O(m+n)\).

False: for every \(n\) there is a network with maximum-flow value \(n\) on which the Forward-Edge-Only Algorithm can stop at value \(1\).

Take nodes \(s, t, u_1,\dots,u_n, v_1,\dots,v_n\) and these edges, all with capacity \(1\):

\begin{equation*} \begin{aligned} &(s,u_i),\ (u_i,v_i),\ (v_i,t) && (1\le i\le n),\\ &(v_i,u_{i+1}) && (1\le i\le n-1). \end{aligned} \end{equation*}

The three-edge paths \(s\to u_i\to v_i\to t\) are pairwise edge-disjoint, so they carry a flow of value \(n\). The cut \((\{s\}, V-\{s\})\) has capacity \(n\), so by (7.8) the maximum-flow value is exactly \(n\).

The algorithm may pick the forward-edge path

\begin{equation*} P = s\to u_1\to v_1\to u_2\to v_2\to\cdots\to u_n\to v_n\to t \end{equation*}

as its first augmenting path. Its bottleneck is \(1\), so afterwards every edge of \(P\) is saturated, and in particular every \((u_i,v_i)\) is saturated. In \(\tilde G_f\) the only edges leaving \(s\) go to \(u_2,\dots,u_n\), and the only edge leaving each \(u_i\) is \((u_i,v_i)\), which is now saturated. So the set of nodes reachable from \(s\) in \(\tilde G_f\) is \(\{s,u_2,\dots,u_n\}\), which does not contain \(t\), and the algorithm halts with a flow of value \(1\).

Now let \(b>1\) be any constant and choose an integer \(n>b\). On this network the algorithm returns a flow of value \(1 = n/n < n/b\), which is less than \(1/b\) times the maximum. So no such constant \(b\) exists.

Delete edges of a minimum \(s\)-\(t\) cut: the optimum value is exactly \(\max(\nu-k,0)\), where \(\nu\) is the maximum flow value of \(G\) (we assume \(k\le |E|\), otherwise no such \(F\) exists).

Algorithm. Run Ford-Fulkerson to get a maximum flow \(f\) with \(\nu(f)=\nu\), and from it a minimum cut \((A^*,B^*)\) by (7.11). Let \(D\) be the set of edges leaving \(A^*\); since all capacities are \(1\), \(|D|=c(A^*,B^*)=\nu\) by (7.13).

• (i) If \(k\le \nu\): let \(F\) be any \(k\) edges of \(D\).
• (ii) If \(k>\nu\): let \(F\) be \(D\) together with any \(k-\nu\) further edges of \(E\).

Upper bound. In \(G^{\prime}\) the cut \((A^*,B^*)\) has capacity \(|D-F|=\max(\nu-k,0)\), so by (7.8) every \(s\)-\(t\) flow in \(G^{\prime}\) has value at most \(\max(\nu-k,0)\).

Lower bound. Let \(F\) be any set of \(k\) edges and \((A,B)\) any \(s\)-\(t\) cut. Removing \(F\) removes at most \(k\) edges out of \(A\), each of capacity \(1\), so

\begin{equation*} \begin{aligned} c_{G^{\prime}}(A,B) &\ge c_G(A,B)-k \ge \nu-k, \end{aligned} \end{equation*}

using (7.13) in \(G\). Also \(c_{G^{\prime}}(A,B)\ge 0\). Hence the minimum cut of \(G^{\prime}\), which equals its maximum flow by (7.13), is at least \(\max(\nu-k,0)\) for every choice of \(F\), and our \(F\) is optimal.

Running time. Every edge out of \(s\) has capacity \(1\) (and \(G\) has no parallel edges), so \(C=\sum_{e\text{ out of }s}c_e\le n-1\) and Ford-Fulkerson runs in \(O(mn)\) time by (7.5); the cut takes \(O(m)\) by (7.11) and choosing \(F\) takes \(O(m)\), for \(O(mn)\) overall.

Split every node \(v\) into an entry copy \(v_{\text{in}}\) and an exit copy \(v_{\text{out}}\) joined by an edge of capacity \(c_v\), and run an ordinary maximum-flow algorithm on the result.

(As in Section 7.1, no edge enters \(s\) and none leaves \(t\); so \(f^{\text{in}}(s)=0\) and the constraint at \(s\) is vacuous.) Let \(M=1+\sum_v c_v\). The network \(G^{\prime}\) has nodes \(v_{\text{in}},v_{\text{out}}\) for every \(v\in V\); a node edge \((v_{\text{in}},v_{\text{out}})\) of capacity \(c_v\) for every \(v\); an edge \((u_{\text{out}},v_{\text{in}})\) of capacity \(M\) for every \((u,v)\in E\); source \(s_{\text{out}}\) and sink \(t_{\text{out}}\).

Flows correspond. Given a feasible node-capacitated \(f\) in \(G\), put

\begin{equation*} f^{\prime}(u_{\text{out}},v_{\text{in}})=f(u,v),\qquad f^{\prime}(v_{\text{in}},v_{\text{out}})=f^{\text{in}}(v). \end{equation*}

Conservation at \(v_{\text{in}}\) is immediate, and at \(v_{\text{out}}\) (\(v\ne s,t\)) it is \(f^{\text{in}}(v)=f^{\text{out}}(v)\). The node edges obey \(f^{\text{in}}(v)\le c_v\), and the other edges obey

\begin{equation*} f(u,v)\le \begin{cases} f^{\text{out}}(u)=f^{\text{in}}(u)\le c_u<M, & u\ne s,\\ f^{\text{in}}(v)\le c_v<M, & u=s. \end{cases} \end{equation*}

Conversely, a flow \(f^{\prime}\) in \(G^{\prime}\) gives \(f(u,v)=f^{\prime}(u_{\text{out}},v_{\text{in}})\). For \(v\ne s,t\), conservation at \(v_{\text{in}}\) and at \(v_{\text{out}}\) gives

\begin{equation*} f^{\text{in}}(v)=f^{\prime}(v_{\text{in}},v_{\text{out}})=f^{\text{out}}(v), \end{equation*}

and the same identity \(f^{\text{in}}(v)=f^{\prime}(v_{\text{in}},v_{\text{out}})\le c_v\) holds for every \(v\). Both maps keep the value, since \(f^{\text{out}}(s)={f^{\prime}}^{\text{out}}(s_{\text{out}})\). So a maximum flow of \(G^{\prime}\), mapped back, is a maximum feasible flow of \(G\), and both have the same value.

Cuts. A node cut is a set \(X\subseteq V\setminus\{s\}\) that contains a node of every \(s\)-\(t\) path in \(G\) (possibly \(t\) itself). Its capacity is \(c(X)=\sum_{v\in X}c_v\).

Theorem. The maximum value of a feasible flow equals the minimum capacity of a node cut.

By (7.13) applied to \(G^{\prime}\), it suffices to show that the minimum capacity of a node cut equals the minimum capacity of an \(s_{\text{out}}\)-\(t_{\text{out}}\) cut in \(G^{\prime}\).

(i) Node cut to \(G^{\prime}\) cut. Take a node cut \(X\). Let \(A\) be the set of nodes reachable from \(s_{\text{out}}\) in \(G^{\prime}\) once the node edges of \(X\) are deleted, and let \(B\) be the rest. Any \(s_{\text{out}}\)-\(t_{\text{out}}\) path in \(G^{\prime}\) traces an \(s\)-\(t\) walk in \(G\), and that walk contains an \(s\)-\(t\) path, so it must pass through a node edge of \(X\). Hence \(t_{\text{out}}\in B\). By the definition of \(A\), the only edges leaving \(A\) are node edges of \(X\), so

\begin{equation*} c(A,B)\le c(X). \end{equation*}

(ii) \(G^{\prime}\) cut to node cut. A minimum cut \((A,B)\) of \(G^{\prime}\) has capacity at most \(c(\{t\})<M\), because by (i) the cut built from \(X=\{t\}\) has capacity at most \(c_t\). So every edge it cuts is a node edge. Put

\begin{equation*} X=\{v : v_{\text{in}}\in A,\ v_{\text{out}}\in B\}, \end{equation*}

so that \(c(X)=c(A,B)\). For any \(s\)-\(t\) path \(s=v_0,v_1,\dots,v_k=t\) in \(G\), the path

\begin{equation*} s_{\text{out}}\to v_{1,\text{in}}\to v_{1,\text{out}}\to\cdots\to t_{\text{in}}\to t_{\text{out}} \end{equation*}

in \(G^{\prime}\) goes from \(A\) to \(B\), so at some point it crosses an edge from \(A\) to \(B\). That edge is a node edge \((v_{i,\text{in}},v_{i,\text{out}})\) with \(i\ge 1\), so \(v_i\in X\). Hence \(X\) is a node cut with \(c(X)=c(A,B)\).

Together,

\begin{equation*} \begin{aligned} \max_f v(f) &= \text{max flow of } G^{\prime} = \text{min cut of } G^{\prime}\\ &= \min\{c(X) : X \text{ a node cut}\}. \end{aligned} \end{equation*}

After the max flow is computed, (7.11) gives a minimum cut \((A,B)\) of \(G^{\prime}\) in linear time, and step (ii) reads off a minimum node cut \(X\).

Running time. \(G^{\prime}\) has \(2n\) nodes and \(m+n\) edges, and building it takes \(O(m+n)\). Preflow-Push with maximum-height selection runs in \(O(mn)+O(n^3)=O(n^3)\) on \(2n\) nodes by (7.30) and (7.33), so the total is \(O(n^3)\) (here \(m=O(n^2)\)).

(a) Add a super-source and super-sink and test whether the maximum flow equals \(|X|\). Build the network \(G^{\prime}\): keep every edge of \(G\) with capacity \(1\); add a source \(s\) with an edge \((s,x)\) of capacity \(1\) for each \(x\in X\); add a sink \(t\) with an edge \((v,t)\) of capacity \(|X|\) for each \(v\in S\). Answer yes iff the maximum \(s\)-\(t\) flow in \(G^{\prime}\) has value \(|X|\).

Routes \(\Rightarrow\) flow. Given routes \(P_x\) (\(x\in X\)) ending at \(v_x\in S\), send one unit along each \(s\to x\xrightarrow{P_x} v_x\to t\). Every edge of \(G\) lies on at most one route, each \((s,x)\) is used once, and each \((v,t)\) is used at most \(|X|\) times, so this is a feasible flow of value \(|X|\).

Flow \(\Rightarrow\) routes. All capacities are integers, so by (7.14) there is an integer maximum flow \(f\), of value \(|X|\). The tracing argument in the proof of (7.42) works for any integer flow if each traced path or cycle is lowered by \(1\) rather than set to \(0\). It splits \(f\) into \(|X|\) \(s\)-\(t\) paths, and each edge \(e\) lies on at most \(f(e)\) of them. Since \(\nu(f)=|X|=f^{\text{out}}(s)\), every edge \((s,x)\) carries one unit, so each \(x\in X\) starts exactly one path. Each path has the form \(s,x,\dots,v,t\) with \(v\in S\), because only safe nodes have edges into \(t\). Deleting \(s\) and \(t\) leaves a path in \(G\) from \(x\) to a safe node. Edges of \(G\) have capacity \(1\), so no two of these paths share an edge, and they form a set of evacuation routes.

Time. The capacity out of \(s\) is \(C=|X|\le n\), and \(G^{\prime}\) has \(m+|X|+|S|=O(m+n)\) edges. By (7.5), Ford-Fulkerson therefore runs in \(O((m+n)n)\) time.

(b) Split every node, as for node capacities (Exercise 13), and make all capacities \(1\). Build \(G^{\prime\prime}\) as follows. Replace each \(v\in V\) by two nodes \(v_{\text{in}},v_{\text{out}}\) joined by an edge \((v_{\text{in}},v_{\text{out}})\) of capacity \(1\). Replace each edge \((u,v)\in E\) by \((u_{\text{out}},v_{\text{in}})\) with capacity \(1\). Add edges \((s,x_{\text{in}})\) for \(x\in X\) and \((v_{\text{out}},t)\) for \(v\in S\), all of capacity \(1\). Answer yes iff the maximum flow in \(G^{\prime\prime}\) has value \(|X|\).

Routes \(\Rightarrow\) flow. For node-disjoint routes, send one unit along \(s\to x_{\text{in}}\to x_{\text{out}}\to\cdots\to v_{\text{in}}\to v_{\text{out}}\to t\) for each route. Every node of \(G\) lies on at most one route, so each edge \((v_{\text{in}},v_{\text{out}})\) carries at most \(1\). The routes end at distinct safe nodes, so each \((v_{\text{out}},t)\) also carries at most \(1\). This gives a flow of value \(|X|\).

Flow \(\Rightarrow\) routes. By (7.14) there is a \(0\)-\(1\) maximum flow, of value \(|X|\), and by (7.42) it contains \(|X|\) edge-disjoint \(s\)-\(t\) paths. As in (a), each path uses exactly one edge \((s,x_{\text{in}})\), with every \(x\in X\) covered, and its last edge is some \((v_{\text{out}},t)\) with \(v\in S\). A path through \(v_{\text{in}}\) must continue along \((v_{\text{in}},v_{\text{out}})\), since that is the only edge leaving \(v_{\text{in}}\). A path reaching \(v_{\text{out}}\) must arrive along that same edge, since it is the only edge entering \(v_{\text{out}}\). Hence two paths through the same node \(v\) of \(G\) would share the edge \((v_{\text{in}},v_{\text{out}})\), which is impossible. Contracting each pair \(v_{\text{in}},v_{\text{out}}\) back to \(v\) and deleting \(s,t\) therefore gives node-disjoint evacuation routes.

Time. \(G^{\prime\prime}\) has \(2n+2\) nodes and \(n+m+|X|+|S|=O(m+n)\) edges, and \(C=|X|\le n\). By (7.5) the running time is \(O((m+n)n)\).

Example. Take \(V=\{x_1,x_2,v\}\), \(E=\{(x_1,v),(x_2,v)\}\), \(X=\{x_1,x_2\}\) and \(S=\{v\}\). The routes \(x_1v\) and \(x_2v\) share no edge, so the answer to (a) is yes. Every route must end at \(v\), the only safe node, so the two routes always share \(v\) and the answer to (b) is no.

(a) Take \(G\) with sides \(X=\{p_1,\dots,p_n\}\), \(Y=\{d_1,\dots,d_n\}\) and an edge \((p_i,d_j)\) exactly when \(d_j\notin S_i\). A perfect matching assigns each person to one night and each night to one person, using only allowed pairs, i.e. it is a feasible schedule; conversely the pairs (person, night cooked) of a feasible schedule are \(n\) disjoint edges of \(G\), a perfect matching.

(b) Turn Alanis’s schedule into a matching of size \(n-1\) or \(n-2\) and finish with at most two Ford-Fulkerson augmentations. Let \(G^{\prime}\) be the flow network of Section 7.5 built from \(G\) (edges \(s\to p\), \(p\to d\) for each edge of \(G\), \(d\to t\), all of capacity \(1\)); \(G\) has \(m\le n^2\) edges, so \(G^{\prime}\) has \(O(n^2)\) edges.

M = the n-2 correct (person, night) pairs of Alanis's schedule
if d_k not in S_i: add (p_i, d_k) to M
else if d_k not in S_j: add (p_j, d_k) to M
f = flow in G' sending 1 unit along s -> p -> d -> t for each (p,d) in M
while v(f) < n:
    BFS from s in the residual graph G'_f
    if t unreachable: report "no feasible schedule"; stop
    augment f along the s-t path found
output the pairs (p,d) with f(p,d) = 1

\(M\) is a matching of \(G\): the \(n-2\) correct pairs use distinct people and distinct nights other than \(d_k,d_\ell\) (the \(n\) nights are all assigned except \(d_\ell\), and only \(d_k\) twice), and at most one pair at \(d_k\) is added, using an allowed edge. Hence \(f\) is a valid integer \(s\)-\(t\) flow with

\begin{equation*} v(f)=|M|\in\{n-2,\,n-1\}. \end{equation*}

Each augmentation keeps \(f\) integral and raises \(v(f)\) by exactly \(1\) (by (7.2) and (7.3), all capacities being \(1\)), so the loop runs at most \(n-v(f)\le 2\) times. If it stops because \(t\) is unreachable in \(G^{\prime}_f\), then \(f\) is a maximum flow by (7.9), of value \(<n\); by (7.37) the maximum matching of \(G\) has size \(<n\), so by (a) there is no feasible schedule. If it reaches \(v(f)=n\), then by (7.34)-(7.36) the edges \(p\to d\) carrying flow form a matching of size \(n\) in \(G\), which by (a) is a feasible schedule.

Building \(G\) and \(G^{\prime}\) and \(f\) takes \(O(n^2)\); each of the at most two iterations is one BFS plus one augmentation on a graph with \(O(n)\) nodes and \(O(n^2)\) edges, so \(O(n^2)\) each. Total: \(O(n^2)\).

Compute a maximum flow in a bipartite network that sends \(r_i\) units from each advertiser to users eligible for that advertiser; a policy exists iff the flow saturates all of \(R = \sum_i r_i\) and every user is eligible for some advertiser.

Call user \(j\) eligible for advertiser \(i\) if \(U_j \cap X_i \ne \emptyset\). Build \(G^{\prime}\) with source \(s\), sink \(t\), a node \(a_i\) per advertiser and a node \(u_j\) per user, and edges

\begin{equation*} \begin{aligned} &(s, a_i) \text{ of capacity } r_i, \qquad (u_j, t) \text{ of capacity } 1,\\ &(a_i, u_j) \text{ of capacity } 1 \text{ whenever } j \text{ is eligible for } i. \end{aligned} \end{equation*}

Run Ford-Fulkerson to get an integer maximum flow \(f\) (7.14). If \(\nu(f) < R\), or some user is eligible for no advertiser, report that no policy exists. Otherwise show user \(j\) the ad of the advertiser \(i\) with \(f(a_i, u_j) = 1\) if there is one, and the ad of any advertiser \(j\) is eligible for if not.

Correctness. If \(\nu(f) = R\), every edge \((s,a_i)\) is saturated, so advertiser \(i\) has exactly \(r_i\) users \(u_j\) with \(f(a_i,u_j)=1\), all eligible; capacity \(1\) on \((u_j,t)\) means each user is counted for at most one advertiser. So every user gets one ad, every ad goes to an eligible user, and advertiser \(i\) gets at least \(r_i\) users. Conversely, given a valid policy, every user is eligible for the advertiser whose ad it sees; pick for each \(i\) any \(r_i\) of the users shown ad \(i\) and send one unit along \(s \to a_i \to u_j \to t\) for each. The capacities hold (each user is picked at most once), so this is a flow of value \(R\), and \(\nu(f) \ge R\). Since \(c(\{s\}, V - \{s\}) = R\), we get \(\nu(f) = R\) by (7.8).

Running time. Testing eligibility costs \(O(k)\) per pair, so building \(G^{\prime}\) takes \(O(mnk)\), and \(G^{\prime}\) has \(O(mn)\) edges. The cut \((V - \{t\}, \{t\})\) has capacity \(n\), so Ford-Fulkerson does at most \(n\) augmentations (each raises the value by at least \(1\)), each costing \(O(mn)\), as in (7.5). The total is \(O(mnk + mn^2)\).

Decompose a maximum flow into \(k\) edge-disjoint \(s\)-\(t\) paths and binary-search each path for its one destroyed edge. That finds all \(k\) destroyed edges with \(k \lceil \log_2 n \rceil\) pings, and then a BFS with no further pings finds the unreachable nodes.

compute an integer max flow f in G (value k), and k edge-disjoint
  s-t paths P_1..P_k from it by (7.42), cycles cut out
for each path P = (v_0 = s, v_1, ..., v_l = t):
    lo = 0, hi = l              # ping(v_lo) yes, ping(v_hi) no
    while hi - lo > 1:
        mid = (lo + hi) / 2
        if ping(v_mid) then lo = mid else hi = mid
    add edge (v_lo, v_hi) to F
BFS from s in G - F; report every node not reached

Correctness. Let \(F^\ast\) be the set of destroyed edges and \(A\) the set of nodes reachable from \(s\) in \(G - F^\ast\), with \(B = V - A\). Every edge of \(G\) leaving \(A\) is in \(F^\ast\), since otherwise its head would be reachable. Also \(t \in B\), so \((A,B)\) is an \(s\)-\(t\) cut and

\begin{equation*} k \le c(A,B) \le |F^\ast| = k, \end{equation*}

where the first inequality is (7.8) applied to \(f\). So the edges leaving \(A\) are exactly \(F^\ast\), and \(f^{\mathrm{out}}(A) \le c(A,B) = k\). Then (7.6) gives

\begin{equation*} k = \nu(f) = f^{\mathrm{out}}(A) - f^{\mathrm{in}}(A) \le k - f^{\mathrm{in}}(A), \end{equation*}

so \(f^{\mathrm{in}}(A) = 0\), and no flow-carrying edge goes from \(B\) into \(A\). Each \(P_r\) uses only edges with \(f(e) = 1\), so once \(P_r\) leaves \(A\) it never comes back. Its nodes in \(A\) therefore form a prefix \(v_0, \dots, v_j\), and the predicate \(\mathit{ping}(v_i)\) is true for \(i \le j\) and false for \(i > j\). The binary search keeps \(v_{lo} \in A\) and \(v_{hi} \in B\) while it shrinks \(hi - lo\), so it stops at the edge \((v_j, v_{j+1})\), which leaves \(A\) and so lies in \(F^\ast\). The \(k\) paths are edge-disjoint, so they give \(k\) distinct edges of \(F^\ast\), which means \(F = F^\ast\). The BFS in \(G - F\) then outputs exactly \(B\).

Pings. Each path is simple, so \(l \le n - 1\), and the search makes at most \(\lceil \log_2 n \rceil\) pings per path. That is \(k \lceil \log_2 n \rceil = O(k \log n)\) pings in all.

(a) Run Ford-Fulkerson on the matching network \(G^{\prime}\) of Section 7.5, starting from the flow given by \(M\) and stopping after \(k\) augmentations. If \(k\) augmentations are possible, return the resulting matching \(M^{\prime}\); if the residual graph runs out of \(s\)-\(t\) paths first, report that there is no solution.

Key fact. An augmentation along an \(s\)-\(t\) path in the residual graph \(G^{\prime}_f\) never uncovers a node of \(Y\). Such a path has the form \(s, x_1, y_1, x_2, y_2, \dots, x_r, y_r, t\), where \(x_1\) and \(y_r\) are unmatched and each \((y_i, x_{i+1})\) is a backward edge for a matched edge. Augmenting replaces the \(r-1\) matched edges \((x_{i+1}, y_i)\) by the \(r\) edges \((x_i, y_i)\), \(i = 1, \dots, r\). Every \(y_i\) is matched afterwards, and nodes off the path keep their partner. So the set of covered nodes of \(Y\) only grows, and each augmentation adds exactly one edge to the matching (by (7.37) the matching edges are the \(X\)-\(Y\) edges carrying flow).

Correctness. If \(k\) augmentations succeed, the key fact shows that \(M^{\prime}\) satisfies (i) and (ii). If they do not, the algorithm has stopped at a flow with no \(s\)-\(t\) path in the residual graph, which is a maximum flow by (7.9). By (7.37) its matching has size \(K_2 < |M| + k\). Any solution would be a matching of size \(|M| + k > K_2\), which is impossible, so the report is correct.

Running time. Each augmentation is a search in \(G^{\prime}_f\) for a path, in \(O(m + n)\) time, and there are at most \(k \le n\) of them. That is \(O(k(m+n)) = O(mn)\) when \(G\) has no isolated nodes.

(b) Take \(X = \{x_1, x_2\}\), \(Y = \{y_1, y_2\}\), \(E = \{(x_1,y_1), (x_1,y_2), (x_2,y_2)\}\), \(M = \{(x_1, y_2)\}\) and \(k = 1\). A solution must have \(2\) edges, so it is a perfect matching. The only perfect matching is \(M^{\prime} = \{(x_1,y_1), (x_2,y_2)\}\), because \((x_1,y_2)\) leaves \(x_2\) with no partner. This \(M^{\prime}\) covers \(y_2\), so it is a solution, and it does not contain \((x_1, y_2)\).

(c) Run the algorithm of (a) with no limit on \(k\), that is, Ford-Fulkerson started from \(M\) until \(G^{\prime}_f\) has no \(s\)-\(t\) path. It ends at a maximum flow by (7.9), so by (7.37) its matching \(M^{\prime}\) has \(|M^{\prime}| = K_2\). By the key fact, \(M^{\prime}\) covers every node covered by \(M\). Hence

\begin{equation*} K_2 = |M^{\prime}| \le K_1 \le K_2, \end{equation*}

so \(K_1 = K_2\).

(a) Find a maximum flow in a doctors-to-days network in which day \(i\) can absorb \(p_i\) units. The lists exist iff the flow has value \(P = \sum_i p_i\).

Build \(G^{\prime}\) with source \(s\), sink \(t\), a node \(u_j\) per doctor and a node \(w_i\) per day, and edges

\begin{equation*} \begin{aligned} &(s, u_j) \text{ of capacity } n, \qquad (w_i, t) \text{ of capacity } p_i,\\ &(u_j, w_i) \text{ of capacity } 1 \text{ for each } i \in L_j. \end{aligned} \end{equation*}

Compute an integer maximum flow \(f\) with Ford-Fulkerson (7.14). If \(\nu(f) = P\), return \(L^{\prime}_j = \{ i : f(u_j, w_i) = 1 \}\); otherwise report that no lists exist.

Correctness. If \(\nu(f) = P\), every edge \((w_i, t)\) is saturated, since the cut \((V - \{t\}, \{t\})\) has capacity \(P\). By conservation at \(w_i\), exactly \(p_i\) doctors \(j\) have \(i \in L^{\prime}_j\), which is (B). Each \(L^{\prime}_j\) uses only edges \((u_j, w_i)\) with \(i \in L_j\), which is (A). Conversely, lists satisfying (A) and (B) give a flow of value \(P\): put \(f(u_j, w_i) = 1\) for \(i \in L^{\prime}_j\), \(f(s, u_j) = |L^{\prime}_j| \le n\), and \(f(w_i, t) = p_i\). So a maximum flow has value \(\ge P\), and hence exactly \(P\).

Running time. \(G^{\prime}\) has \(O(nk)\) edges and \(\nu(f) \le P \le nk\) (if some \(p_i > k\), report failure at once). Ford-Fulkerson therefore runs in \(O(nk \cdot nk) = O(n^2 k^2)\) time, as in (7.5).

(b) Add to the network of (a) a node \(g_j\) for each doctor \(j\) that carries his or her “extra” days. Use the edges of (a), together with

\begin{equation*} \begin{aligned} &(u_j, g_j) \text{ of capacity } c,\\ &(g_j, w_i) \text{ of capacity } 1 \text{ for each } i \notin L_j. \end{aligned} \end{equation*}

Compute an integer maximum flow \(f\). If \(\nu(f) = P\), return \(L^{\prime}_j = \{ i : f(u_j, w_i) = 1 \text{ or } f(g_j, w_i) = 1 \}\); otherwise report that no lists exist.

Correctness. For each pair \((j, i)\) there is exactly one unit-capacity route from \(u_j\) to \(w_i\): directly if \(i \in L_j\), and through \(g_j\) if \(i \notin L_j\). So \(f\) assigns doctor \(j\) to day \(i\) at most once. The days of \(L^{\prime}_j\) outside \(L_j\) are exactly the units through \(g_j\), and there are at most \(c\) of them, which is (A*). Saturation of the edges \((w_i, t)\) gives (B) exactly as in (a). Conversely, lists satisfying (A*) and (B) define a flow of value \(P\): send one unit on the route for each pair with \(i \in L^{\prime}_j\), and set \(f(u_j, g_j) = |L^{\prime}_j - L_j| \le c\) and \(f(s, u_j) = |L^{\prime}_j| \le n\). So the maximum flow has value \(P\).

Running time. The network has \(O(nk)\) edges and maximum flow value \(\le P \le nk\), so Ford-Fulkerson again runs in \(O(n^2 k^2)\) time.

(a) A solution exists iff the network below has a maximum flow of value \(nk\). Build \(G^{\prime}\) with source \(s\), sink \(t\), a node \(b_i\) per balloon and a node \(c\) per condition, and edges

\begin{equation*} \begin{aligned} &(s, b_i) \text{ of capacity } 2, \qquad (c, t) \text{ of capacity } k,\\ &(b_i, c) \text{ of capacity } 1 \text{ for each } c \in S_i. \end{aligned} \end{equation*}

Compute an integer maximum flow \(f\) with Ford-Fulkerson (7.14). If \(\nu(f) = nk\), balloon \(i\) measures \(\{ c : f(b_i, c) = 1 \}\); otherwise answer no.

Correctness. If \(\nu(f) = nk\), every edge \((c, t)\) is saturated, since the cut \((V - \{t\}, \{t\})\) has capacity \(nk\). Conservation then gives each condition \(k\) balloons \(i\) with \(f(b_i, c) = 1\), all distinct and all able to measure \(c\). Each balloon carries at most \(2\) units in, so it measures at most two conditions. Conversely, take a valid assignment and keep, for each condition, only \(k\) of the balloons measuring it. Sending one unit along \(s \to b_i \to c \to t\) for each kept pair respects every capacity, so it is a flow of value \(nk\).

Running time. \(G^{\prime}\) has \(O(mn)\) edges and \(\nu(f) \le 2m\), so Ford-Fulkerson takes \(O(m \cdot mn) = O(m^2 n)\) time, as in (7.5).

(b) Route each condition’s measurements through one node per subcontractor, with capacity \(k - 1\) into the condition. For each condition \(c\) and subcontractor \(\ell \in \{1,2,3\}\), add a node \(c_\ell\). Replace each edge \((b_i, c)\) by \((b_i, c_\ell)\) of capacity \(1\), where \(\ell\) is balloon \(i\)’s subcontractor, and add the edges

\begin{equation*} (c_\ell, c) \text{ of capacity } k - 1, \qquad \ell = 1, 2, 3. \end{equation*}

Keep \((s, b_i)\) of capacity \(2\) and \((c, t)\) of capacity \(k\), and answer yes iff the maximum flow is \(nk\). This is for \(k \ge 2\); for \(k = 1\) a valid solution needs two balloons from different subcontractors on each condition, which is exactly the instance with \(k = 2\), so run the \(k = 2\) network.

Correctness. A flow of value \(nk\) gives, as in (a), exactly \(k\) distinct balloons per condition and at most two conditions per balloon. At most \(k - 1\) of the \(k\) balloons for \(c\) pass through any one \(c_\ell\), so they do not all come from one subcontractor. Conversely, suppose a valid assignment measures \(c\) by a set \(B_c\) of \(\ge k\) balloons that is not all from one subcontractor. Choose \(T_c \subseteq B_c\) with \(|T_c| = k\): take two balloons of \(B_c\) from different subcontractors, and add any \(k - 2\) others. Then \(T_c\) uses at least two subcontractors, so at most \(k - 1\) of its balloons share a subcontractor. Sending one unit along \(s \to b_i \to c_\ell \to c \to t\) for each \(i \in T_c\) therefore respects all capacities and gives a flow of value \(nk\).

Running time. The network has \(m + 4n + 2\) nodes and \(O(mn)\) edges, and the flow value is still at most \(2m\), so the time is again \(O(m^2 n)\).

(a) Take \(n=3\) with \(S_1=S_2=\{1\}\) and \(S_3=\{1,2,3\}\). Any test set contains \((1,1)\) and \((2,1)\) (the only pairs for laptops \(1,2\)), and access points \(2,3\) can only be covered by the two further pairs \((3,2),(3,3)\); so every test set has size at least \(4>n\) (and \(\{(1,1),(2,1),(3,2),(3,3)\}\) is one).

(b) Compute a maximum matching \(M\) in the bipartite graph \(G\) with laptops on one side, access points on the other, and an edge \((\ell,p)\) for each \(p\in S_\ell\); answer yes iff \(2n-|M|\le k\). A test set is exactly an edge cover of \(G\), so it suffices to show that the minimum test set has size \(2n-\nu\), where \(\nu\) is the maximum matching size.

\(\le\): given a matching \(M\), add for each of the \(2n-2|M|\) unmatched nodes one edge at it (one exists by the hypotheses on the \(S_\ell\) and the access points); this is a test set of size \(|M|+(2n-2|M|)=2n-|M|\).

\(\ge\): let \(T\) be a minimum test set. Every pair of \(T\) has an endpoint of \(T\)-degree \(1\), since otherwise deleting it leaves a smaller test set. Hence \(T\) contains no path of three edges (its middle edge would have both endpoints of degree \(\ge 2\)), so each connected component of \((V,T)\) is a star with at least one edge; with \(c\) components covering all \(2n\) nodes, \(|T|=2n-c\). One edge from each star gives a matching of size \(c\le\nu\), so

\begin{equation*} |T| = 2n-c \ge 2n-\nu . \end{equation*}

By (7.38) the Ford-Fulkerson Algorithm finds \(M\) in \(O(mn)\) time, where \(m=\sum_\ell|S_\ell|\le n^2\), so the algorithm runs in \(O(mn)=O(n^3)\) time.

(a) Take

\begin{equation*} M=\begin{pmatrix}1&1&1\\1&0&0\\1&0&0\end{pmatrix}. \end{equation*}

Every row and column contains a \(1\), but rows \(2\) and \(3\) have their only \(1\) in the same column, and swaps never separate entries of a column; so whichever positions rows \(2,3\) end up in, at most one of them gets a \(1\) on the diagonal.

(b) \(M\) is rearrangeable iff the bipartite graph \(G\) with row nodes \(r_1,\ldots,r_n\), column nodes \(c_1,\ldots,c_n\) and an edge \((r_i,c_j)\) for each \(m_{ij}=1\) has a perfect matching; decide this by computing a maximum matching. Row swaps permute rows and column swaps permute columns, independently of each other, and every permutation is a product of transpositions; so the matrices reachable by swaps are exactly

\begin{equation*} M^{\prime}=(m_{\sigma(i)\tau(j)})_{i,j}, \qquad \sigma,\tau \text{ permutations of } \{1,\ldots,n\}. \end{equation*}

If such an \(M^{\prime}\) has all diagonal entries \(1\), then \(m_{\sigma(i)\tau(i)}=1\) for all \(i\), so the edges \((r_{\sigma(i)},c_{\tau(i)})\), \(i=1,\ldots,n\), form a perfect matching of \(G\). Conversely, if \(\{(r_i,c_{\pi(i)})\}\) is a perfect matching, take \(\sigma=\mathrm{id}\), \(\tau=\pi\): then \(m^{\prime}_{ii}=m_{i\pi(i)}=1\) for all \(i\).

\(G\) has at most \(n^2\) edges, so by (7.38) the Ford-Fulkerson Algorithm finds a maximum matching in \(O(n^2\cdot n)=O(n^3)\) time; \(M\) is rearrangeable iff it has size \(n\).

Compute one maximum flow \(f\); the upstream nodes are the set \(U\) of nodes reachable from \(s\) in \(G_f\), the downstream nodes are the set \(D\) of nodes that can reach \(t\) in \(G_f\), and all other nodes are central.

Every minimum cut \((A,B)\) has \(U\subseteq A\) and \(D\subseteq B\). By (7.6) and (7.8),

\begin{equation*} c(A,B)=\nu(f)=f^{\mathrm{out}}(A)-f^{\mathrm{in}}(A)\le f^{\mathrm{out}}(A)\le c(A,B), \end{equation*}

so every edge out of \(A\) is saturated and every edge into \(A\) carries no flow; thus \(G_f\) has no edge from \(A\) to \(B\). A residual path from \(s\in A\) therefore stays in \(A\), giving \(U\subseteq A\); and a residual path from \(v\) to \(t\in B\) cannot start in \(A\), giving \(D\subseteq B\).

Both \((U,V-U)\) and \((V-D,D)\) are minimum cuts. The first is the cut \((A^*,B^*)\) of (7.9). For the second, \(t\in D\) and \(s\notin D\) (an \(s\)-\(t\) path in \(G_f\) would, by (7.3), give a flow of larger value), and \(G_f\) has no edge \((u,w)\) with \(u\notin D\), \(w\in D\) (else \(u\) could reach \(t\)). So every edge leaving \(V-D\) is saturated and every edge entering it carries no flow, whence by (7.6)

\begin{equation*} \nu(f)=f^{\mathrm{out}}(V-D)-f^{\mathrm{in}}(V-D)=c(V-D,D), \end{equation*}

which is minimum by (7.8).

Hence a node of \(U\) is on the source side of every minimum cut (upstream); a node not in \(U\) is on the sink side of \((U,V-U)\) (not upstream); a node of \(D\) is downstream; and a node not in \(D\) is on the source side of \((V-D,D)\) (not downstream). Since \(U\cap D=\emptyset\), the three classes are \(U\), \(D\) and \(V-(U\cup D)\), as claimed.

Running time: one maximum flow, plus building \(G_f\) and doing a breadth-first search from \(s\) in \(G_f\) and one into \(t\) (a search from \(t\) in \(G_f\) with edges reversed), all \(O(m)\); computing a maximum flow already takes \(\Omega(m)\) time, so the total is within a constant factor of one max-flow computation.

Run the algorithm of Exercise 7.23: compute a maximum flow \(f\), the set \(U\) of nodes reachable from \(s\) in \(G_f\) and the set \(D\) of nodes that can reach \(t\) in \(G_f\); the minimum cut is unique iff \(U\cup D=V\), i.e. iff there are no central nodes.

By Exercise 7.23, every minimum cut \((A,B)\) satisfies \(U\subseteq A\) and \(D\subseteq B\), and \((U,V-U)\) and \((V-D,D)\) are minimum cuts.

(i) If \(U\cup D=V\), then \(D=V-U\) (as \(U\cap D=\emptyset\)), so every minimum cut has \(U\subseteq A\subseteq V-D=U\); thus \((A,B)=(U,V-U)\) is the only minimum cut.

(ii) If some \(v\notin U\cup D\), then \(v\in V-U\) and \(v\in V-D\), so \((U,V-U)\) and \((V-D,D)\) are two distinct minimum cuts.

The running time is that of one maximum-flow computation plus \(O(m)\), which is polynomial (e.g. \(O(n^3)\) with the Preflow-Push Algorithm, (7.33)).

Start from the checks \(b_{ij}=a_{ij}\) (for all \(a_{ij}>0\)) and repeatedly cancel cycles of the underlying undirected graph until it is a forest. Writing \(\beta_i(b)\) for the checks received by \(i\) minus those written by \(i\), the starting set is a consistent reconciliation, since

\begin{equation*} \beta_i(a)=\sum_j a_{ji}-\sum_j a_{ij}=\text{imbalance of } i . \end{equation*}

Let \(H\) be the undirected graph with an edge \(\{i,j\}\) whenever \(b_{ij}>0\); it is simple, because \(b_{ij}>0\) only where \(a_{ij}>0\), and at most one of \(a_{ij},a_{ji}\) is positive.

b = a  (one check i -> j for each a_ij > 0)
while H contains a cycle C = v_1, v_2, ..., v_r, v_1:
    call a check on C forward if it goes v_k -> v_(k+1)
        (in the traversal direction), backward otherwise
    if every check on C is forward: reverse the traversal
    d = min of b over the backward checks of C
    add d to every forward check, subtract d from every backward check
    discard checks whose amount became 0
return b

Invariants. Every remaining check \(i\to j\) was in the starting set, so \(a_{ij}>0\) (consistency), and all amounts stay positive since \(d\) is the minimum backward amount. Each \(\beta_i\) is unchanged: a node \(v_k\) of \(C\) meets the two checks joining it to \(v_{k-1}\) and \(v_{k+1}\), and in each of the four orientation cases

\begin{equation*} \begin{aligned} \Delta\beta_{v_k} &= (\text{change from } \{v_{k-1},v_k\}) + (\text{change from } \{v_k,v_{k+1}\})\\ &= (+d) + (-d) = 0 \end{aligned} \end{equation*}

(on \(\{v_{k-1},v_k\}\) a forward check raises what \(v_k\) receives by \(d\), a backward one lowers what \(v_k\) writes by \(d\); on \(\{v_k,v_{k+1}\}\) a forward check raises what \(v_k\) writes, a backward one lowers what \(v_k\) receives). Nodes off \(C\) are untouched. So \(b\) remains a consistent reconciliation throughout.

Termination and size. Each iteration deletes at least one check (the backward check attaining \(d\)) and adds none, so there are at most \(|E(H)|\le\binom n2\) iterations; at the end \(H\) is a forest on \(n\) nodes, so at most \(n-1\) checks are written.

Running time. A cycle is found (or \(H\) shown acyclic) by depth-first search in \(O(n^2)\), and the update is \(O(n)\), so the total is \(O(n^2\cdot n^2)=O(n^4)\).

Cut the drive into at most \(2n+1\) pieces on which the set of base stations in range of the moving phone is constant, and keep a maximum bipartite matching up to date with one augmenting-path search per change.

Write \(p_1=(x_0,y_0)\), so at time \(t\in[0,z]\) the phone is at \(p_1(t)=(x_0+t,y_0)\). For \(b_j=(x_j,y_j)\) the times when \(b_j\) is in range form a closed interval, possibly empty:

\begin{equation*} \begin{aligned} J_j &= \{t\in[0,z] : |p_1(t)-b_j|\le\Delta\}\\ &= [\,x_j-x_0-w_j,\; x_j-x_0+w_j\,]\cap[0,z], \end{aligned} \end{equation*}

with \(w_j=\sqrt{\Delta^2-(y_j-y_0)^2}\) (and \(J_j=\emptyset\) if \(|y_j-y_0|>\Delta\)). Let \(0=e_0<e_1<\dots<e_m=z\) be the distinct numbers among \(0,z\) and the endpoints of the \(J_j\), so \(m\le 2n+1\). Let \(G(t)\) be the bipartite graph on phones and bases with the fixed edges \((p_i,b_j)\), \(i\ge 2\), \(|p_i-b_j|\le\Delta\), plus the edges \((p_1,b_j)\) for \(t\in J_j\). The phones are fully connected at time \(t\) exactly when \(G(t)\) has a perfect matching.

compute the intervals J_j and the event times e_0 < ... < e_m
M = maximum matching of G(midpoint of (e_0, e_1))
for k = 0, ..., m-1:
    t_k = midpoint of (e_k, e_{k+1})
    for each edge (p_1, b_j) present before but not in G(t_k):
        delete it; if it was in M, remove it from M and
        run one augmenting-path search, augmenting if one is found
    for each edge (p_1, b_j) in G(t_k) but not present before:
        add it; run one augmenting-path search, augmenting if found
    if |M| < n: report the point p_1(t_k) and stop
    M_k = M
report: use M_k on the time interval [e_k, e_{k+1}], k = 0, ..., m-1

Correctness. The algorithm keeps \(M\) a maximum matching. Deleting one edge lowers the maximum matching size by at most \(1\), and adding one edge raises it by at most \(1\). So after each change the current \(M\) has size at least the new maximum minus one. If one search finds no augmenting path, \(M\) is maximum by (7.9), applied to the flow network of Section 7.5 through (7.37). Hence \(|M|=n\) at step \(k\) exactly when \(G(t_k)\) has a perfect matching.

On the open interval \((e_k,e_{k+1})\) no endpoint of any \(J_j\) occurs, so \(G(t)=G(t_k)\) there. Each \(J_j\) is closed, so at the endpoints \(G(e_k)\) and \(G(e_{k+1})\) contain every edge of \(G(t_k)\). Thus:

(i) if the algorithm stops at step \(k\), the phones are not fully connected at time \(t_k\), and the reported point \(p_1(t_k)\) is a correct witness;

(ii) otherwise each \(M_k\) is a valid assignment on all of \([e_k,e_{k+1}]\). The plan “use \(M_k\) on \([e_k,e_{k+1})\), switch to \(M_{k+1}\) at \(e_{k+1}\)” keeps the phones fully connected throughout \([0,z]\). If \(z=0\), check \(G(0)\) once instead.

In the example, \(J_1=[0,1+\sqrt3]\) and \(J_2=[3-\sqrt3,4]\). The events are \(0<3-\sqrt3<1+\sqrt3<4\), and the algorithm outputs \(\{p_1b_1,p_2b_2\}\) on the first two pieces and \(\{p_1b_2,p_2b_1\}\) on the last.

Running time. Computing the \(J_j\) and sorting the events takes \(O(n\log n)\), and the initial matching takes \(O(n^3)\) with Ford-Fulkerson (7.38). Each \(J_j\) adds its edge once and deletes it once, so there are at most \(2n\) edge changes. Each costs one augmenting-path search in a graph with \(O(n^2)\) edges, \(O(n^2)\) time, for a total of \(O(n^3)\).

Fair schedules are exactly the integer flows of value \(d\) in a day-person network. The uniform-random “fractional schedule” is a flow of value \(d\), so integrality gives an integer one. (Days with \(S_i=\emptyset\) need no driver and are dropped.)

(a) Build \(G\) with a source \(s\), a node \(u_i\) for each day, a node \(v_j\) for each person, and a sink \(t\), and the edges

\begin{equation*} \begin{aligned} &(s,u_i) &&\text{capacity } 1, &&i=1,\dots,d,\\ &(u_i,v_j) &&\text{capacity } 1, &&p_j\in S_i,\\ &(v_j,t) &&\text{capacity } \lceil\Delta_j\rceil, &&j=1,\dots,k. \end{aligned} \end{equation*}

Put \(f(s,u_i)=1\), \(f(u_i,v_j)=1/|S_i|\) for \(p_j\in S_i\), and \(f(v_j,t)=\Delta_j\). Conservation holds at \(u_i\) (\(1=|S_i|\cdot\frac1{|S_i|}\)) and at \(v_j\) (by the definition of \(\Delta_j\)). The capacities hold because \(1/|S_i|\le 1\) and \(\Delta_j\le\lceil\Delta_j\rceil\). So \(f\) is a flow of value \(d\). The cut \((\{s\},V-\{s\})\) has capacity \(d\), so by (7.8) the maximum flow value is exactly \(d\). All capacities are integers, so by (7.14) there is an integer maximum flow \(f^*\), of value \(d\). In \(f^*\) each \(u_i\) receives one unit and sends it along exactly one edge \((u_i,v_j)\) with \(p_j\in S_i\); let \(p_j\) drive on day \(i\). Then \(p_j\) drives on

\begin{equation*} \#\{i : f^*(u_i,v_j)=1\}=f^*(v_j,t)\le\lceil\Delta_j\rceil \end{equation*}

days, so this is a fair driving schedule.

(b) Build \(G\), run Ford-Fulkerson, and read off the schedule as in (a). By (a) and (7.10), Ford-Fulkerson returns a maximum flow of value \(d\), and it is integer-valued by (7.2). \(G\) has \(m\le d+dk+k\) edges and the capacities out of \(s\) sum to \(C=d\). By (7.5) the running time is \(O(mC)=O(kd^2)\), plus \(O(kd)\) to compute the \(\Delta_j\) and build \(G\).

Model the schedule as an integer circulation with demands and lower bounds (Section 7.7). Lower bounds enforce “at least \(a\)” and “at least \(d_i\)”, the capacities enforce “at most \(b\)” and “one TA per slot”, and the demands \(\mp c\) enforce “exactly \(c\)”.

(a) Let the TAs be \(T_1,\dots,T_r\). Build \(G\) with nodes \(s\) (demand \(-c\)), \(t\) (demand \(+c\)), a node \(T_x\) for each TA and a node \(I_\ell\) for each slot (demand \(0\)). The edges, with [lower bound, capacity], are

\begin{equation*} \begin{aligned} &(s,T_x) && [a,b], && x=1,\dots,r,\\ &(T_x,I_\ell) && [0,1], && T_x \text{ available during } I_\ell,\\ &(I_\ell,t) && [0,1], && \ell=1,\dots,k. \end{aligned} \end{equation*}

Decide whether \(G\) has a feasible circulation by the reduction of (7.52) and then (7.50), that is, with one maximum-flow computation. If it does not, report that no schedule exists. If it does, take an integer-valued one \(f\) (it exists by (7.52), since all data are integers), and let \(T_x\) cover \(I_\ell\) whenever \(f(T_x,I_\ell)=1\).

Correctness. Given a valid schedule, put one unit on \((T_x,I_\ell)\) for each assignment and on \((I_\ell,t)\) for each covered slot, and put the number of hours of \(T_x\) on \((s,T_x)\). Each of these lies in \([a,b]\). The net flow out of \(s\) is the total number of hours, \(c\), so this is a feasible circulation. Conversely, from an integer feasible circulation:

(i) inflow to \(I_\ell\) is at most \(1\), so each slot has at most one TA, and only an available one;

(ii) \(T_x\) holds \(f(s,T_x)\in[a,b]\) hours, by conservation at \(T_x\);

(iii) the number of covered slots is \(f^{\text{in}}(t)=c\), by the demand at \(t\).

So it is a valid schedule.

(b) Insert a node \(D_i\) for each day \(i\). Replace each edge \((I_\ell,t)\) by \((I_\ell,D_i)\) with \([0,1]\), where \(i\) is the day of \(I_\ell\), and add \((D_i,t)\) with \([d_i,k]\). The algorithm is the same. The flow on \((D_i,t)\) equals the number of covered slots on day \(i\), so the lower bound \(d_i\) is exactly the density constraint. Both directions of the argument in (a) go through unchanged. In the example, the flow realizing \(T_1\to I_1\), \(T_2\to I_3\), \(T_2\to I_5\) is feasible with \(d_{\text{Wed}}=d_{\text{Thu}}=1\).

Running time. First reject if \(a>b\) (with \(r\ge1\)), \(ra>c\), \(\sum_i d_i>c\) or \(c>k\). Each is necessary, since no TA can hold between \(a\) and \(b\) hours when \(a>b\), the TAs hold at least \(ra\) hours, the days need at least \(\sum_i d_i\) hours, and at most \(k\) slots exist. Otherwise the auxiliary \(s^*\)-\(t^*\) flow of (7.50) has value \(D=(c-\sum_i d_i)+\sum_i d_i=c\le k\). The positive modified demands are \(c-\sum_i d_i\) at \(t\) and \(d_i\) at \(D_i\), while \(s\) and the \(T_x\) get \(ra-c\le0\) and \(-a\). The network has \(m=O(rk)\) edges, so Ford-Fulkerson takes \(O(mD)=O(rk^2)\) time by (7.5).

Take a minimum cut in the segmentation network of Section 7.10: the source side is “new system”, and application \(1\) is nailed to the sink side.

The objective is

\begin{equation*} \operatorname{val}(S)=\sum_{i\in S}b_i-\sum_{\{i,j\}:\ |\{i,j\}\cap S|=1}x_{ij}. \end{equation*}

Let \(B=\sum_{i\ge2}b_i\). Build \(G\) on the nodes \(\{s,t,1,\dots,n\}\) with edges \((s,i)\) of capacity \(b_i\) for \(i\ge2\), edges \((i,j)\) and \((j,i)\) each of capacity \(x_{ij}\), and an edge \((1,t)\) of capacity \(B+1\). Compute a minimum \(s\)-\(t\) cut \((A^{\prime},B^{\prime})\) and output \(S=A^{\prime}-\{s\}\).

Correctness. For any \(S\subseteq\{2,\dots,n\}\), the cut \((\{s\}\cup S,\ \text{rest})\) is crossed by the edges \((s,i)\) with \(i\notin S\) and by exactly one of \((i,j),(j,i)\) for each pair split by \(S\). So its capacity is

\begin{equation*} \begin{aligned} c(\{s\}\cup S,\ \text{rest}) &=\sum_{i\ge2,\ i\notin S}b_i+\sum_{\text{split pairs}}x_{ij}\\ &=B-\operatorname{val}(S). \end{aligned} \end{equation*}

A cut with \(1\) on the source side contains \((1,t)\), so its capacity is at least \(B+1>B=c(\{s\},V-\{s\})\), and such a cut is never minimum. Hence the minimum cuts are exactly the cuts \(\{s\}\cup S\) with \(S\subseteq\{2,\dots,n\}\) that minimize \(B-\operatorname{val}(S)\), that is, that maximize \(\operatorname{val}(S)\). This is the argument of (7.55), with the “background” benefit of every application set to \(0\).

Running time. One maximum flow and the cut from (7.11) on \(n+2\) nodes, which is \(O(n^3)\) with the Preflow-Push Algorithm by (7.33).

Split each benefit into its positive and negative parts and charge a negative benefit on an edge to the sink. Then a minimum cut again maximizes the objective, as in Section 7.10.

Write \(b_i^+=\max(b_i,0)\) and \(b_i^-=\max(-b_i,0)\), so \(b_i=b_i^+-b_i^-\), and let \(P=\sum_i b_i^+\). Build \(G\) on \(\{s,t,1,\dots,n\}\) with edges \((s,i)\) of capacity \(b_i^+\), edges \((i,t)\) of capacity \(b_i^-\), and edges \((i,j)\) and \((j,i)\) each of capacity \(x_{ij}\). All capacities are nonnegative. Compute a minimum \(s\)-\(t\) cut \((A^{\prime},B^{\prime})\) and output \(S=A^{\prime}-\{s\}\).

Correctness. Every \(S\subseteq\{1,\dots,n\}\) gives the cut \((\{s\}\cup S,\ \text{rest})\), and every \(s\)-\(t\) cut arises this way. Its capacity is

\begin{equation*} \begin{aligned} c(\{s\}\cup S,\ \text{rest}) &=\sum_{i\notin S}b_i^+ +\sum_{i\in S}b_i^- +\sum_{\text{split pairs}}x_{ij}\\ &=P-\Bigl(\sum_{i\in S}(b_i^+-b_i^-)-\sum_{\text{split pairs}}x_{ij}\Bigr)\\ &=P-\operatorname{val}(S). \end{aligned} \end{equation*}

Here \(\operatorname{val}(S)\) is the objective of Exercise 7.29. \(P\) does not depend on \(S\), so a minimum cut gives a set \(S\) of maximum value.

Running time. One minimum-cut computation on \(n+2\) nodes, which is \(O(n^3)\) by (7.33).

Build the bipartite graph \(G\) with sides \(X=\{x_1,\dots,x_n\}\) and \(Y=\{y_1,\dots,y_n\}\) and an edge \((x_i,y_j)\) whenever box \(i\) nests in box \(j\). The minimum number of visible boxes is \(n-|M|\) for a maximum matching \(M\) of \(G\), and an optimal arrangement can be read off from \(M\).

Testing nesting. Write \(a_1\le a_2\le a_3\) and \(b_1\le b_2\le b_3\) for the sorted sides of boxes \(i\) and \(j\). Then \(i\) nests in \(j\) if and only if \(a_k<b_k\) for \(k=1,2,3\). If the sorted order works, it is itself one of the permutations. Conversely, suppose some permutation works. Fix \(k\) and look at the \(k\) sides of \(j\) with values \(b_1,\dots,b_k\). Each is matched to a different side of \(i\) that is strictly smaller, so \(i\) has \(k\) distinct sides all below \(b_k\), and therefore \(a_k<b_k\). Each pair is tested in \(O(1)\) time, so \(G\) has \(m\le n^2\) edges and is built in \(O(n^2)\) time.

Arrangements give matchings. In any arrangement, each box is put inside another box at most once (afterwards it sits inside that box). By the remark in the statement, each box directly receives at most one box. So the operations \((i\to j)\) form a matching \(M\) in \(G\). The visible boxes are exactly those never moved, so

\begin{equation*} \#\text{visible} = n-\#\text{operations} = n-|M| \ge n-|M^*|, \end{equation*}

where \(M^*\) is a maximum matching.

Matchings give arrangements. Let \(M\) be any matching, and let \(H\) be the directed graph on the boxes with an arc \(i\to j\) for each \((x_i,y_j)\in M\). Every box has out-degree and in-degree at most \(1\) in \(H\). Also, \(H\) is acyclic, since \(i\to j\) forces

\begin{equation*} i_1+i_2+i_3 < j_1+j_2+j_3 . \end{equation*}

So \(H\) is a disjoint union of directed paths \(v_1\to v_2\to\cdots\to v_r\). For each path, put \(v_1\) into \(v_2\), then \(v_2\) into \(v_3\), and so on up to \(v_r\). Each step is legal: \(v_t\) nests in \(v_{t+1}\), and \(v_{t+1}\) is still empty because \(v_t\) is the only box ever put into it. The visible boxes are the path ends \(v_r\), and there are \(n-|M|\) of them.

So the minimum equals \(n-|M^*|\), and the construction above with \(M=M^*\) achieves it.

Algorithm.

sort the three sides of every box
build G: edge (x_i, y_j) iff sorted sides of i are
         coordinatewise strictly smaller than those of j
M = maximum matching of G (Ford-Fulkerson, Section 7.5)
for each path v1 -> v2 -> ... -> vr formed by the edges of M:
    put v1 into v2, then v2 into v3, ..., then v(r-1) into vr

Running time. Building \(G\) takes \(O(n^2)\) time. By (7.37) and (7.38), Ford-Fulkerson finds a maximum matching in \(O(mn)=O(n^3)\) time, and tracing the paths takes \(O(n)\) time. The total is \(O(n^3)\).

Yes, for directed and undirected \(G\) alike. By (7.45) (directed) and (7.48) (undirected), \(s\xrightarrow{G,k}t\) holds exactly when deleting any set of fewer than \(k\) edges leaves \(t\) reachable from \(s\).

For \(k=0\) there is nothing to prove. For \(k\ge1\) assume \(x\xrightarrow{G,k}y\) and \(y\xrightarrow{G,k}z\), and take any \(F\subseteq E\) with \(|F|<k\). Then

\begin{equation*} \begin{aligned} x\xrightarrow{G,k}y,\ |F|<k &\;\Rightarrow\; y \text{ is reachable from } x \text{ in } G-F,\\ y\xrightarrow{G,k}z,\ |F|<k &\;\Rightarrow\; z \text{ is reachable from } y \text{ in } G-F. \end{aligned} \end{equation*}

Joining the two walks, \(z\) is reachable from \(x\) in \(G-F\). So no set of fewer than \(k\) edges separates \(x\) from \(z\), and by (7.45) or (7.48) there are \(k\) edge-disjoint \(x\)-\(z\) paths, i.e. \(x\xrightarrow{G,k}z\). \(\blacksquare\)

Yes: in a balanced graph every cut has as many edges leaving it as entering it, so every \(y\)-\(x\) cut is as large as some \(x\)-\(y\) cut.

Give every edge capacity \(1\). For \(S\subseteq V\) write \(e^{\text{out}}(S)\) and \(e^{\text{in}}(S)\) for the number of edges leaving and entering \(S\). An edge with both ends in \(S\) contributes \(+1\) and \(-1\) to the sum below, so summing the balance condition over \(S\) gives

\begin{equation*} 0=\sum_{v\in S}\bigl(\deg^{\text{out}}(v)-\deg^{\text{in}}(v)\bigr)=e^{\text{out}}(S)-e^{\text{in}}(S). \end{equation*}

By (7.43) the maximum \(x\)-\(y\) flow has value at least \(k\). By the Max-Flow Min-Cut Theorem (7.13), every \(x\)-\(y\) cut \((A,V-A)\) (so \(x\in A\), \(y\notin A\)) then satisfies \(e^{\text{out}}(A)\ge k\). Now take any \(y\)-\(x\) cut \((B,V-B)\) with \(y\in B\), \(x\notin B\), and put \(A=V-B\). Then \((A,B)\) is an \(x\)-\(y\) cut, and the edges leaving \(B\) are exactly the edges entering \(A\), so

\begin{equation*} e^{\text{out}}(B)=e^{\text{in}}(A)=e^{\text{out}}(A)\ge k. \end{equation*}

So every \(y\)-\(x\) cut has capacity at least \(k\), and by (7.13) the maximum \(y\)-\(x\) flow has value at least \(k\). By (7.43) there are \(k\) edge-disjoint paths from \(y\) to \(x\). \(\blacksquare\)

(a) Reduce to a bipartite max-flow problem: each device sends \(k\) units of back-up demand to devices in range, and each device can absorb at most \(b\).

Build \(G\) with source \(s\), sink \(t\), a node \(v\) (left copy) and a node \(v^{\prime}\) (right copy) for every device. Add edges \(s\to v\) of capacity \(k\), edges \(v\to u^{\prime}\) of capacity \(1\) whenever \(u\ne v\) and \(\mathrm{dist}(u,v)\le d\), and edges \(u^{\prime}\to t\) of capacity \(b\). Compute a maximum flow \(\varphi\) with Ford-Fulkerson. If its value is \(nk\), output \(B_v=\{u : \varphi(v\to u^{\prime})=1\}\); otherwise report that no choice exists.

Correctness. By (7.14) there is an integer maximum flow. Given an integer flow of value \(nk\), every edge \(s\to v\) is saturated. By conservation at \(v\), exactly \(k\) unit edges \(v\to u^{\prime}\) carry flow, so \(|B_v|=k\) and every member is a different device within \(d\) of \(v\). By conservation at \(u^{\prime}\), the number of \(v\) with \(u\in B_v\) equals \(\varphi(u^{\prime}\to t)\le b\). Conversely, valid back-up sets give a flow of value \(nk\): put \(1\) on \(v\to u^{\prime}\) for \(u\in B_v\), \(k\) on each \(s\to v\), and \(|\{v: u\in B_v\}|\le b\) on \(u^{\prime}\to t\). So the sets exist iff the maximum flow is \(nk\).

Running time. \(G\) has \(O(n)\) nodes and \(m=O(n^2)\) edges, and building it takes \(O(n^2)\) distance computations. The flow value is at most \(nk\), so by (7.5) Ford-Fulkerson takes \(O(m\cdot nk)=O(kn^3)\) time.

(b) Use the same network, but replace the single node \(v\) by a chain \(v_1\to v_2\to\cdots\to v_k\) whose capacities cap how many members may come from the weaker signal classes.

For \(u\ne v\) put \(u\) in class \(c_v(u)=\min\{j : f(\mathrm{dist}(u,v))\ge p_j\}\). Since the \(p_j\) are non-increasing, \(f(\mathrm{dist}(u,v))\ge p_j\) iff \(c_v(u)\le j\). A device \(u\) with \(f(\mathrm{dist}(u,v))<p_k\) gets no class and can never be used. If the hard range \(d\) is also kept, give no class to devices farther than \(d\) as well; nothing else changes. Let

\begin{equation*} S_j(v)=\{u : c_v(u)\le j\},\qquad S_1(v)\subseteq S_2(v)\subseteq\cdots\subseteq S_k(v). \end{equation*}

Reformulation. A \(k\)-set \(B\) satisfies the condition iff \(B\subseteq S_k(v)\) and \(|B\setminus S_j(v)|\le k-j\) for all \(j\).

To see this, order \(B\) by distance as \(u_1,\dots,u_k\). Since \(f\) is decreasing, \(f(d_j)\ge p_j\) means \(u_1,\dots,u_j\in S_j(v)\), so \(|B\cap S_j(v)|\ge j\). Conversely, suppose \(|B\cap S_j(v)|\ge j\), and let \(w\) be the farthest of \(j\) members of \(B\cap S_j(v)\). Then \(d_j\le\mathrm{dist}(w,v)\), so \(f(d_j)\ge f(\mathrm{dist}(w,v))\ge p_j\). Finally, \(|B\cap S_j(v)|\ge j\) iff \(|B\setminus S_j(v)|\le k-j\), because \(|B|=k\) and \(B\subseteq S_k(v)\).

Network. For each device \(v\) create chain nodes \(v_1,\dots,v_k\), and for each device \(u\) a node \(u^{\prime}\). Add the edges

\begin{equation*} \begin{aligned} &s\to v_1 &&\text{capacity } k,\\ &v_j\to v_{j+1}\ (1\le j<k) &&\text{capacity } k-j,\\ &v_{c_v(u)}\to u^{\prime} \ (u \text{ classed for } v) &&\text{capacity } 1,\\ &u^{\prime}\to t &&\text{capacity } b. \end{aligned} \end{equation*}

Compute an integer maximum flow \(\varphi\) (7.14). If its value is \(nk\), output \(B_v=\{u : v_{c_v(u)}\to u^{\prime} \text{ carries flow}\}\); otherwise report infeasibility.

Correctness. Inside the gadget of \(v\), the only way to reach \(v_{j+1}\) is along \(v_j\to v_{j+1}\), and the edges leaving \(v_{j+1},\dots,v_k\) go exactly to the classes \(>j\). So conservation gives

\begin{equation*} \varphi(v_j\to v_{j+1})=\bigl|\{u\in B_v : c_v(u)>j\}\bigr|=|B_v\setminus S_j(v)|. \end{equation*}

Take an integer flow of value \(nk\). Each \(s\to v_1\) is saturated, so \(|B_v|=k\), with distinct members (unit edges) drawn from \(S_k(v)\). The capacity \(k-j\) then gives \(|B_v\setminus S_j(v)|\le k-j\), so \(B_v\) is valid by the reformulation, and as in (a) each \(u\) lies in at most \(b\) sets. Conversely, valid sets \(\{B_v\}\) give a feasible flow of value \(nk\): route one unit \(s\to v_1\to\cdots\to v_{c_v(u)}\to u^{\prime}\to t\) for each \(u\in B_v\). By the display and the reformulation, chain edge \(j\) then carries \(|B_v\setminus S_j(v)|\le k-j\), and \(u^{\prime}\to t\) carries at most \(b\). So the sets exist iff the maximum flow equals \(nk\).

Running time. There are \(O(nk)\) nodes and \(m=O(nk+n^2)=O(n^2)\) edges, using \(k\le n-1\) (if \(k\ge n\) the answer is trivially no). The flow value is at most \(nk\), so by (7.5) Ford-Fulkerson runs in \(O(m\cdot nk)=O(kn^3)\) time.

Force a clicked pixel \(v\) into the foreground by raising the capacity of the edge \((s,v)\) to \(a^{\prime}_v = b_v+\sum_{j:(v,j)\in E}p_{vj}+1\), and repair the current maximum flow with at most \(5d+1\) augmenting-path searches, as in Solved Exercise 1.

Build the network \(G^{\prime}\) of Section 7.10 (edges \((s,i)\) of capacity \(a_i\), \((i,t)\) of capacity \(b_i\), and \((i,j),(j,i)\) of capacity \(p_{ij}\) for every neighboring pair). Compute an integer maximum flow \(f\) by Ford-Fulkerson (7.14), and output \(A_0\), the set of pixels reachable from \(s\) in \(G^{\prime}_f\) (7.11). When pixel \(v\) is clicked, set

\begin{equation*} \Delta_v=\max\Bigl(0,\; b_v+\sum_{j}p_{vj}+1-c(s,v)\Bigr), \end{equation*}

add \(\Delta_v\) to \(c(s,v)\), and then repeatedly search \(G^{\prime}_f\) for an \(s\)-\(t\) path and augment along it, until a search fails. Output as \(A_i\) the pixels reachable from \(s\) in the final residual graph. (A pixel that was already clicked has \(\Delta_v=0\).)

Write \(q^{\prime}(A,B)=\sum_{i\in A}b_i+\sum_{j\in B}a_j+\sum_{|A\cap\{i,j\}|=1}p_{ij}\), so \(q(A,B)=\sum_i(a_i+b_i)-q^{\prime}(A,B)\) and we must minimize \(q^{\prime}\) under the constraints. Let \(H_i\) be the network after clicks \(v_1,\dots,v_i\); only edges \((s,v_k)\) have changed, and each now has capacity \(c(s,v_k)>b_{v_k}+\sum_j p_{v_kj}\).

(i) In \(H_i\), no minimum cut has some \(v_k\) on the \(t\)-side. If \(v=v_k\in B\), moving \(v\) to the \(s\)-side changes the cut capacity by

\begin{equation*} \begin{aligned} &b_v+\sum_{j\in B}p_{vj}-c(s,v)-\sum_{j\in A}p_{jv}\\ &\qquad\le b_v+\sum_{j}p_{vj}-c(s,v)<0 . \end{aligned} \end{equation*}

(ii) For a cut with all \(v_1,\dots,v_i\) on the \(s\)-side, no modified edge \((s,v_k)\) crosses it, so its capacity in \(H_i\) equals its capacity in \(G^{\prime}\), which is \(q^{\prime}(A,B)\) by the computation in Section 7.10.

By (i) and (ii), the minimum cuts of \(H_i\) are exactly the constrained minimizers of \(q^{\prime}\), i.e. the constrained maximizers of \(q\). The reachable set at termination is a minimum cut of \(H_i\) by (7.9), so \((A_i,B_i)\) is correct.

The repair is correct because the flow \(f\) from before the click stays feasible in \(H_i\), and some minimum cut of \(H_{i-1}\) has capacity \(\nu(f)\). That cut’s capacity in \(H_i\) is at most \(\nu(f)+\Delta_{v_i}\). Hence, exactly as in (7.68),

\begin{equation*} \nu(f)\le \max\text{-flow}(H_i)\le \nu(f)+\Delta_{v_i}. \end{equation*}

All capacities are integers, so each augmentation raises the flow value by at least \(1\). So after at most \(\Delta_{v_i}\) augmentations a search fails, and the flow is then maximum by (7.9).

The initial phase is one maximum-flow computation plus an \(O(m)\) search (7.11). For a click, the bounds \(b_v\le d\) and at most four neighbors with \(p_{vj}\le d\) give

\begin{equation*} \Delta_v\le d+4d+1=5d+1 . \end{equation*}

So there are at most \(5d+2\) searches. \(G^{\prime}\) has \(n+2\) nodes and at most \(2n+4n=6n\) edges, so each search and each augmentation in the residual graph (at most \(12n\) edges) takes \(O(n)\) time. The final reachability search is another \(O(n)\). The total per click is

\begin{equation*} O\bigl((5d+2)\,n\bigr)=O(dn) \end{equation*}

(for \(d\ge 1\); when \(d=0\) every segmentation is optimal).

For each \((i,j)\in E\) and each \(k=1,\dots,M\) add the edges \((v_{i,k},v_{j,k})\) and \((v_{j,k},v_{i,k})\), both of capacity \(p_{ij}\), and take \(L=1+\sum_{i}a_{i,0}\); the label of pixel \(i\) is the number of its chain nodes \(v_{i,1},\dots,v_{i,M}\) on the source side of a minimum cut. (We take \(p_{ij}\ge 0\); if some \(a_{i,k}<0\), first add a constant to every \(a_{i,k}\) of pixel \(i\), which shifts every labeling’s cost equally.)

Any \(L>\sum_i a_{i,0}=c(\{s\},V-\{s\})\) suffices: a cut with an \(L\)-edge leaving \(A\) has capacity at least \(L\), so it is not minimum. If no \(L\)-edge leaves \(A\), then \(v_{i,k+1}\in A\) forces \(v_{i,k}\in A\), so \(A\) meets each chain in a prefix

\begin{equation*} A\cap\{v_{i,0},\dots,v_{i,M+1}\}=\{v_{i,0},\dots,v_{i,k_i}\},\qquad 0\le k_i\le M \end{equation*}

(\(k_i\le M\) as \(t\notin A\)). Conversely each labeling \((k_i)\) gives the \(L\)-free cut \(A=\{s\}\cup\{v_{i,m}:1\le m\le k_i\}\), so \(L\)-free cuts and labelings correspond bijectively. In such a cut the only chain edge of \(i\) leaving \(A\) is \((v_{i,k_i},v_{i,k_i+1})\), of capacity \(a_{i,k_i}\); and for \((i,j)\in E\) with \(k_i<k_j\), the edge \((v_{j,m},v_{i,m})\) leaves \(A\) exactly when \(k_i<m\le k_j\) while no edge \((v_{i,m},v_{j,m})\) does (symmetrically for \(k_i>k_j\); nothing is cut if \(k_i=k_j\)). Hence

\begin{equation*} c(A,B)=\sum_{i}a_{i,k_i}+\sum_{(i,j)\in E}|k_i-k_j|\,p_{ij}=q^{\prime}(A_0,\dots,A_M), \end{equation*}

with \(A_k=\{i:k_i=k\}\). So compute a maximum flow, take the minimum cut \((A,B)\) of nodes reachable from \(s\) in the residual graph by (7.11), and output \(k_i=|\{m\ge 1:v_{i,m}\in A\}|\): this cut is \(L\)-free, and every labeling is an \(L\)-free cut of equal capacity, so the output labeling minimizes \(q^{\prime}\).

The network has \(N=nM+2\) nodes (\(n=|V|\)) and \(2n(M+1)+2M|E|\) edges, so by (7.33) the maximum-height Preflow-Push Algorithm runs in \(O(N^3)=O(n^3M^3)\) time, which dominates building the network and reading off the labels.

For each node \(v\), subtract \(\min(c_{sv},c_{vt})\) from both of its terminal edges; this shifts every cut value by the same constant and makes all capacities nonnegative, so an ordinary minimum cut solves the problem.

Merge parallel edges by adding capacities, and for \(v\in V-\{s,t\}\) write \(\sigma_v=c_{(s,v)}\), \(\tau_v=c_{(v,t)}\) (zero if the edge is absent) and \(m_v=\min(\sigma_v,\tau_v)\). Build \(G^{\prime}\) on the same nodes:

• every edge with neither end in \(\{s,t\}\) is kept with its capacity \(c_e\ge 0\);
• \((s,v)\) gets capacity \(\sigma_v-m_v\ge 0\) and \((v,t)\) gets capacity \(\tau_v-m_v\ge 0\);
• edges into \(s\), edges out of \(t\), and the edge \((s,t)\) are deleted.

Compute a minimum \(s\)-\(t\) cut \((A^*,B^*)\) of \(G^{\prime}\) with a max-flow algorithm and output it.

Fix any \(s\)-\(t\) cut \((A,B)\), so \(s\in A\), \(t\in B\). An edge entering \(s\) or leaving \(t\) never goes from \(A\) to \(B\), and \((s,t)\) always does. Edge \((s,v)\) is cut iff \(v\in B\), and \((v,t)\) is cut iff \(v\in A\); exactly one of these holds, so

\begin{equation*} \sigma_v[v\in B]+\tau_v[v\in A]=m_v+(\sigma_v-m_v)[v\in B]+(\tau_v-m_v)[v\in A]. \end{equation*}

Summing over \(v\) and adding the unchanged interior edges,

\begin{equation*} c_G(A,B)=c_{G^{\prime}}(A,B)+K,\qquad K=c_{(s,t)}+\sum_{v\ne s,t} m_v , \end{equation*}

where \(K\) does not depend on the cut. Both graphs have the same set of \(s\)-\(t\) cuts, so a cut minimizes \(c_{G^{\prime}}\) iff it minimizes \(c_G\), and \((A^*,B^*)\) is a minimum cut of \(G\), with value \(c_{G^{\prime}}(A^*,B^*)+K\).

Since \(G^{\prime}\) has only nonnegative capacities, it is an ordinary flow network, so by (7.13) and (7.11) a minimum cut is read off the residual graph of a maximum flow in \(O(m)\) time. The capacities may be arbitrary reals, so use the Preflow-Push Algorithm, which by (7.33) runs in \(O(n^2m)\) time independent of the capacity values. Building \(G^{\prime}\) takes \(O(m+n)\), so the total running time is \(O(n^2m)\).

Compute a minimum partition of the distinct subsets into chains under \(\subsetneq\) by a bipartite matching (minimum chain cover \(= d - \nu\)); a valid solution exists iff this minimum is at most \(\ell\), and each chain becomes one permutation.

Let \(\mathcal{D} = \{A_1, \dots, A_d\}\) be the distinct sets among \(S_1, \dots, S_k\) (\(d \le k\)). Build the bipartite graph \(B\) with a left node \(u_A\) and a right node \(v_A\) for each \(A \in \mathcal{D}\), and an edge \((u_A, v_{A^{\prime}})\) whenever \(A \subsetneq A^{\prime}\).

compute a maximum matching M of B          (Section 7.5)
for each matched edge (u_A, v_A'): set next(A) = A'
for each A in D with no matched edge into v_A:      // chain starts
    p = empty list; prev = empty set; X = A
    loop: append the columns of X - prev to p (any order)
          prev = X; if next(X) undefined, stop; X = next(X)
    append the columns of C - prev to p; output p
if the number of permutations output is <= ell:
    pad with arbitrary permutations to exactly ell; return them
else: report that no valid solution exists

Valid solutions are chain covers. The prefixes of one permutation are nested, so the sets \(S_i\) served by a single \(p_j\) form a chain under \(\subseteq\); a valid solution with \(\ell\) permutations therefore partitions \(\mathcal{D}\) into at most \(\ell\) chains. Conversely, for a chain \(X_1 \subsetneq X_2 \subsetneq \dots \subsetneq X_r\), the permutation listing \(X_1\), then \(X_2 \setminus X_1\), …, then \(X_r \setminus X_{r-1}\), then \(C \setminus X_r\) has each \(X_j\) as its first \(|X_j|\) columns. Hence a valid solution exists iff the minimum number \(c^*\) of chains partitioning \(\mathcal{D}\) satisfies \(c^* \le \ell\), and the loop above turns any chain partition into that many valid permutations.

Chain partitions are matchings. (i) Given a matching \(M\), every \(A\) has at most one successor \(\mathrm{next}(A)\) and at most one predecessor; since \(A \subsetneq \mathrm{next}(A)\) strictly increases \(|A|\), following \(\mathrm{next}\) never cycles, so the pointers split \(\mathcal{D}\) into vertex-disjoint paths, each a chain. A forest of paths on \(d\) nodes with \(|M|\) edges has \(d - |M|\) components, so \(c^* \le d - |M|\). (ii) Given a partition into \(c\) chains, linking each set to the next larger set in its chain uses each \(u_A\) and each \(v_A\) at most once, giving a matching of size \(d - c\). Therefore

\begin{equation*} c^* = d - \nu(B), \end{equation*}

and the matching found yields exactly \(c^*\) permutations, which (padded) is a valid solution whenever \(c^* \le \ell\), while for \(c^* > \ell\) none exists.

Running time. Deduplicating and testing all \(O(k^2)\) pairs for strict inclusion costs \(O(k^2 n)\) (sorted column lists or bit vectors); \(B\) has \(2d \le 2k\) nodes and \(O(k^2)\) edges, so the Ford-Fulkerson bipartite matching of Section 7.5 runs in \(O(k \cdot k^2) = O(k^3)\); writing the permutations costs \(O(kn)\). Total \(O(k^2 n + k^3)\), polynomial.

A rounding exists iff the maximum flow in the bipartite network rows \(\to\) columns (a unit edge per fractional entry, reduced row and column sums as source and sink capacities) saturates the source. Here \(a = (a_{ij})\) is \(m \times n\) with integer row sums \(r_i\) and column sums \(c_j\); an entry is fractional if \(a_{ij} \notin \mathbb{Z}\) (integer entries are forced).

(a) Let \(r_i^{\prime}\) (resp. \(c_j^{\prime}\)) be \(r_i\) (resp. \(c_j\)) minus the number of entries equal to \(1\) in row \(i\) (resp. column \(j\)). Build \(G\) with source \(s\), sink \(t\), a node \(u_i\) per row and \(v_j\) per column, and edges

\begin{equation*} \begin{aligned} &(s, u_i) \text{ of capacity } r_i^{\prime}, \qquad (v_j, t) \text{ of capacity } c_j^{\prime}, \\ &(u_i, v_j) \text{ of capacity } 1 \text{ for each fractional entry } 0 < a_{ij} < 1 . \end{aligned} \end{equation*}

Let \(D = \sum_i r_i^{\prime}\); since \(\sum_i r_i = \sum_j c_j\) and both sides subtract the total number of \(1\) entries, also \(D = \sum_j c_j^{\prime}\). Compute a maximum flow by Ford-Fulkerson; the rounding exists iff its value is \(D\), and then \(x_{ij} = f(u_i, v_j)\) for fractional entries (with \(0\) and \(1\) entries kept) is a rounding.

(\(\Rightarrow\)) Given a rounding \(x\), set \(f(u_i,v_j) = x_{ij}\) on fractional cells, \(f(s,u_i) = r_i^{\prime}\), \(f(v_j,t) = c_j^{\prime}\). Conservation at \(u_i\) holds because the fractional cells of row \(i\) round to a total of \(r_i - \#\{j : a_{ij}=1\} = r_i^{\prime}\) (entries equal to \(0\) stay \(0\)); likewise at \(v_j\). Capacities hold, and the value is \(D\).

(\(\Leftarrow\)) If the maximum flow value is \(D\), by (7.14) there is an integer flow \(f\) of value \(D\); it saturates every \((s,u_i)\), and since \(\sum_j c_j^{\prime} = D\) it saturates every \((v_j,t)\). Integrality and capacity \(1\) give \(f(u_i,v_j) \in \{0,1\}\), and conservation at \(u_i\) and \(v_j\) says that \(x\) has row sums \(r_i^{\prime} + \#\{j: a_{ij}=1\} = r_i\) and column sums \(c_j\).

The source capacities total \(D \le mn\), so Ford-Fulkerson runs in \(O(|E| D) = O((mn)^2)\) time by (7.5), with \(|E| \le mn + m + n\).

(b) Reduce to (a). Write \(a_{ij} = \lfloor a_{ij}\rfloor + b_{ij}\) with \(b_{ij} \in [0,1)\). Rounding \(a_{ij}\) to \(\lfloor a_{ij}\rfloor\) or \(\lceil a_{ij}\rceil\) is the same as rounding \(b_{ij}\) to \(0\) or \(1\) (if \(b_{ij} = 0\) the entry is forced), and the row and column sums of \(b\),

\begin{equation*} \rho_i = r_i - \sum_j \lfloor a_{ij}\rfloor, \qquad \gamma_j = c_j - \sum_i \lfloor a_{ij}\rfloor , \end{equation*}

are integers. So \(x\) is a census rounding of \(a\) iff \(x - \lfloor a\rfloor\) is a \(0/1\) rounding of \(b\) preserving the sums \(\rho_i, \gamma_j\). Run (a) on \(b\): the network has \((s,u_i)\) of capacity \(\rho_i \ge 0\), \((v_j,t)\) of capacity \(\gamma_j \ge 0\), and a unit edge \((u_i,v_j)\) for each fractional \(a_{ij}\); the rounding exists iff the maximum flow equals \(D = \sum_i \rho_i\), and then \(x_{ij} = \lfloor a_{ij}\rfloor + f(u_i,v_j)\). Again \(D = \sum_{ij} b_{ij}\) is at most the number of fractional entries, so the time is \(O((mn)^2)\).

(c) The fractional table itself is a maximum flow. In the network of (b) (which is the network of (a) when all entries are in \([0,1]\)) define

\begin{equation*} f(s,u_i) = \rho_i, \qquad f(u_i,v_j) = b_{ij}, \qquad f(v_j,t) = \gamma_j . \end{equation*}

Capacities hold since \(0 \le b_{ij} < 1\), and conservation holds since \(\sum_j b_{ij} = \rho_i\) and \(\sum_i b_{ij} = \gamma_j\) by definition. Its value is \(D\), which is the capacity of the cut \((\{s\}, V - \{s\})\), so by (7.8) \(f\) is a maximum flow and the maximum flow value is \(D\). All capacities are integers, so by (7.14) there is also an integer flow of value \(D\), and by the (\(\Leftarrow\)) direction of (a) it yields a valid rounding. Hence the rounding always exists, in both (a) and (b), and the algorithm of (b) always finds one.

Let \(H\) be the graph on \(V\) whose edges are the edges \(f\ne e^{\prime}\) with \(c_f<c_{e^{\prime}}-2\varepsilon\). Then \((*)\) holds if and only if \(H\) contains at least \(k+1\) edge-disjoint \(u\)-\(v\) paths. We test this by running Ford-Fulkerson on \(H\) with unit capacities (each undirected edge becomes two opposite arcs of capacity 1, as in Section 7.6), and we stop as soon as the flow value reaches \(k+1\).

Lemma. For any costs \(c^{\prime}\), the edge \(e^{\prime}\) lies in some minimum spanning tree if and only if there is no \(u\)-\(v\) path made only of edges \(f\ne e^{\prime}\) with \(c^{\prime}_f<c^{\prime}_{e^{\prime}}\).

(i) Suppose such a path \(P\) exists, and let \(T\) be a spanning tree that contains \(e^{\prime}\). Deleting \(e^{\prime}\) from \(T\) splits \(V\) into two sides, one containing \(u\) and the other containing \(v\). Some edge \(f\) of \(P\) crosses between them, and \(T-e^{\prime}+f\) is a spanning tree that is strictly cheaper than \(T\). So \(T\) is not minimum.

(ii) Suppose no such path exists. Let \(S\) be the set of nodes that \(u\) can reach using edges cheaper than \(c^{\prime}_{e^{\prime}}\). Then \(v\notin S\), and every edge that leaves \(S\) costs at least \(c^{\prime}_{e^{\prime}}\). Take any minimum spanning tree \(T\) that does not contain \(e^{\prime}\). The path in \(T\) from \(u\) to \(v\) leaves \(S\) through some edge \(f\ne e^{\prime}\), and \(c^{\prime}_f\ge c^{\prime}_{e^{\prime}}\). So \(T-f+e^{\prime}\) is a spanning tree that costs no more than \(T\), which makes it a minimum spanning tree containing \(e^{\prime}\).

Reduction. An adversary picks a perturbation \(c^{\prime}\): it chooses a set \(F\not\ni e^{\prime}\) with \(|F|\le k\), sets the costs of \(F\) freely, and moves every other cost by at most \(\varepsilon\). By the lemma, \(e^{\prime}\) fails to be in any minimum spanning tree exactly when the cheap edges connect \(u\) to \(v\).

Every edge \(f\in H\setminus F\) stays cheaper than \(e^{\prime}\) under every such \(c^{\prime}\):

\begin{equation*} c^{\prime}_f\le c_f+\varepsilon<c_{e^{\prime}}-\varepsilon\le c^{\prime}_{e^{\prime}} . \end{equation*}

So if \(H-F\) still has a \(u\)-\(v\) path, then \(e^{\prime}\) is in no minimum spanning tree.

The adversary has a best response. It sets \(c^{\prime}_{e^{\prime}}=c_{e^{\prime}}-\varepsilon\), sets \(c^{\prime}_f=c_f+\varepsilon\) for every \(f\notin F\), and makes every edge of \(F\) more expensive than \(e^{\prime}\). Under this choice, the edges cheaper than \(e^{\prime}\) are exactly the edges of \(H-F\).

Therefore \((*)\) fails if and only if some set \(F\) of at most \(k\) edges disconnects \(u\) from \(v\) in \(H\). By the undirected Menger theorem (7.48), this happens if and only if \(H\) has at most \(k\) edge-disjoint \(u\)-\(v\) paths. By (7.47), that count is the maximum flow value computed above.

Running time. Building \(H\) takes \(O(m)\) time, and each augmentation takes \(O(m)\) time (proof of (7.5)); there are at most \(k+1\) augmentations, and at most \(n-1\) since the flow never exceeds \(\deg(u)\), so the total is

\begin{equation*} O\bigl(m\cdot\min(k+1,n)\bigr). \end{equation*}

Cut time at every \(a_j,d_j,t_i,t_i^{\prime}\) into elementary intervals, and route each job’s \(\ell_j\) units of work through a flow network into the intervals it may use; a flow of value \(\sum_j\ell_j\) is then turned into a schedule interval by interval with a wrap-around rule.

Let \(\tau_0<\tau_1<\dots<\tau_m\) be the distinct values among all \(a_j,d_j,t_i,t_i^{\prime}\) (\(m\le 2n+2k\)), let \(I_q=[\tau_{q-1},\tau_q]\) with length \(L_q=\tau_q-\tau_{q-1}\), and let \(c_q\) be the number of processors \(i\) with \(t_i\le\tau_{q-1}\) and \(\tau_q\le t_i^{\prime}\). Because every endpoint is a breakpoint, each processor is available either throughout \(I_q\) or nowhere in its interior, and job \(j\) may run in \(I_q\) iff \(a_j\le\tau_{q-1}\) and \(\tau_q\le d_j\). Build \(G\): a source \(s\), a node \(J_j\) per job, a node \(I_q\) per interval, a sink \(t\), with edges

\begin{equation*} \begin{aligned} &(s,J_j)\ \text{of capacity } \ell_j,\qquad (I_q,t)\ \text{of capacity } c_qL_q,\\ &(J_j,I_q)\ \text{of capacity } L_q \text{ whenever } [\tau_{q-1},\tau_q]\subseteq[a_j,d_j]. \end{aligned} \end{equation*}

Compute a maximum flow \(f\) in \(G\). If \(\nu(f)<\sum_j\ell_j\), report that no schedule exists. Otherwise, for each \(q\), take the \(c_q\) processors available on \(I_q\), write the amounts \(x_{jq}=f(J_j,I_q)\) one after another along a line of length \(c_qL_q\), cut it into \(c_q\) consecutive pieces of length \(L_q\), and run piece \(p\) on the \(p\)-th available processor during \(I_q\) (McNaughton’s wrap-around rule).

Correctness. (i) A schedule gives a flow of value \(\sum_j\ell_j\): let \(x_{jq}\) be the time job \(j\) is processed during \(I_q\). Then \(x_{jq}\le L_q\) because \(j\) runs on at most one processor at a time; \(x_{jq}=0\) unless \(I_q\subseteq[a_j,d_j]\); \(\sum_j x_{jq}\le c_qL_q\) because at most \(c_q\) processors are working at any instant of \(I_q\); and \(\sum_q x_{jq}=\ell_j\). So \(f(s,J_j)=\ell_j\), \(f(J_j,I_q)=x_{jq}\), \(f(I_q,t)=\sum_jx_{jq}\) is a flow of that value.

(ii) A flow of value \(\sum_j\ell_j\) gives a schedule: since \(\sum_jx_{jq}\le c_qL_q\), the wrap-around fills at most \(c_q\) processors, each only inside \(I_q\), where it is available, and \(j\) gets exactly \(x_{jq}\) units in \(I_q\subseteq[a_j,d_j]\), so \(\ell_j\) units in total. A job’s segment is split over at most two consecutive processors, say as \([\tau_{q-1}+u,\tau_q]\) on one and \([\tau_{q-1},\tau_{q-1}+u^{\prime}]\) on the next with \((L_q-u)+u^{\prime}=x_{jq}\le L_q\); then \(u^{\prime}\le u\), so the two pieces do not overlap in time and \(j\) is never on two processors at once.

Hence a schedule exists iff the maximum flow has value \(\sum_j\ell_j\) (it can never exceed this, the capacity of the cut \((\{s\},V-\{s\})\)).

Running time. \(G\) has \(O(n+k)\) nodes and \(O(n(n+k))\) edges, and all capacities are integers, so the Preflow-Push Algorithm finds \(f\) in \(O((n+k)^3)\) time by (7.33); building \(G\) and the wrap-around take \(O(n(n+k)+k(n+k))\) more.

Find any feasible flow \(f_0\), then push as much flow as possible backwards, from \(t\) to \(s\), through the network of allowed decreases and increases; the minimum equals the maximum of \(\ell(A,B)\) over cuts that no edge enters. As in Section 7.1 we assume no edge enters \(s\) and none leaves \(t\) (otherwise a \(t\)-\(s\) path lets the value go to \(-\infty\)).

(a) Feasible flow. For each \(e=(u,v)\) with \(\ell(e)>0\): if \(G\) has a \(v\)-\(u\) path, add \(\ell(e)\) units around the cycle it closes with \(e\); else if \(G\) has an \(s\)-\(u\) path and a \(v\)-\(t\) path, add \(\ell(e)\) units along the walk they form with \(e\); else declare the instance infeasible. Adding a constant along a closed walk or an \(s\)-\(t\) walk keeps conservation and only increases edge values, so the sum \(f_0\) is feasible. Conversely let \(f\) be feasible with \(f(e)>0\) and no cycle through \(e\); let \(W\) be the set of nodes reachable from \(v\) by edges of positive flow, so \(u\notin W\), \(s\notin W\), and no positive-flow edge leaves \(W\). If \(t\notin W\), summing conservation over \(W\) gives

\begin{equation*} 0=f^{\rm in}(W)-f^{\rm out}(W)=f^{\rm in}(W)\ge f(e)>0, \end{equation*}

a contradiction; so \(v\) reaches \(t\), and symmetrically \(s\) reaches \(u\). Hence the test is exact.

Minimization. Let \(C=\nu(f_0)+1\) and build \(H\) on \(V\): for each \(e=(u,v)\in E\) put an arc \((u,v)\) of capacity \(C\) (room to increase) and an arc \((v,u)\) of capacity \(f_0(e)-\ell(e)\) (room to decrease). Compute a maximum \(t\)-\(s\) flow \(g\) in \(H\) and return

\begin{equation*} f(e)=f_0(e)+g(u,v)-g(v,u)\qquad(e=(u,v)\in E). \end{equation*}

Then \(f(e)\ge f_0(e)-(f_0(e)-\ell(e))=\ell(e)\), \(f\) is conserved at every node but \(s,t\) (as \(f_0\) and \(g\) are), and \(\nu(f)=\nu(f_0)-\nu(g)\); since the only \(H\)-arcs entering \(s\) are the decrease arcs of edges \((s,w)\), also \(\nu(g)\le\nu(f_0)\).

(b) For an \(s\)-\(t\) cut \((A,B)\) with no edge from \(B\) to \(A\), let \(\ell(A,B)=\sum_{e\text{ out of }A}\ell(e)\) (such cuts exist, e.g. \(A=V-\{t\}\)). Claim: if a feasible flow exists, the minimum flow value equals the maximum of \(\ell(A,B)\) over these cuts. For every feasible \(f^{\prime}\) and such a cut, (7.6) gives

\begin{equation*} \nu(f^{\prime})={f^{\prime}}^{\rm out}(A)-{f^{\prime}}^{\rm in}(A)={f^{\prime}}^{\rm out}(A)\ge\ell(A,B). \end{equation*}

For the \(f\) of (a), let \(B\) be the set of nodes reachable from \(t\) in the residual graph \(H_g\) and \(A=V-B\); \(s\in A\) since \(g\) is maximum, and by (7.9) (applied to \(H\) with source \(t\)) the \(H\)-cut \((B,A)\) has capacity \(\nu(g)\le\nu(f_0)<C\), so no \(C\)-arc goes from \(B\) to \(A\), i.e. no edge of \(G\) enters \(A\). For \(e=(u,v)\) with \(u\in A\), \(v\in B\), the residual capacity from \(v\) to \(u\) in \(H_g\) is

\begin{equation*} \big(f_0(e)-\ell(e)-g(v,u)\big)+g(u,v)=f(e)-\ell(e), \end{equation*}

which is \(0\) since \(u\) is not reachable from \(t\). Therefore \(\nu(f)=f^{\rm out}(A)-0=\ell(A,B)\). So \(f\) attains the lower bound, which proves both that \(f\) is a minimum feasible flow and that min-flow \(=\) max-cut.

Running time. The feasibility test is \(O(m(m+n))\) by search, \(f_0\) is built in \(O(mn)\), and \(g\) comes from one maximum flow on \(n\) nodes and \(2m\) arcs, \(O(n^3)\) by the Preflow-Push Algorithm (7.33).

This is the Project Selection Problem of Section 7.11 with profits \(p_v=d_v\) and the edges of \(G\) reversed as precedence constraints. “No edge into \(S\)” says exactly

\begin{equation*} v\in S,\ (u,v)\in E\ \Longrightarrow\ u\in S, \end{equation*}

which is the precedence constraint “\(v\) requires \(u\)”. So build the graph \(G^{\prime}\) of Section 7.11: a source \(s\) and a sink \(t\); an edge \((s,v)\) of capacity \(d_v\) for each \(v\) with \(d_v>0\); an edge \((v,t)\) of capacity \(-d_v\) for each \(v\) with \(d_v<0\); and for each \((u,v)\in E\) an edge \((v,u)\) of capacity \(C+1\), where \(C=\sum_{v:\,d_v>0}d_v\). Compute a minimum cut \((A^{\prime},B^{\prime})\) of \(G^{\prime}\) and output \(S=A^{\prime}-\{s\}\) if \(c(A^{\prime},B^{\prime})<C\), and \(S=\emptyset\) otherwise.

By (7.56) and (7.57), the cuts of capacity at most \(C\) are exactly the cuts \((S\cup\{s\},(V-S)\cup\{t\})\) with \(S\) having no entering edge, and their capacity is \(C-\sum_{v\in S}d_v\). So by (7.58) the minimum cut gives a feasible \(S\) of maximum total demand, namely \(C-c(A^{\prime},B^{\prime})\); when this is positive, \(S\ne V\) because \(\sum_{v\in V}d_v=0\).

Running time. \(G^{\prime}\) has \(n+2\) nodes and at most \(m+n\) edges, so one run of the Preflow-Push Algorithm finds the minimum cut in \(O(n^3)\) time (7.33), and (7.11) reads off \(A^{\prime}\) in \(O(m+n)\) more.

Add a new sink \(t\) with an edge \((v,t)\) for every \(v\in T\), give every edge capacity \(1\), compute a minimum \(r\)-\(t\) cut \((A,B)\), and output \(F=\{(u,v)\in E: u\in A,\ v\in B\}\); the optimum is \(|T|-c(A,B)\).

For any cut \((A,B)\) of this network \(G^{\prime}\) (with \(r\in A\), \(t\in B\)), the edges leaving \(A\) are the edges of \(E\) from \(A\) to \(B\) and the edges \((v,t)\) with \(v\in T\cap A\), so

\begin{equation*} c(A,B)=|E(A,B)|+|T\cap A|. \end{equation*}

(i) For every \(F\subseteq E\), let \(A\) be the set of nodes reachable from \(r\) in \((V,E-F)\) and \(B=(V-A)\cup\{t\}\). Every edge of \(E\) leaving \(A\) lies in \(F\), and the disconnected terminals are exactly \(T-A\), so

\begin{equation*} c(A,B)\le|F|+|T|-q(F),\qquad\text{i.e.}\qquad q(F)-|F|\le|T|-c(A,B). \end{equation*}

(ii) For the minimum cut \((A,B)\) and \(F=E(A,B)\), every \(r\)-\(v\) path with \(v\in B\) leaves \(A\) along an edge of \(F\), so every terminal in \(B\) is disconnected in \((V,E-F)\) and

\begin{equation*} q(F)-|F|\ge|T\cap B|-|E(A,B)|=|T|-c(A,B). \end{equation*}

Together, (i) applied to an optimal \(F^*\) and (ii) give \(q(F)-|F|\ge|T|-c_{\min}\ge q(F^*)-|F^*|\), so \(F\) is optimal.

Running time. The cut \((\{r\},(V-\{r\})\cup\{t\})\) has capacity at most \(n\), so the Ford-Fulkerson Algorithm performs at most \(n\) augmentations of \(O(m+n)\) each (7.5), and (7.11) gives the cut in \(O(m+n)\) more: \(O(n(m+n))\) overall.

Write \(\phi(S)=\sum_{i\in S}s_i-\sum_{i\in S,\,j\notin S}e_{ij}\); we maximize \(\phi\) by a minimum cut over sets forced to contain one country and exclude another, for the \(2(n-1)\) pairs that involve country \(1\), and answer yes iff some maximum is \(\ge0\).

Let \(P=\sum_{i:\,s_i>0}s_i\). Build \(G\) on the countries plus a source \(\sigma\) and a sink \(\tau\), with an edge \((i,j)\) of capacity \(e_{ij}\) for each pair, an edge \((\sigma,i)\) of capacity \(s_i\) for each \(s_i>0\), and an edge \((i,\tau)\) of capacity \(-s_i\) for each \(s_i<0\). For the cut \((S\cup\{\sigma\},(V-S)\cup\{\tau\})\),

\begin{equation*} \begin{aligned} c&=\sum_{i\in S,\,j\notin S}e_{ij}+\sum_{i\in S,\,s_i<0}(-s_i)+\sum_{i\notin S,\,s_i>0}s_i\\ &=\sum_{i\in S,\,j\notin S}e_{ij}-\sum_{i\in S}s_i+P=P-\phi(S), \end{aligned} \end{equation*}

and every \(\sigma\)-\(\tau\) cut has this form. For a pair \((a,b)\) of distinct countries let \(G_{ab}\) be \(G\) plus edges \((\sigma,a)\) and \((b,\tau)\) of capacity \(M=P+\sum_{i,j}e_{ij}+\sum_i|s_i|+1\). The cut with \(S=\{a\}\) has capacity less than \(M\), so a minimum cut of \(G_{ab}\) uses neither new edge, i.e. it has \(a\in S\), \(b\notin S\), and among such \(S\) it minimizes \(P-\phi(S)\). Hence

\begin{equation*} \max_{S:\,a\in S,\,b\notin S}\phi(S)\ \ge 0\iff c_{\min}(G_{ab})\le P. \end{equation*}

A set is nonempty and proper iff it contains some \(a\) and misses some \(b\); and then either \(1\in S\) (take \(a=1\) and \(b\notin S\)) or \(1\notin S\) (take \(b=1\) and \(a\in S\)). So a nonempty proper free-standing set exists iff \(c_{\min}(G_{1b})\le P\) for some \(b\ne1\) or \(c_{\min}(G_{a1})\le P\) for some \(a\ne1\); the source side of that cut, minus \(\sigma\), is such a set.

Running time. \(2(n-1)\) minimum cuts in graphs with \(n+2\) nodes and \(O(n^2)\) edges, each \(O(n^3)\) by the Preflow-Push Algorithm (7.33), for \(O(n^4)\) in total.

(a) Maximize \(e(S)-\beta|S|\) as a Project Selection instance (Section 7.11) with \(\beta\) slightly below \(\alpha\), and answer yes iff the optimum is positive.

Write \(\alpha=p/q\) with \(q\ge 1\) and put \(\beta=\alpha-\frac{1}{2qn}\). The projects are \(E\cup V\): each edge \(e\) has profit \(p_e=1\), each node \(v\) has profit \(p_v=-\beta\), and edge \(uv\) requires both \(u\) and \(v\). For a feasible set \(A\) with \(S=A\cap V\) we have \(A\cap E\subseteq E(S)\), so

\begin{equation*} \text{profit}(A)=|A\cap E|-\beta|S|\le e(S)-\beta|S|, \end{equation*}

and equality holds for \(A=S\cup E(S)\). So the optimum equals \(\Phi(\beta)=\max_{S\subseteq V}\bigl(e(S)-\beta|S|\bigr)\), and if \(A\) is optimal then \(S=A\cap V\) attains \(\Phi(\beta)\). By (7.58), the source side \(A^{\prime}\) of a minimum cut in the Section 7.11 network gives an optimal \(A=A^{\prime}-\{s\}\). Multiplying all profits by \(2qn\) makes them integers (\(2qn\) for an edge, \(1-2pn\) for a node) without changing the optimal sets. Output yes iff \(\Phi(\beta)>0\).

Correctness. If some \(S\) has \(e(S)/|S|\ge\alpha\), then

\begin{equation*} e(S)-\beta|S|=\bigl(e(S)-\alpha|S|\bigr)+\frac{|S|}{2qn}>0 . \end{equation*}

Conversely, suppose \(\Phi(\beta)>0\) and take a maximizer \(S\). Then \(S\ne\emptyset\), since the empty set scores \(0\), and \(e(S)/|S|>\beta\). Write \(e(S)/|S|=a/k\) with \(1\le k\le n\). If \(a/k<p/q\) we would get

\begin{equation*} \frac pq-\frac ak=\frac{pk-aq}{qk}\ge\frac1{qk}\ge\frac1{qn}>\frac1{2qn}, \end{equation*}

which gives \(a/k<\beta\), a contradiction. So \(e(S)/|S|\ge\alpha\).

Running time. The network has \(N=m+n+2\) nodes and \(M=O(m+n)\) edges. Its integer capacities are at most \(C=O(qnm+|p|n)\), and the edges of “infinite” capacity can be given capacity \(C+1\) as in Section 7.11. The Scaling Max-Flow Algorithm (Section 7.3) runs in \(O(M^2\log C)\) time, which is polynomial in \(n\), \(m\) and the bit length of \(\alpha\).

(b) Binary search with (a) over the finitely many possible cohesiveness values, then read the set off the final cut.

Every cohesiveness value lies in \(F=\{a/k: 0\le a\le m,\ 1\le k\le n\}\), a set of at most \((m+1)n\) values, and the optimum \(\alpha^*\) lies in \(F\). The answer of (a) is yes exactly when \(\alpha\le\alpha^*\), so it is monotone in \(\alpha\). Sort \(F\) and binary search over it with (a). This finds \(\alpha^*\), the largest element of \(F\) that gets a yes, using \(O(\log(mn))\) calls.

Now run the construction of (a) once more with \(\alpha=\alpha^*\) and return \(S=A^{\prime}\cap V\) from the minimum cut. This \(S\) maximizes \(e(S)-\beta|S|\), and \(\Phi(\beta)>0\) because \(\alpha^*\) is attained. The converse argument of (a) then gives \(S\ne\emptyset\) and \(e(S)/|S|\ge\alpha^*\), so \(S\) has maximum cohesiveness.

Every \(\alpha\in F\) has \(q\le n\) and \(|p|\le m\), so each flow computation takes \(O((m+n)^2\log(nm))\) time. Building and sorting \(F\) takes \(O(mn\log(mn))\) time. The total is polynomial.

(a) Set each height to the residual distance: \(h(v)=d_t(v)\), the number of edges on a shortest \(v\)-\(t\) path in the initial residual graph \(G_f\), whenever that path exists. If \(v\) cannot reach \(t\) but can reach \(s\), set \(h(v)=n+d_s(v)\). Every remaining node gets \(h(v)=2n-1\). Keep \(h(s)=n\) and \(h(t)=0\).

To compute this, build \(G_f\) and run a BFS from \(t\) along reversed edges. Then run a second reversed BFS from \(s\) through the nodes that the first BFS did not reach. This is \(O(m)\).

In the initial \(G_f\), node \(s\) has no outgoing edges: every edge \((s,v)\) is saturated, and every edge \((u,s)\) carries flow \(0\). So no shortest path to \(t\) passes through \(s\). Also, a node on a residual path to \(s\) that starts at a node unable to reach \(t\) cannot reach \(t\) itself. Hence \(d_t(v)\le n-1\) and \(n\le n+d_s(v)\le 2n-1\).

Compatibility: \(s\) has no residual out-edges and \(h(t)=0\), so let \((v,w)\in E_f\) with \(v\ne s,t\).

(i) If \(v\) reaches \(t\), then either \(w\) reaches \(t\) and \(d_t(v)\le d_t(w)+1\), or \(h(v)\le n-1<h(w)+1\) (this includes \(w=s\)).

(ii) If \(v\) reaches \(s\) but not \(t\), then \(w\) cannot reach \(t\). If \(w\) reaches \(s\) (this includes \(w=s\), with \(d_s(s)=0\)), then \(n+d_s(v)\le n+d_s(w)+1\). Otherwise \(h(v)\le 2n-1=h(w)\le h(w)+1\).

(iii) If \(v\) reaches neither, then neither does \(w\), and \(2n-1\le 2n\).

So \((f,h)\) is compatible, and the analysis of Section 7.4 still applies. Every initial height is at most \(2n-1\), and the proof of (7.26) covers every node that is later relabeled, so (7.26)–(7.28) hold as stated. In (7.29), the starting potential \(\sum_{e_f(v)>0}h(v)\) grows by at most \(2n^2\), so the \(O(n^2m)\) bound is unchanged.

Maximality: let \(h^{\prime}\) be any compatible labeling and \(v=v_0,v_1,\dots,v_k\) a shortest residual path. Applying steepness along the path gives

\begin{equation*} h^{\prime}(v)\le h^{\prime}(v_k)+k=\begin{cases} d_t(v), & v_k=t,\\ n+d_s(v), & v_k=s.\end{cases} \end{equation*}

So every node that reaches \(s\) or \(t\) gets the largest height that any compatible labeling allows. For a node that reaches neither, compatibility puts no upper bound on its height, so we use the ceiling \(2n-1\) from (7.26).

(b) Gap relabeling only raises heights, and it leaves \(s\) (height \(n\)) and \(t\) (height \(0<h\)) unchanged. So it can only break the invariant on a residual edge \((v,w)\) with \(v\in A\), \(w\notin A\). For such an edge,

\begin{equation*} h(w)\ge h(v)-1\ge h,\qquad h(w)\ne h\ (\text{gap}),\qquad w\notin A\ \Rightarrow\ h(w)\ge n, \end{equation*}

so the new height satisfies \(h(v)=n\le h(w)+1\). If both \(v,w\in A\), both heights become \(n\). If \(v\notin A\), then \(h(v)\) is unchanged and \(h(w)\) does not decrease.

Hence (7.24) still holds: \(f\) remains a preflow compatible with \(h\). If the algorithm stops, (7.22) shows that \(f\) is a maximum flow.

Termination and the bounds are unaffected. Heights stay monotone, and by (7.25) and (7.26) they stay at most \(2n-1\) (a gap relabel sets heights to \(n\)). So the total height increase per node, from all causes, is at most \(2n-1\). The counting in (7.27)–(7.29) therefore goes through, and each gap relabel (applied only when \(A\ne\emptyset\)) uses up at least one unit of this increase.

(c) \((A,B)\) is an \(s\)-\(t\) cut, because \(t\in B\) trivially and \(s\in A\) by (7.21). Freezing only restricts which push and relabel steps are allowed, so (7.24) still gives compatibility.

At termination, every node \(v\ne s,t\) with \(e_f(v)>0\) has \(h(v)=n\). Now suppose \(v\in B-\{t\}\). Applying steepness along a simple residual \(v\)-\(t\) path, which has at most \(n-1\) edges, gives \(h(v)\le n-1\). So \(e_f(v)=0\) for all \(v\in B-\{t\}\).

No residual edge leaves \(A\), since its tail would then reach \(t\). So every edge from \(A\) to \(B\) is saturated, and every edge from \(B\) to \(A\) carries flow \(0\). Hence

\begin{equation*} c(A,B)=f^{\mathrm{in}}(B)-f^{\mathrm{out}}(B)=\sum_{v\in B}e_f(v)=e_f(t). \end{equation*}

Now take any \(s\)-\(t\) cut \((A^{\prime},B^{\prime})\). Every \(v\ne s\) has \(e_f(v)\ge 0\), and \(s\notin B^{\prime}\), so

\begin{equation*} \begin{aligned} c(A,B)=e_f(t)&\le\sum_{v\in B^{\prime}}e_f(v)=f^{\mathrm{in}}(B^{\prime})-f^{\mathrm{out}}(B^{\prime})\\ &\le f^{\mathrm{in}}(B^{\prime})\le c(A^{\prime},B^{\prime}). \end{aligned} \end{equation*}

So \((A,B)\) has minimum capacity.

(d) Repeatedly take a node \(v\ne s,t\) with excess and walk backward from it along edges that carry positive flow. If the walk reaches \(s\), return excess along that path. If it closes a cycle, cancel the cycle.

for each node x: ptr(x) = first edge into x
for each node v other than s, t:
    while e(v) > 0:
        walk P = v; x = v
        while x != s:
            advance ptr(x) past edges with zero flow
            (u, x) = ptr(x)
            if u is already on P:
                C = cycle on P closed by (u, x)
                subtract min flow on C from every edge of C
                restart walk from v
            prepend u to P; x = u
        d = min(e(v), min flow on the edges of P)
        subtract d from every edge of P   (P runs from s to v)
return f

Correctness: whenever the walk is at a node \(x\ne s\), some edge into \(x\) carries positive flow. This holds for \(x=v\) because \(e_f(v)>0\). For an earlier node \(x\) of the walk, the flow on \((x,y)\) is positive, so \(f^{\mathrm{out}}(x)>0\), and \(e_f(x)\ge 0\) then gives \(f^{\mathrm{in}}(x)>0\). So the walk is always defined.

Subtracting \(d\) along an \(s\)-\(v\) path, or subtracting the bottleneck around a cycle, keeps every flow value between \(0\) and \(c_e\). It also leaves the excess unchanged at every node except \(v\) (whose excess drops by \(d\)) and \(s\).

No node with positive flow on an out-edge is ever \(t\). In part (c), \(t\) is never active, so no push ever leaves \(t\), and the initial flow is \(0\) there. So \(t\) lies on no walk, and \(e_f(t)\) never changes. Excesses at nodes other than \(s\) never increase, so a node is finished once its excess is \(0\).

At the end, every \(v\ne s,t\) has \(e_f(v)=0\), so \(f\) is a flow. Its value is \(e_f(t)\), which by part (c) equals \(c(A,B)\). By (7.8), this flow is maximum.

Running time: flows only decrease, so an edge whose flow becomes \(0\) stays at \(0\). Each pointer therefore moves forward only, for \(O(m)\) pointer work in total.

Each walk visits at most \(n\) nodes, so it costs \(O(n)\) apart from pointer moves. Each walk ends in one of two ways:

• a cycle cancellation, which zeroes at least one edge (at most \(m\) times overall);
• a path return, which zeroes an edge or the excess \(e_f(v)\) (at most \(m+n\) times overall).

So there are \(O(m+n)\) walks, and the total is

\begin{equation*} O\big(n(m+n)+m\big)=O(mn), \end{equation*}

using \(m\ge n/2\) (the book assumes every node has an incident edge).

Throughout we use the convention of Section 7.1 that no edge enters \(s\) and no edge leaves \(t\). Then \(f^{in}(t)=e_f(t)\) and \(e_f(s)=-f^{out}(s)\le 0\). For a set \(B\) of nodes, the terms of edges with both ends in \(B\) cancel, so \[ \sum_{v\in B} e_f(v)=f^{in}(B)-f^{out}(B). \qquad (\dagger) \]

(a) For every \(s\)-\(t\) cut \((A,B)\) we have \(f^{in}(t)\le c(A,B)\); taking a minimum cut gives the claim by (7.13). Indeed, \(t\in B\) and \(s\notin B\), so every \(v\in B-\{t\}\) has \(e_f(v)\ge 0\) by preflow condition (ii). Hence

\begin{equation*} \begin{aligned} f^{in}(t)=e_f(t)\le \sum_{v\in B} e_f(v) &=f^{in}(B)-f^{out}(B)\\ &\le f^{in}(B)\le c(A,B). \end{aligned} \end{equation*}

(b) The edges from \(A\) to \(B\) are all saturated and the edges from \(B\) to \(A\) all carry zero flow. By (7.21), \(t\notin A\), so \((A,B)\) is an \(s\)-\(t\) cut.

• If \(e=(u,w)\) with \(u\in A\), \(w\in B\) had \(f(e)<c_e\), then the forward edge \((u,w)\) would lie in \(G_f\) and would put \(w\) in \(A\).
• If \(e=(u,w)\) with \(u\in B\), \(w\in A\) had \(f(e)>0\), then the backward edge \((w,u)\) would lie in \(G_f\) and would put \(u\) in \(A\).

So \(f^{in}(B)=c(A,B)\) and \(f^{out}(B)=0\), and \((\dagger)\) gives \(\sum_{v\in B}e_f(v)=c(A,B)\).

(c) We use buckets of large-excess nodes indexed by height, a pointer \(L\) to the lowest nonempty bucket, and the current-edge pointers of (7.33). We also cap each push so that no receiving node ends up with more than \(2\Delta\) of excess (part (d) needs this cap). Let \(\Delta_0=2^{\lceil\log_2 C\rceil}\). There are then \(\lceil\log_2C\rceil+1\) phases, \(\Delta=\Delta_0,\Delta_0/2,\dots,1\). Call a node \(v\ne s,t\) big if \(e_f(v)\ge\Delta\).

Push rule. Suppose the selected node \(v\) is a big node of minimum height and \((v,w)\in E_f\) with \(h(w)<h(v)\). Then \(w\) is in \(\{s,t\}\) or has \(e_f(w)<\Delta\), because \(w\) is lower than every big node. Push \[ \delta=\min\bigl(e_f(v),\ r_f(v,w),\ 2\Delta-e_f(w)\bigr), \] leaving out the last term when \(w\in\{s,t\}\). Since \(0<\delta\le\min(e_f(v),r_f(v,w))\), the proof of (7.24) applies unchanged: \(f\) stays a preflow compatible with \(h\). The proofs of (7.26)-(7.28) and (7.31)-(7.32) never use the exact value of \(\delta\), so they hold as well. The push rule keeps the invariant

(I) during phase \(\Delta\), \(e_f(v)\le 2\Delta\) for every \(v\ne s,t\).

At the start of the first phase, \(e_f(v)=c_{(s,v)}\le C\le\Delta_0\). At the start of any later phase, \(e_f(v)<2\Delta\), because the previous phase ended with no excess at least \(2\Delta\). A push raises \(e_f(w)\) to at most \(2\Delta\).

Data structures. Keep the adjacency lists with \(current(v)\) pointers as in (7.33). Keep doubly linked buckets \(Q[0],\dots,Q[2n-1]\), where \(Q[k]\) holds the big nodes of height \(k\) (heights are at most \(2n-1\) by (7.26)). Each node stores a pointer to its own list cell, and \(L\) is an index with \(Q[j]\) empty for all \(j<L\). To take a step, increase \(L\) while \(Q[L]\) is empty, then let \(v\) be the head of \(Q[L]\). Advance \(current(v)\) past inadmissible edges. If the list runs out, relabel \(v\), which is legal by (7.32); then move \(v\) to \(Q[L+1]\) and reset \(current(v)\). Otherwise push on \(current(v)\). If \(e_f(v)\) drops below \(\Delta\), delete \(v\) from its bucket. If \(w\) becomes big, insert it into \(Q[L-1]\) and set \(L\leftarrow L-1\). When \(L\) passes \(2n-1\), the phase ends: halve \(\Delta\) and rebuild the buckets and \(L\) by one scan of the nodes. In the last phase \(\Delta=1\) and the excesses are integers (7.24), so the algorithm ends with zero excess at every \(v\ne s,t\). Then \(f\) is a flow compatible with \(h\) (7.24), hence maximum by (7.22).

Running time.

• (i) Setting up the initial preflow costs \(O(m)\), and rebuilding the buckets costs \(O(n)\) per phase, which is \(O(n\log C)\) in total.
• (ii) Each push and each relabel costs \(O(1)\). There are fewer than \(2n^2\) relabels by (7.27), at most \(2nm\) saturating pushes by (7.28), and \(K\) nonsaturating pushes.
• (iii) By (7.32), \(current(v)\) passes over each of the \(d_v\) edges at \(v\) at most once between relabels of \(v\). This costs \(O(\sum_v 2n\,d_v)=O(mn)\), as in (7.33).
• (iv) Within a phase, \(L\) decreases only when a push makes its receiver big, so it decreases by \(1\) at most once per push. A node becomes big only by receiving a push, and the receiver sits at height \(L-1\). Since \(0\le L\le 2n\), the total increase of \(L\) is at most \(2n\) plus the total decrease. Over all phases this is \(O(n\log C+nm+K)\).

Adding these up, the running time is \(O(mn+n\log C+K)\).

(d) Every nonsaturating push decreases \(\Phi\) by at least \(1\). Within a phase, only a relabel can increase \(\Phi\), and by at most \(2\) each time; halving \(\Delta\) doubles \(\Phi\), which we handle with a fresh bound at the start of each phase. Here we sum over \(v\ne s\); the dropped term \(h(s)e_f(s)\le0\) belongs to the source, and with it gone \(\Phi\ge 0\).

• (i) A push of \(\delta\) from \(v\) to \(w\) changes \(\Phi\) by \(\delta(h(w)-h(v))/\Delta=-\delta/\Delta\) when \(w\ne s\), and by \(-\delta h(v)/\Delta\le-\delta/\Delta\) when \(w=s\). A nonsaturating push has \(\delta<r_f(v,w)\), so either \(\delta=e_f(v)\ge\Delta\) (\(v\) was selected) or \(\delta=2\Delta-e_f(w)>\Delta\) (since \(e_f(w)<\Delta\)). In both cases \(\Phi\) drops by at least \(1\).
• (ii) A relabel of \(v\) raises \(\Phi\) by \(e_f(v)/\Delta\le 2\), by (I).
• (iii) At the start of a phase, \(e_f(v)<2\Delta\) for \(v\ne s,t\) (and \(\Phi=0\) before the first push), \(h(t)=0\), and \(h(v)\le 2n-1\) by (7.26). Hence \(\Phi<2(n-2)(2n-1)\).

So if phase \(p\) has \(R_p\) relabels, it has at most \(2(n-2)(2n-1)+2R_p\) nonsaturating pushes. Since \(\sum_p R_p<2n^2\) by (7.27), the total is

\begin{equation*} \begin{aligned} K&\le(\lceil\log_2C\rceil+1)\cdot 2(n-2)(2n-1)+4n^2\\ &=O(n^2\log C). \end{aligned} \end{equation*}

Combined with (c), the algorithm runs in \(O(mn+n^2\log C)\) time.

Yes: the feasible sets satisfy the exchange property below, and greedy keeps the largest values that this property allows.

If \(A, B\) are feasible with \(|A| < |B|\), then \(A \cup \{b\}\) is feasible for some \(b \in B \setminus A\). Indeed, take matchings \(M_A, M_B\) covering exactly \(A\) and \(B\); the components of \(M_A \oplus M_B\) are alternating paths and cycles, and as \(|M_B| > |M_A|\) one of them is a path \(P\) beginning and ending with \(M_B\)-edges. By bipartiteness its ends are a customer \(b\) and a station \(s\), both uncovered by \(M_A\) (an \(M_A\)-edge there would extend \(P\)), so \(b \notin A\) and \(M_A \oplus P\) is a matching covering \(A \cup \{b\}\).

Greedy’s output \(X = \{g_1, \dots, g_m\}\) (in acceptance order) is feasible by construction, and \(v_{g_1} \ge \dots \ge v_{g_m}\). Let \(O = \{o_1, \dots, o_r\}\) be an optimal feasible set with \(v_{o_1} \ge \dots \ge v_{o_r}\). We claim that \(m \ge r\) and that

\begin{equation*} v_{g_i} \ge v_{o_i} \qquad (1 \le i \le r). \end{equation*}

Suppose the claim fails, and let \(i\) be the first index where either \(g_i\) does not exist or \(v_{g_i} < v_{o_i}\). Apply the exchange property to \(A = \{g_1, \dots, g_{i-1}\}\) and \(B = \{o_1, \dots, o_i\}\). Both are feasible (every subset of a feasible set is feasible), and \(|A| = i-1 < i = |B|\), so there is an \(o_j \in B \setminus A\) with \(A \cup \{o_j\}\) feasible. Since \(j \le i\),

\begin{equation*} v_{o_j} \ge v_{o_i} > v_{g_i} \quad (\text{when } g_i \text{ exists}), \end{equation*}

so greedy examines \(o_j\) before \(g_i\) (or at some point, if \(g_i\) does not exist). At that moment the promised set is contained in \(A\), since only \(g_1, \dots, g_{i-1}\) have been accepted so far. Adding \(o_j\) to it gives a subset of the feasible set \(A \cup \{o_j\}\), which is feasible, so greedy accepts \(o_j\). Every customer greedy accepts before \(g_i\) is one of \(g_1, \dots, g_{i-1}\), so \(o_j \in A\), a contradiction. Summing the claim over \(i\),

\begin{equation*} \sum_{x\in X} v_x \ge \sum_{i=1}^{r} v_{g_i} \ge \sum_{i=1}^{r} v_{o_i} = \sum_{x\in O} v_x , \end{equation*}

where the first inequality uses \(v \ge 0\). Hence greedy is optimal. \(\blacksquare\)

Reduce to the Minimum-Cost Perfect Matching Problem of Section 7.13, matching jobs to slots \((i,k)\), where slot \((i,k)\) is the \(k\)-th position on machine \(i\), finishing at \(k\ell_i\). Here monotone is read as nondecreasing: finishing later never costs less.

Build a bipartite graph. On one side put the slots \((i,k)\) for \(1\le i\le m\), \(1\le k\le n\) (\(N=mn\) of them; no machine ever receives more than \(n\) jobs). On the other side put the \(n\) jobs plus \(N-n\) dummy jobs. Join every job \(j\) to every slot \((i,k)\) with cost \(c_j(k\ell_i)\ge 0\), and join every dummy to every slot with cost \(0\). Both sides have size \(N\), so the algorithm of Section 7.13 computes a minimum-cost perfect matching \(M\). To read off a schedule, take the real jobs that \(M\) places on machine \(i\), at slots \(k_1<k_2<\dots<k_{r_i}\), and run them on machine \(i\) in that order.

Correctness. Let \(\mathrm{OPT}\) be the minimum schedule cost.

(i) \(\mathrm{cost}(M)\le\mathrm{OPT}\). Any schedule \(S\) puts each job \(j\) in a distinct slot \((i,k)\) with \(t_S(j)=k\ell_i\), where \(k\le n\). Matching the dummies to the \(N-n\) unused slots gives a perfect matching of cost \(\sum_j c_j(t_S(j))=\mathrm{cost}(S)\).

(ii) The output schedule \(S_M\) satisfies \(\mathrm{cost}(S_M)\le \mathrm{cost}(M)\). The job matched to slot \((i,k_q)\) is the \(q\)-th job on machine \(i\), and \(q\le k_q\) because \(k_1<\dots<k_q\) are distinct positive integers. Monotonicity and zero-cost dummies then give

\begin{equation*} \mathrm{cost}(S_M)=\sum_i\sum_{q=1}^{r_i} c_{j_{i,q}}(q\ell_i)\le \sum_i\sum_{q=1}^{r_i} c_{j_{i,q}}(k_q\ell_i)=\mathrm{cost}(M). \end{equation*}

Combining (i) and (ii), \(\mathrm{OPT}\le\mathrm{cost}(S_M)\le\mathrm{cost}(M)\le\mathrm{OPT}\), so \(S_M\) is optimal.

Running time. The graph has \(2N=2mn\) nodes and \(N^2=m^2n^2\) edges, and building it takes \(mn^2\) evaluations of the \(c_j\). By (7.66), the matching costs \(N\) shortest-path computations with nonnegative lengths. Each one is a Dijkstra run in \(O(N^2)\) time on this dense graph, so the total is \(O(N^3)=O(m^3n^3)\), which is polynomial.

Build the bipartite costar graph \(G\) on \(X \cup Y\) (edge \(xy\) iff \(x\) and \(y\) appeared in a movie together) and compute a maximum matching \(M\); \(P_1\) can force a win iff \(M\) is perfect (\(|M| = n\)), and otherwise \(P_0\) can.

(i) \(|M| = n\). \(P_1\) answers every \(x_i\) with \(y_i = M(x_i)\). This is legal: \(x_i y_i \in E\), and the earlier actors are \(y_j = M(x_j)\) with \(x_j \ne x_i\), so \(y_i \ne y_j\) because \(M\) is a matching. Hence \(P_1\) always has a move, and since the game ends after at most \(2n\) moves, \(P_0\) is the one who gets stuck.

(ii) \(|M| < n\). Some \(x_1 \in X\) is unmatched by \(M\); \(P_0\) opens with \(x_1\) and answers every \(y_i\) with \(x_{i+1} = M(y_i)\). Suppose \(P_0\) has played this way through \(y_i\). If \(y_i\) were unmatched, then

\begin{equation*} P = x_1\, y_1\, x_2\, y_2 \cdots x_i\, y_i \end{equation*}

has \(y_j x_{j+1} \in M\) for \(j < i\), and \(x_j y_j \notin M\) for every \(j\) (\(x_1\) is unmatched, and for \(j \ge 2\) the partner of \(x_j\) is \(y_{j-1} \ne y_j\)). So \(P\) is an alternating path with both ends unmatched, and \(M \oplus P\) is a matching with \(|M| + 1\) edges, contradicting maximality. So \(M(y_i)\) exists and is adjacent to \(y_i\); it is new because \(M(y_i) \ne x_1\) (since \(x_1\) is unmatched) and \(M(y_i) \ne M(y_j) = x_{j+1}\) for \(j < i\) (since \(y_i \ne y_j\)). Hence \(P_0\) always has a move, and \(P_1\) is the one who gets stuck.

By (7.38), Ford-Fulkerson on the flow network of Section 7.5 finds \(M\) in \(O(mn)\) time, where \(m\) is the number of costar pairs; building \(G\) and comparing \(|M|\) with \(n\) costs \(O(m + n)\), so the algorithm runs in \(O(mn)\) time.

(a) Yes. Interval Scheduling is solvable in polynomial time: the greedy earliest-finish-time algorithm of Section 4.1 returns a maximum set of nonoverlapping intervals by (4.3), in \(O(n \log n)\) time, and we answer “yes” iff that set has size at least \(k\). An algorithm that solves the problem in polynomial time using zero calls to a black box for Vertex Cover is a reduction in the sense of Section 8.1, so Interval Scheduling \(\le_P\) Vertex Cover. (In Karp form: run the greedy algorithm, then output the fixed Vertex Cover instance (one vertex, no edges, \(k = 0\)) if the answer is yes and (one edge \(uv\), \(k = 0\)) if it is no.)

(b) Unknown, because it would resolve \(\mathcal{P}\) vs. \(\mathcal{NP}\).

(i) If Independent Set \(\le_P\) Interval Scheduling, then since Interval Scheduling is in \(\mathcal{P}\) (part (a)), (8.1) puts Independent Set in \(\mathcal{P}\); Independent Set is NP-complete by (8.16), so \(\mathcal{P} = \mathcal{NP}\) by (8.12).

(ii) If \(\mathcal{P} = \mathcal{NP}\), then Independent Set \(\in \mathcal{NP}\) is solvable in polynomial time, and as in (a) it reduces to any problem, Interval Scheduling included.

So the reduction exists if and only if \(\mathcal{P} = \mathcal{NP}\).

Diverse Subset is Independent Set in disguise: customers are vertices, products are edges, and a customer buys exactly the edges incident to it.

Membership in NP. A certificate is the set \(S\); the checker verifies \(|S| \ge k\) and that every column \(j\) has \(A[i,j] > 0\) for at most one \(i \in S\), in \(O(mn)\) time.

Reduction. Independent Set is NP-complete by (8.16); we show Independent Set \(\le_P\) Diverse Subset. Given \(G = (V, E)\) and \(k\), we may assume \(k \le |V|\) (otherwise the answer is no, and we output the fixed no-instance with two customers who both bought one product and \(k = 2\)). Build the \(|V| \times |E|\) array

\begin{equation*} A[v, e] = \begin{cases} 1 & v \text{ is an end of } e, \\ 0 & \text{otherwise,} \end{cases} \end{equation*}

in \(O(|V|\,|E|)\) time, and keep the same \(k\). For \(S \subseteq V\),

\begin{equation*} \begin{aligned} S \text{ diverse} &\iff \text{no column } e = uv \text{ has two buyers in } S \\ &\iff \text{no edge } uv \text{ has } u, v \in S \\ &\iff S \text{ independent in } G, \end{aligned} \end{equation*}

since the buyers of product \(e = uv\) are exactly \(u\) and \(v\). Hence \(G\) has an independent set of size at least \(k\) iff \(A\) has a diverse subset of size at least \(k\), and by (8.14) Diverse Subset is NP-complete.

Efficient Recruiting contains Vertex Cover: counselors are vertices, sports are edges, and a counselor is qualified in exactly the edges incident to it.

Membership in NP. A certificate is the set \(H\) of hired counselors; check \(|H| \le k\) and that each of the \(n\) sports has a qualified member of \(H\), in \(O(nm)\) time.

Reduction. Vertex Cover is NP-complete by (8.16); we show Vertex Cover \(\le_P\) Efficient Recruiting. Given \(G = (V, E)\) and \(k\): if \(k \ge |V|\) the answer is yes (\(V\) itself is a cover), and we output the fixed yes-instance with \(m = 2\) counselors, one sport in which both are qualified, and \(k = 1\). Otherwise \(k < |V|\), and we output the instance with counselors \(V\) (so \(m = |V| > k\)), one sport \(s_e\) for each \(e \in E\), the qualified set of \(s_e = uv\) being \(\{u, v\}\), and the same \(k\); this takes \(O(|V| + |E|)\) time. For \(H \subseteq V\),

\begin{equation*} \begin{aligned} H \text{ staffs every sport} &\iff \forall\, e = uv \in E:\ H \cap \{u, v\} \ne \emptyset \\ &\iff H \text{ is a vertex cover of } G, \end{aligned} \end{equation*}

so \(G\) has a vertex cover of size at most \(k\) iff at most \(k\) counselors can be hired to cover every sport. By (8.14), Efficient Recruiting is NP-complete.

Write \(R_p\) for the set of resources requested by process \(p\). A set \(S\) of processes can be made simultaneously active iff the sets \(R_p\), \(p \in S\), are pairwise disjoint (give each resource of \(R_p\) to \(p\); conversely, a resource in \(R_p \cap R_q\) cannot serve both \(p\) and \(q\)). So the question is whether some \(k\) of the \(R_p\) are pairwise disjoint.

(a) NP-complete. Membership in NP: the certificate is the set \(S\) of \(k\) processes, and pairwise disjointness of \(\{R_p\}_{p \in S}\) is checked in \(O(nm)\) time with a marker array over the resources. Reduction: Independent Set (NP-complete by (8.16)) \(\le_P\) Resource Reservation. Given \(G = (V, E)\) and \(k\), make one resource per edge and one process per vertex, with \(R_v = \{e \in E : v \in e\}\), and keep \(k\). For \(S \subseteq V\),

\begin{equation*} \begin{aligned} \{R_v\}_{v \in S} \text{ pairwise disjoint} &\iff \text{no edge } e = uv \text{ has } u, v \in S \\ &\iff S \text{ is independent in } G, \end{aligned} \end{equation*}

because \(R_u \cap R_v\) is the set of edges joining \(u\) and \(v\). So \(G\) has an independent set of size \(k\) iff \(k\) processes can be active, and (8.14) gives NP-completeness.

(b) Polynomial. Answer yes iff some pair \(p \ne q\) has \(R_p \cap R_q = \emptyset\), by the opening observation. There are \(\binom{n}{2}\) pairs, each tested in \(O(m)\) time with a marker array, for \(O(n^2 m)\) in total.

(c) Polynomial, by bipartite matching. Build a bipartite graph \(G\) with the people on one side and the equipment on the other; first set aside the processes with \(R_p = \emptyset\) (always active; say \(z\) of them). A process requesting person \(a\) and equipment \(b\) becomes an edge \(ab\). A process requesting only person \(a\) becomes an edge from \(a\) to a new dummy equipment node of its own, and symmetrically for one requesting only equipment. Two processes conflict iff their edges share an end (dummy nodes are private), so active sets of nonempty-request processes are exactly the matchings of \(G\), and

\begin{equation*} \max |\text{active set}| = z + \nu(G), \end{equation*}

where \(\nu(G)\) is the maximum matching size. Answer yes iff \(z + \nu(G) \ge k\). By (7.37) and (7.38), Ford-Fulkerson computes \(\nu(G)\) (parallel edges, from processes with the same pair, are harmless); \(G\) has at most \(n\) edges and \(m + n\) nodes, and the flow value is at most \(n\), so there are at most \(n\) augmentations of \(O(m + n)\) each, for \(O(n(m + n))\) time.

(d) NP-complete. Membership follows from (a). The reduction in (a) already produces an instance of this special case: resource \(e = uv\) is requested by exactly the two processes \(u\) and \(v\). So Independent Set \(\le_P\) this special case, and by (8.14) it is NP-complete.

Vertex Cover is the special case of Hitting Set in which every \(B_i\) is an edge.

Membership in NP. A certificate is \(H\); check \(|H| \le k\) and \(H \cap B_i \ne \emptyset\) for each \(i\), in \(O(nm)\) time.

Reduction. Vertex Cover is NP-complete by (8.16); we show Vertex Cover \(\le_P\) Hitting Set. Given \(G = (V, E)\) and \(k\), set \(A = V\), take one set \(B_e = \{u, v\}\) for each edge \(e = uv \in E\), and keep \(k\); this is \(O(|V| + |E|)\) time. For \(H \subseteq V\),

\begin{equation*} \begin{aligned} H \text{ is a hitting set} &\iff \forall\, e = uv \in E:\ H \cap \{u, v\} \ne \emptyset \\ &\iff H \text{ is a vertex cover of } G, \end{aligned} \end{equation*}

so \(G\) has a vertex cover of size at most \(k\) iff the collection \(\{B_e\}\) has a hitting set of size at most \(k\). By (8.14), Hitting Set is NP-complete.

Reduce Vertex Cover (NP-complete by (8.16)) to it: one variable per vertex, one clause \((x_u \vee x_v)\) per edge.

Membership in NP. The certificate is an assignment; we check in polynomial time that every clause contains a variable set to 1 and that at most \(k\) variables are 1.

Reduction. Given an instance \((G = (V, E), k)\) of Vertex Cover, introduce a variable \(x_v\) for each \(v \in V\) and a monotone clause \(C_e = (x_u \vee x_v)\) for each edge \(e = (u, v) \in E\); keep the same \(k\). This takes \(O(|V| + |E|)\) time. An assignment corresponds to the set \(S = \{v : x_v = 1\}\), and

\begin{equation*} \begin{aligned} \text{all } C_e \text{ satisfied} &\iff \forall (u,v) \in E:\ x_u = 1 \text{ or } x_v = 1\\ &\iff \forall (u,v) \in E:\ u \in S \text{ or } v \in S \iff S \text{ is a vertex cover}, \end{aligned} \end{equation*}

with exactly \(|S|\) variables true. Hence a satisfying assignment with at most \(k\) true variables exists if and only if \(G\) has a vertex cover of size at most \(k\). So Vertex Cover \(\le_P\) Monotone Satisfiability with Few True Variables, and the problem, being in NP, is NP-complete by (8.14).

Reduce 3-Dimensional Matching (NP-complete by (8.20)) to it by prefixing every triple with every possible \(w\).

Membership in NP. The certificate is a list of \(n\) tuples of \(C\); we check in polynomial time that they are pairwise disjoint.

Reduction. Given an instance of 3-Dimensional Matching, namely sets \(X, Y, Z\) of size \(n\) and a set \(T \subseteq X \times Y \times Z\), let \(W = \{w_1, \dots, w_n\}\) be \(n\) new elements and \[ C = \{ (w_i, x, y, z) : 1 \le i \le n,\ (x, y, z) \in T \}, \] which has \(n|T|\) tuples and is built in polynomial time.

(i) If \(t_1, \dots, t_n \in T\) form a 3-dimensional matching, then \((w_1, t_1), \dots, (w_n, t_n)\) are \(n\) tuples of \(C\) that are pairwise disjoint: they differ in the \(W\) coordinate, and the triples are disjoint.

(ii) If \(n\) pairwise disjoint tuples \((w_{i_r}, t_r)\), \(r = 1, \dots, n\), lie in \(C\), then each \(t_r \in T\) and the \(t_r\) are pairwise disjoint in their \(X\), \(Y\), \(Z\) coordinates, so \(t_1, \dots, t_n\) is a 3-dimensional matching.

Thus 3-Dimensional Matching \(\le_P\) 4-Dimensional Matching, and 4-Dimensional Matching, being in NP, is NP-complete by (8.14).

Reduce 3-Dimensional Matching (NP-complete by (8.20)): make every element a symbol with one magnet, and every triple a three-letter word.

Membership in NP. Let \(N\) be the total number of magnets and \(c_a\) the number of copies of symbol \(a\). The empty word uses no magnet and can be discarded, so every word used has length at least 1 and appears at most \(N\) times. The certificate is a multiplicity \(m_s \in \{0, \dots, N\}\) for each word \(s\) of the vocabulary. The verifier checks, for each symbol \(a\), \[ \sum_{s} m_s \cdot \#_a(s) = c_a , \] where \(\#_a(s)\) is the number of occurrences of \(a\) in \(s\). This is polynomial in the input size even if the counts \(c_a\) are written in binary.

Reduction. Given an instance \(X, Y, Z\) (each of size \(n\), pairwise disjoint) and \(T \subseteq X \times Y \times Z\) of 3-Dimensional Matching, let the symbols be \(X \cup Y \cup Z\), with exactly one magnet for each symbol. For each triple \((x, y, z) \in T\), put the three-letter string \(xyz\) in the vocabulary. This takes \(O(n + |T|)\) time.

(i) If \(t_1, \dots, t_n\) is a 3-dimensional matching, spelling the words of \(t_1, \dots, t_n\) uses \(3n\) magnets with no symbol twice, so it uses each of the \(3n\) magnets exactly once.

(ii) Conversely, take a spelling that uses every magnet exactly once. Each symbol has a single copy, so no word is used twice and the words used are pairwise disjoint triples of \(T\). Each uses 3 of the \(3n\) magnets, so there are exactly \(n\) of them, and together they cover every element of \(X \cup Y \cup Z\). That is a 3-dimensional matching.

Hence 3-Dimensional Matching \(\le_P\) Using Up All the Refrigerator Magnets, which is therefore NP-complete by (8.14).

Reduce Set Packing (NP-complete by (8.16)): each set becomes a path that starts at a private node and then runs through its elements in increasing order.

Membership in NP. The certificate is a list of \(k\) of the requests; we check in polynomial time that their node sets are pairwise disjoint.

Reduction. Let a Set Packing instance have ground set \(U = \{u_1, \dots, u_n\}\), sets \(S_1, \dots, S_m \subseteq U\) and a number \(k\). Build the directed graph \(G\) on the nodes \(U \cup \{s_1, \dots, s_m\}\). For each \(i\), write \(S_i = \{u_{a_1}, \dots, u_{a_r}\}\) with \(a_1 < \dots < a_r\), and add the edges and the request \[ P_i = s_i \to u_{a_1} \to u_{a_2} \to \dots \to u_{a_r} . \] (If \(S_i = \emptyset\), then \(P_i\) is the single node \(s_i\).) Keep the same \(k\). All edges go from some \(s_i\) to some \(u\), or from \(u_a\) to \(u_b\) with \(a < b\), so each \(P_i\) is a genuine path in \(G\). The construction takes time \(O(m + n + \sum_i |S_i|)\).

The node set of \(P_i\) is \(\{s_i\} \cup S_i\), and the nodes \(s_i\) are distinct, so for \(i \ne j\) \[ P_i \cap P_j = S_i \cap S_j . \] Hence a family of requests is pairwise node-disjoint exactly when the corresponding sets are pairwise disjoint, and \(k\) disjoint paths exist if and only if \(k\) disjoint sets exist. So Set Packing \(\le_P\) Path Selection, and Path Selection, being in NP, is NP-complete by (8.14).

(a) Reduce Vertex Cover (NP-complete by (8.16)): orient each edge and make it a one-edge trail.

Membership in NP. The certificate is a set \(A\) of at most \(k\) nodes; we check in polynomial time that every \(P_i\) contains a node of \(A\).

Reduction. Given an undirected graph \(H = (V, E)\) and \(k\), number the vertices \(v_1, \dots, v_n\). Let \(G\) be the directed graph on \(V\) with an edge \(v_a \to v_b\) for each \(\{v_a, v_b\} \in E\) with \(a < b\). For each such edge, take the trail \(P_e = v_a \to v_b\), a path in \(G\), and keep the same \(k\). This takes linear time. Since \(P_e\) has node set \(\{v_a, v_b\} = e\), \[ A \text{ meets every } P_e \iff A \text{ meets every edge of } H \iff A \text{ is a vertex cover of } H . \] So ad placements on at most \(k\) nodes exist if and only if \(H\) has a vertex cover of size at most \(k\). Hence Vertex Cover \(\le_P\) Strategic Advertising, which is NP-complete by (8.14).

(b) Find the nodes one at a time: keep a node \(v\) exactly when \(\mathcal{S}\) confirms that the trails missing \(v\) can still be hit with one fewer advertisement. Write \(\mathcal{S}(Q, k^{\prime})\) for the call on \(G\), a subfamily \(Q\) of the trails, and the bound \(k^{\prime}\); this is a valid instance of the problem.

if S(all trails, k) = no: output "no such set"; stop
Q := all trails;  k' := k;  A := empty
while Q is nonempty:
    for each node v lying on some trail of Q:
        Q_v := trails of Q not containing v
        if S(Q_v, k' - 1) = yes:
            A := A + {v};  Q := Q_v;  k' := k' - 1
            break out of the for loop
output A

Correctness. If the first call says no, the answer “no” is correct. Otherwise we maintain the invariant

(I) \(Q\) can be hit by some set of at most \(k^{\prime}\) nodes, and \(A\) hits every trail not in \(Q\), with \(|A| + k^{\prime} = k\).

It holds initially. It is preserved by an update, because \(\mathcal{S}(Q_v, k^{\prime}-1) = \) yes says that \(Q_v\) can be hit by at most \(k^{\prime}-1\) nodes, and \(v\) hits every trail of \(Q \setminus Q_v\).

Each pass of the while loop does find a \(v\). Since \(Q \ne \emptyset\), (I) gives a set \(B\), \(1 \le |B| \le k^{\prime}\), hitting \(Q\); make it minimal, so that every \(v \in B\) lies on some trail of \(Q\). For such a \(v\), the set \(B \setminus \{v\}\) of size at most \(k^{\prime}-1\) hits \(Q_v\), so \(\mathcal{S}(Q_v, k^{\prime}-1)\) answers yes. (Also \(k^{\prime} \ge 1\), so the bound passed to \(\mathcal{S}\) is never negative.)

Each pass removes at least one trail from \(Q\), because \(v\) lies on a trail of \(Q\), so the loop ends with \(Q = \emptyset\). By (I), \(A\) then hits every \(P_i\) and \(|A| = k - k^{\prime} \le k\).

Running time. Each pass decreases \(k^{\prime}\) by 1 and \(k^{\prime} \ge 0\) throughout, so there are at most \(\min(k, t)\) passes. Each pass makes at most \(|V|\) calls to \(\mathcal{S}\) and does polynomial bookkeeping. In total there are at most \(1 + |V| \min(k, t)\) calls to \(\mathcal{S}\) and polynomially many other steps.

Reduce 3-SAT (NP-complete by (8.15)) to Plot Fulfillment with a “chain of binary choices” graph.

Membership in NP. The certificate is the \(s\)-\(t\) path; we check in polynomial time that consecutive nodes are joined by edges, that \(t\) occurs only at the end, and that the path meets every \(T_i\). (If repeated nodes are allowed, deleting cycles between consecutive theme hits leaves a witness of length at most \((k+1)|V|\).)

Reduction. Given a 3-SAT instance with variables \(x_1, \ldots, x_n\) and clauses \(C_1, \ldots, C_m\), build the directed graph with nodes \(u_0, u_1, \ldots, u_n\) and \(v_i^{T}, v_i^{F}\) for \(1 \le i \le n\), edges

\begin{equation*} u_{i-1} \to v_i^{T} \to u_i, \qquad u_{i-1} \to v_i^{F} \to u_i \qquad (1 \le i \le n), \end{equation*}

\(s = u_0\), \(t = u_n\), and one theme per clause:

\begin{equation*} T_j = \{ v_i^{T} : x_i \in C_j \} \cup \{ v_i^{F} : \neg x_i \in C_j \} \qquad (1 \le j \le m). \end{equation*}

This has \(3n+1\) nodes and \(4n\) edges. The graph is acyclic, so every \(s\)-\(t\) path is simple and meets \(t\) only at its end; the \(s\)-\(t\) paths are exactly the \(2^n\) paths that pass, for each \(i\), through exactly one of \(v_i^{T}, v_i^{F}\). Match such a path \(P\) with the assignment \(x_i = \text{true} \iff v_i^{T} \in P\). Then

\begin{equation*} \begin{aligned} P \cap T_j \neq \emptyset &\iff \exists i:\ (x_i \in C_j,\ v_i^{T} \in P) \text{ or } (\neg x_i \in C_j,\ v_i^{F} \in P)\\ &\iff \text{some literal of } C_j \text{ is true under the assignment.} \end{aligned} \end{equation*}

So a path meeting every \(T_j\) exists if and only if some assignment satisfies every clause, which proves both directions. The construction takes polynomial time, so 3-SAT \(\le_P\) Plot Fulfillment, and Plot Fulfillment is NP-complete. \(\blacksquare\)

Reduce 3-SAT (NP-complete by (8.15)) to Evasive Path. The path picks one literal per clause, and two-node zones forbid it to pick both a literal and its negation.

Membership in NP. The certificate is the \(s\)-\(t\) path. Deleting any cycle from a walk does not increase how many nodes it has in any zone, so we may take a simple path, with at most \(|V|\) nodes. We check its edges and count its nodes in each \(Z_i\) in polynomial time.

Reduction. Given clauses \(C_1, \ldots, C_m\) with \(C_j = \ell_{j1} \vee \ell_{j2} \vee \ell_{j3}\), build nodes \(u_0, \ldots, u_m\) and \(c_{jp}\) for \(1 \le j \le m\), \(1 \le p \le 3\), with edges

\begin{equation*} u_{j-1} \to c_{jp} \to u_j \qquad (1 \le j \le m,\ 1 \le p \le 3), \end{equation*}

\(s = u_0\), \(t = u_m\), and one zone \(\{c_{jp}, c_{j^{\prime}p^{\prime}}\}\) for every pair of occurrences with \(\ell_{j^{\prime}p^{\prime}} = \neg \ell_{jp}\). There are at most \(\binom{3m}{2}\) zones, so the construction is polynomial. The graph is acyclic, and the \(s\)-\(t\) paths are exactly the choices of one occurrence \(c_{j p_j}\) per clause.

(\(\Rightarrow\)) Given a satisfying assignment, let \(p_j\) index a true literal of \(C_j\), and take the path through \(c_{1p_1}, \ldots, c_{mp_m}\). Two chosen occurrences are both true, so they are never complementary, and the path has at most one node in each zone.

(\(\Leftarrow\)) Given an evasive path through \(c_{1p_1}, \ldots, c_{mp_m}\), the chosen literals \(\{\ell_{jp_j}\}\) contain no complementary pair, since such a pair would put two nodes of one zone on the path. So the assignment that makes every chosen literal true (and every other variable arbitrary) is well defined, and it satisfies every \(C_j\) through \(\ell_{jp_j}\).

Hence 3-SAT \(\le_P\) Evasive Path, and Evasive Path is NP-complete. \(\blacksquare\)

Set Packing (NP-complete by (8.16), defined in Section 8.1) is the special case of Winner Determination in which every price is \(1\).

Membership in NP. The certificate is the set \(A\) of accepted bids. We check in polynomial time that the sets \(S_i\), \(i \in A\), are pairwise disjoint and that \(\sum_{i \in A} x_i \ge B\).

Reduction. Given a Set Packing instance (a ground set \(U\), subsets \(S_1, \ldots, S_m\), and a target \(k\)), take the items to be \(U\), the bids to be \((S_i, 1)\) for \(1 \le i \le m\), and \(B = k\). A set \(A\) of bids is acceptable exactly when \(\{S_i : i \in A\}\) is a packing, and its revenue is

\begin{equation*} \sum_{i \in A} x_i = |A|. \end{equation*}

So revenue at least \(B = k\) is possible if and only if there are at least \(k\) pairwise disjoint sets among the \(S_i\), and both directions follow. The construction copies the input, so Set Packing \(\le_P\) Winner Determination, and Winner Determination is NP-complete. \(\blacksquare\)

Reduce Independent Set (NP-complete by (8.16)) to Multiple Interval Scheduling: give each edge its own time slot, and let each vertex’s job use the slots of its incident edges. (The book prints “11 A.M. to 2 A.M.” in the statement; 2 P.M. is meant.)

Membership in NP. The certificate is a set of \(k\) accepted jobs. We check in polynomial time that no interval of one accepted job meets an interval of another.

Reduction. Given a graph \(G = (V, E)\) with \(V = \{v_1, \ldots, v_n\}\), \(E = \{e_1, \ldots, e_m\}\), and a target \(k\), define pairwise disjoint intervals

\begin{equation*} \begin{aligned} I_{e_j} &= [2j,\, 2j+1] && (1 \le j \le m),\\ J_{v_i} &= [2m+2i,\, 2m+2i+1] && (1 \le i \le n), \end{aligned} \end{equation*}

and for each vertex \(v\) the job

\begin{equation*} \mathrm{job}(v) = \{ J_v \} \cup \{ I_e : e \in E,\ v \in e \}, \end{equation*}

with the same \(k\). (\(J_v\) only keeps jobs of isolated vertices nonempty.) Because the intervals are pairwise disjoint and \(J_v\) belongs to one job only, for \(u \ne v\)

\begin{equation*} \begin{aligned} \mathrm{job}(u) \text{ and } \mathrm{job}(v) \text{ overlap} &\iff \exists e \in E:\ u \in e \text{ and } v \in e\\ &\iff (u, v) \in E. \end{aligned} \end{equation*}

So a set \(S \subseteq V\) is independent in \(G\) if and only if the jobs \(\{\mathrm{job}(v) : v \in S\}\) are pairwise non-overlapping. Hence \(G\) has an independent set of size at least \(k\) if and only if at least \(k\) jobs can be accepted, which gives both directions. The instance has \(n\) jobs and \(2m + n\) intervals, so Independent Set \(\le_P\) Multiple Interval Scheduling, and Multiple Interval Scheduling is NP-complete. \(\blacksquare\)

Reduce Set Cover (NP-complete by (8.16)) to Nearby Electromagnetic Observation: the frequencies are the elements, location \(\ell_i\) stands for the set \(S_i\), and frequency \(j\) is blocked at exactly the locations whose set misses \(j\).

Membership in NP. The certificate is the set \(L^{\prime}\) itself. For each frequency \(j\) and each \(\ell \in L^{\prime}\), we test whether some source \((F_i, L_i)\) has \(j \in F_i\) and \(\ell \in L_i\). This takes \(O(n\,k\,b)\) membership tests, so \(|L^{\prime}| \le k\) and sufficiency are checked in polynomial time.

Reduction. Given a Set Cover instance (a ground set \(U = \{1, \ldots, n\}\), subsets \(S_1, \ldots, S_m\), and a target \(k\)), take frequencies \(U\), locations \(\ell_1, \ldots, \ell_m\), the same \(k\), and one interference source per frequency:

\begin{equation*} (F_j, L_j) = \bigl(\{j\},\ \{\ell_i : j \notin S_i\}\bigr) \qquad (1 \le j \le n). \end{equation*}

Only source \(j\) involves frequency \(j\), so \(j\) is blocked at \(\ell_i\) if and only if \(j \notin S_i\). For \(C \subseteq \{1, \ldots, m\}\), this gives

\begin{equation*} \begin{aligned} \{\ell_i : i \in C\} \text{ is sufficient} &\iff \forall j\ \exists i \in C:\ j \text{ is not blocked at } \ell_i\\ &\iff \forall j\ \exists i \in C:\ j \in S_i\\ &\iff \textstyle\bigcup_{i \in C} S_i = U. \end{aligned} \end{equation*}

So a sufficient set of size at most \(k\) exists if and only if some at most \(k\) of the \(S_i\) cover \(U\), which gives both directions. The instance has \(n\) sources of total size \(O(nm)\), so Set Cover \(\le_P\) Nearby Electromagnetic Observation, and Nearby Electromagnetic Observation is NP-complete. \(\blacksquare\)

Reduce from 3-Dimensional Matching. Make the triples the ground set, and require that the chosen set of triples contains exactly one triple through each element.

Membership in NP. The certificate is \(X\) itself. We can compute every \(|X \cap A_i|\) and compare it with \(c_i\) in \(O(mn)\) time.

Reduction. Take an instance of 3-Dimensional Matching: disjoint sets \(X_0, Y_0, Z_0\), each of size \(q\), and a set \(T \subseteq X_0 \times Y_0 \times Z_0\). This problem is NP-complete by (8.20) in Section 8.6. Build the following instance:

\begin{equation*} \begin{aligned} U &= T, \\ A_e &= \{\, t \in T : e \text{ is a coordinate of } t \,\} \quad (e \in X_0 \cup Y_0 \cup Z_0), \\ c_e &= 1 . \end{aligned} \end{equation*}

This gives \(n = |T|\) and \(m = 3q\) sets, and it is built in \(O(q\,|T|)\) time.

Equivalence. For any \(M \subseteq T\),

\begin{equation*} \begin{aligned} |M \cap A_e| = 1 \ \forall e &\iff \text{every } e \in X_0 \cup Y_0 \cup Z_0 \\ &\qquad \text{lies in exactly one triple of } M . \end{aligned} \end{equation*}

(\(\Rightarrow\)) Suppose \(M\) is a perfect three-dimensional matching. Every element lies in exactly one of its triples, so \(M\) itself is a feasible set \(X\) for the Intersection Inference instance.

(\(\Leftarrow\)) Suppose \(X \subseteq T\) satisfies \(|X \cap A_e| = 1\) for all \(e\). Then every element lies in exactly one triple of \(X\). Each triple has exactly one coordinate in \(X_0\), so counting triples by their \(X_0\)-coordinate gives \(|X| = \sum_{e \in X_0} |X \cap A_e| = q\). Therefore \(X\) is a set of \(q\) triples covering each element exactly once, which is a perfect three-dimensional matching.

So 3-Dimensional Matching \(\le_P\) Intersection Inference. Since the problem is also in NP, Intersection Inference is NP-complete.

Reduce from Subset Sum, NP-complete by (8.23): each item becomes a choice between an edge of weight \(w_i\) and a detour of weight \(0\), and one back edge of weight \(-W\) closes the cycle.

Membership in NP. The certificate is a sequence of vertices. In polynomial time we check that it is a simple cycle of \(G\) and that its weights add up to \(0\).

Reduction. Let natural numbers \(w_1,\dots,w_n\) and a target \(W\) be an instance of Subset Sum. Build \(G\) with vertices \(v_0,\dots,v_n,u_1,\dots,u_n\) and these edges:

\begin{equation*} \begin{aligned} &(v_{i-1},v_i)\ \text{of weight } w_i \quad (i=1,\dots,n),\\ &(v_{i-1},u_i),\ (u_i,v_i)\ \text{of weight } 0 \quad (i=1,\dots,n),\\ &(v_n,v_0)\ \text{of weight } -W. \end{aligned} \end{equation*}

This graph has \(2n+1\) vertices and \(3n+1\) edges. Each weight has the same bit length as an input number (or one bit more for \(-W\)), so the construction takes polynomial time.

Structure of the cycles. Delete the edge \((v_n,v_0)\). Every remaining edge goes from layer \(i-1\) to layer \(i\) or from \(u_i\) to \(v_i\), so \(G-(v_n,v_0)\) is acyclic. Hence every cycle of \(G\) uses \((v_n,v_0)\), and what is left of the cycle is a path from \(v_0\) to \(v_n\) in that DAG. Such a path goes through every \(v_i\) exactly once, and for each \(i\) it reaches \(v_i\) from \(v_{i-1}\) in one of two ways: along the direct edge, or through \(u_i\). Its vertices are all distinct, so the cycle is simple. The simple cycles of \(G\) therefore correspond one-to-one to subsets \(S\subseteq\{1,\dots,n\}\), where \(S\) is the set of indices \(i\) at which the direct edge is taken. The cycle for \(S\) has weight

\begin{equation*} w(C_S)=\sum_{i\in S}w_i+\sum_{i\notin S}(0+0)-W=\sum_{i\in S}w_i-W . \end{equation*}

Equivalence. (i) Suppose \(\sum_{i\in S}w_i=W\) for some \(S\). Then \(C_S\) is a simple cycle with \(w(C_S)=0\). (ii) Suppose \(C\) is a simple cycle of weight \(0\). By the structure above, \(C=C_S\) for some \(S\), and then \(\sum_{i\in S}w_i=W\).

So Subset Sum \(\le_P\) Zero-Weight-Cycle. Since Zero-Weight-Cycle is also in NP, it is NP-complete.

We reduce Set Cover to it. Each set becomes a member who votes Yes on the issues for its elements and abstains on all the others.

Decisive Subset is in NP: the certificate is the subset \(M^{\prime}\) itself. We check \(|M^{\prime}|\le k\), then recount every issue using only the votes of \(M^{\prime}\) and compare with the committee’s decision, in \(O(nt)\) time.

For hardness, Set Cover is NP-complete by (8.16). Take an instance of it: a ground set \(U=\{u_1,\dots,u_t\}\), subsets \(S_1,\dots,S_m\subseteq U\), and a bound \(k\). If \(\bigcup_j S_j\ne U\) the answer is no, and we output a fixed no-instance: one member, one issue on which that member votes Yes, and \(k=0\). The empty set decides that issue negatively, so it is not decisive. Otherwise we build a committee with one member \(m_j\) for each set \(S_j\) and one issue \(i\) for each element \(u_i\):

\begin{equation*} \text{vote of } m_j \text{ on issue } i= \begin{cases} \text{Yes}, & u_i\in S_j,\\ \text{Abstain}, & u_i\notin S_j, \end{cases} \end{equation*}

and we keep the same bound \(k\). The table has \(mt\) entries, so this takes polynomial time.

Nobody ever votes No. So for any \(M^{\prime}\subseteq M\), the subset \(M^{\prime}\) decides issue \(i\) affirmatively exactly when some member of \(M^{\prime}\) votes Yes on it:

\begin{equation*} \text{\(M’\) is affirmative on issue } i \iff \exists\, m_j\in M^{\prime} \text{ with } u_i\in S_j . \end{equation*}

Every \(u_i\) lies in some \(S_j\), so the whole committee is affirmative on every issue. Hence

\begin{equation*} \begin{aligned} M^{\prime} \text{ is decisive} &\iff \forall i\ \exists\, m_j\in M^{\prime} : u_i\in S_j\\ &\iff \textstyle\bigcup_{m_j\in M^{\prime}} S_j = U . \end{aligned} \end{equation*}

The map \(\{S_j : j\in J\}\mapsto\{m_j : j\in J\}\) preserves size. It gives both directions:

(i) If \(\{S_j\}_{j\in J}\) is a set cover with \(|J|\le k\), then \(\{m_j\}_{j\in J}\) is a decisive subset of size at most \(k\).

(ii) If \(M^{\prime}\) is a decisive subset with \(|M^{\prime}|\le k\), then \(\{S_j : m_j\in M^{\prime}\}\) is a set cover of size at most \(k\).

So Set Cover \(\le_P\) Decisive Subset. Since Decisive Subset is in NP, it is NP-complete. \(\blacksquare\)

(a) Polynomial time, by a maximum-flow computation. Build a network with source \(s\), a node \(c_i\) for each cannister, a node \(t_j\) for each truck, and sink \(t\), with edges

\begin{equation*} \begin{aligned} &(s,c_i) \text{ of capacity } 1 && \text{for every cannister } i,\\ &(c_i,t_j) \text{ of capacity } 1 && \text{whenever truck } j \text{ may carry cannister } i,\\ &(t_j,t) \text{ of capacity } k && \text{for every truck } j. \end{aligned} \end{equation*}

Run Ford-Fulkerson and answer yes if and only if the maximum flow has value \(n\).

If a valid loading exists, send one unit along \(s\to c_i\to t_j\to t\) for each cannister \(i\) placed in truck \(j\): each \((s,c_i)\) and \((c_i,t_j)\) carries at most \(1\), each \((t_j,t)\) carries the number of cannisters in truck \(j\), which is at most \(k\), so this is a flow of value \(n\). Conversely, if the maximum flow is \(n\), then by (7.14) there is an integer flow \(f\) of value \(n\). Each \((s,c_i)\) then carries exactly \(1\) (the \(n\) source edges have total capacity \(n\)), so by conservation exactly one edge \((c_i,t_j)\) out of \(c_i\) carries \(1\); put cannister \(i\) in that truck \(j\), which is permitted because the edge exists. Truck \(j\) receives \(f^{\text{in}}(t_j)=f(t_j,t)\le k\) cannisters, so no truck is overloaded.

The network has \(O(n+m)\) nodes and \(E=O(nm)\) edges, and the capacities out of \(s\) sum to \(C=n\), so by (7.5) Ford-Fulkerson runs in \(O(EC)=O(n^2m)\) time.

(b) NP-complete. It is in NP: a certificate is the truck assigned to each cannister, and in time linear in \(n\) plus the number of forbidden pairs we check that every truck has at most \(k\) cannisters and no forbidden pair shares a truck.

For hardness we reduce from 3-Coloring, NP-complete by (8.22) (Section 8.7). Given a graph \(G=(V,E)\), create one cannister per node, declare the pair \(\{u,v\}\) forbidden for each edge \((u,v)\in E\), and take \(m=3\) trucks with capacity \(k=n=|V|\). This is clearly polynomial.

(\(\Rightarrow\)) If \(G\) has a 3-coloring \(c\colon V\to\{1,2,3\}\), load cannister \(v\) into truck \(c(v)\). Adjacent nodes get different colors, so no forbidden pair shares a truck, and each truck holds at most \(n=k\) cannisters.

(\(\Leftarrow\)) If a valid loading exists, color each node \(v\) by the index of the truck holding cannister \(v\). For every edge \((u,v)\in E\) the pair \(\{u,v\}\) is forbidden, so \(u\) and \(v\) are in different trucks and receive different colors; this is a proper 3-coloring of \(G\).

Hence \(G\) is 3-colorable if and only if the constructed instance has a valid loading, so 3-Coloring \(\le_P\) problem (b), and with membership in NP, problem (b) is NP-complete.

Reduce 3-Coloring to it: make edges distance 2, non-edges distance 1, and ask for \(k = 3\) clusters of diameter \(B = 1\).

The problem is in NP: the certificate is the partition \(S_1, \dots, S_k\); checking that it is a partition and that \(d(p, q) \le B\) for every pair inside a common set takes \(O(n^2)\) time.

For hardness, 3-Coloring is NP-complete by (8.22); given a graph \(G = (V, E)\), build the instance with one object per vertex, \(k = 3\), \(B = 1\), and

\begin{equation*} d(u, v) = \begin{cases} 0 & u = v, \\ 2 & (u, v) \in E, \\ 1 & u \ne v,\ (u, v) \notin E. \end{cases} \end{equation*}

This \(d\) is symmetric and positive off the diagonal, so it is a legal instance, built in \(O(|V|^2)\) time. For any set \(S \subseteq V\),

\begin{equation*} \max_{u, v \in S} d(u, v) \le 1 \iff \text{no edge of } G \text{ has both ends in } S, \end{equation*}

because the only distances exceeding \(1\) are the edge distances.

(\(\Rightarrow\)) If \(G\) has a proper 3-coloring, take \(S_c\) to be the vertices of color \(c\) for \(c = 1, 2, 3\). Each \(S_c\) is an independent set, so it has diameter at most \(1 = B\).

(\(\Leftarrow\)) If \(V = S_1 \cup S_2 \cup S_3\) is a partition into sets of diameter at most \(1\), then by the display no edge lies inside any \(S_c\). So coloring every vertex of \(S_c\) with color \(c\) is a proper 3-coloring. (If some \(S_c\) is empty, that color is simply unused.)

Hence \(\text{3-Coloring} \le_P \text{Low-Diameter Clustering}\), and Low-Diameter Clustering is NP-complete.

Reduce 3-SAT to FCC by making each clause a component whose options are its literals, and declaring complementary literals incompatible.

FCC \(\in \mathcal{NP}\): the certificate is the selection \((x_1, \ldots, x_k)\), and we check \(x_j \in A_j\) for all \(j\) and that none of the \(\binom{k}{2}\) selected pairs is in \(P\), in polynomial time.

Hardness: we show 3-SAT \(\le_P\) FCC, where 3-SAT is NP-complete by (8.15). Given clauses \(C_1, \ldots, C_m\) over variables \(x_1, \ldots, x_n\), write \(C_j = \ell_{j1} \vee \ell_{j2} \vee \ell_{j3}\) and build

\begin{equation*} \begin{aligned} A_j &= \{(j,1), (j,2), (j,3)\} \qquad (j = 1, \ldots, m),\\ P &= \{((j,s), (j^{\prime},s^{\prime})) : j \ne j^{\prime},\ \ell_{js} = \neg \ell_{j^{\prime}s^{\prime}}\}. \end{aligned} \end{equation*}

The option sets are disjoint and every pair in \(P\) joins different sets; there are \(3m\) options and \(|P| \le 9m^2\), so the instance is built in polynomial time.

(i) If \(\nu\) satisfies every clause, select in each \(A_j\) an option \((j,s)\) with \(\ell_{js}\) true under \(\nu\). Two selected literals are both true, so they are not complementary, and no selected pair lies in \(P\).

(ii) If \((j, s_j)_{j=1}^m\) is fully compatible, then no two of the selected literals \(\ell_{1s_1}, \ldots, \ell_{ms_m}\) are complementary (a complementary pair from different clauses would be in \(P\)). So we can set every selected literal true, and the remaining variables arbitrarily. Each clause \(C_j\) then contains the true literal \(\ell_{js_j}\), so the formula is satisfied.

Therefore the formula is satisfiable if and only if the FCC instance has a fully compatible configuration. By (8.14), FCC is NP-complete. \(\blacksquare\)

Add a new node \(v\) joined to every node of \(G\), and ask \(\mathcal{A}\) about the resulting connected graph \(G^{\prime}\) with the same \(k\).

IndepSet(G = (V, E), k):
  if k <= 0: return yes
  if k == 1: return yes if V is nonempty, else no
  if k > |V|: return no
  G' = (V + {v}, E + {(v, u) : u in V})     # v a new node
  return A(G', k)

The cases \(k \le 1\) and \(k > |V|\) are answered correctly by inspection (the empty set, or any single node, is independent; no set exceeds \(|V|\)). For \(2 \le k \le |V|\), \(G^{\prime}\) is connected (every node of \(V\) is adjacent to \(v\)), so \(\mathcal{A}\) answers yes or no, and its answer is the right one for \(G\):

\begin{equation*} \begin{aligned} S \subseteq V \text{ independent in } G &\iff S \text{ independent in } G^{\prime},\\ S \text{ independent in } G^{\prime},\ |S| \ge 2 &\Rightarrow v \notin S, \end{aligned} \end{equation*}

the second because \(v\) is adjacent to every other node of \(G^{\prime}\). So the independent sets of size at least \(2\) in \(G^{\prime}\) are exactly those of \(G\), and \(G\) has one of size at least \(k\) iff \(G^{\prime}\) does.

Running time: \(G^{\prime}\) has \(|V| + 1\) nodes and \(|E| + |V|\) edges and is built in \(O(|V| + |E|)\) time; then one call to \(\mathcal{A}\) with \(k \le |V|\), which is polynomial in the size of \(G\) (the cap on \(k\) matters, since \(\mathcal{A}\) is polynomial in the value of \(k\)).

A shortest common string \(u\) has length at most \(L_A L_B\), where \(L_A = \sum_i |a_i|\) and \(L_B = \sum_j |b_j|\), because a repeated “overhang state” at two \(A\)-cut points could be cut out. (We take \(u\) nonempty and delete empty strings from \(A\) and \(B\), which changes no nonempty concatenation.)

Fix a shortest nonempty common \(u\), an \(A\)-factorization \(u = a_{i_1} \cdots a_{i_s}\) and a \(B\)-factorization of it. Let \(0 < p_1 < \cdots < p_{s-1} < |u|\) be the interior \(A\)-cut positions. For a cut \(p\), let \(\sigma(p) = 0\) if \(p\) is also a \(B\)-cut. Otherwise \(p\) falls strictly inside a \(B\)-piece \(b_j\) occupying \(u[p-d, p-d+|b_j|)\) with \(1 \le d \le |b_j| - 1\), and we set \(\sigma(p) = (j, d)\).

(i) \(\sigma(p) = 0\) is impossible: \(u[0,p)\) would be a shorter nonempty common string.

(ii) \(\sigma(p) = \sigma(q) = (j,d)\) with \(p < q\) is impossible. Let \(u = xyz\) with \(x = u[0,p)\), \(y = u[p,q)\) and \(z = u[q,|u|)\). Both \(p\) and \(q\) are \(A\)-cuts, so \(xz\) is a concatenation over \(A\). On the \(B\) side, \(u[0,p-d)\) and \(u[q-d+|b_j|, |u|)\) are concatenations over \(B\), and \(u[p-d,p) = u[q-d,q)\) is the length-\(d\) prefix of \(b_j\). Hence

\begin{equation*} \begin{aligned} xz &= u[0,p-d)\; u[p-d,p)\; u[q,q-d+|b_j|)\; u[q-d+|b_j|,|u|)\\ &= u[0,p-d)\; b_j\; u[q-d+|b_j|,|u|), \end{aligned} \end{equation*}

which is a concatenation over \(B\). It is nonempty (\(p \ge 1\)) and shorter than \(u\), contradicting minimality.

So the \(s - 1\) interior cuts carry distinct states of the form \((j,d)\), and there are only \(\sum_j (|b_j| - 1) \le L_B - 1\) such states. Therefore

\begin{equation*} s \le L_B, \qquad |u| = \sum_{r=1}^{s} |a_{i_r}| \le s \max_i |a_i| \le L_A L_B \le \tfrac14 (L_A + L_B)^2. \end{equation*}

which is quadratic in the total input length. \(\blacksquare\)

Set Cover is the special case \(b = |Y|\): put the sets on side \(X\), the elements on side \(Y\), and join each set to its elements.

Membership in \(\mathcal{NP}\): the certificate is \(E^{\prime}\), and we count the endpoints of \(E^{\prime}\) in \(X\) and in \(Y\) in \(O(|E|)\) time.

Hardness: Set Cover \(\le_P\) \((a,b)\)-Skeleton, where Set Cover is NP-complete by (8.16). Given a ground set \(U\) with \(|U| = n\), subsets \(S_1, \ldots, S_m\) and a bound \(k\), let

\begin{equation*} X = \{S_1, \ldots, S_m\},\quad Y = U,\quad E = \{(S_i, u) : u \in S_i\},\quad a = k,\quad b = n. \end{equation*}

This is built in time linear in \(\sum_i |S_i|\).

(i) If \(S_{i_1}, \ldots, S_{i_\ell}\) with \(\ell \le k\) cover \(U\), take \(E^{\prime}\) to be all edges at these \(\ell\) nodes. Exactly \(\ell \le a\) nodes of \(X\) are incident to \(E^{\prime}\), and every \(u \in U\) lies in some chosen \(S_{i_r}\), so all \(n = b\) nodes of \(Y\) are incident to \(E^{\prime}\).

(ii) If \(E^{\prime}\) is an \((a,b)\)-skeleton, let \(C\) be the set of nodes of \(X\) incident to \(E^{\prime}\), so \(|C| \le k\). At least \(b = n\), hence all, nodes \(u \in Y\) are incident to some edge \((S_i, u) \in E^{\prime}\), and then \(S_i \in C\) and \(u \in S_i\). So \(C\) is a set cover of size at most \(k\).

So the Set Cover instance is a yes-instance iff \(G\) has an \((a,b)\)-skeleton. By (8.14), the skeleton problem is NP-complete. \(\blacksquare\)

Reduce from Set Cover by giving each element \(u\) its own unit interval, and letting \(f_i\) have a tent of area \(1\) over the interval of every element of \(S_i\). Then the integral of the max counts the covered elements.

Membership in \(\mathcal{NP}\): the certificate is the index set \(\{i_1, \ldots, i_k\}\). Let \(x_0 < \cdots < x_N\) be the union of the breakpoints of the chosen functions (with \(N\) at most the input size). On each \([x_{r-1}, x_r]\) all chosen functions are linear, and the at most \(\binom{k}{2}\) crossing points of pairs of them, each the solution of a linear equation with rational input coefficients, split it into pieces on which the maximum is a single linear function. The integral is the sum of the exact trapezoid areas of these at most \(N(k^2+1)\) pieces, computed in polynomial time with rational arithmetic, and we compare it to \(B\).

Hardness: Set Cover \(\le_P\) this problem, where Set Cover is NP-complete by (8.16). Given \(U = \{1, \ldots, n\}\), sets \(S_1, \ldots, S_m\) and a bound \(k\), let \(t = n\), \(B = n\), \(k^{\prime} = \min(k, m)\), and define the tent

\begin{equation*} T_u(x) = 2\max\bigl(0,\ 1 - |2x - 2u + 1|\bigr) \end{equation*}

on \([0,n]\). It is \(0\) outside \((u-1, u)\), rises linearly to height \(2\) at \(x = u - \tfrac12\), and has \(\int_0^n T_u = \tfrac12 \cdot 1 \cdot 2 = 1\). Set \(f_i = \sum_{u \in S_i} T_u\). This function is continuous and piecewise linear with at most \(3|S_i| + 2\) integer or half-integer breakpoints, so the instance is polynomial in size.

The tents have disjoint open supports, so on \([u-1, u]\) each \(f_i\) equals \(T_u\) if \(u \in S_i\) and \(0\) otherwise. For any index set \(I\),

\begin{equation*} \int_0^n \max_{i \in I} f_i = \sum_{u=1}^n \int_{u-1}^{u} \max_{i \in I} f_i = \Bigl|\bigcup_{i \in I} S_i\Bigr| \le n. \end{equation*}

So \(k^{\prime}\) functions with integral \(\ge B = n\) exist iff \(k^{\prime}\) of the sets cover \(U\). Since adding sets to a cover keeps it a cover, this holds iff some at most \(k^{\prime}\) sets cover \(U\), and since only \(m\) sets exist, iff some at most \(k\) sets cover \(U\). By (8.14), the problem is NP-complete. \(\blacksquare\)

Reduce Subset Sum (NP-complete by (8.23)) to Number Partitioning by adding two “balancing” numbers that are forced onto opposite sides.

Membership in NP. The certificate is the partition \((S_1, S_2)\); adding up both sides in binary and comparing takes polynomial time.

Reduction. Let \(w_1, \ldots, w_n\), \(W\) be an instance of Subset Sum. Discard every \(w_i = 0\) (this changes no subset sum) and let \(T = \sum_i w_i\). If \(T = 0\), output the yes-instance \(\{1, 1\}\) when \(W = 0\) and the no-instance \(\{1, 2\}\) otherwise; if \(W > T\), output \(\{1, 2\}\). Otherwise \(T \ge 1\) and \(0 \le W \le T\), and output the positive integers

\begin{equation*} w_1, \ldots, w_n, \qquad y = 2T - W, \qquad z = T + W . \end{equation*}

Their total is \(T + (2T - W) + (T + W) = 4T\), so a valid partition has both sides equal to \(2T\). Since \(y + z = 3T > 2T\), the numbers \(y\) and \(z\) lie on opposite sides; the side containing \(y\) consists of \(y\) and a set \(A\) of the \(w_i\), and

\begin{equation*} \sum_{i \in A} w_i + (2T - W) = 2T \iff \sum_{i \in A} w_i = W . \end{equation*}

(i) If some \(A\) has \(\sum_{i \in A} w_i = W\), then \(S_1 = A \cup \{y\}\) and \(S_2 = (\text{rest}) \cup \{z\}\) both sum to \(2T\). (ii) If a partition exists, the display gives a subset \(A\) with sum \(W\).

The construction is polynomial (the new numbers have \(O(\log T + \log W)\) bits), so Subset Sum \(\le_P\) Number Partitioning, and Number Partitioning is NP-complete by (8.14). \(\blacksquare\)

Number Partitioning (NP-complete by Exercise 8.26) is the special case \(k = 2\), \(B = \lfloor S^2/2 \rfloor\) with \(S = \sum_j x_j\).

Membership in NP. The certificate assigns each \(x_j\) to one of the \(k\) sets; the \(k\) sums, their squares and the comparison with \(B\) are computed in time polynomial in the input length (at most \(\min(k, n)\) sets are nonempty, and empty sets contribute \(0\)).

Reduction. Map the Number Partitioning instance \(x_1, \ldots, x_n\) to \((x_1, \ldots, x_n;\ k = 2,\ B = \lfloor S^2/2 \rfloor)\). For a split into two sets with sums \(a\) and \(b = S - a\),

\begin{equation*} a^2 + b^2 = \frac{S^2 + (a - b)^2}{2} . \end{equation*}

(i) If \(a = b\), then \(S\) is even and \(a^2 + b^2 = S^2/2 = B\). (ii) If \(a^2 + b^2 \le B \le S^2/2\), then \((a - b)^2 \le 0\), so \(a = b\).

So the numbers have an equal-sum partition if and only if they have a \(2\)-set partition with squared sums at most \(B\). The map is polynomial, so Number Partitioning \(\le_P\) this problem, which is therefore NP-complete by (8.14). \(\blacksquare\)

Reduce Independent Set (NP-complete by (8.16)) by subdividing every edge of \(G\) and joining all the subdivision nodes into a clique.

Membership in NP. The certificate is \(I\); check \(|I| \ge k\) and, for each pair \(u, v \in I\), that \((u, v) \notin E\) and no \(w\) is adjacent to both, in \(O(|V|^3)\) time.

Reduction. Given \((G, k)\) with \(G = (V, E)\), build \(G^{\prime}\) on \(V \cup \{w_e : e \in E\}\) with edges

\begin{equation*} \{(u, w_e), (v, w_e) : e = (u, v) \in E\} \cup \{(w_e, w_f) : e \ne f \in E\}, \end{equation*}

and ask for a strongly independent set of size at least \(k\). In \(G^{\prime}\) no two original nodes are adjacent, and the only common neighbours of \(u, v \in V\) are nodes \(w_e\) with \(e = (u, v)\), so

\begin{equation*} u, v \in V \text{ are at distance} \le 2 \text{ in } G^{\prime} \iff (u, v) \in E . \qquad (*) \end{equation*}

(i) If \(I\) is independent in \(G\), then \(I\) is strongly independent in \(G^{\prime}\) by \((*)\). (ii) Let \(I^{\prime}\) be strongly independent in \(G^{\prime}\) with \(|I^{\prime}| \ge k\). If \(I^{\prime} \subseteq V\), it is independent in \(G\) by \((*)\). Otherwise \(I^{\prime}\) contains exactly one \(w_e\) (the \(w\)’s form a clique), say \(e = (u, v)\); every node of positive degree in \(G\) is adjacent to some \(w_f\) and so within distance \(2\) of \(w_e\), so \(I^{\prime} \setminus \{w_e\}\) consists of isolated nodes of \(G\), and \((I^{\prime} \setminus \{w_e\}) \cup \{u\}\) is an independent set of \(G\) of the same size.

\(G^{\prime}\) has \(|V| + |E|\) nodes and \(O(|E|^2)\) edges, so Independent Set \(\le_P\) Strongly Independent Set, which is NP-complete by (8.14). \(\blacksquare\)

Reduce Vertex Cover (NP-complete by (8.16)) by attaching to every edge \((u, v)\) a new node adjacent to exactly \(u\) and \(v\). (A superset of a dominating set dominates, so for \(k \le |V|\) “exactly \(k\) copies” and “at most \(k\) copies” are the same question; for \(k > |V|\) the answer is no.)

Membership in NP. The certificate is the set \(D\) of \(k\) nodes; checking that each node lies in \(D\) or has a neighbour in \(D\) takes \(O(|V| + |E|)\) time.

Reduction. Let \((G, k)\) ask for a vertex cover of size at most \(k\). Deleting isolated nodes of \(G\) changes no vertex cover, so assume \(G = (V, E)\) has none, and if \(k \ge |V|\) output a trivial yes-instance. Otherwise build \(G^{\prime}\) on \(V \cup \{w_e : e \in E\}\) with edge set

\begin{equation*} E \cup \{(u, w_e), (v, w_e) : e = (u, v) \in E\}, \end{equation*}

and ask for a dominating set of size \(k\) in \(G^{\prime}\).

(i) Let \(C\) be a vertex cover of \(G\) with \(|C| \le k\). Each \(w_e\) is adjacent to an endpoint of \(e\), which lies in \(C\); each \(v \in V \setminus C\) has an edge \((v, u)\) (no isolated nodes), and \(u \in C\) since \(C\) covers it. So \(C\) dominates \(G^{\prime}\), and padding it gives \(k\) nodes. (ii) Let \(D\) dominate \(G^{\prime}\) with \(|D| = k\). Replace each \(w_e \in D\), \(e = (u, v)\), by \(u\): since \(N[w_e] = \{w_e, u, v\} \subseteq N[u]\), the result \(D^{\prime} \subseteq V\) still dominates and \(|D^{\prime}| \le k\). For each \(e = (u, v)\), the node \(w_e \notin D^{\prime}\) has neighbours only \(u, v\), so \(u \in D^{\prime}\) or \(v \in D^{\prime}\); thus \(D^{\prime}\) is a vertex cover of \(G\) of size at most \(k\).

\(G^{\prime}\) has \(|V| + |E|\) nodes and \(3|E|\) edges, so Vertex Cover \(\le_P\) Dominating Set, which is NP-complete by (8.14). \(\blacksquare\)

Take \(Y\) = Independent Set (NP-complete by (8.16)) and map \((G, k)\), \(G = (V, E)\) with \(V = \{1, \ldots, n\}\), to the polynomial and bound

\begin{equation*} p(x) = \sum_{(i, j) \in E} x_i x_j - \sum_{i=1}^{n} x_i, \qquad B = -k . \end{equation*}

For \(S \subseteq V\) with indicator vector \(\chi_S\), writing \(e(S)\) for the number of edges with both ends in \(S\),

\begin{equation*} p(\chi_S) = e(S) - |S| . \end{equation*}

(i) If \(G\) has an independent set \(I\) with \(|I| \ge k\), then \(p(\chi_I) = -|I| \le -k = B\).

(ii) Suppose \(p(x) \le B\) for some \(x \in [0, 1]^n\). Each monomial of \(p\) has degree at most \(1\) in each variable, so with the other coordinates fixed \(p\) is affine in \(x_i\) and is no larger at one of \(x_i = 0\), \(x_i = 1\) than at the current value. Rounding the coordinates one at a time this way gives a corner \(\chi_S\) with \(e(S) - |S| \le p(x) \le -k\). While \(S\) contains an edge, delete one of its endpoints: \(|S|\) drops by \(1\) and \(e(S)\) by at least \(1\), so \(e(S) - |S|\) does not increase. The process ends at an independent set \(I\) with

\begin{equation*} -|I| = e(I) - |I| \le e(S) - |S| \le -k, \quad\text{i.e.}\quad |I| \ge k . \end{equation*}

The polynomial has integer coefficients, \(|E| + n\) monomials, and is written down in linear time, so Independent Set \(\le_P\) Multivariable Polynomial Minimization. \(\blacksquare\)

Reduce Vertex Cover to Undirected Feedback Set by putting every edge of \(G\) on its own triangle.

Membership in \(\mathcal{NP}\): the certificate is \(X\); we check \(|X| \le k\) and that \(G - X\) is acyclic (by breadth-first search, a graph is acyclic iff each component with \(c\) nodes has \(c - 1\) edges), in polynomial time.

Hardness: Vertex Cover is NP-complete by (8.16). Given \((G, k)\) with \(G = (V, E)\), build \(G^{\prime}\) by adding, for each edge \(e = (u, v) \in E\), a new node \(w_e\) joined to both \(u\) and \(v\):

\begin{equation*} \begin{aligned} V^{\prime} &= V \cup \{w_e : e \in E\},\\ E^{\prime} &= E \cup \{(u, w_e), (v, w_e) : e = (u, v) \in E\}, \end{aligned} \end{equation*}

and ask for a feedback set of size at most \(k\). This takes \(O(|V| + |E|)\) time.

(i) If \(C\) is a vertex cover of \(G\) with \(|C| \le k\), then \(C\) is a feedback set of \(G^{\prime}\). In \(G^{\prime} - C\) the nodes of \(V - C\) form an independent set of \(G\) (every edge of \(G\) has an end in \(C\)), so the only edges left are of the form \((x, w_e)\). Each \(w_e\) is adjacent only to the two ends of \(e\), and at least one of them is in \(C\), so \(w_e\) has degree at most \(1\) in \(G^{\prime} - C\). Every node on a cycle has degree at least \(2\), yet every edge of \(G^{\prime} - C\) has an end of degree at most \(1\), so \(G^{\prime} - C\) has no cycle.

(ii) If \(X\) is a feedback set of \(G^{\prime}\) with \(|X| \le k\), set

\begin{equation*} C = (X \cap V) \cup \{u_e : w_e \in X\}, \qquad u_e = \text{one fixed end of } e. \end{equation*}

Then \(|C| \le |X| \le k\). For each \(e = (u, v) \in E\) the triangle \(u, v, w_e\) is a cycle of \(G^{\prime}\), so \(X\) contains \(u\), \(v\) or \(w_e\), and in each case \(C\) contains an end of \(e\). Hence \(C\) is a vertex cover of \(G\).

Therefore \(G\) has a vertex cover of size at most \(k\) if and only if \(G^{\prime}\) has a feedback set of size at most \(k\). By (8.14), Undirected Feedback Set is NP-complete. \(\blacksquare\)

Reduce Hamiltonian Path to Perfect Assembly by making each node a one-letter symbol, each node the string of that letter doubled, and each directed edge a two-letter library string.

Membership in \(\mathcal{NP}\): the certificate is the permutation \(i_1, \ldots, i_n\); for each of the \(n - 1\) consecutive pairs we scan \(T\) for a corroborating string, in \(O(nm\ell)\) time.

Hardness: Hamiltonian Path (on directed graphs) is NP-complete by (8.19). Given a directed graph \(G = (V, E)\) with \(V = \{1, \ldots, n\}\), take the alphabet \(V\) (so \(q = n\)), \(\ell = 1\), and

\begin{equation*} S = \{s_v = vv : v \in V\}, \qquad T = \{t_{(u,v)} = uv : (u, v) \in E\}. \end{equation*}

This is built in \(O(|V| + |E|)\) time. With \(\ell = 1\), a string \(xy \in T\) corroborates \((s_a, s_b)\) iff \(x\) equals the last symbol \(a\) of \(s_a = aa\) and \(y\) equals the first symbol \(b\) of \(s_b = bb\), so

\begin{equation*} \begin{aligned} \text{some } t \in T \text{ corroborates } (s_a, s_b) &\iff ab \in T\\ &\iff (a, b) \in E. \end{aligned} \end{equation*}

Hence an ordering \(s_{v_1}, s_{v_2}, \ldots, s_{v_n}\) of \(S\) is a perfect assembly iff \((v_j, v_{j+1}) \in E\) for \(j = 1, \ldots, n - 1\), that is, iff \(v_1, v_2, \ldots, v_n\) is a Hamiltonian path in \(G\). Since orderings of \(S\) correspond one-to-one to orderings of \(V\), \(S\) has a perfect assembly with respect to \(T\) if and only if \(G\) has a Hamiltonian path. By (8.14), Perfect Assembly is NP-complete. \(\blacksquare\)

Reduce Subset Sum to the trade problem with one person who owns the numbers as objects and one person who owns a single object that both of them value near the target \(W\).

Membership in \(\mathcal{NP}\): the certificate is \((i, j, A_i, A_j)\); we check \(A_i \subseteq\) possessions of \(p_i\), \(A_j \subseteq\) possessions of \(p_j\), and the two strict inequalities by adding at most \(2m\) binary numbers, in polynomial time.

Hardness: Subset Sum (natural numbers \(w_1, \ldots, w_n\) and a target \(W\): does some subset sum to exactly \(W\)?) is NP-complete by (8.23). If \(W = 0\) the answer is yes (empty subset), and we output a fixed instance that has a trade: \(p_1\) owns \(a\) and \(p_2\) owns \(b\), with \(v_1(a) = 0, v_1(b) = 1, v_2(a) = 1, v_2(b) = 0\). If \(W \ge 1\), make two people, let \(p_1\) own objects \(a_1, \ldots, a_n\) and \(p_2\) own one object \(b\), and set

\begin{equation*} v_1(a_i) = v_2(a_i) = w_i, \qquad v_1(b) = W + 1, \qquad v_2(b) = W - 1. \end{equation*}

All values are natural numbers with \(O(\log W + \log w_i)\) bits. Write \(w(A) = \sum_{a_i \in A} w_i\). A trade gives some \(A \subseteq \{a_1, \ldots, a_n\}\) against some \(B \subseteq \{b\}\). If \(B = \emptyset\), then \(p_1\) would need \(0 > w(A)\), which is impossible; so \(B = \{b\}\), and the trade conditions read

\begin{equation*} \begin{aligned} v_1(b) > v_1(A) &\iff W + 1 > w(A) \iff w(A) \le W,\\ v_2(A) > v_2(b) &\iff w(A) > W - 1 \iff w(A) \ge W, \end{aligned} \end{equation*}

using that \(w(A)\) and \(W\) are integers. So a two-person trade is possible if and only if some \(A\) has \(w(A) = W\), that is, iff the Subset Sum instance is a yes-instance. By (8.14), the trade problem is NP-complete. \(\blacksquare\)

Reduce Vertex Cover to Influence Maximization with a two-layer graph: a node \(x_v\) of threshold \(1\) for each vertex, and a node \(y_e\) of threshold \(1/2\) fed by the two ends of each edge, asking for \(b = k + |E|\).

Membership in \(\mathcal{NP}\): the certificate is \(S\); we check \(|S| \le k\), run the simulation (at most \(n\) rounds, each a pass over the edges with one rational comparison per node) and check \(f(S) \ge b\), all in polynomial time.

Hardness: Vertex Cover is NP-complete by (8.16). Let \((H, k)\) be an instance with \(H = (U, F)\), \(|U| = n\), \(|F| = m\). If \(k \ge n\), then \(U\) is a cover and we output any fixed yes-instance; so assume \(k \le n\). Build the directed graph \(G\) on \(X \cup Y\), where

\begin{equation*} \begin{aligned} X &= \{x_u : u \in U\}, & \theta(x_u) &= 1,\\ Y &= \{y_e : e \in F\}, & \theta(y_e) &= 1/2, \end{aligned} \end{equation*}

with edges \((x_u, y_e), (x_v, y_e)\) for each \(e = (u, v) \in F\), and ask whether some \(|S| \le k\) has \(f(S) \ge k + m\). Each \(x_u\) has no incoming edges and positive threshold, so it is an adopter iff \(x_u \in S\); each \(y_e\) has exactly two in-neighbours, so it adopts iff \(y_e \in S\) or an end of \(e\) is in \(S \cap X\). With \(C_S = \{u : x_u \in S\}\) this gives

\begin{equation*} \begin{aligned} f(S) &= |S \cap X| + |\{e \in F : y_e \in S \text{ or } e \text{ has an end in } C_S\}|\\ &\le |S \cap X| + m. \end{aligned} \end{equation*}

(i) If \(C\) is a vertex cover of \(H\) with \(|C| \le k\), enlarge it to a cover of size exactly \(k\) (possible as \(k \le n\)) and take \(S = \{x_u : u \in C\}\). Every \(y_e\) adopts, so \(f(S) = k + m\).

(ii) If \(|S| \le k\) and \(f(S) \ge k + m\), the display gives \(|S \cap X| \ge k\), so \(S \subseteq X\) and \(|C_S| = k\). Then no \(y_e\) is in \(S\), and \(f(S) = k + m\) forces every \(y_e\) to adopt, i.e. every edge has an end in \(C_S\). So \(C_S\) is a vertex cover of size \(k\).

The construction has \(n + m\) nodes and \(2m\) edges. Hence \(H\) has a vertex cover of size at most \(k\) iff the instance has a seed set of size at most \(k\) with influence at least \(k + m\), and by (8.14) Influence Maximization is NP-complete. \(\blacksquare\)

Reduce Subset Sum to HSoDT! with a single route on which droid \(i\) can be bought for \(w_i\) and later sold for \(2w_i\), starting with \(z = W\) and asking for \(B = 2W\).

Membership in \(\mathcal{NP}\): the certificate is the path \(P\) and, for each planet \(p\) on \(P\) and each type \(j\), the numbers bought (\(\le s(j, p)\)) and sold (\(\le d(j, p)\)), all of polynomial bit-length. The verifier walks \(P\), at each planet first performing the sales and then the purchases, and checks that holdings and money never go negative and that the final money is at least \(B\). Performing the sales first loses nothing: a type sold at \(p\) is not bought at \(p\), and sales only add money, so any feasible order of the same transactions at \(p\) remains feasible after the reordering.

Hardness: Subset Sum is NP-complete by (8.23). Given natural numbers \(w_1, \ldots, w_n\) and \(W\), use \(n\) droid types and the path

\begin{equation*} s = p_0 \to p_1 \to p_2 \to \cdots \to p_n \to q = t, \end{equation*}

with \(s(i, p_i) = 1\), \(x(i, p_i) = w_i\), and \(d(i, q) = 1\), \(y(i, q) = 2w_i\), all other supplies and demands \(0\), \(z = W\) and \(B = 2W\). This is a DAG with \(n + 2\) planets, built in polynomial time, and no planet has both supply and demand for one type. The only route is this path. Let \(A\) be the set of types bought and \(A^{\prime} \subseteq A\) the set sold at \(q\); since money only decreases along \(p_1, \ldots, p_n\), buying \(A\) is feasible iff \(w(A) \le W\), and then

\begin{equation*} \text{score} = W - w(A) + 2w(A^{\prime}) \le W + w(A). \end{equation*}

(i) If \(w(A) = W\), buy \(A\) and sell it all: the score is \(W + W = 2W = B\).

(ii) If the score is at least \(2W\), then \(W + w(A) \ge 2W\), so \(w(A) \ge W\); with feasibility \(w(A) \le W\) this gives \(w(A) = W\).

So the player can reach score \(B\) iff some subset of \(\{w_i\}\) sums to \(W\), and by (8.14) HSoDT! is NP-complete. \(\blacksquare\)

Reduce Hamiltonian Path to it: make each node a special and each edge \((u,v)\) an ingredient that \(u\) needs fresh and \(v\) can take as \(u\)’s leftovers, but only on the following day.

We read “safe for \(t(j)\) days” as: bought on day \(d\), usable on days \(d, \ldots, d + t(j) - 1\) (under the other reading use \(t(j) = 1\) below in place of \(2\)).

Membership in \(\mathcal{NP}\): the certificate is the order of the specials together with a purchase plan: for each day \(d\) and ingredient \(I_j\), the number of units bought, and how many grams of each lot go to each special. WLOG no lot is bigger than the total need \(\lceil \sum_i a(i,j)/s(j) \rceil\) units, so the plan has \(O(k^2 n)\) numbers of polynomial bit length. Checking it is direct: each special gets its \(a(i,j)\) grams, fresh ingredients come from that day’s lots, no lot is used after it expires or beyond its size, and the total cost is \(\le x\).

Hardness: Hamiltonian Path (on directed graphs) is NP-complete by (8.19). Given \(G = (V, E)\) with \(|V| = n^{\prime} \ge 2\), build this instance:

• one special for each \(v \in V\), so \(k = n^{\prime}\);
• one ingredient \(I_{uv}\) for each edge \((u,v) \in E\), with \(s = 2\) grams, \(c = 1\), \(t = 2\);
• special \(u\) needs \(1\) gram of \(I_{uv}\), which must be fresh, and special \(v\) needs \(1\) gram of \(I_{uv}\), which need not be fresh;
• budget \(x = 2|E| - (n^{\prime} - 1)\).

Fix an order \(\pi\), and write \(\mathrm{pos}(v)\) for the day of special \(v\). Ingredients are independent, so take one edge \((u,v)\). Special \(u\) must buy one unit of \(I_{uv}\) on day \(\mathrm{pos}(u)\); buying it any other day would not be fresh. Its leftover gram is usable only on days \(\mathrm{pos}(u)\) and \(\mathrm{pos}(u)+1\), and no other purchase is free. Hence the cheapest cost of \(I_{uv}\) is

\begin{equation*} 1 + [\mathrm{pos}(v) \ne \mathrm{pos}(u) + 1], \end{equation*}

and so

\begin{equation*} \min \text{cost}(\pi) = 2|E| - \#\{i : (\pi_i, \pi_{i+1}) \in E\}. \end{equation*}

The count on the right is at most \(n^{\prime} - 1\), with equality iff every consecutive pair of \(\pi\) is an edge, i.e. iff \(\pi\) is a Hamiltonian path of \(G\). Therefore some schedule costs at most \(x = 2|E| - (n^{\prime}-1)\) iff \(G\) has a Hamiltonian path.

The instance has \(n^{\prime}\) specials and \(|E|\) ingredients and is built in linear time, so Hamiltonian Path \(\le_P\) Daily Special Scheduling. By (8.14), Daily Special Scheduling is NP-complete.

Reduce Subset Sum to it: build a chain of \(n\) two-route segments, where the \(i\)th segment has a route of length \(w_i\) (take item \(i\)) and a route of risk \(w_i\) (skip item \(i\)).

Membership in \(\mathcal{NP}\): the certificate is the path \(P\). We check that it is an \(s\)-\(t\) path, then add up its lengths and risks and compare them with \(L\) and \(R\).

Hardness: Subset Sum is NP-complete by (8.23). Given \(w_1, \ldots, w_n\) and \(W\), let \(N = \sum_i w_i\). Build \(G\) on the nodes \(v_0, \ldots, v_n, u_1, \ldots, u_n\) with \(s = v_0\) and \(t = v_n\). For each \(i\) add the edges

\begin{equation*} \begin{aligned} (v_{i-1}, v_i)&: \quad \ell = w_i,\ r = 0,\\ (v_{i-1}, u_i)&: \quad \ell = 0,\ r = w_i,\\ (u_i, v_i)&: \quad \ell = 0,\ r = 0, \end{aligned} \end{equation*}

and set \(L = W\) and \(R = N - W\).

Each \(v_i\) with \(0 < i < n\) separates \(s\) from \(t\), so a simple \(s\)-\(t\) path passes \(v_0, v_1, \ldots, v_n\) in order. Between \(v_{i-1}\) and \(v_i\) it takes either the direct edge or the detour through \(u_i\). Write \(A\) for the set of indices where it takes the direct edge. Then

\begin{equation*} \text{length}(P) = \sum_{i \in A} w_i, \qquad \text{risk}(P) = N - \sum_{i \in A} w_i . \end{equation*}

So length \(\le W\) and risk \(\le N - W\) hold together iff \(\sum_{i \in A} w_i = W\). Every \(A \subseteq \{1, \ldots, n\}\) arises from such a path, so a feasible path exists iff some subset sums to exactly \(W\).

The graph has \(2n + 1\) nodes and \(3n\) edges, and \(L\) and \(R\) have the bit length of the input, so the reduction runs in polynomial time. Hence Subset Sum \(\le_P\) Galactic Shortest Path, and by (8.14) Galactic Shortest Path is NP-complete.

Reduce Set Cover to it: connect a root to one node per set, connect each set node to its elements, and ask for a tree joining the root to all the elements with \(c + m\) edges.

Membership in \(\mathcal{NP}\): the certificate is \(F\). We check \(|F| \le k\) and, with one BFS in \((V, F)\), that all of \(X\) lies in one component.

Hardness: Set Cover is NP-complete by (8.16). Take an instance with universe \(U = \{u_1, \ldots, u_m\}\) (\(m \ge 1\)), sets \(S_1, \ldots, S_n\), and bound \(c\). Build \(G\) on the nodes \(\{r\} \cup \{u_1, \ldots, u_m\} \cup \{\sigma_1, \ldots, \sigma_n\}\) with these edges:

• \((r, \sigma_j)\) for every \(j\);
• \((\sigma_j, u_i)\) whenever \(u_i \in S_j\).

Set \(X = \{r, u_1, \ldots, u_m\}\) and \(k = c + m\).

(\(\Rightarrow\)) Let \(S_{j_1}, \ldots, S_{j_q}\) be a cover with \(q \le c\). Take the \(q\) edges \((r, \sigma_{j_p})\), and for each \(u_i\) one edge \((\sigma_{j_p}, u_i)\) to a chosen set containing it. This gives \(q + m \le k\) edges, and every \(u_i\) is joined to \(r\).

(\(\Leftarrow\)) Let \(F\) have at most \(k\) edges, and let \(C\) be the component of \((V, F)\) that contains \(X\). Write \(C = X \cup \{\sigma_j : j \in Q\}\). A spanning tree of \(C\) uses edges of \(F\), so

\begin{equation*} |X| + |Q| - 1 = m + |Q| \le |F| \le c + m, \qquad\text{hence}\qquad |Q| \le c . \end{equation*}

Each \(u_i\) lies in \(C\) together with \(r \ne u_i\), so it has an \(F\)-edge inside \(C\). All of its neighbours are set nodes, so \(u_i \in S_j\) for some \(j \in Q\). Thus \(\{S_j : j \in Q\}\) is a cover of size at most \(c\).

The construction has \(1 + m + n\) nodes and at most \(n + nm\) edges, so Set Cover \(\le_P\) Graphical Steiner Tree. By (8.14), Graphical Steiner Tree is NP-complete.

Reduce 3-SAT to it: each variable pair must route along a “true” chain or a “false” chain, and each clause pair must route through a node of an unused chain, which exists only when one of its literals is true.

Membership in \(\mathcal{NP}\): the certificate is \(P_1, \ldots, P_k\). We check that each \(P_i\) is a directed \(s_i\)-\(t_i\) path and that no node appears twice.

Hardness: 3-SAT is NP-complete by (8.15). Take variables \(x_1, \ldots, x_n\) and clauses \(C_1, \ldots, C_m\), and build \(G\) as follows.

• For each variable \(x_i\): nodes \(s_i, t_i, a_{i1}, \ldots, a_{im}, b_{i1}, \ldots, b_{im}\), and the two chains

\begin{equation*} \begin{aligned} &s_i \to a_{i1} \to a_{i2} \to \cdots \to a_{im} \to t_i \quad (\text{true chain}),\\ &s_i \to b_{i1} \to b_{i2} \to \cdots \to b_{im} \to t_i \quad (\text{false chain}). \end{aligned} \end{equation*}

• For each clause \(C_j\): nodes \(c_j, c^{\prime}_j\), and for each literal of \(C_j\) the edges \(c_j \to b_{ij} \to c^{\prime}_j\) if the literal is \(x_i\), or \(c_j \to a_{ij} \to c^{\prime}_j\) if it is \(\neg x_i\).

The pairs are \((s_i, t_i)\) for \(i \le n\) and \((c_j, c^{\prime}_j)\) for \(j \le m\).

The nodes \(t_i\) and \(c^{\prime}_j\) have no out-edges, and \(c_j\) has no in-edges. So an \(s_i\)-\(t_i\) path cannot pass through any clause terminal, and it must be one whole chain. Now take a \(c_j\)-\(c^{\prime}_j\) path. Its second node is some \(a_{ij}\) or \(b_{ij}\). From there it can only move forward along the chain, to larger second index, or step to the clause sink of the current index. The only node with an edge into \(c^{\prime}_j\) has second index \(j\), so the path must step straight to \(c^{\prime}_j\). Hence it is \(c_j \to y \to c^{\prime}_j\), where \(y\) is the node of one literal of \(C_j\).

(\(\Leftarrow\)) Given disjoint paths, set \(x_i\) true iff \(P_i\) is the true chain. The clause path for \(C_j\) uses \(y \in \{a_{ij}, b_{ij}\}\) off the chain \(P_i\) takes:

• (i) \(y = b_{ij}\): then \(P_i\) is the true chain, so \(x_i\) is true, and \(x_i \in C_j\).
• (ii) \(y = a_{ij}\): then \(P_i\) is the false chain, so \(x_i\) is false, and \(\neg x_i \in C_j\).

Either way \(C_j\) is satisfied.

(\(\Rightarrow\)) Given a satisfying assignment, route \(P_i\) along the true chain if \(x_i\) is true and along the false chain otherwise. For each \(C_j\) pick a true literal and route \(c_j \to y \to c^{\prime}_j\), where \(y\) is \(b_{ij}\) (if the literal is \(x_i\)) or \(a_{ij}\) (if it is \(\neg x_i\)). Such a \(y\) lies on the chain \(P_i\) does not use. Different clauses use nodes with different second index \(j\), so all the paths are node-disjoint.

\(G\) has \(O(nm)\) nodes and edges, so 3-SAT \(\le_P\) Directed Disjoint Paths. By (8.14), Directed Disjoint Paths is NP-complete.

Reduce 3-Dimensional Matching to it, already with all \(s_v = 1\): \(r\) feeds triple nodes, which feed elements. Three private targets of \(r\) use up its spare sending slots, so that exactly \(n\) triples get informed and they must cover all \(3n\) elements.

Membership in \(\mathcal{NP}\): a node needs to receive the message only once, so WLOG a scheme makes at most \(|V| - 1\) sends. The certificate is this list of (time, sender, receiver) triples, with times \(\le b\) written in binary. We check four things: each sender has already received the message, each send is along an edge, the switching gaps are respected, and every node of \(T\) has received the message by time \(b\).

Hardness: 3-Dimensional Matching is NP-complete by (8.20). Take disjoint sets \(X, Y, Z\) of size \(n\) and triples \(\tau_1, \ldots, \tau_m \subseteq X \times Y \times Z\). Build \(G\) as follows:

• nodes \(r\), one node \(\tau_q\) for each triple, one node for each element of \(X \cup Y \cup Z\), and dummies \(d_1, d_2, d_3\);
• edges \(r \to \tau_q\) for all \(q\), \(r \to d_1, d_2, d_3\), and \(\tau_q \to\) each of its three elements;
• \(T = X \cup Y \cup Z \cup \{d_1, d_2, d_3\}\), \(s_v = 1\) for all \(v\), and \(b = n + 3\).

(\(\Rightarrow\)) Let \(\tau_1, \ldots, \tau_n\) be a perfect matching. Node \(r\) sends to \(\tau_p\) at time \(p - 1\), and to \(d_1, d_2, d_3\) at times \(n, n+1, n+2\). Node \(\tau_p\) receives at time \(p\) and sends to its three elements at times \(p, p+1, p+2\), so they receive by time \(p + 3 \le n + 3\). Every node sends at most once per step, which \(s_v = 1\) allows, so the completion time is at most \(b\).

(\(\Leftarrow\)) In a scheme with completion time \(\le n + 3\), the useful sends of \(r\) happen at times \(0, \ldots, n+2\), so there are at most \(n + 3\) of them. Each dummy can only hear from \(r\), which uses three sends. Hence at most \(n\) triple nodes are informed. Each element can hear only from the triple nodes containing it. Each triple node has just three out-neighbours, so the informed triples cover at most \(3 \cdot n\) elements, with equality only if they are pairwise disjoint and there are exactly \(n\) of them. All \(3n\) elements are reached, so equality holds, and the informed triples form a perfect three-dimensional matching.

The graph has \(m + 3n + 4\) nodes and \(4m + 3\) edges, so 3-Dimensional Matching \(\le_P\) Broadcast Time. By (8.14), Broadcast Time is NP-complete.

(a) \(G\) has a cycle cover if and only if the bipartite graph \(B\) with sides \(V^{out} = \{v^{out} : v \in V\}\) and \(V^{in} = \{v^{in} : v \in V\}\) and an edge \((u^{out}, v^{in})\) for each \((u, v) \in E\) has a perfect matching.

If \(G\) has a cycle cover, every node \(u\) has exactly one successor \(\sigma(u)\) on its cycle and exactly one predecessor, so \(\{(u^{out}, \sigma(u)^{in}) : u \in V\}\) is a perfect matching of \(B\). Conversely, a perfect matching \(M\) of \(B\) defines \(\sigma(u) = \) the node with \((u^{out}, \sigma(u)^{in}) \in M\); each \(u\) has one image and one preimage, so \(\sigma\) is a permutation of \(V\) with \((u, \sigma(u)) \in E\) for all \(u\). The cycles of the permutation \(\sigma\) are node-disjoint, cover \(V\), and each is a directed cycle of \(G\) because every step \(u \to \sigma(u)\) is an edge.

\(B\) has \(2n\) nodes and \(m\) edges, so by (7.38) Ford-Fulkerson finds a maximum matching in \(O(mn)\) time, and we answer yes iff it has size \(n\).

(b) Reduce 3-Dimensional Matching (NP-complete by (8.20)) by replacing each triple with a 9-node gadget that can be tiled by directed triangles in exactly two ways: one that also absorbs the triple’s three elements, and one that absorbs none.

Membership in NP: the certificate is the list of cycles; we check in polynomial time that each is a cycle of \(G\) with at most three edges and that every node lies on exactly one of them.

Construction: given \(X = \{x_i\}\), \(Y = \{y_i\}\), \(Z = \{z_i\}\) of size \(n\) and triples \(T\), put the \(3n\) element nodes in \(G\), and for each \(t = (x, y, z) \in T\) add new nodes \(a_1, \ldots, a_9\) (private to \(t\)) and the 18 edges

\begin{equation*} \begin{aligned} &x \to a_1 \to a_2 \to x, \quad a_2 \to a_3 \to a_1,\\ &y \to a_4 \to a_5 \to y, \quad a_5 \to a_6 \to a_4,\\ &z \to a_7 \to a_8 \to z, \quad a_8 \to a_9 \to a_7,\\ &a_3 \to a_6 \to a_9 \to a_3 . \end{aligned} \end{equation*}

No pair of edges is antiparallel and there are no loops, so the allowed cycles are exactly the directed triangles. Element nodes have out-edges only to \(a_1, a_4, a_7\) of gadgets and in-edges only from \(a_2, a_5, a_8\), so every triangle lies in one gadget plus possibly its own element nodes, and the triangles of gadget \(t\) are

\begin{equation*} \begin{aligned} &\text{outer: } \{x, a_1, a_2\},\ \{y, a_4, a_5\},\ \{z, a_7, a_8\},\\ &\text{middle: } \{a_1, a_2, a_3\},\ \{a_4, a_5, a_6\},\ \{a_7, a_8, a_9\},\\ &\text{inner: } \{a_3, a_6, a_9\}. \end{aligned} \end{equation*}

In any triangle cover, consider the inner triangle of \(t\): (i) it is used: then \(a_3, a_6, a_9\) are taken, no middle triangle is available, and \(a_1, a_4, a_7\) must lie in the three outer triangles (“on”: \(x, y, z\) are covered by \(t\)); (ii) it is not used: \(a_3\) lies only in the inner triangle and \(\{a_1, a_2, a_3\}\), so that middle triangle is used, and likewise for \(a_6, a_9\); the gadget covers no element (“off”).

Hence a cover of \(G\) by cycles of length at most 3 is exactly a choice of on-triples covering each element node exactly once, i.e. a set of disjoint triples covering \(X \cup Y \cup Z\), a perfect 3-dimensional matching. Conversely, a perfect matching \(M\) gives a cover: turn \(t \in M\) on and every other gadget off. \(G\) has \(3n + 9|T|\) nodes and \(18|T|\) edges, so the reduction is polynomial, and the problem is NP-complete by (8.14).

Reuse the 3-Dimensional Matching reduction of Exercise 8.41(b) with \(k = |V|/3\): in a graph with no antiparallel edges, a partition into \(|V|/3\) domains is exactly a partition into directed triangles.

Membership in NP: the certificate is the partition; we check that there are at least \(k\) parts, each of size at least 2, and that each induced subgraph \(G[X]\) is strongly connected (two BFS runs from one node of \(X\), in \(G[X]\) and its reverse), all in polynomial time.

Hardness: from an instance of 3-Dimensional Matching (NP-complete by (8.20)) build the graph \(G\) of Exercise 8.41(b), with \(N = 3n + 9|T|\) nodes, and set \(k = N/3\); \(G\) has no loops and no antiparallel pair of edges, and \(G\) can be partitioned into directed triangles iff the 3DM instance has a perfect matching.

Key fact: in \(G\) every domain has at least 3 nodes, and a 3-node domain \(X\) spans a directed triangle. A 2-node domain \(\{u, v\}\) would need both \((u, v)\) and \((v, u)\). If \(|X| = 3\), each node of \(X\) needs an out-edge and an in-edge inside \(X\), so \(G[X]\) has at least 3 edges; with no antiparallel pairs it has at most \(\binom{3}{2} = 3\), so each node has in- and out-degree exactly 1 in \(G[X]\), which is a directed 3-cycle.

(\(\Rightarrow\)) If \(V\) is partitioned into at least \(N/3\) domains, each of size at least 3, then

\begin{equation*} N = \sum_{X} |X| \ \ge\ 3 \cdot \#\text{domains} \ \ge\ 3 \cdot \frac{N}{3} = N, \end{equation*}

so every domain has exactly 3 nodes and spans a directed triangle. This is a partition of \(G\) into triangles, so the 3DM instance has a perfect matching.

(\(\Leftarrow\)) A perfect matching gives a partition of \(G\) into \(N/3\) directed triangles by Exercise 8.41(b), and each triangle is a domain.

The construction is polynomial, so Domain Decomposition is NP-complete by (8.14).

We do (b): the answer is “yes” if and only if every clause \(C_j\) contains at least one existentially quantified variable, i.e. some \(x_i\) with \(i\) odd; this is checked by one scan of the clauses in \(O(k)\) time.

(i) Suppose every clause contains some \(x_i\) with \(i\) odd. Let the \(\exists\) quantifiers always choose \(x_i = 1\). Whatever values \(x_2, x_4, \ldots, x_{n-1}\) take, every clause then contains a true term, so

\begin{equation*} \Phi(1, x_2, 1, x_4, \ldots, x_{n-1}, 1) = 1 \quad \text{for all } x_2, x_4, \ldots, x_{n-1} \in \{0,1\}, \end{equation*}

and the quantified formula is true.

(ii) Suppose some clause \(C_j\) contains only variables \(x_i\) with \(i\) even. Let the \(\forall\) quantifiers always choose \(x_i = 0\). Whatever values \(x_1, x_3, \ldots, x_n\) take, all three terms of \(C_j\) are \(0\), so \(C_j = 0\), \(\Phi = 0\), and the quantified formula is false.

Membership: the first player wins from the position (current node \(v\), visited set \(S\)) iff

\begin{equation*} \mathrm{Win}(v, S) = \bigvee_{(v,w) \in E,\; w \notin S} \neg\, \mathrm{Win}(w, S \cup \{w\}), \end{equation*}

and evaluating this recursively, exactly as in the algorithm of (9.4), uses recursion depth at most \(|V|\) (each move visits a new node) with \(O(|V|)\) bits per frame, so \(O(|V|^2)\) space; hence the problem is in PSPACE.

Hardness: we show Competitive 3-SAT \(\le_P\) Geography on a Graph; since QSAT \(\le_P\) Competitive 3-SAT by (9.10) and QSAT is PSPACE-complete by (9.9), this suffices. Let \(\Phi = C_1 \wedge \cdots \wedge C_k\) over \(x_1, \ldots, x_n\) (\(n\) odd). Build \(G\):

• for each \(i\) a diamond: nodes \(a_i, t_i, f_i, b_i\) with edges \((a_i, t_i), (a_i, f_i), (t_i, b_i), (f_i, b_i)\), and edges \((b_i, a_{i+1})\) for \(i < n\), \((b_n, c)\);
• a node \(C_j\) for each clause with edge \((c, C_j)\); for each term of \(C_j\), an edge \((C_j, f_i)\) if the term is \(x_i\) and \((C_j, t_i)\) if it is \(\overline{x_i}\);
• start node \(s = a_1\).

This has \(4n + k + 1\) nodes and is built in polynomial time. Read “the game passes through \(t_i\)” as \(x_i = 1\) and “through \(f_i\)” as \(x_i = 0\).

Every node other than \(a_i\), \(c\), \(C_j\) has out-degree \(1\), and in the first \(3n\) moves its successor is still unvisited, so these moves are forced. Each diamond takes three moves, so the choice at \(a_i\) is made at move \(3i - 2\): by player 1 for \(i\) odd and player 2 for \(i\) even, exactly as in Competitive 3-SAT. Move \(3n\) (player 1) reaches \(c\); player 2 picks a clause \(C_j\); then player 1 must move from \(C_j\) to a node \(t_i\) or \(f_i\), which is unvisited exactly when the corresponding term of \(C_j\) is true under the chosen assignment, since the game visited \(t_i\) iff \(x_i = 1\):

\begin{equation*} \begin{aligned} &(C_j, f_i) \text{ usable} \iff f_i \text{ unvisited} \iff x_i = 1, \\ &(C_j, t_i) \text{ usable} \iff t_i \text{ unvisited} \iff x_i = 0 . \end{aligned} \end{equation*}

If player 1 can make this move, player 2 must then leave \(t_i\) or \(f_i\), whose only successor \(b_i\) is visited, so player 2 loses. Hence, once the assignment is fixed, player 1 wins iff every clause has a true term, i.e. iff \(\Phi = 1\) (otherwise player 2 picks a false clause and player 1 is stuck at it).

So the game on \(G\) is Competitive 3-SAT on \(\Phi\) with forced moves added, and player 1 has a forced win on \((G, s)\) iff player 1 has a forced win in Competitive 3-SAT on \(\Phi\). Geography on a Graph is therefore PSPACE-complete.

In a DAG no walk revisits a node, so the visited set never matters and the player to move at \(v\) wins iff some successor of \(v\) is a losing node; compute this label for every node in reverse topological order.

compute a topological order v_1, ..., v_n of G
for v = v_n down to v_1:
    W[v] = true if some edge (v, w) has W[w] = false, else false
first player has a forced win iff W[s] = true
(otherwise the second player has a forced win)

Correctness: if the game ever moved from \(v\) back to an earlier node, \(G\) would contain a directed cycle; so every node reachable in one move is unvisited, and the position is determined by the current node \(v\) alone. Every successor \(w\) of \(v\) comes after \(v\) in the topological order, so \(W[w]\) is already computed when \(W[v]\) is. By induction on this order, \(W[v]\) is true iff the player to move at \(v\) has a forced win: (i) \(v\) a sink: the mover is stuck and loses, and \(W[v]\) = false; (ii) some \(W[w]\) = false: the mover goes to \(w\), where the opponent moves from a losing node, so the mover wins; (iii) all \(W[w]\) = true: every move hands the opponent a winning node, so the mover loses. The game ends within \(n\) moves, so one of the two players has a forced win, and it is player 1 iff \(W[s]\) = true.

Running time: topological sorting takes \(O(m + n)\) (Section 3.6) and the loop examines each edge once, so the total is \(O(m + n)\).

Branch on which element of an unhit set goes into \(H\), exactly as the Vertex Cover Algorithm of Section 10.1 branches on the ends of an edge (an edge is a set of size \(c = 2\)).

HS(collection B, k):
  if B is empty: return "yes"
  if k = 0: return "no"
  let B1 be any set of B
  for each element a of B1:
    B(a) = the sets of B that do not contain a
    if HS(B(a), k - 1) = "yes": return "yes"
  return "no"

Correctness. The analogue of (10.3): for any set \(B_1\) of the collection \(\mathcal B\),

\begin{equation*} \mathcal B \text{ has a hitting set of size} \le k \iff \exists\, a \in B_1 :\ \mathcal B(a) \text{ has a hitting set of size} \le k-1 . \end{equation*}

(\(\Rightarrow\)) \(H\) hits \(B_1\), so pick \(a \in H \cap B_1\); then \(H - \{a\}\) hits every set not containing \(a\), and \(|H - \{a\}| \le k-1\). (\(\Leftarrow\)) If \(H^{\prime}\) hits \(\mathcal B(a)\) then \(H^{\prime} \cup \{a\}\) hits \(\mathcal B(a)\) and every set containing \(a\), and has size \(\le k\). The base cases are immediate (the empty collection is hit by \(\emptyset\); a nonempty one is not hit by a set of size \(0\); an empty \(B_1\) correctly gives “no”), so induction on \(k\) shows HS answers correctly.

Running time. The recursion tree has depth at most \(k\) and every node has at most \(c\) children, so it has at most \(\sum_{j=0}^{k} c^j \le (k+1)c^k\) nodes. Building one reduced collection \(\mathcal B(a)\) means testing \(a \in B_j\) for each of the \(m\) sets, \(O(cm)\) time, and each node builds at most \(c\) of them. Hence the total time is

\begin{equation*} O\big((k+1)c^{k} \cdot c^2 m\big) = O\big(f(c,k)\cdot m\big), \qquad f(c,k) = (k+1)c^{k+2}, \end{equation*}

plus \(O(n + cm)\) to read the input, which is of the required form \(O(f(c,k)\cdot p(n,m))\).

(a) We prove the equivalence by induction on \(d\), and the running time is \(O(3^d \cdot m) = O(3^d n^3)\) for \(m\) clauses.

If \(\Phi\) is satisfying, “yes” is correct (\(\Phi^{\prime} = \Phi\)). If \(\Phi\) is not satisfying and \(d = 0\), the only assignment at distance \(0\) is \(\Phi\) itself, so “no” is correct. Otherwise \(d \ge 1\) and \(C_i\) is false under \(\Phi\); note \(d(\Phi, \Phi_j) = 1\) for \(j = 1,2,3\).

(Soundness) If Explore\((\Phi_j, d-1)\) says “yes”, the induction hypothesis gives a satisfying \(\Phi^{\prime}\) with

\begin{equation*} d(\Phi,\Phi^{\prime}) \le d(\Phi,\Phi_j) + d(\Phi_j,\Phi^{\prime}) \le 1 + (d-1) = d . \end{equation*}

(Completeness) Suppose \(\Phi^{\prime}\) is satisfying with \(d(\Phi,\Phi^{\prime}) \le d\). Then \(\Phi^{\prime}\) makes some term of \(C_i\) true, say the \(j\)-th, whose variable \(x\) \(\Phi\) makes false; so \(\Phi^{\prime}(x) \ne \Phi(x) = \neg\Phi_j(x)\), i.e. \(\Phi_j\) agrees with \(\Phi^{\prime}\) on \(x\) and with \(\Phi\) elsewhere. Hence

\begin{equation*} d(\Phi_j,\Phi^{\prime}) = d(\Phi,\Phi^{\prime}) - 1 \le d - 1, \end{equation*}

and by induction Explore\((\Phi_j, d-1)\) returns “yes”, so Explore\((\Phi,d)\) does too.

Running time. Each call makes at most \(3\) calls with parameter one smaller, so the recursion tree has at most \(\sum_{j=0}^{d} 3^j < \tfrac32 \cdot 3^{d}\) nodes. Each node scans the \(m\) clauses once (to test satisfaction and find \(C_i\)) and copies an \(n\)-bit assignment three times, \(O(m + n)\) work. With no repeated clause, \(m \le (2n)^3\), so

\begin{equation*} T(n,d) = O\big(3^d (m+n)\big) = O\big(3^d \, n^3\big). \end{equation*}

(b) Run Explore\((\mathbf 0, \lfloor n/2 \rfloor)\) and Explore\((\mathbf 1, \lfloor n/2 \rfloor)\), where \(\mathbf 0\) and \(\mathbf 1\) set every variable to \(0\), resp. \(1\), and report “satisfiable” iff either says “yes”.

Each variable disagrees under \(\Phi^{\prime}\) with exactly one of \(\mathbf 0, \mathbf 1\), so

\begin{equation*} d(\mathbf 0,\Phi^{\prime}) + d(\mathbf 1,\Phi^{\prime}) = n \;\Rightarrow\; \min\{d(\mathbf 0,\Phi^{\prime}),\, d(\mathbf 1,\Phi^{\prime})\} \le \lfloor n/2 \rfloor . \end{equation*}

So if a satisfying \(\Phi^{\prime}\) exists, one of the two calls says “yes” by (a); and if either says “yes”, a satisfying assignment exists by (a). By (a) the two calls cost

\begin{equation*} 2 \cdot O\big(3^{n/2} n^3\big) = O\big(n^3 \cdot (\sqrt 3)^n\big), \end{equation*}

which is the bound with \(p(n) = n^3\).

Dynamic programming over subsets: for \(S \subseteq V\) with \(v_1 \in S\) and \(v \in S\), let \(H[S,v]\) be true iff \(G\) has a path from \(v_1\) to \(v\) whose vertex set is exactly \(S\). Then

\begin{equation*} \begin{aligned} H[\{v_1\}, v_1] &= \text{true}, \qquad H[S, v_1] = \text{false} \ \ (|S| \ge 2),\\ H[S, v] &= \bigvee_{u \in S - \{v\},\ (u,v) \in E} H[S - \{v\}, u] \quad (v \ne v_1), \end{aligned} \end{equation*}

filled in order of increasing \(|S|\); the answer is \(H[V, v_n]\) (for \(n = 1\) the answer is trivially yes).

Correctness, by induction on \(|S|\). A path \(P\) from \(v_1\) to \(v \ne v_1\) with vertex set \(S\) has a last edge \((u,v)\), and \(P\) minus \(v\) is a path from \(v_1\) to \(u\) with vertex set \(S - \{v\}\); so \(H[S,v]\) true forces the right side true. Conversely, if \(H[S-\{v\},u]\) is witnessed by a path \(P^{\prime}\) and \((u,v) \in E\), then \(v \notin S - \{v\}\), so \(P^{\prime}\) followed by \((u,v)\) is still a path, with vertex set \(S\). (A path from \(v_1\) back to \(v_1\) through other vertices would repeat \(v_1\), hence the false entries.) A Hamiltonian path from \(v_1\) to \(v_n\) is exactly a path from \(v_1\) to \(v_n\) with vertex set \(V\).

Running time. There are at most \(2^{n-1} \cdot n\) entries, and each is an OR over at most \(n-1\) predecessors \(u\) (with an adjacency matrix and \(S\) stored as a bitmask, \(O(1)\) per term), so the total is

\begin{equation*} O(2^n \cdot n^2), \end{equation*}

i.e. \(p(n) = n^2\).

Peel off an “ear” (a degree-2 vertex whose two neighbours are adjacent), decompose the rest by induction, and hang the ear’s triangle off a piece containing the two neighbours. All pieces are triangles, so the width is \(3 - 1 = 2\).

Ears exist. Let \(n \ge 4\). Some chord exists, since otherwise the interior is one bounded face bordered by \(n > 3\) edges. Among all chords \((a,b)\) and the two arcs of the circle they cut off, choose a pair whose arc has the fewest vertices strictly inside it; there is at least one such vertex. Any other chord with both ends on this arc (ends included) would cut off a smaller arc, so there is none. Any chord from an inner vertex of the arc to a vertex off the arc has interleaved endpoints with \((a,b)\), so by convexity it crosses \((a,b)\) in the interior, which is not allowed. So the region bounded by \((a,b)\) and the arc is a single face, bordered by (number of inner vertices) \(+\,2\) edges, which must equal \(3\). Hence the arc has exactly one inner vertex \(v\), \(v\) has degree 2 with neighbours \(a, b\), and \((a,b) \in E\). Deleting \(v\) leaves the vertices on the circle with consecutive ones adjacent (the chord \((a,b)\) becomes a side), merges the face \(avb\) into the outer region, and leaves every other bounded face as it was; so \(G - v\) is a triangulated cycle graph on \(n - 1\) vertices.

The decomposition, by induction on \(n\). For \(n = 3\), take one piece \(V\). For \(n \ge 4\), take an ear \(v\) with neighbours \(a, b\) and a width-2 decomposition \((T^{\prime}, \{V_t\})\) of \(G - v\). By Edge Coverage some piece \(V_s \ni a, b\); add a new leaf \(t_v\) adjacent to \(s\) with \(V_{t_v} = \{a, v, b\}\). Then: (i) Node and Edge Coverage: the only new node and edges, \(v\), \((a,v)\), \((v,b)\), lie in \(V_{t_v}\). (ii) Coherence for \(v\): \(v\) lies in the single piece \(V_{t_v}\). (iii) Coherence for \(a\) (and \(b\)): its subtree in \(T^{\prime}\) contains \(s\), and we add \(t_v\), which is adjacent to \(s\). (iv) Coherence for any other \(x\): its subtree is unchanged.

Algorithm. Keep adjacency sets, current degrees, and a stack of degree-2 vertices. While more than 3 vertices remain, pop a vertex \(v\) that is still present with degree 2; with \(n^{\prime} \ge 4\) vertices left, any degree-2 vertex is an ear (its neighbours are its two circle neighbours \(a,b\), and the bounded face at \(v\) is a triangle with sides \((a,v)\), \((v,b)\), so \((a,b) \in E\)). Record \((v,a,b)\), delete \(v\), and push \(a\) or \(b\) if its degree drops to 2. The ear argument above shows the stack never runs dry. Then build the tree in reverse: start with the final triangle as one piece, keep a hash map from each edge to some piece containing it, and for each recorded ear \((v,a,b)\), in reverse order, attach \(\{a,v,b\}\) to the piece stored for \((a,b)\) and store \((a,v)\) and \((v,b)\) under the new piece. This is exactly the induction above, so it produces a valid decomposition of width 2. A triangulated \(n\)-gon has \(2n - 3\) edges, and each deletion and each attachment takes \(O(1)\) time, so the algorithm runs in \(O(n)\) time.

(a) Root the tree at \(r\) and compute, bottom-up, three values per node, as in the tree dynamic program of (10.7). For a node \(v\) with subtree \(T_v\) and children \(u_1, \ldots, u_d\): (i) \(A[v]\): min cost of \(S \subseteq T_v\) with \(v \in S\) and every node of \(T_v\) dominated; (ii) \(B[v]\): same, but \(v \notin S\) (so \(v\) is dominated by a child in \(S\)); (iii) \(C[v]\): \(v \notin S\), \(v\) not dominated inside \(T_v\), every other node of \(T_v\) dominated. Writing \(\mu_u = \min(A[u], B[u])\),

\begin{equation*} \begin{aligned} A[v] &= c(v) + \textstyle\sum_{u} \min(A[u], B[u], C[u]), \qquad C[v] = \textstyle\sum_u B[u],\\ B[v] &= \textstyle\sum_u \mu_u + \max\big(0,\ \min_u (A[u] - \mu_u)\big) \qquad (B[v] = \infty \text{ if } v \text{ is a leaf}), \end{aligned} \end{equation*}

and the answer is \(\min(A[r], B[r])\); the sets are recovered by tracing back.

The subtrees \(T_{u_i}\) are disjoint and their only edges to the rest of \(T_v\) go to \(v\), so the conditions on the parts \(S \cap T_{u_i}\) separate child by child, and only through whether \(u_i \in S\) and whether \(u_i\) is dominated. If \(v \in S\), each \(u_i\) is dominated by \(v\), so any of the three states is allowed for it. If \(v \notin S\), no \(u_i\) can be in state (iii), since \(u_i\) has no other neighbor outside \(T_{u_i}\). In case (iii) every \(u_i\) must also avoid \(S\). In case (ii) at least one \(u_i\) must be in \(S\), and the cheapest way is to give each child its best of \(A, B\) and then, if no child chose \(A\), switch the child with the smallest extra cost \(A[u] - \mu_u\). Each node takes \(O(\deg v)\) time, so the total is \(O(n)\).

(b) Run a dynamic program over the decomposition \((T, \{V_t\})\), as in (10.18), where the state records each piece node’s role. We may make it nonredundant (Section 10.4), so by (10.16) it has at most \(n\) pieces. Root \(T\) at \(r\) and use \(G_t\) as in Section 10.4. A labelling \(\sigma : V_t \to \{1, D, 0\}\) means \(1\): in \(S\); \(D\): not in \(S\), must have a neighbor in \(S\); \(0\): not in \(S\), no requirement. Let \(f_t(\sigma)\) be the minimum of \(c(S)\) over \(S \subseteq V(G_t)\) such that \(S \cap V_t = \sigma^{-1}(1)\), every node of \(G_t - V_t\) is dominated by \(S\), and every \(x\) with \(\sigma(x) = D\) has a neighbor in \(S\). The answer is \(\min\{f_r(\sigma) : \sigma(V_r) \subseteq \{1, D\}\}\). Each piece has \(|V_t| \le 3\), so there are at most \(27\) labellings.

Separation facts. Let \(t_1, \ldots, t_d\) be the children of \(t\). By (10.13) the sets \(G_{t_i} - V_t\) are disjoint with no edges between them. By (10.14) applied to the edge \((t, t_i)\), each \(y \in V(G_{t_i}) - V_t\) has all its neighbors in \(G_{t_i}\). A node \(x \in V_t - V_{t_i}\) has no neighbor in \(G_{t_i} - V_t\), and by Coherence \(V_t \cap V(G_{t_i}) = V_t \cap V_{t_i}\).

Recurrence. Let \(U = \sigma^{-1}(1)\), and let \(X_\sigma\) be the set of \(x\) with \(\sigma(x) = D\) and no neighbor in \(U\); each must be dominated from below. For a child \(t_i\) and \(R \subseteq X_\sigma \cap V_{t_i}\), let

\begin{equation*} g_i(\sigma, R) = \min_{\sigma_i} f_{t_i}(\sigma_i) - c(U \cap V_{t_i}), \end{equation*}

over labellings \(\sigma_i\) of \(V_{t_i}\) with: \(\sigma_i = 1\) exactly on \(U \cap V_{t_i}\) among nodes of \(V_t\); \(\sigma_i = D\) on \(R\); \(\sigma_i = 0\) on the other nodes of \(V_t \cap V_{t_i}\); and \(\sigma_i \in \{1, D\}\) on \(V_{t_i} - V_t\). Then

\begin{equation*} \begin{aligned} f_t(\sigma) = c(U) + \min \Big\{ &\textstyle\sum_{i=1}^d g_i(\sigma, R_i) :\\ &R_1, \ldots, R_d \text{ partition } X_\sigma \Big\}, \end{aligned} \end{equation*}

where an empty minimum is \(\infty\) (for a leaf, \(f_t(\sigma) = c(U)\) if \(X_\sigma = \emptyset\) and \(\infty\) otherwise).

Proof of the recurrence. (\(\ge\)) Take an optimal \(S\), and assign each \(x \in X_\sigma\) to one child whose \(G_{t_i} - V_t\) contains a neighbor of \(x\) in \(S\). One exists by the separation facts, and it has \(x \in V_{t_i}\). Let \(R_i\) be the nodes assigned to \(t_i\). Then \(S_i = S \cap V(G_{t_i})\) is feasible for the labelling \(\sigma_i\) above, and the nodes of \(V_{t_i} - V_t\) really are dominated because their neighbors lie in \(G_{t_i}\). Since the sets \(S_i - V_t\) are disjoint,

\begin{equation*} c(S) = c(U) + \textstyle\sum_i \big(c(S_i) - c(U \cap V_{t_i})\big) \ge \text{RHS}. \end{equation*}

(\(\le\)) Conversely, let \(S_i\) attain \(g_i(\sigma, R_i)\) and put \(S = U \cup \bigcup_i S_i\). Then \(S \cap V_t = U\), every node below \(t\) is dominated inside its own \(G_{t_i}\), every \(D\)-node outside \(X_\sigma\) is dominated by \(U\), and every node of \(X_\sigma\) is dominated by its responsible child. The same display gives \(c(S) = \text{RHS}\).

Running time. For fixed \(\sigma\), compute the partition minimum by folding in children one at a time over the at most \(8\) subsets \(Y \subseteq X_\sigma\):

\begin{equation*} \Phi_0(\emptyset) = 0,\qquad \Phi_j(Y) = \min_{R \subseteq Y \cap V_{t_j}} \Phi_{j-1}(Y - R) + g_j(\sigma, R), \end{equation*}

with \(\Phi_0(Y) = \infty\) for \(Y \neq \emptyset\), so that \(f_t(\sigma) = c(U) + \Phi_d(X_\sigma)\). Each \(g_j(\sigma, R)\) scans the \(27\) labellings of \(V_{t_j}\). A node \(t\) therefore costs \(O(27 \cdot 27 \cdot 27 \cdot d_t) = O(d_t)\), and summed over the at most \(n\) pieces of a nonredundant decomposition the DP takes \(O(n)\) time, which is polynomial.

Run a dynamic program up the tree decomposition whose subproblems are indexed by the possible “traces” of a solution on a piece \(V_t\); since \(|V_t| \le 3\), there are only \(O(k^3)\) traces, even though \(k\) is part of the input.

Preprocessing. If a node lies in two different pairs the answer is no; a pair with \(s_i = t_i\) is served by the one-node path, so delete \(s_i\) and the pair. So the \(2k\) terminals are now distinct. A solution is the same thing as an edge set \(F\) such that \((V, F)\) has no cycle, every terminal has \(F\)-degree exactly \(1\), every other node has \(F\)-degree \(0\) or \(2\), and each component of \((V,F)\) with edges joins \(s_i\) to \(t_i\) for some \(i\). Make \(T\) nonredundant, so it has at most \(n\) pieces by (10.16), and root it at \(r\). Assign each edge \(e = (u,v)\) to the node of \(T\) closest to \(r\) whose piece contains both \(u\) and \(v\) (the nodes whose pieces contain \(u\) and \(v\) form a nonempty subtree, so this node is unique), and let \(E_t\) be the edges assigned to \(t\) and \(F_t\) the part of \(F\) assigned to nodes of the subtree \(T_t\). A node of \(G_{T_t} - V_t\) has, by (10.14), all its incident edges assigned inside \(T_t\), so its \(F\)-degree is already final in \(F_t\).

Subproblems. The trace of \(F_t\) on \(V_t\) records: the \(F_t\)-degree of each \(v \in V_t\); the partition of \(V_t\) into the components of \((G_{T_t}, F_t)\); and, for each such component, the set of terminals it contains. A trace is realizable if some \(F_t \subseteq\) (edges assigned in \(T_t\)) is acyclic, has degree \(\le 1\) at terminals and \(\le 2\) elsewhere, has final degrees (\(1\) at terminals, \(0\) or \(2\) elsewhere) at every node of \(G_{T_t} - V_t\), and no component of it contains two terminals of different pairs. There are \(3^3\) degree vectors, at most \(5\) partitions of \(V_t\), and at most \(3k+1\) terminal sets per block (none, one of the \(2k\) terminals, or one of the \(k\) pairs), so \(O(k^3)\) traces per piece.

Recurrence. For \(t\) with children \(t_1, \dots, t_d\), start from the trace of \(F_t = \emptyset\) on \(V_t\) (degrees \(0\), singletons, each block labelled by its own terminal), branch on including each edge of \(E_t\), and then absorb the children one at a time: a realizable trace of \(t_j\) is first restricted to \(V_t \cap V_{t_j}\), keeping it only if every node of \(V_{t_j} - V_t\) has final degree and every component disjoint from \(V_t\) holds a complete pair \(\{s_i, t_i\}\) (or is an unused non-terminal); then it is glued on by adding degrees, merging blocks that share a node and taking unions of terminal sets. A glued trace is discarded if a degree bound is exceeded, if two terminals of different pairs land in one block, or if gluing creates a cycle, which is visible on the traces alone: merging the child’s blocks into the current blocks one at a time, a cycle appears exactly when a child block contains two nodes that already lie in one merged block. Because the edge sets assigned to different subtrees are disjoint and, by (10.13), \(G_{T_{t_1}} - V_t, \dots, G_{T_{t_d}} - V_t\) share no nodes and no edges, every union of realizations of the glued traces is a realization of the result, and conversely every \(F_t\) splits into \(F \cap E_t\) and the \(F_{t_j}\), whose traces are realizable. Induction up the tree therefore shows the recurrence produces exactly the realizable traces.

Answer. The instance is a yes-instance iff the root \(r\) has a realizable trace in which every node of \(V_r\) has final degree and no block holds a single terminal: then \((V, F)\) is acyclic with degrees \(1\) at terminals and \(0,2\) elsewhere, so its non-trivial components are paths whose two ends are terminals of the same pair, giving all \(k\) paths \(P_i\); the converse is immediate. Following back-pointers recovers the paths.

Running time. Each of the \(\le n\) pieces has \(O(k^3)\) traces; absorbing one child compares \(O(k^3) \cdot O(k^3)\) pairs in constant time each, and there are \(n-1\) child absorptions in total, so the algorithm runs in \(O(n k^6) = O(n^7)\) time.

(a) Take \(k(w) = w + 1\). Induct on \(n\), the case \(n = 1\) being clear. Take a nonredundant tree decomposition of \(G\) of width \(\le w\) and a leaf \(t\) of \(T\); as in the proof of (10.16), some node \(v \in V_t\) lies in no other piece. Every edge at \(v\) lies in a piece containing \(v\), i.e. in \(V_t\), so

\begin{equation*} \deg(v) \le |V_t| - 1 \le w . \end{equation*}

The graph \(G - v\) has tree-width \(\le w\) (a subgraph never has larger tree-width, as shown in the proof of (10.15)), so by induction it has a \((w+1)\)-coloring; at most \(w\) colors appear on the neighbors of \(v\), so a free color remains for \(v\).

(b) Find a decomposition, then for \(c = 1, 2, \dots, w+1\) test \(c\)-colorability by dynamic programming over it, in the style of (10.18); the answer is the first \(c\) that succeeds, and some \(c \le w+1\) succeeds by (a).

Decomposition. Run the algorithm of (10.21) with parameter \(w+1\). Since \(G\) has tree-width \(\le w < w+1\), it must return a tree decomposition \((T, \{V_t\})\) of width \(< 4(w+1)\), so \(|V_t| \le 4w+4\); make it nonredundant, so \(T\) has at most \(n\) nodes by (10.16), and root it.

Subproblems. For a node \(t\) and a proper \(c\)-coloring \(\varphi\) of \(G[V_t]\), let \(g_t(\varphi)\) be true iff \(\varphi\) extends to a proper \(c\)-coloring of \(G_{T_t}\), the subgraph induced by the pieces in the subtree \(T_t\). If \(t\) has children \(t_1, \dots, t_d\),

\begin{equation*} g_t(\varphi) = \bigwedge_{i=1}^{d} \ \bigvee \Big\{ g_{t_i}(\psi) : \psi = \varphi \text{ on } V_t \cap V_{t_i} \Big\} . \end{equation*}

Necessity is clear (restrict an extension to each \(G_{T_{t_i}}\)). Sufficiency: pick such a \(\psi_i\) with an extension \(\chi_i\) for each \(i\); by (10.13) the sets \(V(G_{T_{t_i}}) - V_t\) are disjoint, so \(\varphi\) and the \(\chi_i\) combine into one coloring \(\chi\) of \(G_{T_t}\), which agrees with \(\chi_i\) on all of \(G_{T_{t_i}}\). Every edge of \(G_{T_t}\) lies in \(V_t\) (properly colored by \(\varphi\)) or meets some \(G_{T_{t_i}} - V_t\); in the latter case it lies in a piece containing that end, which is in \(T_{t_i}\), so it is an edge of \(G_{T_{t_i}}\) properly colored by \(\chi_i\). Hence \(\chi\) is proper. At the root, \(G\) is \(c\)-colorable iff \(g_r(\varphi)\) holds for some \(\varphi\).

Running time. Each piece has at most \(c^{|V_t|} \le (w+1)^{4w+4}\) colorings, each checked for properness in \(O(w^2)\) time, and evaluating the recurrence across one tree edge compares \(O((w+1)^{8w+8})\) pairs at \(O(w)\) cost each. Over \(\le n\) tree edges and \(w+1\) values of \(c\), the dynamic program takes \(O(f_1(w)\, n)\) time; step (10.21) takes \(O(f_2(w)\, mn)\) and \(m \le wn\) by (a)’s degree bound applied repeatedly. The total is \(O(f(w) \cdot n^2)\).

Match each clause to a distinct variable occurring in it, and set that variable so that its literal in the matched clause is true.

Let the clauses be \(C_1, \dots, C_m\), each with exactly three literals. Counting literal occurrences two ways gives \(3m = 3n\), so \(m = n\). Build the bipartite graph \(H\) with sides \(X = \{C_1, \dots, C_m\}\) and \(Y = \{x_1, \dots, x_n\}\) and an edge \((C_j, x_i)\) whenever \(x_i\) or \(\overline{x_i}\) occurs in \(C_j\). For \(A \subseteq X\) let \(\Gamma(A)\) be its set of neighbors. The \(3|A|\) literal occurrences in the clauses of \(A\) are all occurrences of variables in \(\Gamma(A)\), and each variable has only \(3\) occurrences in total, so

\begin{equation*} 3|A| \le 3|\Gamma(A)|, \qquad\text{i.e.}\qquad |\Gamma(A)| \ge |A| . \end{equation*}

Since \(|X| = |Y|\), (7.40) rules out a set \(A\) with \(|\Gamma(A)| < |A|\), so \(H\) has a perfect matching \(M\), and (7.40) finds it in \(O(mn) = O(n^2)\) time. For each \((C_j, x_i) \in M\) set \(x_i = 1\) if \(x_i\) occurs in \(C_j\) and \(x_i = 0\) otherwise (then \(\overline{x_i}\) occurs in \(C_j\)). Each variable is matched to exactly one clause, so this is a well-defined assignment, and each clause contains a literal made true by its matched variable. Hence every such instance is satisfiable, and the assignment is found in \(O(n^2)\) time.

Root \(T\) and compute, bottom-up, the best cut inside each subtree for every possible number of its nodes on side \(A\) and every side of its root.

Root \(T\) at \(r\); let \(T_v\) be the subtree at \(v\), \(n_v = |T_v|\), and \(w_e\) the weight of edge \(e\). For \(0 \le j \le n_v\) and \(b \in \{A, B\}\) let \(\mathrm{OPT}_v(j, b)\) be the maximum, over partitions of \(T_v\) into \((A_v, B_v)\) with \(|A_v| = j\) and \(v\) on side \(b\), of the weight of edges of \(T_v\) cut by the partition (\(-\infty\) if no such partition exists). Process the children \(c_1, \dots, c_d\) of \(v\) one at a time: let \(S_i = \{v\} \cup T_{c_1} \cup \dots \cup T_{c_i}\) and \(g_i(j, b)\) the analogous optimum on \(S_i\), so \(g_0(1, A) = g_0(0, B) = 0\) and all other \(g_0\) values are \(-\infty\). Then

\begin{equation*} \begin{aligned} g_i(j, b) = \max_{\ell,\, b^{\prime}} \Big\{ & g_{i-1}(j - \ell, b) + \mathrm{OPT}_{c_i}(\ell, b^{\prime}) \\ & + w_{(v, c_i)} \cdot [\, b \ne b^{\prime} \,] \Big\}, \end{aligned} \end{equation*}

and \(\mathrm{OPT}_v = g_d\). This is correct because the edges of the tree on \(S_i\) are the edges on \(S_{i-1}\), the edges of \(T_{c_i}\), and the single edge \((v, c_i)\), while \(S_{i-1}\) and \(T_{c_i}\) are disjoint. So a partition of \(S_i\) is exactly a partition of \(S_{i-1}\) together with one of \(T_{c_i}\), its \(A\)-count is the sum of the two counts, and its cut weight is the sum of the two cut weights plus \(w_{(v,c_i)}\) when \(v\) and \(c_i\) are on different sides. Each part can be optimized independently once \((j - \ell, b)\) and \((\ell, b^{\prime})\) are fixed, so induction on \(n_v\) gives correctness. The answer is

\begin{equation*} \max\big\{ \mathrm{OPT}_r(n/2, A),\ \mathrm{OPT}_r(n/2, B) \big\}, \end{equation*}

and the partition is recovered by back-pointers.

Running time. Absorbing \(c_i\) costs \(O(|S_{i-1}| \cdot n_{c_i})\), one unit for each pair consisting of a node already in \(S_{i-1}\) and a node of \(T_{c_i}\). Each pair of nodes of \(T\) is counted this way at most once, at their lowest common ancestor, so the total is \(O(n^2)\).

(a) Take \(K = 2\) and \((w_1, w_2, w_3) = (1, 2, 1)\). The greedy algorithm loads \(\{1\}\) and sends it off because \(1 + 2 > 2\). It then loads \(\{2\}\) and sends it off because \(2 + 1 > 2\), and finally loads \(\{1\}\). That is \(3\) trucks, but the packing \(\{w_1, w_3\}, \{w_2\}\) uses only \(2\).

(b) Any two consecutive greedy loads exceed \(K\): if the greedy algorithm uses \(k\) trucks with loads \(L_1, \dots, L_k\), truck \(j+1\) was started only because its first container did not fit on top of \(L_j\), so \(L_j + L_{j+1} > K\) for \(1 \le j < k\). (Every \(w_i \le K\), or no packing exists.) With \(W = \sum_i w_i\) and \(k^*\) the optimum, summing over the \(k - 1\) consecutive pairs gives

\begin{equation*} \begin{aligned} (k-1)K &< \sum_{j=1}^{k-1} (L_j + L_{j+1}) \le 2\sum_{j=1}^{k} L_j = 2W \le 2Kk^*, \end{aligned} \end{equation*}

where the last step holds because each of the \(k^*\) optimal trucks carries at most \(K\). Hence \(k^* > (k-1)/2\). Since \(k^*\) is an integer, \(k^* \ge k/2\), that is, \(k \le 2k^*\).

(a) Run Greedy-Set-Cover (Section 11.3) with unit weights on the universe \(U = P\) and the sets

\begin{equation*} S_q = \{\, p \in P : d(p,q) \le \Delta \,\}, \qquad q \in P. \end{equation*}

A subset \(R \subseteq P\) is representative exactly when \(\bigcup_{q \in R} S_q = P\), so representative sets correspond one-to-one to set covers \(\{S_q : q \in R\}\) of the same size, and the optimal cover has \(s^*\) sets. The instance is feasible, because \(d(p,p) = 0\) (an exact self-alignment costs nothing) and so \(P\) itself is representative. Every set has \(|S_q| \le n\), so by (11.11) the greedy cover has size at most

\begin{equation*} H(n)\, s^* \le (1 + \ln n)\, s^* = O(s^* \log n). \end{equation*}

For the running time, the \(n^2\) distances are each computed by the polynomial-time sequence alignment dynamic program of Section 6.6. Building the sets and running Greedy-Set-Cover then takes polynomial time.

(b) The Center Selection algorithm fixes the number of centers \(k\) and approximates the radius, and it does so only within a factor of \(2\). By (11.6), a run with radius \(r = \Delta\) that succeeds with at most \(k\) centers only guarantees that every protein lies within \(2\Delta\) of a center. Here the cut-off \(\Delta\) is a hard constraint and the number of centers is what we must keep small, so a cover at radius \(2\Delta\) is not a representative set at all. The analysis in (11.6) and (11.7) also relies on the triangle inequality, which a sequence alignment distance with arbitrary gap and mismatch costs need not satisfy.

(a) Take \(A = \{1, 10\}\) with \(a_1 = 1\), \(a_2 = 10\), and \(B = 10\). The algorithm takes \(a_1\), then rejects \(a_2\) because \(1 + 10 > 10\), and returns total sum \(1\). The feasible set \(\{10\}\) has total sum \(10\), and \(1 < 10/2\).

(b) Discard every \(a_i > B\), sort the remaining numbers in decreasing order, and run the algorithm of (a) on them. Let \(T\) be the total it returns and \(\mathrm{OPT}\) the best feasible total. No discarded number can belong to a feasible set.

(i) If every remaining number is accepted, then \(S\) contains every number that can appear in a feasible set, so \(T = \mathrm{OPT}\).

(ii) Otherwise some \(a_j\) is rejected, and let \(T_j\) be the running total at that moment. The largest remaining number \(a_1 \le B\) is always accepted (it is examined first, with \(T = 0\)), and \(a_1 \ge a_j\) by the sorting, so \(T_j \ge a_1 \ge a_j\). Therefore

\begin{equation*} 2T \ge 2T_j \ge T_j + a_j > B \ge \mathrm{OPT}. \end{equation*}

In both cases \(T \ge \mathrm{OPT}/2\). The sort takes \(O(n \log n)\) time and the filter and the single pass take \(O(n)\), for \(O(n \log n)\) in total.

Use the pricing method of Section 11.4. Here the sets \(B_i\) play the role of the edges and the elements play the role of the vertices. Each set \(B_i\) pays a price \(p_i \ge 0\). The prices are fair if \(\sum_{i : a \in B_i} p_i \le w_a\) for every element \(a\), and an element is tight when equality holds. (Assume each \(B_i \ne \emptyset\); otherwise no hitting set exists.)

Set p_i = 0 for all i
While some set B_i contains no tight element
  Raise p_i by min over a in B_i of (w_a - sum of p_k with a in B_k)
EndWhile
Return H = the set of tight elements

Each raise is the largest increase that keeps the prices fair, so the prices stay fair throughout and at least one element of \(B_i\) becomes tight. When the loop stops, every \(B_i\) contains a tight element, so \(H\) is a hitting set.

Fair prices give a lower bound on every hitting set \(H^*\), exactly as in (11.13). Every \(B_i\) meets \(H^*\) and all prices are nonnegative, so

\begin{equation*} \begin{aligned} \sum_{i=1}^m p_i \le \sum_{i=1}^m \sum_{a \in H^* \cap B_i} p_i = \sum_{a \in H^*} \sum_{i : a \in B_i} p_i \le w(H^*). \end{aligned} \end{equation*}

All elements of \(H\) are tight, and a price \(p_i\) is counted once for each element of \(H \cap B_i\), which happens at most \(|B_i| \le b\) times. So, as in (11.14),

\begin{equation*} \begin{aligned} w(H) = \sum_{a \in H} \sum_{i : a \in B_i} p_i = \sum_{i=1}^m |H \cap B_i|\, p_i \le b \sum_{i=1}^m p_i \le b\, w(H^*). \end{aligned} \end{equation*}

Taking \(H^*\) optimal gives the factor \(b\). Each iteration makes some new set \(B_i\) contain a tight element, and tight elements stay tight, so there are at most \(m\) iterations. Each iteration takes \(O(\sum_i |B_i|)\) time, so the total time is \(O(m \sum_i |B_i|)\), which is polynomial.

The makespan satisfies \(T \le \bar{L} + 50 \le \tfrac{7}{6}\bar{L} < 1.2\,\bar{L}\), where \(\bar{L} = \frac{1}{10}\sum_k t_k \ge 300\) is the average load.

Let machine \(M_i\) attain the makespan \(T = T_i\), and let \(j\) be the last job assigned to it. As in the proof of (11.3), \(M_i\) had the smallest load of the ten machines when \(j\) was assigned. Its load then was \(T_i - t_j\), so ten times that load is at most the total load at that moment, which is at most the final total. Hence \(T_i - t_j \le \frac{1}{10}\sum_k t_k = \bar{L}\). With \(t_j \le 50\) and \(\bar{L} \ge 3000/10 = 300\), this gives

\begin{equation*} \begin{aligned} T = (T_i - t_j) + t_j \le \bar{L} + 50 \le \bar{L} + \tfrac{1}{6}\bar{L} = \tfrac{7}{6}\bar{L} < 1.2\,\bar{L}. \end{aligned} \end{equation*}

Run Greedy-Balance with “earliest finish”: take the jobs in any order and put job \(i\) on the machine on which it would finish soonest, i.e. on a slow machine \(q\) minimizing \(L_q + t_i\) or a fast machine \(q\) minimizing \(L_q + \frac12 t_i\), whichever is smaller (\(L_q\) the current load).

Let \(T^*\) be the optimal makespan and \(W = \sum_i t_i\). In time \(T^*\) a slow machine does at most \(T^*\) units of (slow-machine) work and a fast one at most \(2T^*\), and job \(i\) takes at least \(\frac12 t_i\) wherever it runs, so (the analogues of (11.1) and (11.2))

\begin{equation*} T^* \ge \frac{W}{m+2k}, \qquad T^* \ge \tfrac12 \max_i t_i . \end{equation*}

Let machine \(q\) attain the greedy makespan \(F\), and let \(j\) be the last job placed on it. When \(j\) was placed, its finish time on \(q\) was \(F\) and this was the minimum over all machines, so every slow machine then had load \(\ge F - t_j\) and every fast machine load \(\ge F - \frac12 t_j\); a fast machine with load \(L\) holds \(2L\) units of work. All these jobs differ from \(j\), so

\begin{equation*} \begin{aligned} W - t_j &\ge m(F - t_j) + 2k\left(F - \tfrac12 t_j\right) = (m+2k)F - (m+k)t_j,\\ F &\le \frac{W}{m+2k} + \frac{m+k-1}{m+2k}\, t_j\\ &\le T^* + t_j \le T^* + 2T^* = 3T^*. \end{aligned} \end{equation*}

Each job is placed by scanning the \(m+k\) machines, so the running time is \(O(n(m+k))\) (or \(O(n \log(m+k))\) with two priority queues, one per machine type).

(a) Greedy: take the customers in order \(1, \ldots, n\) and show each one the ad whose current total weight \(W_j\) is smallest (ties to the lowest index).

Let \(W_1, \ldots, W_m\) be the final weights and \(W = \min_j W_j\) the greedy spread. Some ad has weight at most the average, so \(s \le \bar v/m\). Fix any ad \(A_j\) with \(W_j > 0\) and let \(i\) be the last customer shown \(A_j\). When \(i\) arrived, \(A_j\) had the minimum weight, which is at most the then-current (hence at most the final) weight of the minimum ad, so

\begin{equation*} W_j \le W + v_i \le W + \frac{\bar v}{2m}, \end{equation*}

and this holds trivially when \(W_j = 0\). Summing over the \(m\) ads, one of which has weight exactly \(W\),

\begin{equation*} \begin{aligned} \bar v = \sum_{j} W_j &\le mW + (m-1)\frac{\bar v}{2m} \le mW + \frac{\bar v}{2},\\ \text{so}\quad W &\ge \frac{\bar v}{2m} \ge \frac{s}{2}. \end{aligned} \end{equation*}

With a heap keyed on \(W_j\) the algorithm runs in \(O(n \log m)\) time.

(b) Take \(m = 2\) and values \(1, 1, 2, 2, 2\) in this order; \(\bar v = 8\) and every \(v_i \le 2 = \bar v/(2m)\). Greedy gives customer 1 to \(A_1\), 2 to \(A_2\), 3 to \(A_1\), 4 to \(A_2\) (weights \(3, 3\)), and 5 to \(A_1\), ending with weights \(5\) and \(3\): spread \(3\). The optimum shows \(A_1\) to customers \(1, 2, 3\) and \(A_2\) to customers \(4, 5\), with weights \(4, 4\): spread \(4\) (optimal since \(s \le \bar v/m = 4\)).

True: simulate Greedy-Balance and always feed it a job that an optimal schedule (re-targeted as we go) still wants on the machine Greedy-Balance is about to load.

Fix an optimal assignment with job sets \(B_1, \ldots, B_m\) and makespan \(T^*\). We maintain target sets \(B_1, \ldots, B_m\) partitioning the jobs, with \(\sum_{j \in B_q} t_j \le T^*\) for every \(q\), such that the jobs Greedy-Balance has so far put on machine \(q\) form a subset \(C_q \subseteq B_q\); let \(R_q = B_q \setminus C_q\) and \(L_q = \sum_{j \in C_q} t_j\). Initially \(C_q = \emptyset\). While jobs remain, let \(q\) be the machine Greedy-Balance will load next (a machine of minimum \(L_q\), under its own tie-breaking rule, which we can simulate).

(i) \(R_q \neq \emptyset\): feed any job of \(R_q\); it goes to \(q\), and the invariant is kept.

(ii) \(R_q = \emptyset\): pick \(p\) with \(R_p \neq \emptyset\) and swap the remainders, setting \(B_q := C_q \cup R_p\) and \(B_p := C_p\); then feed a job of the new \(R_q\) as in (i). The new targets still have load at most \(T^*\), because \(L_q \le L_p\):

\begin{equation*} \begin{aligned} \textstyle\sum_{B_q} t_j &= L_q + \textstyle\sum_{R_p} t_j \le L_p + \textstyle\sum_{R_p} t_j \le T^*,\\ \textstyle\sum_{B_p} t_j &= L_p \le T^*. \end{aligned} \end{equation*}

Each step assigns one job and keeps the invariant, so after \(n\) steps every \(R_q\) is empty and Greedy-Balance’s machine \(q\) holds exactly \(B_q\), of load at most \(T^*\); its makespan is therefore the optimum \(T^*\).

Greedily build a maximal matching: scan the triples of \(T\) once, adding a triple to \(M\) whenever none of its three elements is already covered by \(M\).

\(M\) is a 3-dimensional matching by construction, and it is maximal: a triple rejected during the scan shares an element with a triple already in \(M\). Let \(M^*\) be a maximum matching. Each \(t \in M^*\) meets some triple of \(M\) (if \(t \in M\) it meets itself), so we may charge \(t\) to one element \(e(t) \in t\) covered by \(M\). The triples of \(M^*\) are disjoint, so \(t \mapsto e(t)\) is injective into the \(3|M|\) elements covered by \(M\):

\begin{equation*} |M^*| \le 3|M|, \qquad\text{i.e.}\qquad |M| \ge \tfrac13 |M^*|. \end{equation*}

With a covered-flag per element of \(X \cup Y \cup Z\), each triple is tested in \(O(1)\), so the running time is \(O(|T| + |X| + |Y| + |Z|)\).

(a) If \(v \in T \setminus S\), the node \(v^{\prime}\) chosen in the iteration that deleted \(v\) works. Since \(v \notin S\), \(v\) was deleted as a neighbor of the chosen node \(v^{\prime}\), so \((v, v^{\prime})\) is an edge and \(v^{\prime} \in S\); and \(v\) was still present when \(v^{\prime}\) was picked as a node of maximum weight, so \(w(v) \le w(v^{\prime})\).

(b) Map each \(v \in T\) to \(f(v) \in S\): \(f(v) = v\) if \(v \in S\), and otherwise \(f(v) = v^{\prime}\) from (a), so \(w(v) \le w(f(v))\) always. If \(u \in S \cap T\), then \(f^{-1}(u) = \{u\}\), because a \(v \in T\) with \(f(v) = u \ne v\) would be adjacent to \(u \in T\), contradicting independence of \(T\). If \(u \in S \setminus T\), then \(f^{-1}(u)\) consists of neighbors of \(u\), so \(|f^{-1}(u)| \le 4\). Hence, for \(T\) a maximum-weight independent set,

\begin{equation*} w(T) = \sum_{u \in S} \sum_{v \in f^{-1}(u)} w(v) \le \sum_{u \in S} |f^{-1}(u)|\, w(u) \le 4\, w(S). \end{equation*}

Round the weights (not the values) up to multiples of \(b = \epsilon W/n\) and solve the rounded instance exactly with the Knapsack dynamic program of Section 6.4, whose capacity is now only \(O(n/\epsilon)\).

Take \(W > 0\) (if \(W = 0\), return the zero-weight items). Discard every item with \(w_i > W\) (none of them can lie in \(\mathcal{O}\)). For the remaining items put \[ \tilde w_i = \lceil w_i/b \rceil, \qquad C = \lfloor W/b \rfloor + n = \lfloor n/\epsilon \rfloor + n, \] and run the recurrence (6.11) on weights \(\tilde w_i\), values \(v_i\) and capacity \(C\); return the optimal set \(\mathcal{A}\) it finds.

Value. Every \(i\in\mathcal{O}\) survives the discard, and since \(\sum_{\mathcal{O}}\tilde w_i\) is an integer,

\begin{equation*} \sum_{i\in\mathcal{O}} \tilde w_i \le \sum_{i\in\mathcal{O}}\Big(\frac{w_i}{b}+1\Big) \le \frac{W}{b} + n \ \Rightarrow\ \sum_{i\in\mathcal{O}} \tilde w_i \le C, \end{equation*}

so \(\mathcal{O}\) is feasible for the rounded instance and the optimum \(\mathcal{A}\) has \(\sum_{\mathcal{A}} v_i \ge \sum_{\mathcal{O}} v_i = V\).

Weight. Since \(w_i \le b\tilde w_i\),

\begin{equation*} \begin{aligned} \sum_{i\in\mathcal{A}} w_i &\le b\sum_{i\in\mathcal{A}}\tilde w_i \le bC \\ &\le b\Big(\frac{W}{b}+n\Big) = W + \epsilon W = (1+\epsilon)W. \end{aligned} \end{equation*}

Running time. By (6.12) the dynamic program takes \(O(nC) = O(n^2/\epsilon)\) time (plus \(O(n)\) for the rounding), polynomial for fixed \(\epsilon\).

Example. Here \(b = 0.25\), \((\tilde w_1,\dots,\tilde w_4) = (20,16,4,24)\) and \(C = 44\); the rounded optimum is \(\{2,3,4\}\) (rounded weight \(44\)), of true weight \(11 \le 11\) and value \(21 \ge 13\).

Run Greedy-Set-Cover (Section 11.3) on the implicit Set Cover instance whose sets are all “stars” \((s,X)\) with \(s\in S\), \(\emptyset\ne X\subseteq U\), of weight \(w(s,X) = f_s + \sum_{u\in X} d_{us}\), and open the sites of the chosen stars.

Implementing the greedy step. With \(R\) the uncovered users, Greedy-Set-Cover picks the star minimizing \(w(s,X)/|X\cap R|\). Replacing \(X\) by \(X\cap R\) keeps the denominator and does not raise the weight (all \(d_{us}\ge 0\)), so we may take \(X\subseteq R\); and for fixed \(s\) and \(|X| = k\) the weight is smallest when \(X\) is the \(k\) users of \(R\) with the smallest \(d_{us}\). Hence the step is an exact minimization over \(|S|\cdot|R|\) candidates:

R = U ; A = empty
while R is nonempty:
    for each site s:
        sort R by d[u][s] into u_1, u_2, ...
        for k = 1..|R|:
            ratio(s,k) = (f_s + d[u_1][s] + ... + d[u_k][s]) / k
    take (s,k) of minimum ratio
    A = A + {s} ; R = R - {u_1, ..., u_k}
return A

Approximation. Let \(\mathcal{C}\) be the chosen stars and \(A^*\) an optimal site set of cost \(\mathrm{OPT}\). Assigning each user to its cheapest site of \(A^*\) partitions \(U\) into stars \((s,X_s)\), \(s\in A^*\), a set cover of weight exactly \(\mathrm{OPT}\), so the optimal cover has weight \(w^*\le\mathrm{OPT}\). Conversely, in the facility solution \(A\) each user \(u\) covered by \((s,X)\in\mathcal{C}\) pays at most \(d_{us}\), and each \(f_s\) is paid once even if \(s\) heads several stars. With (11.11) and \(d^* \le |U| = n\),

\begin{equation*} \begin{aligned} \sum_{s\in A} f_s + \sum_{u\in U}\min_{s\in A} d_{us} &\le \sum_{(s,X)\in\mathcal{C}} \Big(f_s + \sum_{u\in X} d_{us}\Big) \\ &\le H(d^*)\, w^* \le H(n)\,\mathrm{OPT}. \end{aligned} \end{equation*}

Running time. Each iteration covers at least one user, so there are at most \(n\) iterations, each costing \(O(|S|\, n\log n)\) for the sorts and prefix sums; the total is \(O(|S|\, n^2\log n)\).

No. Let \(G\) be the 6-cycle \(v_1v_2v_3v_4v_5v_6v_1\) with every weight \(w_e=1\). This graph is connected and bipartite, with \(X=\{v_1,v_3,v_5\}\) and \(Y=\{v_2,v_4,v_6\}\). By the definition in Section 12.3, node \(u\) is satisfied exactly when \(\sum_{v:\,e=(u,v)} w_e s_us_v \le 0\). For a node of degree 2 with unit weights, this means at least one of its two edges is good.

Start with every node at \(+1\). All six edges are bad, so every node is unsatisfied. The algorithm may run as follows.

(i) Flip \(v_1\), which is unsatisfied. Now \(s=(-1,+1,+1,+1,+1,+1)\), and \(v_4\) still has two bad edges, so it is unsatisfied.

(ii) Flip \(v_4\). Now \(s=(-1,+1,+1,-1,+1,+1)\).

In this configuration the edges \(v_1v_2, v_6v_1, v_3v_4, v_4v_5\) are good and the edges \(v_2v_3, v_5v_6\) are bad. For each node, \(\sum_v s_us_v\) is

\begin{equation*} \begin{aligned} v_1, v_4 &: \ -1-1=-2\le 0,\\ v_2, v_3, v_5, v_6 &: \ +1-1=0\le 0, \end{aligned} \end{equation*}

so every node is satisfied and the State-Flipping Algorithm stops here. Two of the six edges are not good, so the algorithm did not reach the all-good configuration. \(\blacksquare\)

(a) Take left side \(\{x_1, x_2\}\), right side \(\{y_1, y_2\}\) and edges \(x_1y_1\), \(x_1y_2\), \(x_2y_1\) (a path \(y_2 - x_1 - y_1 - x_2\)). If the algorithm adds \(x_1y_1\) first, then every remaining edge (\(x_1y_2\) and \(x_2y_1\)) has a matched endpoint, so it stops with \(\{x_1y_1\}\) of size \(1\), whereas \(\{x_1y_2, x_2y_1\}\) is a matching of size \(2\).

(b) Let \(V(M)\) be the set of endpoints of edges of \(M\), so \(|V(M)| \le 2|M|\). The edges of \(M^{\prime}\) are pairwise vertex-disjoint, so each vertex of \(V(M)\) lies on at most one edge of \(M^{\prime}\); hence

\begin{equation*} \#\{e^{\prime} \in M^{\prime} : e^{\prime} \cap V(M) \ne \emptyset\} \le |V(M)| \le 2|M| < |M^{\prime}|. \end{equation*}

So some \(e^{\prime} \in M^{\prime}\) has neither endpoint in \(V(M)\). Then \(e^{\prime} \notin M\), and \(e^{\prime}\) shares no endpoint with any edge of \(M\), so \(M \cup \{e^{\prime}\}\) is a matching.

(c) Let \(M\) be the output and \(M^*\) a maximum matching. On termination no edge has both endpoints unmatched by \(M\), i.e. there is no edge \(e \notin M\) with \(M \cup \{e\}\) a matching. If \(|M^*| > 2|M|\), then (b) with \(M^{\prime} = M^*\) produces exactly such an edge, which is impossible. Therefore

\begin{equation*} |M^*| \le 2|M|, \qquad\text{i.e.}\qquad |M| \ge \tfrac12 |M^*|. \end{equation*}

The improving moves are exactly the transfers of a job with \(0 < t_j < d\) off the heavier machine \(H\), where \(d = |T_1 - T_2|\) and \(T = T_1 + T_2\): moving a job of size \(t\) off \(H\) changes the difference to \(|d - 2t|\), and moving one onto \(H\) changes it to \(d + 2t\); since

\begin{equation*} |d - 2t| < d \iff 0 < t < d , \end{equation*}

which is the claim. \((\ast)\)

(a) WLOG \(T_1 \ge T_2\), so \(H = M_1\) (if \(d = 0\) there is nothing to prove). At a local optimum, \((\ast)\) says every job \(j \in A\) has \(t_j = 0\) or \(t_j \ge d\). Let \(A^+ = \{j \in A : t_j > 0\}\).

• (i) \(A^+ = \emptyset\): then \(T_1 = 0 \ge T_2\), so \(T_1 = T_2 = 0\).
• (ii) \(A^+ = \{j\}\): then \(T_1 = t_j \le T/2\), so \(T_1 \le T_2\), i.e. \(T_1 = T_2\).
• (iii) \(|A^+| \ge 2\): the smallest job of \(A^+\) is at most \(T_1/2\), so \(T_1 - T_2 = d \le T_1/2\), i.e. \(T_1 \le 2T_2\).

In every case \(T_2 \le T_1 \le 2T_2\), which gives \(\frac12 T_1 \le T_2 \le 2T_1\).

(b) Let \(d_0 > d_1 > d_2 > \cdots\) be the differences before successive moves (strictly decreasing by definition of a move; the run stops if \(d = 0\)), and let \(j_k\) be the job moved at step \(k\).

Sizes of moved jobs are non-increasing. At step \(k\), \(j_k\) is the largest job on \(H\) with \(t < d_k\). If \(H\) is still heavier after the move, every job eligible at step \(k+1\) is on \(H\) with \(t < d_{k+1} < d_k\) and is not \(j_k\), so it was eligible at step \(k\) and \(t_{j_{k+1}} \le t_{j_k}\). If the move flips the heavier side, then \(t_{j_k} > d_k/2\) and

\begin{equation*} d_{k+1} = 2t_{j_k} - d_k < t_{j_k}, \end{equation*}

so by \((\ast)\) every later eligible job has size \(< d_{k+1} < t_{j_k}\). \((\dagger)\)

No job moves twice. Suppose job \(j\) moves at step \(k\) (off \(H_k\), onto the lighter machine \(L_k\)) and again at step \(m > k\). It stays on \(L_k\) in between, so by \((\ast)\) \(L_k\) is the heavier machine at step \(m\) and \(t_j < d_m\). Since \(H_k\) is heavier at step \(k\) and \(L_k\) at step \(m\), some move at a step \(s - 1 \in [k, m-1]\) flips the heavier side; call its job \(i\). Then \(d_s = 2t_i - d_{s-1} < t_i\) by \((\dagger)\), and \(t_i \le t_j\) because sizes are non-increasing and \(s - 1 \ge k\). Hence

\begin{equation*} t_j < d_m \le d_s < t_i \le t_j , \end{equation*}

a contradiction. So each job moves at most once and there are at most \(n\) moves.

(c) Take \(n = 4\) with \(t = (2, 2, 1, 1)\); it satisfies the hypothesis of (a), since \(2 \le \frac12 \cdot 6\). The initial assignment is \(A = \{1, 2\}\), \(B = \{3, 4\}\), so \(T_1 = 4\), \(T_2 = 2\), \(d = 2\). Both jobs on the heavier machine have size \(2 \not< d\), so by \((\ast)\) no move improves and the algorithm (in either variant) stops with \(|T_1 - T_2| = 2\). The partition \(\{1, 3\}\), \(\{2, 4\}\) achieves \(|T_1 - T_2| = 0\), so this local optimum is not optimal.

The book prints \(B(i) \subseteq A(j)\); the intended condition is \(B(i) \subseteq A(i)\), which is what we use.

(a) The potential \(\Phi = \sum_k T_k^2\) (sum of squared machine loads) strictly decreases with every improving move. A swap on \(M_i, M_j\) leaves every other load unchanged and preserves \(S = T_i + T_j = T_i^{\prime} + T_j^{\prime}\). For any \(x + y = S\) we have \(|x - y| = 2\max(x,y) - S\), so

\begin{equation*} \begin{aligned} {T_i^{\prime}}^2 + {T_j^{\prime}}^2 &= \tfrac12\bigl(S^2 + (2\max(T_i^{\prime},T_j^{\prime}) - S)^2\bigr) \\ &< \tfrac12\bigl(S^2 + (2\max(T_i,T_j) - S)^2\bigr) = T_i^2 + T_j^2, \end{aligned} \end{equation*}

where the strict inequality uses \(S/2 \le \max(T_i^{\prime},T_j^{\prime}) < \max(T_i,T_j)\), on which range \(u \mapsto (2u - S)^2\) is strictly increasing. Hence \(\Phi\) strictly decreases at each step, so no assignment is ever visited twice. There are only \(m^n\) assignments of \(n\) jobs, so the heuristic stops after at most \(m^n - 1\) moves, and it stops exactly when no improving move exists, i.e. at a stable assignment.

(b) Let \(T^*\) be the optimal makespan and let \(M_i\) be a machine of maximum load \(T_i = T\) in a stable assignment. If \(T = 0\) there is nothing to prove; otherwise \(M_i\) holds a job \(\ell\) with \(t_\ell > 0\). For any \(j \ne i\), the swap with \(B(i) = \{\ell\}\), \(B(j) = \emptyset\) yields loads \(T - t_\ell\) and \(T_j + t_\ell\), and it is not improving, so (as \(T - t_\ell < T = \max(T_i,T_j)\))

\begin{equation*} T_j + t_\ell \ge T, \quad\text{i.e.}\quad T_j \ge T - t_\ell \qquad (j \ne i), \end{equation*}

and trivially \(T_i \ge T - t_\ell\). Summing over all machines and using (11.1),

\begin{equation*} m\,(T - t_\ell) \le \sum_k T_k = \sum_j t_j \le m\,T^*, \end{equation*}

so \(T - t_\ell \le T^*\). By (11.2), \(t_\ell \le \max_j t_j \le T^*\). Therefore

\begin{equation*} T = (T - t_\ell) + t_\ell \le T^* + T^* = 2T^*. \end{equation*}

Color every node independently and uniformly at random with one of the three colors.

For an edge \(e=(u,v)\) let \(X_e\) be the indicator that \(e\) is satisfied, and \(X=\sum_{e\in E}X_e\). Conditioning on the color of \(u\), the color of \(v\) is uniform and independent, so it agrees with probability \(\frac13\). By linearity of expectation,

\begin{equation*} \begin{aligned} E[X] &= \sum_{e\in E} E[X_e] = \sum_{e\in E}\Pr[\text{\(e\) satisfied}] = \tfrac{2}{3}|E| \\ &\ge \tfrac{2}{3}c^*, \end{aligned} \end{equation*}

since no coloring satisfies more than all \(|E|\) edges. The algorithm takes \(O(|V|)\) time.

Method (2) (deterministic). Order the nodes \(v_1,\dots,v_n\) and color them in turn, giving \(v_i\) the color used least often among its already-colored neighbours \(v_j\), \(j<i\). If \(v_i\) has \(d_i\) such neighbours, the least-used of the three colors occurs at most \(d_i/3\) times among them, so at least \(\frac23 d_i\) of these edges are satisfied, and they stay satisfied since colors are never changed. Each edge is counted exactly once, at its later endpoint, so

\begin{equation*} \#\text{satisfied} \ge \sum_{i}\tfrac{2}{3}d_i = \tfrac{2}{3}|E| \ge \tfrac{2}{3}c^*, \end{equation*}

in \(O(|V|+|E|)\) time.

\(E[X] = 79{,}400\).

For each voter \(i\) let \(X_i\) be the indicator that \(i\) votes for \(D\), so \(X = \sum_{i=1}^{100000} X_i\). A voter intending \(D\) votes for \(D\) unless an error occurs, so \(E[X_i] = \Pr[X_i = 1] = \frac{99}{100}\); a voter intending \(R\) votes for \(D\) only by error, so \(E[X_i] = \frac{1}{100}\). By linearity of expectation (13.8), which needs no independence,

\begin{equation*} \begin{aligned} E[X] &= \sum_{i \text{ intends } D} E[X_i] + \sum_{i \text{ intends } R} E[X_i] \\ &= 80{,}000 \cdot \tfrac{99}{100} + 20{,}000 \cdot \tfrac{1}{100} \\ &= 79{,}200 + 200 = 79{,}400. \end{aligned} \end{equation*}

(a) \(S\) is conflict-free and \(E[|S|]=n/2^{d+1}\). Suppose \((P_i,P_j)\) is a conflicting pair with both \(P_i,P_j\in S\). Then \(x_i=1\), because \(P_i\) joined. But \(P_j\) joined too, and \(P_j\) joins only if every neighbour chose \(0\), so \(x_i=0\). This is a contradiction.

For the expectation, use the general protocol of part (b) with \(p=\tfrac12\). Let \(X_i\) be the indicator of \(P_i\in S\). The event \(P_i\in S\) says that \(d+1\) distinct processes, namely \(P_i\) and its \(d\) neighbours, made prescribed independent choices. So

\begin{equation*} \Pr[X_i=1]=p(1-p)^d, \qquad E[|S|]=\sum_{i=1}^n E[X_i]=np(1-p)^d \end{equation*}

by linearity of expectation (13.8). At \(p=\tfrac12\) this gives \(E[|S|]=n\cdot 2^{-(d+1)}\).

(b) Take \(p=1/(d+1)\). The derivation of (a) holds for any \(p\), so \(E[|S|]=n f(p)\) with \(f(p)=p(1-p)^d\) on \([0,1]\). If \(d=0\), then \(f(p)=p\) is maximized at \(p=1=1/(d+1)\). If \(d\ge1\),

\begin{equation*} f^{\prime}(p)=(1-p)^{d-1}\bigl((1-p)-dp\bigr)=(1-p)^{d-1}\bigl(1-(d+1)p\bigr), \end{equation*}

which is positive on \((0,\tfrac1{d+1})\) and negative on \((\tfrac1{d+1},1)\). Hence \(f\) is unimodal and attains its maximum at \(p=\tfrac1{d+1}\). Then

\begin{equation*} E[|S|]=\frac{n}{d+1}\left(\frac{d}{d+1}\right)^{d}. \end{equation*}

(a) \(E[\text{in}(v_j)] = H_{n-1}-H_{j-1} = \Theta(\log(n/j))\), where \(H_m=\sum_{i=1}^m 1/i\) (with \(H_0=0\)).

Let \(X_k\) be the indicator that \(v_k\) links to \(v_j\). This is possible only when \(k>j\), and then \(\Pr[X_k=1]=1/(k-1)\). By linearity of expectation,

\begin{equation*} E[\text{in}(v_j)]=\sum_{k=j+1}^{n}\frac{1}{k-1}=\sum_{i=j}^{n-1}\frac1i=H_{n-1}-H_{j-1}. \end{equation*}

For the asymptotics, \(1/i\ge\int_i^{i+1}dx/x\) and \(1/i\le 2/(i+1)\le 2\int_{i}^{i+1}dx/x\), so

\begin{equation*} \ln\frac nj=\int_j^n\frac{dx}{x}\;\le\;\sum_{i=j}^{n-1}\frac1i\;\le\;2\int_j^n\frac{dx}{x}=2\ln\frac nj . \end{equation*}

So \(E[\text{in}(v_j)]=\Theta(\log(n/j))\).

(b) For \(n\ge 2\) the expected number of nodes with no incoming links is exactly \(n/2\) (for \(n=1\) it is \(1\)).

Node \(v_j\) has no incoming link exactly when none of \(v_{j+1},\dots,v_n\) chooses it. These choices are independent, so

\begin{equation*} \begin{aligned} \Pr[\text{in}(v_j)=0]&=\prod_{k=j+1}^{n}\Bigl(1-\frac1{k-1}\Bigr) =\prod_{m=j}^{n-1}\frac{m-1}{m}=\frac{j-1}{n-1}. \end{aligned} \end{equation*}

The product telescopes, and the formula also covers \(j=1\): there the factor with \(m=1\) is \(0\), and \(v_1\) is certainly chosen by \(v_2\). Summing these indicator probabilities by linearity of expectation gives

\begin{equation*} E[\#\{j:\text{in}(v_j)=0\}]=\sum_{j=1}^{n}\frac{j-1}{n-1}=\frac{1}{n-1}\cdot\frac{n(n-1)}{2}=\frac n2 . \end{equation*}

Proposal C, and (for \(n\ge 2\)) only Proposal C, gives the Shapley value.

For \(\ell\le i\), let \(Y_{i\ell}\) be the indicator that \(T_i\) comes first in \(\mathcal{O}\) among \(T_\ell,T_{\ell+1},\dots,T_n\). Write \(j\) for the largest index arriving before \(T_i\) (\(j=0\) if there is none). If \(j>i\), then \(T_i\) is never first among \(T_\ell,\dots,T_n\) for any \(\ell\le i\), because \(T_j\) is in that set and came earlier. If \(j<i\), then \(T_i\) is first among \(T_\ell,\dots,T_n\) exactly when \(j<\ell\). In either case

\begin{equation*} X_i = k\,\bigl|\{\ell : j<\ell\le i\}\bigr| = k\sum_{\ell=1}^{i} Y_{i\ell}. \end{equation*}

That is, \(T_i\) pays for \(e_\ell\) exactly when it is the first town beyond \(e_\ell\) to arrive. In a uniformly random order, each of the \(n-\ell+1\) towns \(T_\ell,\dots,T_n\) is equally likely to come first among them, so \(E[Y_{i\ell}]=1/(n-\ell+1)\). Linearity of expectation then gives

\begin{equation*} E[X_i] = \sum_{\ell=1}^{i} \frac{k}{n-\ell+1}. \end{equation*}

This is exactly Proposal C’s charge to \(T_i\): of each edge \(e_\ell\) with \(\ell\le i\), \(T_i\) pays the share \(k/(n-\ell+1)\), and it pays nothing toward edges \(e_\ell\) with \(\ell>i\).

Proposals A and B differ from C already when \(n=2\) (total cost \(2k\)):

Take \(\alpha=\tfrac13\) and output a uniformly random ordering of the \(n\) markers.

For a constraint \(C=(\mu_i,\mu_j,\mu_k)\) (three distinct markers), the relative order of \(\mu_i,\mu_j,\mu_k\) in a uniformly random permutation is uniform over the \(3!=6\) orders, by symmetry. Exactly two of them, \(\mu_i\mu_j\mu_k\) and \(\mu_k\mu_j\mu_i\), put \(\mu_j\) in the middle, so with \(X_C\) the indicator that \(C\) is satisfied,

\begin{equation*} \Pr[X_C=1]=\frac{2}{6}=\frac13 . \end{equation*}

By linearity of expectation, with \(X=\sum_C X_C\) the number of satisfied constraints,

\begin{equation*} \mathbf E[X]=\sum_{C}\mathbf E[X_C]=\frac{k}{3}\ \ge\ \frac{k^*}{3}, \end{equation*}

since \(k^*\le k\) (a triple with a repeated marker is never satisfiable, so discard it first; this leaves \(k^*\) unchanged). The shuffle takes \(O(n)\) time (Fisher-Yates).

(a) A clause with \(\ell \ge 1\) terms on distinct variables is false only when all \(\ell\) independent terms are false, so with \(Z\) the number of satisfied clauses, linearity of expectation gives

\begin{equation*} E[Z] = \sum_{j=1}^{k} \left(1 - 2^{-|C_j|}\right) \ge \sum_{j=1}^{k} \tfrac12 = \tfrac{k}{2}. \end{equation*}

Example: the two clauses \(\{x_1\}\) and \(\{\overline{x_1}\}\) (\(k = 2\)). Every assignment makes exactly one of them true, so at most \(1 = k/2\) clause can be satisfied.

(b) Independently, set \(x_i\) true with probability \(0.6\) if \(\{x_i\}\) is a clause, false with probability \(0.6\) if \(\{\overline{x_i}\}\) is a clause, and true with probability \(1/2\) otherwise (no conflicting pairs, so at most one of the first two cases applies).

Under this rule every single term is false with probability at most \(0.6\): a term is false with probability \(0.4\) if it agrees with a unit clause, \(0.6\) if it is the negation of a unit clause’s term, and \(0.5\) if its variable has no unit clause. Hence: (i) A single-term clause \(\{t\}\) has \(t\) biased in its favour, so \(\Pr[\text{satisfied}] = 0.6\). (ii) A clause with \(\ell \ge 2\) terms is false only if all of its terms are false. These involve distinct, independently set variables, so \(\Pr[\text{satisfied}] \ge 1 - 0.6^{\ell} \ge 1 - 0.36 = 0.64\).

By linearity of expectation, \(E[Z] \ge 0.6k\).

(c) First remove the conflicts, then run (b). For each variable \(x_i\), let \(a_i\) be the number of copies of the clause \(\{x_i\}\) and \(b_i\) the number of copies of \(\{\overline{x_i}\}\). If \(a_i, b_i \ge 1\), delete the \(\min(a_i, b_i)\) copies of whichever unit clause is less frequent (break ties arbitrarily). Let \(t = \sum_i \min(a_i, b_i)\) be the total number of deleted clauses. The remaining \(k - t\) clauses contain no conflicting pair. Run the algorithm of (b) on them and output the resulting assignment for the original instance.

For each variable \(i\), pair the \(\min(a_i, b_i)\) deleted clauses with the same number of copies of the opposite unit clause. This gives \(t\) disjoint pairs \(\{x_i\}, \{\overline{x_i}\}\), and every assignment falsifies exactly one clause of each pair, so

\begin{equation*} \mathrm{OPT} \le k - t. \end{equation*}

Deleted clauses that happen to be satisfied only increase the count. Applying (b) to the conflict-free instance with \(k - t\) clauses therefore gives

\begin{equation*} E[Z] \ge 0.6\,(k - t) \ge 0.6\,\mathrm{OPT}. \end{equation*}

Counting and deleting unit clauses is one pass over the input and sampling is \(O(n)\), so the algorithm runs in linear time.

Repeatedly delete a node of minimum degree in the current induced subgraph until \(k\) nodes remain; this deterministic peeling never lowers the edge density \(|E(G[X])|/\binom{|X|}{2}\).

X = V
while |X| > k:
    v = a node of minimum degree in G[X]
    X = X - {v}
return X

If \(k \le 1\) (or \(n \le 1\)) the required bound is \(0\) and any \(k\)-set works, so assume \(k \ge 2\). We prove by induction on the number of deletions that

\begin{equation*} |E(G[X])| \ \ge\ \frac{m\,|X|(|X|-1)}{n(n-1)}, \end{equation*}

which holds with equality at the start (\(X=V\)). Suppose it holds for a set \(X\) with \(|X| = N > k\), so \(N \ge 3\), and let \(M = |E(G[X])|\). The degrees in \(G[X]\) sum to \(2M\), so the minimum degree is at most \(2M/N\), and deleting that node \(v\) leaves

\begin{equation*} \begin{aligned} |E(G[X - \{v\}])| &\ge M - \frac{2M}{N} = M\,\frac{N-2}{N} \\ &\ge \frac{m\,N(N-1)}{n(n-1)}\cdot\frac{N-2}{N} = \frac{m\,(N-1)(N-2)}{n(n-1)}, \end{aligned} \end{equation*}

which is the invariant for the set of size \(N-1\) (we used \(N-2 > 0\)). Once \(|X| = k\) the invariant is exactly the required bound.

Running time: there are \(n-k\) rounds. Keep each node’s degree in the current \(G[X]\); a round finds the minimum in \(O(n)\) time, and deleting \(v\) lowers its neighbours’ degrees in \(O(\deg v)\) time. The total is \(O(n^2 + m)\), which is polynomial.

Refuse the first \(n/2\) bids, and let \(M\) be the largest of them. Then accept the first later bid that is larger than \(M\). If no such bid arrives, the item is not sold.

The seller wins on the event

\begin{equation*} E = \{\text{the 2nd-highest bid is among the first } n/2, \text{ and the highest is among the last } n/2\}. \end{equation*}

On \(E\), \(M\) is the second-highest bid overall. So the only bid after position \(n/2\) that beats \(M\) is the highest bid, and the strategy accepts exactly that bid.

Because the order is uniformly random, the second-highest bid lands in the first half with probability \(\frac{n/2}{n}\). Given that, the highest bid is equally likely to be in any of the remaining \(n-1\) positions, and \(n/2\) of those are in the second half. Hence

\begin{equation*} \begin{aligned} \Pr[\text{accept the highest bid}] \ge \Pr[E] &= \frac{n/2}{n}\cdot\frac{n/2}{n-1} \\ &= \frac{n}{4(n-1)} > \frac14 . \end{aligned} \end{equation*}

If \(X\) counts the updates, \(E[X] = H(n) = \sum_{k=1}^{n} 1/k\), so \(\ln(n+1) < E[X] < 1 + \ln n\) by (13.10); it depends only on \(n\), not on the bid values.

Write the bids in decreasing order. For \(k = 1, \dots, n\), let \(X_k\) be the indicator that the agent whose bid is the \(k\)-th largest causes an update, and let \(X = \sum_k X_k\) count the updates. That agent updates \(b^*\) exactly when its bid is larger than everything seen before it. Since all bids are positive and \(b^*\) starts at \(0\), this happens exactly when it arrives before each of the \(k-1\) agents with larger bids. The arrival order is uniformly random, so its restriction to these \(k\) agents is also uniform, and each of the \(k\) is equally likely to come first. By linearity of expectation (13.8),

\begin{equation*} \begin{aligned} E[X] &= \sum_{k=1}^{n} E[X_k] = \sum_{k=1}^{n} \Pr[\text{rank-}k\text{ agent precedes the } k-1 \text{ higher ones}] \\ &= \sum_{k=1}^{n} \frac{1}{k} = H(n). \end{aligned} \end{equation*}

The limits are \(\frac1e\), \(\frac1e\) and \(\frac3e - 1 \approx 0.104\).

Let \(X_j\) be the number of jobs sent to machine \(j\); each job lands on \(j\) independently with probability \(\frac1k\), so

\begin{equation*} \begin{aligned} p_0 &= \Pr[X_j = 0] = \left(1 - \tfrac1k\right)^k, \\ p_1 &= \Pr[X_j = 1] = k \cdot \tfrac1k \left(1 - \tfrac1k\right)^{k-1} \\ &= \left(1 - \tfrac1k\right)^{k-1}, \end{aligned} \end{equation*}

and both \(p_0 \to \frac1e\) and \(p_1 \to \frac1e\) as \(k \to \infty\) by (13.1).

(a) By Linearity of Expectation (13.8) over the indicators of the events \(X_j = 0\), \(N(k) = k p_0\), so \(N(k)/k = p_0 \to \frac1e\).

(b) Machine \(j\) rejects \(\max(X_j - 1, 0) = X_j - 1 + [X_j = 0]\) jobs. Since \(\sum_j X_j = k\),

\begin{equation*} R(k) = \sum_{j=1}^k E\big[X_j - 1 + [X_j = 0]\big] = k - k + k p_0 = N(k), \end{equation*}

so \(R(k)/k = p_0 \to \frac1e\).

(c) Machine \(j\) rejects \(\max(X_j - 2, 0) = X_j - 2 + 2[X_j = 0] + [X_j = 1]\) jobs (check the cases \(X_j = 0, 1, \ge 2\)), so by (13.8)

\begin{equation*} \begin{aligned} \frac{R_2(k)}{k} &= \frac{k - 2k + 2k p_0 + k p_1}{k} = 2p_0 + p_1 - 1 \\ &\longrightarrow \frac2e + \frac1e - 1 = \frac3e - 1. \end{aligned} \end{equation*}

Take nodes \(s, t, v_1, \dots, v_n\) with one edge \((s, v_i)\) and two parallel edges \((v_i, t)\) for each \(i\) (a multigraph, as in the Contraction Algorithm of Section 13.2); the method then succeeds with probability exactly \((2/3)^n\).

Cuts: if \(S\) is the \(s\)-side, each \(v_i \in S\) contributes its \(2\) edges to \(t\) and each \(v_i \notin S\) contributes its \(1\) edge to \(s\), so

\begin{equation*} c(S) = n + |S \cap \{v_1, \dots, v_n\}|, \end{equation*}

and the unique minimum \(s\)-\(t\) cut is \(S = \{s\}\), of capacity \(n\).

The process: there are no edges between the \(v_i\), so every contraction merges some uncontracted \(v_i\) into the supernode \(s\) or into the supernode \(t\); its remaining edges then join \(s\) to \(t\) and are deleted. After \(n\) contractions only \(s\) and \(t\) remain, and the cut returned is \(\{s\}\) together with the \(v_i\) merged into \(s\). Hence the method finds the minimum cut iff every contraction uses an edge to \(t\). When \(m\) of the \(v_i\) are uncontracted, the remaining edges are \(m\) edges to \(s\) and \(2m\) edges to \(t\), so the chosen edge goes to \(t\) with probability \(\frac{2m}{3m} = \frac23\), independently of the history. Therefore

\begin{equation*} \Pr[\text{min } s\text{-}t \text{ cut found}] = \left(\tfrac23\right)^n, \end{equation*}

which is exponentially small in the number \(n + 2\) of nodes.

Take \(c = \sqrt{2/\varepsilon}\).

Write \(D = X_1 - X_2 = \sum_{j=1}^{2n} Y_j\), where \(Y_j = +1\) if ball \(j\) goes to bin 1 and \(Y_j = -1\) otherwise. The \(Y_j\) are independent with \(E[Y_j] = 0\) and \(Y_j^2 = 1\), so by Linearity of Expectation (13.8)

\begin{equation*} E[D^2] = \sum_{j} E[Y_j^2] + \sum_{j \ne l} E[Y_j]\,E[Y_l] = 2n. \end{equation*}

Since \(D^2 \ge c^2 n \cdot [D^2 > c^2 n]\) pointwise, taking expectations (Markov’s inequality) gives

\begin{equation*} \begin{aligned} \Pr\left[X_1 - X_2 > c\sqrt n\right] &\le \Pr\left[D^2 > c^2 n\right] \\ &\le \frac{E[D^2]}{c^2 n} = \frac{2}{c^2} = \varepsilon, \end{aligned} \end{equation*}

for every \(n \ge 1\).

(a) For every odd \(n \ge 3\), take disjoint sets \(A, B, C\) of \(n\) processes each, \(P = A \cup B \cup C\), and jobs \(P_1 = A \cup B\), \(P_2 = B \cup C\), \(P_3 = A \cup C\), \(P_4 = \dots = P_n = A \cup B\); each has exactly \(2n\) processes. If \(a, b, c\) are the numbers of processes of \(A, B, C\) placed on \(M_1\), perfect balance of \(J_1, J_2, J_3\) requires

\begin{equation*} \begin{aligned} a + b = b + c = a + c = n &\Longrightarrow 2(a + b + c) = 3n \\ &\Longrightarrow a = b = c = \tfrac n2, \end{aligned} \end{equation*}

impossible for odd \(n\).

(b) Assign every process to \(M_1\) or \(M_2\) independently with probability \(\frac12\) each, check every job, and repeat until the assignment is nearly balanced; this is a Las Vegas algorithm, so its output is always correct.

Fix a job \(J_i\) and let \(X\) be the number of its \(2n\) processes on \(M_1\), a sum of \(2n\) independent 0-1 variables with \(E[X] = n\). By the Chernoff bound (13.42) with \(\mu = n\) and \(\delta = \frac13\),

\begin{equation*} \Pr\left[X > \tfrac43 n\right] < \left[\frac{e^{1/3}}{(4/3)^{4/3}}\right]^n < 0.951^n, \end{equation*}

and the same bound holds for \(2n - X\), the count on \(M_2\). A union bound over the \(n\) jobs and two machines gives