optimal solution minimizing number of $3’s has at most one $3

yes optimal solution minimizing number of $3’s has at most one $3 ($3 + $3  $5 + $1) has at most two $1’s ($1+$1+$1  $3) has value at most $4 in $1 and $3 has the same number of $5 as greedy sol

no 8 = 4 + 4 8 = 6 + 1 + 1

yes optimal solution minimizing number of $4’s has at most one $4 ($4 + $4  $7 + $1) has at most three $1’s ($1+$1+$1+$1  $4) has value at most $6 in $1 and $4 has the same number of $7 as greedy sol

MAIN IDEA: if there is a counterexample then there is a small counterexample 1<A<B

LEMMA: optimal solution for the smallest counterexample doesn’t contain B E = O1 + OA * A + OB * B E = G1 + GA * A + GB * B E-B = O1 + OA * A + (OB-1)*B E-B = G1 + GA * A + (GB-1)*B

LEMMA: optimal solution for the smallest counterexample doesn’t contain B copies of A (A+A+...+A  B+B+...+B) A copies of 1 (1+1+...+1  A) E  (B-1)*A + (A-1) = A*B-1

MAIN IDEA: if there is a counterexample then there is a small counterexample THEOREM: if there is a counterexample then there is on with E  A*B-1

for all C  AB-1 find optimum (dynamic programming) check if agrees with greedy

LEMMA: greedy solution for the smallest counterexample doesn’t contain A E = O1 + OA * A E = G1 + GA * A + GB * B E-A = O1 + (OA-1)* A E-A = G1 + (GA-1)* A + GB*B

LEMMA: optimal solution for the smallest counterexample doesn’t contain 1 E = O1 + OA * A E = G1 + GB * B E-1 = (O1-1)+ OA * A E-1 = (G1-1)+ + GB * B

LEMMA: If there exists a counterexample, then there exists a counterexample E = OA * A E = G1 + GB * B with OA <B and G1<A

LEMMA: If there exists a counterexample, then there exists a counterexample E = OA * A E = G1 + GB * B with OA <B and G1<A with GB = 1

polynomial-time solution • check if P= B/A A is a counterexample

check if P= B/A A is a counterexample 6 = 5 + 1 = 2*3 yes 8 = 6 + 1 + 1 = 2*4 no 8 = 7 +1 = 2*4 yes

each measurement has 3 outcomes 3 measurements  27 outcomes N=14  2*14 = 28 outcomes

2/3 S G G G S S 1/3 1/3 1/3

M[i,j] = min { P[j] + min M[k,j] + M[i-k,j] 1ki-1 P[i] + min M[i,k] + M[i,j-k] 1kj-1

K[i,s]  K[i-1,s] if sW[i] and K[i-1,s-W[i]]+V[i]>K[i,s] then K[i,s]  K[i-1,s-W[i]]+V[i]

M(m,n)=m * n - 1 proof: induction on m+n base case m+n=2  m=n=1 ok m * n  m1 * n and m2 * n, by IH (m1*n – 1) + (m2 * n – 1 ) + 1 = m * n -1

binary search tree INSERT DELETE SEARCH 5 4 7 2 depth  running time 1 3

B-tree INSERT DELETE SEARCH 2 5 3 4 7 1 branching factor > 2 * makes balancing easier * efficient for “burst memory” (HDD) uniform depth

B-tree . . . branching factor > 2 * makes balancing easier * efficient for “burst memory” (HDD) 103 . . . 106 109

B-tree every node other than the root has T-1 keys (i.e., T children) every node has  2T-1 keys (i.e., 2T children) if T=2 the number of children is 2,3, or 4

B-tree - insert 10 20 30 23 24 29 25 27 INSERT(T,26)

B-tree - insert 10 20 30 23 24 29 25 26 27 INSERT(T,26)

B-tree - insert 10 20 30 23 24 29 25 26 27 full leaf INSERT(T,28)

B-tree - insert 20 10 24 30 23 26 29 25 27 28 full leaf INSERT(T,28)

B-tree - insert split proactively 10 20 30 23 24 29 25 27 INSERT(T,26)

B-tree - insert split proactively 20 10 24 30 23 29 25 26 27 INSERT(T,26)

B-tree - insert split proactively 20 10 24 30 23 29 25 26 27 INSERT(T,28)

B-tree - insert split proactively 20 10 24 30 23 26 29 25 27 28 INSERT(T,28)

B-tree - insert 2T-1 keys  T-1 and T-1 keys uniform depth – the only operation increasing depth is splitting the root every node other than the root has T-1 keys (i.e., T children) every node has  2T-1 keys (i.e., 2T children)

B-tree - delete 20 10 24 30 23 26 29 25 27 28 DELETE(T,28)

B-tree - delete leaf deletion 20 10 24 30 23 26 29 25 27 DELETE(T,28)

B-tree - delete leaf deletion 20 10 24 30 23 26 29 25 27 DELETE(T,27) ?

optimal solution minimizing number of $3’s has at most one $3