1. Static Dictionaries Collection of items. Each item is a pair.
(key, element)
Pairs have different keys.
Operations are:
initialize/create
get (search)
Each item/key/element has an estimated access frequency (or probability).
Consider binary search tree only.

2. Example Key Probability a 0.8 b 0.1 c a < b < c a b b a c c
Cost of a search equals number of key comparisons.
Cost = 0.8 * * * 3
= 1.2
Cost = 0.8 * * * 2
= 1.9

3. Search Types Successful. Unsuccessful.b c f1 f2 f3
Successful.
Search for a key that is in the dictionary.
Terminates at an internal node.
Unsuccessful.
Search for a key that is not in the dictionary.
Terminates at an external/failure node.

4. Internal And External Nodesf0 a b c f1 f2 f3
A binary tree with n internal nodes has n + 1 external nodes.
Let s1, s2, …, sn be the internal nodes, in inorder.
key(s1) < key(s2) < … < key(sn).
Let key(s0) = –infinity and key(sn+1) = infinity.
Let f0, f1, …, fn be the external nodes, in inorder.
fi is reached iff key(si) < search key < key(si+1).

5. Cost Of Binary Search Tree
Let pi = probability for key(si).
Let qi = probability for key(si) < search key < key(si+1).
Sum of ps and qs = 1.
Cost of tree = S0 <= i <= n qi (level(fi) – 1)
+ S1<= i <= n pi * level(si)
Cost = weighted path length.
Note that Huffman trees minimize the weighted external path length. Now we want to minimize the sum of weighted external path length and weighted internal path length.

6. Brute Force Algorithm
Generate all binary search trees with n internal nodes.
Compute the weighted path length of each.
Determine tree with minimum weighted path length.
Number of trees to examine is O(4n/n1.5).
Brute force approach is impractical for large n.

7. Dynamic Programming Keys are a1 < a2 < …< an.
Let Ti j= least cost tree for ai+1, ai+2, …, aj.
T0n= least cost tree for a1, a2, …, an. a3 a5 a6 a7 a4 f2 f3 f5 f4 f7 f6
T2,7
Ti j includes pi+1, pi+2, …, pj and qi, qi+1, …, qj.

8. Terminology Ti j= least cost tree for ai+1, ai+2, …, aj.
ci j= cost of Ti j
= Si <= u <= j qu (level(fu) – 1)
+ Si < u <= j pu * level(su).
ri j= root of Ti j.
wi j= weight of Ti j
= sum of ps and qs in Ti j
= pi+1+ pi+2+ …+ pj + qi + qi+1 + … + qj

9. i = j Ti j includes pi+1, pi+2, …, pj and qi, qi+1, …, qj.
Ti i includes qi only. fi
Tii
ci i = cost of Ti i = 0.
ri i = root of Ti i = 0.
wi i = weight of Ti i
= sum of ps and qs in Ti i
= qi

10. i < j Ti j= least cost tree for ai+1, ai+2, …, aj.
Ti j includes pi+1, pi+2, …, pj and qi, qi+1, …, qj.
Let ak, i < k <= j, be in the root of Ti j. ak L R
Ti j
L includes pi+1, pi+2, …, pk-1 and qi, qi+1, …, qk-1.
R includes pk+1, pi+2, …, pj and qk, qk+1, …, qj.

11. cost(L) L includes pi+1, pi+2, …, pk-1 and qi, qi+1, …, qk-1.
cost(L) = weighted path length of L when viewed as a stand alone binary search tree.

12. Contribution To cij Ti j ci j = Si <= u <= j qu (level(fu) – 1)ak L R
Ti j L
ci j = Si <= u <= j qu (level(fu) – 1)
+ Si < u <= j pu * level(su).
When L is viewed as a subtree of Ti j , the level of each node is 1 more than when L is viewed as a stand alone tree.
So, contribution of L to cij is cost(L) + wi k-1.

13. cij Ti j Contribution of L to cij is cost(L) + wi k-1.ak L R
Ti j
Contribution of L to cij is cost(L) + wi k-1.
Contribution of R to cij is cost(R) + wkj.
cij = cost(L) + wi k-1 + cost(R) + wkj + pk
= cost(L) + cost(R) + wij

14. cij Ti j cij = cost(L) + cost(R) + wij cost(L) = cik-1 cost(R) = ckjak L R
Ti j
cij = cost(L) + cost(R) + wij
cost(L) = cik-1
cost(R) = ckj
cij = cik-1 + ckj + wij
Don’t know k.
cij = mini < k <= j{cik-1 + ckj} + wij

15. cij Ti j cij = mini < k <= j{cik-1 + ckj} + wijak L R
Ti j
cij = mini < k <= j{cik-1 + ckj} + wij
rij = k that minimizes right side.

16. Computation Of c0n And r0n
Start with ci i = 0, ri i = 0, wi i = qi, 0 <= i <= n (zero-key trees).
Use cij = mini < k <= j{cik-1 + ckj} + wij to compute cii+1, ri i+1, 0 <= i <= n – 1 (one-key trees).
Now use the equation to compute cii+2, ri i+2, 0 <= i <= n – 2 (two-key trees).
Now use the equation to compute cii+3, ri i+3, 0 <= i <= n – 3 (three-key trees).
Continue until c0n and r0n(n-key tree) have been computed.

17. Computation Of c0n And r0n
cij, rij, i <= j 1 2 3 4

18. Complexity cij = mini < k <= j{cik-1 + ckj} + wij
O(n) time to compute one cij.
O(n2) cijs to compute.
Total time is O(n3).
May be reduced to O(n2) by using
cij = min ri,j-1 < k <= ri+1,j{cik-1 + ckj} + wij

19. Construct T0n Root is r0n. Suppose that r0n = 10. T0n T09 T10,n
Construct T09 and T10,n recursively.
Time is O(n).