Treaps

Review:

• Dictionaries for ordered sets
• Binary tree.
• Tree balancing by rotations
• drawbacks in geometry: rebuild on rotation

Returning to average case:

• Assign random ``arrival orders'' to keys
• Build tree as if arrived in that order
• Average case applies
• No rotations on searches

Choosing priorities

• define arrival by random priorities
• assume continuous distribution, fix.
• eg, use 2 log n bits, w.h.p. no collisions

Treaps.

• tree has keys in heap order of priorities
• unique tree given priorities--follows from insertion order
• implement insert/delete etc.
• rotations to maintain heap property

Depth d (x) analysis

• Tree is trace of a quicksort
• We proved O(log n) w.h.p.
• for x rank k, E[d (x)] = H_k + H_{n - k + 1} - 1
• S^- = {y $\in$S | y$\le$x}
• Q_x = ancestors of x
• Show E[Q^-_x] = H_k.
• to show: y $\in$Q_x^- iff inserted before all z, y < z$\le$x.
• deduce: item j away has prob 1/j. Add.
• Suppose y $\in$Q_x^-.
• The inserted before x
• Suppose some z between inserted before y
• Then y in left subtree of z, x in right, so not ancestor
• Thus, y before every z
• Suppose y first
• then x follows y on all comparisons (no z splits
• So ends up in subtree of y

Rotation analysis

• Insert/Delete time
• define spines
• equal left spine of right sub plus right spine of left sub
• proof: when rotate up, on spine increments, other stays fixed.
• R_x length of right spine of left subtree
• E[R_x] = 1 - 1/k if rank k
• To show: y $\in$R_x iff
• inserted after x
• all z, y < z < x, arrive after y.
• if z before y, then y goes left, so not on spine
• deduce: if r elts between, r! of (r + 2)! permutations work.
• So probability 1/r².
• Expectation $\sum$1/(1 ^. 2) + 1/(2 ^. 3) + ^... = 1 - 1/k
• subtle: do analysis only on elements inserted in real-time before x, but now assume they arrive in random order in virtual priorities.

skip lists

• ruler intuition
• achieve with geometric variables
• backwards analysis of search path
• insert/delete time

Shortest Paths

classical shortest paths.

• dijkstra's algorithm
• floyd's algorithm. similarity to matrix multiplication

Matrices

• length 2 paths by squaring
• matrix multiplication. strassen.
• shortest paths by ``funny multiplication.''
• huge integer implementation
• base-(n + 1) integers

Boolean matrix multiplication

• easy.
• gives objects at distance 2.
• gives n-mul algorithm for problem
• what about recursive?
• well can get to within 2: let T_k be boolean ``distance less than or equal to 2^k. Squaring gives T_{k + 1}.
• what about exact?

Seidel's distance algorithm.

• log-size integers:
• parities suffice:
• square G to get adjacency A', distance D'
• if D_ij even then D_ij = 2D'_ij
• if D_ij odd then D_ij = 2D'_ij - 1
• For neighbors i, k,
• D_ij - 1$\le$D_kj$\le$D_ij + 1
• exists k, D_kj = D_ij - 1
• Parities
• If D_ij even, then D'_kj$\ge$D'_ij for every neighbor k
• If D_ij odd, then D'_kj$\le$D'_ij for every neighbor k, and strict for at least one
• Add
• D_ij even iff S_ij = $\sum_{k}^{}$D'_kj$\ge$D_ijd (i)
• D_ij odd iff $\sum_{k}^{}$D'_kj < D_ijd (i)
• How determine? find S = AD'

To find paths: Witness product.

• easy case: unique witness
• multiply column c by c.
• read off witness identity
• reduction to easy case:
• suppose r columns have witness, where 2^k$\le$r$\le$2^{k + 1}
• choose each column with probability 2^-k.
• prob. exactly one witness: r ^. 2^-k(1 - 2^-k)^{r - 1}$\ge$(1/2)(1/e²)

Mod 3:

• Recall some neighbor distance down by one
• so compute distances mod 3.
• suppose D_ij = 1 mod 3
• then look for k neighbor of i such that D_kj = 0 mod 3
• let D_ij^(s) = 1 iff D_ij = s mod 3
• than AD^(s) has ij = 1 iff a neighbor k of i has D_kj^(s)
• so, witness matrix mul!