yes
optimal solution minimizing number of $3’s
($3 + $3  $5 + $1)
has at most one $3
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
($4 + $4  $7 + $1)
has at most one $4
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
E = G1
+ OA * A
+ 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
1/3
G
1/3
G
1/3
S
S
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
1
3 4
7
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 27
INSERT(T,26)
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
INSERT(T,28)
full leaf
B-tree - insert
10 20 30
23 24 29
25 26 27
INSERT(T,28)
full leaf
B-tree - insert
10 20 30
23 24 29
25 26 27
INSERT(T,28)
full leaf
B-tree - insert 20
10
30
23 24 29
25 26 27
INSERT(T,28)
full leaf
B-tree - insert 20
10
24 30
23
29
25 26 27
INSERT(T,28)
full leaf
B-tree - insert 20
10
24 30
23
26 29
25
INSERT(T,28)
27
full leaf
B-tree - insert 20
10
24 30
23
26 29
25
INSERT(T,28)
27 28
full leaf
split proactively
B-tree - insert
10 20 30
23 24 29
25 27
INSERT(T,26)
B-tree - insert
10
split proactively
20
30
23 24 29
25 27
INSERT(T,26)
B-tree - insert
10
split proactively
20
30
23 24 29
25 27
INSERT(T,26)
B-tree - insert
10
split proactively
20
24 30
23
29
25 27
INSERT(T,26)
B-tree - insert
10
split proactively
20
24 30
23
29
25 27
INSERT(T,26)
B-tree - insert
10
split proactively
20
24 30
23
29
25 26 27
INSERT(T,26)
B-tree - insert
10
split proactively
20
24 30
23
29
25 26 27
INSERT(T,28)
B-tree - insert
10
split proactively
20
24 30
23
26 29
25
INSERT(T,28)
27 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
10
20
24 30
23
26 29
25
DELETE(T,28)
27 28
B-tree - delete
10
leaf deletion
20
24 30
23
26 29
25
DELETE(T,28)
27
B-tree - delete
10
leaf deletion
20
24 30
23
26 29
25
DELETE(T,27)
?
27