Transcript Space-Efficient Static Trees and Graphs

Space-Efficient Static Trees
and Graphs
Guy Jacobson
IEEE Symposium on
Foundations of Computer Science, 1989
Speaker: 吳展碩
1
2
3
4
5
6
7
1
2
2
3
8
3
4
5
nil
4
6
nil
5
nil
6
7
nil
7
8
nil
nil
8
nil
nil
nil
• A pointer needs lg n bits to address n
different locations.
• Using pointers to represent the linking
relation of a graph will therefore occupy
(n lg n) bits.
Outline
• To store a binary tree in asymptotically
optimal space
– Represent a tree in O(n) bits
– Efficient tree-traversal in space-efficient
trees
• To store planar graphs in asymptotically
optimal space
Binary Trees in 2n+1 bits
1.
2.
3.
Mark all the nodes of the tree with 1.
Add external nodes to the tree, and mark them all with 0.
Read off the makes of nodes of the tree in level-order.
1
1
2
1
3
4
5
7
1
6
8
1
0
1
0
1
0
1
0
0
0
1 1 1 1 1 0 1 0 0 1 0 1 0 0 0 0 0
1
0
0
0
Binary Trees in 2n+1 bits
1.
2.
3.
Mark all the nodes of the tree with 1.
Add external nodes to the tree, and mark them all with 0.
Read off the makes of nodes of the tree in level-order.
1
1
2
1
3
4
5
7
1
6
8
1
0
1
0
1
0
1
0
0
0
1
0
1
2
3
4
5
6
7
8
1 1 1 1 1 0 1 0 0 1 0 1 0 0 0 0 0
0
0
• How to compute the linking relations
in a space-efficient tree?
1
1
2
1
3
4
5
7
1
6
8
1
0
1
0
1
0
1
0
0
0
1 1 1 1 1 0 1 0 0 1 0 1 0 0 0 0 0
1
0
0
0
Rank and Select
• Define two operations rank(m) and select(m) as
follows:
rank(m): Counts the number of 1s from position 1 up to
position m in a binary string
select(m): Finds the m-th 1s in a binary string
• Example:
1
2
3
4
5
1
1
1
1
1
1
2
3
4
5
rank(10) = 7
select(7) = 10
6
0
7
1
6
8
0
9
0
10
11
12
13
14
15
16
17
1
0
1
0
0
0
0
0
7
8
Algorithm to Compute
Linking Relations
left-child(m)  2  rank(m)
right-child(m)  2  rank(m)  1
parent(m)  select(m2)
1
1
2
3
2
3
4
5
4
7
6
5
8
9
6
10
11
12
7
8
14
1
2
3
4
5
1
1
1
1
1
1
2
3
4
5
15
6
0
13
7
1
6
8
0
16
9
0
17
10
11
12
13
14
15
16
17
1
0
1
0
0
0
0
0
7
8
• How to compute rank(m) and select(m)
efficiently? (e.g. constant time)
Compute Rank(m) and Select(m)
The rank directory:
• Conceptually break the bit-string into blocks of
length lg2n. Keep a table containing the number of
1s up to the last position in each block. This takes
n / lg n bits.
• Break each block into sub-blocks of length ½lg n.
Keep a table containing the number of 1s within
the block up to the last position in each sub-block.
This takes n lglg2n / lg n bits.
• Keep a pre-computed table giving the number of 1s
up to every possible position in every possible
distinct sub-block.
n bits
1
2
n/lg2n
3
101100 110011 001...
... ...
..11 000010 101000
lg2n
0
3
7
... ... ... ...
lg n
n / lg n bits
½lg n
0
lglg2n
2n lglg2n / lg n bits
55
56
n bits
1
2
n/lg2n
3
101100 110011 001...
... ...
..11 000010 101000
lg2n
0
3
7
... ... ... ...
55
56
lg n
n / lg n bits
½lg n
0
Precomputed Table
lglg2n
2½lg n  ½lg n  lg½lg n bits
2n lglg2n / lg n bits
Planar Graphs in O(n) Space
• Represent a special case of planar graphs called onepage graphs in O(n) bits
• k-page graphs can be represented in O(kn) bits
• Any planar graph can be embedded in a four-page
graph.
Yannakakis, M. "Four pages are necessary and sufficient for planar
graphs." Proceedings of the 18th ACM Symposium on Theory of
Computing, pages 104-108, 1986.
One-page graph
• One-page Graph:
All edges are lying to one side and can not cross.
One-page graph in O(n) Space
• One-page Graph:
All edges are lying to one side and can not cross.
|
(((
|
)(
|
(
|
))
|
)(
|
))
• How to compute the linking relations
in the parenthesis string?
Finding the close parenthesis
which match the open one
• First, break the string of parentheses into
blocks of length lgn.
Definitions
Far parenthesis:
An open parenthesis p is called a far parenthesis if and only if p's matching
parenthesis lies outside its own block.
Pioneer:
A far parenthesis is a pioneer if and only if its matching parenthesis lies in a
different block that of the previous far parenthesis.
The number of pioneers is at most 2lgn.
Dotted lines denote the matches of far parentheses
Red ones denote the matches of pioneers
Use a Directory Structure
of Size O(n) bits for
Matching Parentheses
Matching Parentheses
• For a parenthesis p, its matching parenthesis q can be found
out as follows:
Case1: p and q are in the same block
lgn
Using precomputed table
Matching Parentheses
• Case2: p and q are not in the same block
Find the pioneer of p and use it to locate the block containing q
Compute the position of q via nesting depths
O(n) bits
O(n) bits
O(n) bits + number of pioneers  lg n bits
o(n) bits
Conclusion
• A space-efficient data structure
achieve almost optimal space while
supporting the required operations almost
as efficient as using pointers to represent it.
References
• Dinesh P. Mehta and Sartaj Sahni. Handbook of Data
Structures and Applications. Chapman & Hall/CRC, 2005.