Dynamic Programming--notes

Introduction, and WIS in Path Graphs
1. Problem Statement
1.1 Input: A path graph $G=(V, E)$ with nonnegative weight on vertices.
1.2 Desired output: Subset of nonadajacent vertices -an independent set –of maximmum total weight.
Next: Iterate through our algorithm design principles.
Brute-force search: Requires exponential time.
2. A Greedy Approach
2.1 Greedy: Iteratively choose the max-weight vertex not adjacent to any previously chosen vertex.
2.2 A Divide & Conquer Approach
Idea: Recursively compute the max-weight IS of 1st half, ditto(同上) for 2nd half, then combine the solutions.
3. Optimal Substructure
3.1 Critical step: Reason about structure of an optimal solution.
[In terms of optimal solutions of smaller subproblems]
3.2 Motivation: This thought experiment narrows down the set of candidate for the optimal solution; can search through the small set using brute-force-search
Notation: Let $S \subseteq V$ be a max-weight independent set(IS). Let $v_n=$ last vertex of path.
3.2 A Case Analysis
case1: Suppose $v_n \notin S$. Let $G' = G$ with $v_n$ deleted.
Note: $S$ also an IS of $G'$.
Note: $S$ must be a max-weight IS of $G'$.
Case2: Suppose $v_n \in S$.
Note: Previous vertex $v_{n-1} \notin S$[by definition of an IS]. Let $G'' =G$with $v_{n-1},v_n$ deleted.
Note: $S - \{ v_n\}$ is an IS of $G''$.
Note: Must in fact be a max-weight IS of $G''$ .
4. Toward an Algorithm
Upshot: A max-weight IS must be either
(i) a max-weight IS of $G'$ or.
(ii) $v_n$ + a max-weight IS of $G''$.
Corollary: f we knew whether or not $v_n$ was in the max-weight IS, could recursively compute the max-weight IS of $G''$ and be done.
(Crazy ?) idea: Try both possibilities + return the better solution.
5. The Story So far
5.1 Uprshot: If we know whether or not $v_n$ is in the max-weight IS, then could recursively compute the max-weight IS of $G'$ or $G''$ and be done.
Proposed algorithm:
$-$ Recursively compute $S_1$ = max-weight IS of $G'$.
$-$ Recursively compute $S_2$ = max-weight IS of $G''$.
$-$ Return $S_1$ or $S_2 \cup \{v_n\}$ ,whichever is better.
Good news: Correct.
Bad news: Exponential time.
5.2 Eliminating Redundancy
Obvious fix: The first time you solve a subproblem cache its solution in a global table for $O(1)$-time lookup later on.[memoization]
Even better: Reformulate as a bottom-up iterative algorithm. Let $G_i$ = 1st vertices of G.
Plan: Populate array A left to right with A[i] = value of max-weight IS of $G_i$.
Initialization: A[0] = 0, A[1] = $w_1$
Main loop: For $i = 2,3,...,n$:
$A[i]$ = max $\{ A[i-1], A[i-2] + w_i \}$
Run time: Obviously $O(n)$.

A Reconstruction Algorithm
Let A = filled-in array.
$-$ Let $S = \emptyset$
$-$ While $i \geq 1$
$--$ If $A[i-1] \geq A[i-2] + w_i$
$---$ Decrease $i$ by 1
$--$ Else
$----$ Add $v_i$ to $S$, decrease $i$ by 2
$-$ Return $S$
Claim: Final output S is a max-weight IS of G.
Principles of Dynamic Programming
Fact: Our WIS algorithm is a dynamic programming algorithm!
Key ingredients of dynamix programming:
(1) Identify a small number of subroblems.
[e..g., compute the max-weight IS of $G_i$ for $i=0,1,,,,n$]
(2) Can quickly + correctly solve “larger” subproblems given the solutions to “smaller subproblems”.
[Usually via a recurrence such as A[i] = max {A[i-1], A[i-2] + $W_i$}]
(3) After solving all subproblems, can quickly compute the final solution.
[Usually, it’s just the answer to the “biggest” subproblem].