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 yes

no 8 = =

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 = O 1 + O A * A + O B * B E = G 1 + G A * A + G B * B E-B = O 1 + O A * A + (O B -1)*B E-B = G 1 + G A * A + (G B -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 (  A) E  (B-1)*A + (A-1) = A*B-1

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

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 = O 1 + O A * A E = G 1 + G A * A + G B * B E-A = O 1 + (O A -1)* A E-A = G 1 + (G A -1)* A + G B *B

LEMMA: optimal solution for the smallest counterexample doesn’t contain 1 E = O 1 + O A * A E = G 1 + G B * B E-1 = (O 1 -1)+ O A * A E-1 = (G 1 -1)+ + G B * B

LEMMA: If there exists a counterexample, then there exists a counterexample E = O A * A E = G 1 + G B * B with O A <B and G 1 <A

LEMMA: If there exists a counterexample, then there exists a counterexample E = O A * A E = G 1 + G B * B with O A <B and G 1 <A with G B = 1

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

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

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

SG S SGG 1/3 2/3

M[i,j] = min { P[j] + min M[k,j] + M[i-k,j] P[i] + min M[i,k] + M[i,j-k] 1  k  i-1 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  m 1 * n and m 2 * n, by IH (m 1 *n – 1) + (m 2 * n – 1 ) + 1 = m * n -1

binary search tree depth  running time INSERT DELETE SEARCH

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

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

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 INSERT(T,26)

B-tree - insert INSERT(T,26)

B-tree - insert INSERT(T,26)

B-tree - insert INSERT(T,26) 27

B-tree - insert INSERT(T,28) 27 full leaf

B-tree - insert INSERT(T,28) 27 full leaf

B-tree - insert INSERT(T,28) 27 full leaf

B-tree - insert INSERT(T,28) 27 full leaf

B-tree - insert INSERT(T,28) 27 full leaf

B-tree - insert INSERT(T,28) 27 full leaf

B-tree - insert INSERT(T,28) 27 full leaf 28

B-tree - insert INSERT(T,26) split proactively

B-tree - insert INSERT(T,26) split proactively

B-tree - insert INSERT(T,26) split proactively

B-tree - insert INSERT(T,26) split proactively

B-tree - insert INSERT(T,26) split proactively

B-tree - insert INSERT(T,26) split proactively 2627

B-tree - insert INSERT(T,28) split proactively 2627

B-tree - insert INSERT(T,28) split proactively

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

B-tree - delete DELETE(T,28)

B-tree - delete DELETE(T,28) leaf deletion

B-tree - delete DELETE(T,27) leaf deletion ?