1 / 21

Compact Representations of Separable Graphs

Compact Representations of Separable Graphs. From a paper of the same title submitted to SODA by: Dan Blandford and Guy Blelloch and Ian Kash. Standard Graph Representations. Standard Adjacency List - |V| + 2|E| words = O(|E|lg|V|) bits - |V| + |E| words if stored as an array

baris
Télécharger la présentation

Compact Representations of Separable Graphs

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Compact Representations of Separable Graphs From a paper of the same title submitted to SODA by: Dan Blandford and Guy Blelloch and Ian Kash

  2. Standard Graph Representations • Standard Adjacency List - |V| + 2|E| words = O(|E|lg|V|) bits - |V| + |E| words if stored as an array • For arbitrary graphs, lower bound is O(|E| lg (|V|2/|E|)) bits, which adjacency list meets for sparse graphs, i.e. |E| = O(|V|)

  3. Representations for Planar Graphs that use O(|V|) bits • No Query Support - Turan [1984], First to come up with an O(|V|) bit compression scheme - Keeler and Westbrook [1995], Improved constants - Deo and Litow [1998], First use of separators - He, Kao and Lu [2000], Optimal high order term • Query Support - Jacobson [1989], O( lg |V|) adjacency queries - Munro and Raman [1997], O(1) adjacency queries - Based on page embeddings and balanced parentheses, so not generally applicable

  4. A Vertex Separator An Edge Separator Graph Separators • Formally, a class of Graphs is separable if: • Every member has a cut set of size βf(|V|) for some β > 0 such that • Each component has at most αn vertices for some α < 1 • We concern ourselves with the case f(|V|) = |V|c, 0 < c < 1

  5. Classes of Graphs With Small Separators Many Interesting and Useful Classes - Planar (and all bounded genus) - Telephone / Power / Road networks - 3D Meshes (Miller et al. [1997]) - Link Structure of Web

  6. Results Theory for both edge and vertex separators • Compress Graphs to O(|V|) bits • Meets Lower Bound for Query Times - Degree Queries – O(1) - Adjacency Queries – O(1) - Neighbor Queries – O(D), D = Degree Implementation for edge separators

  7. Main Ideas 1) Build separator tree 2) Order based on tree 3) Compress using difference encoded adjacency table 4) Use root find tree* * Vertex separators only

  8. A Graph and Its Separator Tree 1 1 1 3 4 2 1 3 1 1 1 2 1 4 2 3 4 4 1 3 2 Final Numbering: 1 2 3 4

  9. Difference Coded Adjacency Table • Instead of storing absolute numbers, store offsets • i.e.: 1,1,3,2,1 instead of 1,2,5,7,8 • Makes numbers stored smaller • By itself, it offers no advantage

  10. Gamma Code • Variable length encoding with 2 parts • 1st Part: Unary code of length of 2nd part • 2nd Part: Number in binary • Encoding n takes 2└lg(n+1)┘=O(lg(n)) bits • There are other codes with similar properties (Ex: Delta Code)

  11. u v u v Theorem: Using a difference coded adjacency table this ordering requires O(|V|) bits

  12. Sketch of Proof • The maximum distance between the numbers of u and v is the number of vertices in their Least Common Ancestor in the separator tree (n) • With Gamma Code this takes O(lg(n)) bits • Recurrence: S(n) ≤ 2S(.5n) + O(nc lg(n)) • As a geometrically decreasing recurrence, this solves to S(|V|) = O(|V|)

  13. Decoding Vertex i in O(1) time • We can decode lg(|V|) bits at a time through table lookup • An Edge Takes O(lg(|V|)) bits, and the degree of a vertex for a graph with good edge separators is constant • We decode the entire vertex using a constant number of table lookups Pointer to Vertex i Vertex i-1 Degree Edge 1 Edge 2 Edge 3 Vertex i+1

  14. Problem! • This assumes we have a pointer to vertex i • Requires |V| pointers of lg |V| bits each = O(|V| lg|V|), but the graph uses only O(|V|) • Can afford a pointer to a BLOCK of lg |V| vertices O(lg |V| * |V| / lg |V|) = O(|V|) • Can afford a pointer to a SUBBLOCK of at least k lg |V| bits • Can afford extra 2 lg |V| bits per block

  15. Offset for 2nd Subblock Offset for 3rd Subblock Next Subblocks Getting a Pointer to Vertex i in O(1) Pointer to Block (calculate as i / lg (|V|) Previous Block 100110 Pointer to Block Pointer to Offsets Next Block Flags to determine subblocks. A 1 is the start of a subblock Prev. Subblocks The Process: 1) Calculate block number 2) Identify subblock number 3) Get subblock offset 4) Add offset to pointer 5) Decode any Previous vertices (at most k lg |V| bits)

  16. Graphs Used For Testing

  17. Experimental Space Results

  18. Experimental Time Results

  19. Conclusions • Our Method uses O(|V|) bits to compress a graph with good separators • On test graphs with good separators, it used less than 12 bits per edge, including overhead • It meets the lower bounds for queries • With unoptimized table lookup it takes 3 times as long to search as a standard adjacency list representation and 6 times as long as an array based adjacency list

  20. Future Work • Test decoding speed on more graphs • Optimize decoding • Allow addition / deletion of edges • More Efficient Separator Generator • Implement Vertex Separators

  21. Create a Page Embedding Represent vertices and edges as parentheses - () for a vertex - ( for start of an edge - ) close for end - Figure on left: ()((())(()))((())(())) No good page embedding algorithm for arbitrary graphs Planar Embeddings and Parentheses

More Related