Results 1  10
of
11
Lineartime compression of boundedgenus graphs into informationtheoretically optimal number of bits
 In: 13th Symposium on Discrete Algorithms (SODA
, 2002
"... 1 I n t roduct ion This extended abstract summarizes a new result for the graph compression problem, addressing how to compress a graph G into a binary string Z with the requirement that Z can be decoded to recover G. Graph compression finds important applications in 3D model compression of Computer ..."
Abstract

Cited by 16 (1 self)
 Add to MetaCart
(Show Context)
1 I n t roduct ion This extended abstract summarizes a new result for the graph compression problem, addressing how to compress a graph G into a binary string Z with the requirement that Z can be decoded to recover G. Graph compression finds important applications in 3D model compression of Computer Graphics [12, 1720] and compact routing table of Computer Networks [7}. For brevity, let a ~rgraph stand for a graph with property n. The informationtheoretically optimal number of bits required to represent an nnode ngraph is [log 2 N~(n)], where N,~(n) is the number of distinct nnode *rgraphs. Although determining or approximating the close forms of N ~ (n) for nontrivial classes of n is challenging, we provide a lineartime methodology for graph compression schemes that are informationtheoretically optimal with respect to continuous uperadditive functions (abbreviated as optimal for the rest of the extended abstract). 1 Specifically, if 7r satisfies certain properties, then we can compress any nnode medge 1rgraph G into a binary string Z such that G and Z can be computed from each other in O(m + n) time, and that the bit count of Z is at most fl(n) + o(fl(n)) for any continuous uperadditive function fl(n) with log 2 N~(n) < fl(n) + o(fl(n)). Our methodology is applicable to general classes of graphs; this extended abstract focuses on graphs with sublinear genus. 2 For example, if the input nnode,rgraph G is equipped with an embedding on its genus surface, which is a reasonable assumption for graphs arising from 3D model compression, then our methodology is applicable to any 7r satisfying the following statements:
A compact routing scheme and approximate distance oracle for powerlaw graphs
, 2009
"... Abstract. Compact routing addresses the tradeoff between table sizes and stretch, which is the worstcase ratio between the length of the path a packet is routed through by the scheme and the length of a shortest path from source to destination. We adapt the compact routing scheme by Thorup and Zwic ..."
Abstract

Cited by 5 (1 self)
 Add to MetaCart
Abstract. Compact routing addresses the tradeoff between table sizes and stretch, which is the worstcase ratio between the length of the path a packet is routed through by the scheme and the length of a shortest path from source to destination. We adapt the compact routing scheme by Thorup and Zwick to optimize it for powerlaw graphs. We analyze our adapted routing scheme based on the theory of unweighted random powerlaw graphs with fixed expected degree sequence by Aiello, Chung, and Lu. Our result is the first theoretical bound coupled to the parameter of the powerlaw graph model for a compact routing scheme. In particular, we prove that, for stretch 3, instead of routing tables with Õ(n1/2) bits as in the general scheme by Thorup and Zwick, expected sizes of O(n γ log n) bits are sufficient, and that all the routing tables can be constructed at once in expected time O(n 1+γ log n), with γ = τ−2 2τ−3 + ε, where τ ∈ (2, 3) is the powerlaw exponent and ε> 0 (which implies ε < γ < 1/3 + ε). Both bounds also hold with probability at least 1 − 1/n (independent of ε). The routing scheme is a labeled scheme, requiring a stretch5 handshaking step and using addresses and message headers with O(log n log log n) bits, with probability at least 1 − o(1). We further demonstrate the effectiveness of our scheme by simulations on realworld graphs as well as synthetic powerlaw graphs. With the same techniques as for the compact routing scheme, we also adapt the approximate distance oracle by Thorup and Zwick for stretch 3 and obtain a new upper bound of expected Õ(n1+γ) for space and preprocessing for random powerlaw graphs. 1
Exploring Generic
 Proceedings of the IFIP TC2 Working Conference on Generic Programming, Schloss Dagstuhl
, 2004
"... doi:10.1182/blood200902204800 ..."
Shortest paths in less than a millisecond
 ACM SIGCOMM Workshop on Online Social Networks (WOSN
, 2012
"... We consider the problem of answering pointtopoint shortest path queries on massive social networks. The goal is to answer queries within tens of milliseconds while minimizing the memory requirements. We present a technique that achieves this goal for an extremely large fraction of path queries by ..."
Abstract

Cited by 3 (2 self)
 Add to MetaCart
We consider the problem of answering pointtopoint shortest path queries on massive social networks. The goal is to answer queries within tens of milliseconds while minimizing the memory requirements. We present a technique that achieves this goal for an extremely large fraction of path queries by exploiting the structure of the social networks. Using evaluations on realworld datasets, we argue that our technique offers a unique tradeoff between latency, memory and accuracy. For instance, for the LiveJournal social network (roughly 5 million nodes and 69 million edges), our technique can answer 99.9 % of the queries in less than a millisecond. In comparison to storing all pair shortest paths, our technique requires at least 550 × less memory; the average query time is roughly 365 microseconds — 430 × faster than the stateoftheart shortest path algorithm. Furthermore, the relative performance of our technique improves with the size (and density) of the network. For the Orkut social network (3 million nodes and 220 million edges), for instance, our technique is roughly 2588 × faster than the stateoftheart algorithm for computing shortest paths.
Compact Routing for the Future Internet
, 2012
"... The Internet relies on its interdomain routing system to allow data transfer between any two endpoints regardless of where they are located. This routing system currently uses a shortest path routing algorithm (modified by local policy constraints) called the Border Gateway Protocol. The massive gr ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
The Internet relies on its interdomain routing system to allow data transfer between any two endpoints regardless of where they are located. This routing system currently uses a shortest path routing algorithm (modified by local policy constraints) called the Border Gateway Protocol. The massive growth of the Internet has led to large routing tables that will continue to grow. This will present a serious engineering challenge for router designers in the longterm, rendering state (routing table) growth at this pace unsustainable. There are various shortterm engineering solutions that may slow the growth of the interdomain routing tables, at the expense of increasing the complexity of the network. In addition, some of these require manual configuration, or introduce additional points of failure within the network. These solutions may give an incremental, constant factor, improvement. However, we know from previous work that all shortest path routing algorithms require forwarding state that grows linearly with the size of the network in the worst case. Rather than attempt to sustain interdomain routing through a shortest path routing algorithm, compact routing algorithms exist that guarantee worstcase sublinear state requirements at all nodes by allowing an upperbound on path length relative to the theoretical shortest path,
Faster Approximate Distance Queries and Compact Routing in Sparse Graphs
, 2012
"... A distance oracle is a compact representation of the shortest distance matrix of a graph. It can be queried to retrieve approximate distances and corresponding paths between any pair of vertices. A lower bound, due to Thorup and Zwick, shows that a distance oracle that returns paths of worstcase st ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
A distance oracle is a compact representation of the shortest distance matrix of a graph. It can be queried to retrieve approximate distances and corresponding paths between any pair of vertices. A lower bound, due to Thorup and Zwick, shows that a distance oracle that returns paths of worstcase stretch (2k−1) must require spaceΩ(n 1+1/k) for graphs over n nodes. The hard cases that enforce this lower bound are, however, rather dense graphs with average degreeΩ(n 1/k). We present distance oracles that, for sparse graphs, substantially break the lower bound barrier at the expense of higher query time. For any 1≤α ≤ n, our distance oracles can return stretch 2 paths using O(m+ n 2 /α) space and stretch 3 paths using O(m+n 2 /α 2) space, at the expense of O(αm/n) query time. By setting appropriate values ofα, we get the first distance oracles that have size linear in the size of the graph, and return constant stretch paths in nontrivial query time. The query time can be further reduced to O(α), by using an additional O(mα) space for all our distance oracles, or at the cost of a small constant additive stretch. We use our stretch 2 distance oracle to design a compact routing scheme that requires Õ(n 1/2) memory at each node and, after a handshaking phase, routes along paths with worstcase stretch 2. Moreover, supported by largescale simulations on graphs including the ASlevel Internet graph, we argue that our stretch2 scheme would be simple and efficient to implement as a distributed compact routing protocol. An earlier version of this paper appeared in INFOCOM 2011[1]. The extended version presents results that improve upon the results presented in the conference version; significantly more simplified presentation and proofs for the results in the conference version; and in addition, distance oracles for unweighted graphs.
A LinearSize Logarithmic Stretch PathReporting Distance Oracle for General Graphs
, 2014
"... In a seminal paper [27] for any nvertex undirected graph G = (V,E) and a parameter k = 1, 2,..., Thorup and Zwick constructed a distance oracle of size O(kn1+1/k) which upon a query (u, v) constructs a path Π between u and v of length δ(u, v) such that dG(u, v) ≤ δ(u, v) ≤ (2k−1)dG(u, v). The que ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
In a seminal paper [27] for any nvertex undirected graph G = (V,E) and a parameter k = 1, 2,..., Thorup and Zwick constructed a distance oracle of size O(kn1+1/k) which upon a query (u, v) constructs a path Π between u and v of length δ(u, v) such that dG(u, v) ≤ δ(u, v) ≤ (2k−1)dG(u, v). The query time of the oracle from [27] is O(k) (in addition to the length of the returned path), and it was subsequently improved to O(1) [29, 11]. A major drawback of the oracle of [27] is that its space is Ω(n · log n). Mendel and Naor [18] devised an oracle with space O(n1+1/k) and stretch O(k), but their oracle can only report distance estimates and not actual paths. In this paper we devise a pathreporting distance oracle with size O(n1+1/k), stretch O(k) and query time O(n), for an arbitrarily small > 0. In particular, for k = log n our oracle provides logarithmic stretch using linear size. Another variant of our oracle has linear size, polylogarithmic stretch, and query time O(log log n). For unweighted graphs we devise a distance oracle with multiplicative stretch O(1), additive stretch O(β(k)), for a function β(), space O(n1+1/k · β), and query time O(n), for an arbitrarily small constant > 0. The tradeoff between multiplicative stretch and size in these oracles is far below Erdős’s girth conjecture threshold (which is stretch 2k − 1 and size O(n1+1/k)).
Shortest Paths in Microseconds
"... Computing shortest paths is a fundamental primitive for several social network applications including sociallysensitive ranking, locationaware search, social auctions and social network privacy. Since these applications compute paths in response to a user query, the goal is to minimize latency whil ..."
Abstract
 Add to MetaCart
(Show Context)
Computing shortest paths is a fundamental primitive for several social network applications including sociallysensitive ranking, locationaware search, social auctions and social network privacy. Since these applications compute paths in response to a user query, the goal is to minimize latency while maintaining feasible memory requirements. We present ASAP, a system that achieves this goal by exploiting the structure of social networks. ASAP preprocesses a given network to compute and store a partial shortest path tree (PSPT) for each node. The PSPTs have the property that for any two nodes, each edge along the shortest path is with high probability contained in the PSPT of at least one of the nodes. We show that the structure of social networks enable the PSPT of each node to be an extremely small fraction of the entire network; hence, PSPTs can be stored efficiently and each shortest path can be computed extremely quickly. For a real network with 5 million nodes and 69 million edges, ASAP computes a shortest path for most node pairs in less than 49 microseconds per pair. ASAP, unlike any previous technique, also computes hundreds of paths (along with corresponding distances) between any node pair in less than 100 microseconds. Finally, ASAP admits efficient implementation on distributed programming frameworks like MapReduce. 1.
Distance Oracles for Stretch Less Than 2 Abstract
"... We present distance oracles for weighted undirected graphs that return distances of stretch less than 2. For the realistic case of sparse graphs, our distance oracles exhibit a smooth threeway tradeoff between space, stretch and query time — a phenomenon that does not occur in dense graphs. In par ..."
Abstract
 Add to MetaCart
(Show Context)
We present distance oracles for weighted undirected graphs that return distances of stretch less than 2. For the realistic case of sparse graphs, our distance oracles exhibit a smooth threeway tradeoff between space, stretch and query time — a phenomenon that does not occur in dense graphs. In particular, for any positive integer t and for any 1≤α ≤ n, our distance oracle is of size O(m+n 2 /α) and returns distances of stretch at most(1+ 2 t+1) in time O((αµ)t), whereµ=2m/n is the average degree of the graph. The query time can be further reduced to O((α+µ) t) at the expense of a small additive stretch. 1
SATBased Approaches to Treewidth Computation: An Evaluation
"... Abstract—Treewidth is an important structural property of graphs, tightly connected to computational tractability in eg various constraint satisfaction formalisms such as constraint programming, Boolean satisfiability, and answer set programming, as well as probabilistic inference, for instance. An ..."
Abstract
 Add to MetaCart
Abstract—Treewidth is an important structural property of graphs, tightly connected to computational tractability in eg various constraint satisfaction formalisms such as constraint programming, Boolean satisfiability, and answer set programming, as well as probabilistic inference, for instance. An obstacle to harnessing treewidth as a way to efficiently solving bounded treewidth instances of NPhard problems is that deciding treewidth, and hence computing an optimal treedecomposition, is in itself an NPcomplete problem. In this paper, we study the applicability of Boolean satisfiability (SAT) based approaches to determining the treewidths of graphs, and at the same time obtaining an associated optimal treedecomposition. Extending earlier studies, we evaluate various SAT and MaxSAT based strategies for treewidth computation, and compare these approaches to practical dedicated exact algorithms for the problem. I.