Succinct Representation of Balanced Parentheses, Static Trees and Planar Graphs J. Ian Munro &...
-
Upload
kent-plaskett -
Category
Documents
-
view
218 -
download
2
Transcript of Succinct Representation of Balanced Parentheses, Static Trees and Planar Graphs J. Ian Munro &...
Succinct Representation of Balanced Parentheses , Static Trees and Planar Graphs
J . Ian Munro
&
Venkatesh Raman
Outline
• Introduction
• Balanced Parentheses
• Static Trees– Rooted Ordered Tree
– Binary Trees
• Planar Graphs
• Balanced Parentheses Implementation
Problem
We would like to represent tree with
minimal number of bits , permitting the
regular operations in constant time .
Information limit
Number of trees on n nodes:
or about .
So , at least 2n bits needed ( ignoring
logarithmic terms ) to encode an arbitrary
tree .
)1(2
nn
ncn n
n 2/32
2
2n bit representation
• Do a preorder traversal of the tree– if visit a node for a first time – output “(“– if visit a node for a last time – output “)”
We got a balanced nested parenthesis
sequence .
Example
1 2 33 44 2 55 66 1( ( ( ) ( ) ) ( ) ( ) )
0 0 01 01 1 01 01 1
1
43
2 5 6
Balanced Parentheses Operations
• findclose(i)• findopen(i)• excess(i) - find the difference of the number of open
and close parentheses at position i.
• enclose(i) - given a parenthesis pair , opened at position i , find its closest enclosing matching parenthesis pair.
We will see there implementation in constant time using 2n+o(n) bits …
O(1)
Static Trees – Rooted Ordered Tree
• We use isomorphism between general ordered trees and balanced parenthesis expressions as was described earlier.
• Node represented by its corresponding left parenthesis .
Rooted Ordered Tree ( Cont.)
• parent(i) - is a left parenthesis of enclose(i)
• size of subtree(i) – all nodes between i and findclose(i) , number of nodes is half a difference between them. 1
43
2 5 6
1 2 33 44 2 55 66 1( ( ( ) ( ) ) ( ) ( ) )
( ( ( ) ( ) ) ( ) ( ) )
parent (3):
subtree (2):
Rooted Ordered Tree(Cont)
The i-th child of node x:
1
43
2 5 6
1 2 33 44 2 55 66 1( ( ( ) ( ) ) ( ) ( ) )
• if the parenthesis next to x’s “(“ is “)”, than x has no children.• otherwise “(“ and its matching “)” form the first child.• if the next parenthesis is “(“ together with matching parenthesis match the second child of x and so on ...( ( ( ) ( ) ) ( ) ( ) )1 2 33 44 2 55 66 1
( ( ( ) ( ) ) ( ) ( ) )1 2 33 44 2 55 66 1
( ( ( ) ( ) ) ( ) ( ) )
General ordered tree - conclusion
We can find:
parent , size of subtree in O(1) right (first) or left(last) son of node x in O(1). i-th child of x in O(i)
using 2n+o(n) bits
Static Trees – Binary treesQ: For a node that has only one child ,
how we can distinct is it right or left
son ?
1 1
2 2
A: Use isomorphism between binary
trees and rooted ordered trees.
( ( ) )
Isomorphism example
1
2
7
106
5
8
9
3 4 96 8
10
7
1
0
5
3
2 4
Binary TreeEquivalent Rooted
Ordered Tree
Binary trees ( cont. )
• Ordered root has a root which doesn’t correspond to any node in the binary tree .
• The left child in the binary is the leftmost child in the ordered tree.
• The right child in the binary is the next sibling to the right in the ordered tree.
• The root of the binary is the leftmost child of the root of the ordered tree.
Example – parent(i)
0 1 2 3 3 2 4 4 1 5 6 7 7 6 8 8 9 9 5 10 10 0
( ( ( ( ) ) ( ) ) ) ( ( ) ) ( ) ( ) ) ( ) )
1
2
7
106
5
8
9
3 4
parent 2 parent 9
96 8
10
7
1
0
5
3
2 4
Binary Tree
Example – subtree(i)
0 1 2 3 3 2 4 4 5 5 1 6 6 0
( ( ( ( ) ) ( ) ( ) ) ( ) )
4
1
2 6
5
3
5
1
0
6
3
2 4
subtree 2:
right subtree left subtree
Binary Treeenclose 2
Binary trees ( cont. )
For a given left parenthesis of node x at position i: parent : if i = 1 no parent ( root) if symbol at position i-1 is “(“ than it its parent else findopen(i-1) is its parent. left child : if symbol at position i+1 is “(“. right child : if symbol at position findclose(i)+1 is
“(“. subtree : all nodes in the subtree and its right
siblings.
Binary tree - conclusions
We can find:
parent , size of subtree , left and right child
in O(1) using 2n+o(n) bits
Planar graphs
Definition :
A k-page book embedding of a graph
G=(V,E) is a printing order of V , plus a partition of E into k pages . The edges on a given page must not intersect .
• Planar graphs can be embedded
in four pages .
One-Page Graphs - example
1 2 3 4 5 6 7
() (( () )( () (( () ) () ))( () ))( () )
Parenthesis representation uses 2n+2m bits
adjacent(i,j) - example
1 2 3 4 5 6 7
() (( () )( () (( () ) () ))( () ))( () )
adjacent(i,j) – cont.
() )))) ((( () ))) .... ()
excess i excess i+1#closed #opened
#closed + #opened = degree(i)
#closed - #opened = excess i – excess i+1
First open parenthesis of i:
j
One-Page Graphs ( cont. )
• Given node i , we can find node i+1 in O(1) ; given edge , we can find node it belongs to in O(1) using o(n) extra space
( using rank , select operations - won’t be shown here ).
One-Page Graphs ( cont. )
• degree(i) – difference indices between nodes i and i+1.
• adjacent( i , j) – find the matching parenthesis of the first open parenthesis after the pair corresponding to vertex i. if its index less than j , adjacent(i,j)=false , otherwise find the matching parenthesis of the last close parenthesis after the pair corresponding to vertex j .If it corresponds to i, adjacent(i ,j ) = true.
One-Page Graphs - conclusion
Can be represented using 2n+2m+o(n+m) bits.
Adjacency of a pair of vertices , the degree of any given vertex can be found in O(1) , the neighbors of a vertex i can be produced in O( degree(i) ) time.
Graph with more than one page
• Represent each page separately , share the same order of vertices .
• If the graph has k pages , a vertex requires 2k bits whereas an edge 2 bits.
• The parenthesis representation requires 2nk + 2m bits.
• Adjacency of a pair of vertices , the degree of any given vertex can be found in O(k) , the neighbors of a vertex i can be produced in O( degree(i) + k ) time.
Planar graphs - conclusions
• Space requirement is at most: 8n+m+o(m+n) = 14n+o(n) , since m is at most 3n.
• Time performance is like one–page graphs.
Balanced Parentheses – implementation in 2n+o(n)
Theorem:Given a nested string of 2n balanced
parentheses , using o(n) auxiliary bits we can
perform the operations: findclose(i) , findopen(i),
excess(i) and enclose(i) in constant time.
Proof:
Divide sequence to blocks:big blocksmall block
nb lg2
)lg(lglg22
4 nb
...big block big block...
small block
Definition
• far parenthesis – if its matching parenthesis lies outside its block
• far parenthesis is a pioneer if its matching parenthesis lies in a different block than that of the previous far parenthesis in the sequence.
( ( ( ) ) ( ) ) ( )
far
pioneer
Proof:Imagine a graph with a node for each block.
Create an edge between blocks if there is pioneer
between them .
None of the edges can cross.
No double edges.
We got outer-planar graph , one of its properties
that it has at most 2b – 3 edges.
Theorem:The number of pioneers in b blocks is at most
2b – 3.
With each pioneer parenthesis we keep
address of its matching parenthesis.
Space requirement:
nnnnn lglg*lg2
findclose(i) – for far parenthesis
Given left far parenthesis , find its excess and its preceding pioneer
Given pioneer , find far parenthesis target block.
Given target block , find first close parenthesis withthe same right excess.
Intuition – step1:
...big block ...small block
nn lglg2
nn lg2
#big blocks =
#small blocks =
nlg
nlglg
Storing with each big block head:
• the position of the immediately preceding pioneer (to its left) in big block.
• excess in binary ( (#0 - #1) up to that position) – value between (0 -n) .
Storing with each small block head:
• the position of the immediately preceding pioneer ( and 0 if there is no pioneer ).
• the excess in binary ( starting from the big block head ) at that position.
• a bit indicating whether there is a pioneer in the small block.
• and ...
Storing all possible small blocks:
• a bitmap of pioneers in the small block if the small block contains a pioneer.
number of possible small blocks:
for each entries of size
bits storing previous pioneer index .
)(lg2lglg4)lg(lg4
2
nnn
)lg(lg2
4 n nlglglg
nTotal nnn
lglglg*4*: )lg(lg)(lg2lglg4
Find the preceding pioneer address for a far parenthesis.
• Given i , check if its small block has pioneer.
• if yes , consult bitmap if exist pioneer before i.
• if not , the small block header or the big block header will give the address.
• Analogous strategy is to find excess of far parenthesis at the given position ...
• Once we find the preceding pioneer parenthesis of a given far, we know the target big block of the given parenthesis from pioneer information.
Given left far parenthesis , find its excess and its preceding pioneer
Given pioneer , find far parenthesis target block.
Given left far parenthesis , find its excess and its preceding pioneer
Given pioneer , find far parenthesis target block.
Given target block , find first close parenthesis withthe same right excess.
Looking for a first parenthesis with excess e in a given block
• excess within a big block is at most .
• store a table for every excesses .
nlg2
nlg
excess place
i
j (i<j)
k (j<k)
... ...
nlg
nlg2
nlg3
nnnnn
n
n
nlglglglglg
lg
lglg
2
2
#big blocks
#table entries
size of entry
Table complexity:
Looking for a first parenthesis with excess e in a given block ( cont.)
for two consecutive entries in table:
• if ( j – i > lg n / 2 ) keep all entries nlg
nnnnnnn lglglglglg*lg*lg2
number such portions
Space requirement:
Looking for a first parenthesis with excess e in a given block ( cont.)
for two consecutive entries in table:
• if ( j – i <= log n / 2 ) keep table of answers.
nnn
lglg*lg*2 2
lg
#of possible strings
for each excess value
Space requirement:
We can find the matching closing
parenthesis for a far open parenthesis
using o(n) bits of extra storage in O(1).
We also can find the excess value at every
far position at constant time.
What about not far parenthesis ?
• Use exactly the same strategy for far parenthesis with respect to the small blocks within the big block .
• small block
• tiny block
)lg(lglg22
4 nb
nlglg2
Q:What about not far parenthesis inside small block ? A:Table of answersFor every possible string of small block ( of
length ) and for every position in that string create a table entry.
In each entry two values:excess in binarynext one or previous zero or none of them .
Space: o(n)
)lg(lg2
4 n
What we have done ?
findclose(i)findopen(i)excess(i) enclose(i)
enclose(i)
• e = excess(i)
• Look for right parenthesis with e-1 in a target block of closing parenthesis .
• What if its not in that block ?
• With every block header we keep a pointer to the parenthesis that has right excess one less that the minimum at that block .
Conclusions
• Parentheses representation in 2n+o(n) with findclose(i) , findopen(i) , excess(i) , enclose(i) in constant time.
• Static trees representation in 2n+o(n) that can find parent , left child , right child , size of the subtree in constant time.
• Planar graph representation in 8n+ 2m + o(m + n) that can answer adjacent , degree in constant time , give all neighbors in O(degree ) time.