Fractional Cascading

•Fractional Cascading I: A Data Structuring Technique•Fractional Cascading II: Applications

[Chazaelle & Guibas 1986]•Dynamic Fractional Cascading [Mellhorn & Naher 1990]

Elik Etzion January 2002

AgendaPreviewFormal problem definition & Final resultsExample ApplicationIntersecting a polygonal path with a line

Data structure & Algorithm descriptionTime & Space complexity analysisDynamization

PreviewThe problem: Iterative search in sorted listsExamples:

Look up a word in different dictionariesGeometric retrieval problems

The solution: Fractional Cascading Correlate the lists in a way that every search uses the results of the previous search

Formal DefinitionU – an ordered setG = (V,E) – Catalog Graph

undirectedfor each v V C(v) U catalog of vFor each e E R(e) = [ l(e) , r(e) ] range of elocally bounded degree d v V and k U there are at most d edges e = (v,w)

with k R(e)[2,7]

[22,50]

[20,27]

Degree = 4Locally bounded degree = 2[5,15]

Formal Definition - operations

QueryInput : k U , G` = (V`,E`) connected sub-tree of G , e E` k R(e)Outputfor each v V` x C(v) such that x is the successor of k in C(v)

Deletiongiven a key k C(v) and its position in C(v), delete k from C(v)

Insertiongiven a key kU and its successor in C(v), insert k into C(v)

Results

n |V| ,

Space: O(N + |E|) Time:

Vv

vCN |)(|

Query Insert / Delete

Trivial nlogN 1

Static/Semi-

Dynamic

log(N + |E|) + n 1

Dynamic log(N + |E|) + nloglog (N + |E|)

nloglog (N + |E|)amortized

Example application

ProblemInput: Polygonal path P, Arbitrary query line lOutput: intersections of P & l

Solution complexityTrivial space: O(n)

time: O(n)Using FC space: O(nlogn)

time: O((k+1)log[n/(k+1)])

k – number of intersections reported

Example application - Solution

Observation: a straight line l intersects a polygonal path P if and only if l intersects the convex hull CH(p) of P

Notation: F(p) & S(p) – first & second half path of P

Preprocessing:

CH[F(P)]CH[S(P)]

CH[P]

Example application - Algorithm

Intersect( P , l ) {

if |P| = 1 then compute P l directly

else if l doesn’t intersect CH(p) then exitelse{

Intersect ( F(p) , l )Intersect ( S(p) , l )

}}

Example application - Algorithm

Convex hull intersection algorithm:Find the 2 slopes of l in the slope sequence of CH

FC view:Catalog graph: pre-processed CH binary treeCatalogs: slope sequence of the the CHsThe query key: 2 slopes of l

Example application - Complexity

SpaceO(nlogn) - each edge participates in at most logn CHs

Time (static)O(logn + size of sub tree actually visited)O((k+1)log[n/(k+1)])

Data Structure – Illustration

w

v

20 23 48 62 70 80 87 91

20 34 90 95 99

[l,r] l bridge r bridge

y’

x’ x

y

B(x,y)

A(w)

A(v)

- non proper- proper

y.count

x.count

99

75

Data Structure - Definitions

For each node vA(v) C(v) – augmented catalogimplemented as a doubly linked list of recordsC(v) contains proper elementsA(v) – C(v) contains non-proper elements

Record members:key, next, prev, kind

special n.p members:target – node of G incident to vpointer – pointer to a np element in A(x.target) (the other end of the bridge)count – number of elements until the previous bridgein_S – is in a non- balanced block

Bridges & Blocks

(x,y)- a bridge between nodes v & wx A(v) – C(v)y A(w) – C(w)x.pointer = y y.pointer = x x.target = w y.target = vx.key = y.keyx.kind = y.kind = non-proper

Every edge e(v,w) has at list 2 bridgesx.key=y.key = l(e) , x.key = y.key = r(e) Block B(x,y) A(v) A(w)the elements between (x,y) bridge and its neighbor bridge between v & w|B(x,y)| = x.count + y.count

FCQuery

FCQuery (G, G’, k ) (V1, V2 .. Vn) = order of nodes in G’aug_succ = BinarySearch( A(V1), k )successor[1] = FindProper(A(V1), aug_succ)for i = 2 .. n

aug_succ = FCSearch(Vi, k, succssesor[i-1])

successor[i] = FindProper(A(Vi), aug_succ)return successor[1..n]

FCSearch & FindProper

FCSearch ( w, k, x ) x’ = xwhile x’.target != w do x1 = x’.nexty = x’.pointerWhile y.pred.key k do y= y.predreturn y

FindProper in the static caseimplemented in O(1) time using a pointer

from each non-proper element to its proper successor

Block Size

Tradeoff Small blocks increase space complexity but decrease time complexityLarge blocks increase time complexity but decrease space complexity

Block InvariantThere are tow constants a, b with a b such that for all blocks B(x,y) holds: |B(x,y)| b |B(x,y)| a or B(x,y) is the only block between A(x.target) and A(y.target)

Block Lemma

Let

da

vAS

vCN

Vv

Vv

3

|)(|

|)(|

Then |S| 3N+12|E|

Proof …

Complexity Analysis (static)

Space Linear in the size of the catalog graph according to the Block LemmaTime

FindProper O( 1 )

FCSearchO( 1 ) block size is constant

BinarySearch O ( log(|A(V1)|) ) = O ( log(N + |E|) )

FCQuery – O (log(N + |E|) + n )

Dynamization

ChallengesFindProper can’t be implemented simply by using a pointer from each non-proper element to its proper successorInsertions & Deletions violate the Block Invariant

SolutionData Structure based onVan Emde Boas Priority QueueBlock rebalancing

Union- Split DS

FindProperInput: a pointer to some item xOutput: a pointer to a proper item y such that all the items between x & y are non-proper ( y is the proper successor of x)

ADDInput: a pointer to some item xEffect: adds a non-proper item immediately before x

EraseInput: a pointer to a non-proper item xDelete x

Union Input: a pointer to a non-proper item xEffect: change the mark of x to proper

SplitInput: a pointer to a proper item xEffect: change the mark of x to non-proper

Insert – Illustrationy0 y

B(y,z)

A(v)

A(w)

y’

z

A(u)

z’

B(y’,z’)

x

Insert AlgorithmInsert (x , y0)

ADD( x , y0 )if x.kind = proper then UNION(x)insert x into the doubly linked list before y0

y = y0 , A = do b times

w = y.targetif ( y.kind = non-proper and wA and x.key R(v,w) )A = A {w} y.count++z = y.pointerif ( y.In_S = false and y.count + z.count > b)S = S {B(y,z)}y.In_s = true , z.In_S = truey = y.next

Delete AlgorithmDelete (x)

if x.kind = proper then SPLIT(x)DELETE(x)remove x from the doubly linked y = x.next , A = do b times

w = y.targetif ( y.kind = non-proper and wA and x.key R(v,w) )

A = A {w} y.count--z = y.pointerif ( y.In_S = false and y.count + z.count < a and

B(z,y) isn’t the only block between v and w )S = S {B(y,z)}y.In_s = true , z.In_S = true

y = y.next

Balance AlgorithmFor each block B(x,y) S do

l = compute the size of B(x,y) by running to the previous parallel bridge [ O(l) ]

if ( l > b)divide B(x,y) into 3l/b + 1 parts by inserting 2* 3l/b non-proper elements [6l/b O(INSERT) ]

else if ( l < a )concatenate B(x,y) with its right neighbor block B(x’,y’)

by deleting the (x,y) bridge [O(ERASE)]

check if B(x’,y’) S by scanning b elements until reaching the (x’,y’) bridge and checking x’.In_s flag [O(b)]

// if not reached then B(x’,y’) S if B(x’,y’) S

x’.count += x.count , y’.count += y.count if (x’.count > b) S = S {B(x’,y’)}

else S = S – B(x,y)

Complexity Analysis (Dynamic)

Union – Split DS for n elements complexitySpace: o (n)Time : FIND, Union & split: O(loglogn) worst case

ADD, Erase: O(loglogn) amortized ADD/ ERASE in semi-dynamic: O(1)

FC complexitySpace: Remains Linear in the size of the catalog graph because the block invariant is kept by rebalancingTime:FindProper: O( log log(N + |E|) )FCSearch: O( 1 ) BinarySearch O ( log(N + |E|) )FCQuery – O (log(N + |E|) + n log log(N + |E|) )Insert/Delete - O( log log(N + |E|) ) or O (1) or semi-dynamicBalance – O ( log(N + |E|) ) amortized (complex proof)