arXiv subjects

Danupon Nanongkai

Publications and source records attributed to Danupon Nanongkai.

72 records · Page 4Linked to original sources

arXiv2015

Dynamic Approximate All-Pairs Shortest Paths: Breaking the O(mn) Barrier and Derandomization

We study dynamic $(1+ε)$-approximation algorithms for the all-pairs shortest paths problem in unweighted undirected $n$-node $m$-edge graphs under edge deletions. The fastest algorithm for this problem is a randomized algorithm with a total update time of $\tilde O(mn/ε)$ and constant query time by Roditty and Zwick [FOCS 2004]. The fastest deterministic algorithm is from a 1981 paper by Even and Shiloach [JACM 1981]; it has a total update time of $O(mn^2)$ and constant query time. We improve these results as follows: (1) We present an algorithm with a total update time of $\tilde O(n^{5/2}/ε)$ and constant query time that has an additive error of $2$ in addition to the $1+ε$ multiplicative error. This beats the previous $\tilde O(mn/ε)$ time when $m=Ω(n^{3/2})$. Note that the additive error is unavoidable since, even in the static case, an $O(n^{3-δ})$-time (a so-called truly subcubic) combinatorial algorithm with $1+ε$ multiplicative error cannot have an additive error less than $2-ε$, unless we make a major breakthrough for Boolean matrix multiplication [Dor et al. FOCS 1996] and many other long-standing problems [Vassilevska Williams and Williams FOCS 2010]. The algorithm can also be turned into a $(2+ε)$-approximation algorithm (without an additive error) with the same time guarantees, improving the recent $(3+ε)$-approximation algorithm with $\tilde O(n^{5/2+O(\sqrt{\log{(1/ε)}/\log n})})$ running time of Bernstein and Roditty [SODA 2011] in terms of both approximation and time guarantees. (2) We present a deterministic algorithm with a total update time of $\tilde O(mn/ε)$ and a query time of $O(\log\log n)$. The algorithm has a multiplicative error of $1+ε$ and gives the first improved deterministic algorithm since 1981. It also answers an open question raised by Bernstein [STOC 2013].

cs.DS↗

arXiv2014

Graph Products Revisited: Tight Approximation Hardness of Induced Matching, Poset Dimension and More

Graph product is a fundamental tool with rich applications in both graph theory and theoretical computer science. It is usually studied in the form $f(G*H)$ where $G$ and $H$ are graphs, * is a graph product and $f$ is a graph property. For example, if $f$ is the independence number and * is the disjunctive product, then the product is known to be multiplicative: $f(G*H)=f(G)f(H)$. In this paper, we study graph products in the following non-standard form: $f((G\oplus H)*J)$ where $G$, $H$ and $J$ are graphs, $\oplus$ and * are two different graph products and $f$ is a graph property. We show that if $f$ is the induced and semi-induced matching number, then for some products $\oplus$ and *, it is subadditive in the sense that $f((G\oplus H)*J)\leq f(G*J)+f(H*J)$. Moreover, when $f$ is the poset dimension number, it is almost subadditive. As applications of this result (we only need $J=K_2$ here), we obtain tight hardness of approximation for various problems in discrete mathematics and computer science: bipartite induced and semi-induced matching (a.k.a. maximum expanding sequences), poset dimension, maximum feasible subsystem with 0/1 coefficients, unit-demand min-buying and single-minded pricing, donation center location, boxicity, cubicity, threshold dimension and independent packing.

cs.DM↗

arXiv2014

Distributed Symmetry Breaking in Hypergraphs

Fundamental local symmetry breaking problems such as Maximal Independent Set (MIS) and coloring have been recognized as important by the community, and studied extensively in (standard) graphs. In particular, fast (i.e., logarithmic run time) randomized algorithms are well-established for MIS and $Δ+1$-coloring in both the LOCAL and CONGEST distributed computing models. On the other hand, comparatively much less is known on the complexity of distributed symmetry breaking in {\em hypergraphs}. In particular, a key question is whether a fast (randomized) algorithm for MIS exists for hypergraphs. In this paper, we study the distributed complexity of symmetry breaking in hypergraphs by presenting distributed randomized algorithms for a variety of fundamental problems under a natural distributed computing model for hypergraphs. We first show that MIS in hypergraphs (of arbitrary dimension) can be solved in $O(\log^2 n)$ rounds ($n$ is the number of nodes of the hypergraph) in the LOCAL model. We then present a key result of this paper --- an $O(Δ^ε\text{polylog}(n))$-round hypergraph MIS algorithm in the CONGEST model where $Δ$ is the maximum node degree of the hypergraph and $ε> 0$ is any arbitrarily small constant. To demonstrate the usefulness of hypergraph MIS, we present applications of our hypergraph algorithm to solving problems in (standard) graphs. In particular, the hypergraph MIS yields fast distributed algorithms for the {\em balanced minimal dominating set} problem (left open in Harris et al. [ICALP 2013]) and the {\em minimal connected dominating set problem}. We also present distributed algorithms for coloring, maximal matching, and maximal clique in hypergraphs.

cs.DC↗

arXiv2014

Almost-Tight Distributed Minimum Cut Algorithms

We study the problem of computing the minimum cut in a weighted distributed message-passing networks (the CONGEST model). Let $λ$ be the minimum cut, $n$ be the number of nodes in the network, and $D$ be the network diameter. Our algorithm can compute $λ$ exactly in $O((\sqrt{n} \log^{*} n+D)λ^4 \log^2 n)$ time. To the best of our knowledge, this is the first paper that explicitly studies computing the exact minimum cut in the distributed setting. Previously, non-trivial sublinear time algorithms for this problem are known only for unweighted graphs when $λ\leq 3$ due to Pritchard and Thurimella's $O(D)$-time and $O(D+n^{1/2}\log^* n)$-time algorithms for computing $2$-edge-connected and $3$-edge-connected components. By using the edge sampling technique of Karger's, we can convert this algorithm into a $(1+ε)$-approximation $O((\sqrt{n}\log^{*} n+D)ε^{-5}\log^3 n)$-time algorithm for any $ε>0$. This improves over the previous $(2+ε)$-approximation $O((\sqrt{n}\log^{*} n+D)ε^{-5}\log^2 n\log\log n)$-time algorithm and $O(ε^{-1})$-approximation $O(D+n^{\frac{1}{2}+ε} \mathrm{poly}\log n)$-time algorithm of Ghaffari and Kuhn. Due to the lower bound of $Ω(D+n^{1/2}/\log n)$ by Das Sarma et al. which holds for any approximation algorithm, this running time is tight up to a $ \mathrm{poly}\log n$ factor. To get the stated running time, we developed an approximation algorithm which combines the ideas of Thorup's algorithm and Matula's contraction algorithm. It saves an $ε^{-9}\log^{7} n$ factor as compared to applying Thorup's tree packing theorem directly. Then, we combine Kutten and Peleg's tree partitioning algorithm and Karger's dynamic programming to achieve an efficient distributed algorithm that finds the minimum cut when we are given a spanning tree that crosses the minimum cut exactly once.

cs.DS↗

arXiv2014

Pre-Reduction Graph Products: Hardnesses of Properly Learning DFAs and Approximating EDP on DAGs

The study of graph products is a major research topic and typically concerns the term $f(G*H)$, e.g., to show that $f(G*H)=f(G)f(H)$. In this paper, we study graph products in a non-standard form $f(R[G*H]$ where $R$ is a "reduction", a transformation of any graph into an instance of an intended optimization problem. We resolve some open problems as applications. (1) A tight $n^{1-ε}$-approximation hardness for the minimum consistent deterministic finite automaton (DFA) problem, where $n$ is the sample size. Due to Board and Pitt [Theoretical Computer Science 1992], this implies the hardness of properly learning DFAs assuming $NP\neq RP$ (the weakest possible assumption). (2) A tight $n^{1/2-ε}$ hardness for the edge-disjoint paths (EDP) problem on directed acyclic graphs (DAGs), where $n$ denotes the number of vertices. (3) A tight hardness of packing vertex-disjoint $k$-cycles for large $k$. (4) An alternative (and perhaps simpler) proof for the hardness of properly learning DNF, CNF and intersection of halfspaces [Alekhnovich et al., FOCS 2004 and J. Comput.Syst.Sci. 2008].

cs.CC↗

arXiv2014

Distributed Approximation Algorithms for Weighted Shortest Paths

A distributed network is modeled by a graph having $n$ nodes (processors) and diameter $D$. We study the time complexity of approximating {\em weighted} (undirected) shortest paths on distributed networks with a $O(\log n)$ {\em bandwidth restriction} on edges (the standard synchronous \congest model). The question whether approximation algorithms help speed up the shortest paths (more precisely distance computation) was raised since at least 2004 by Elkin (SIGACT News 2004). The unweighted case of this problem is well-understood while its weighted counterpart is fundamental problem in the area of distributed approximation algorithms and remains widely open. We present new algorithms for computing both single-source shortest paths (\sssp) and all-pairs shortest paths (\apsp) in the weighted case. Our main result is an algorithm for \sssp. Previous results are the classic $O(n)$-time Bellman-Ford algorithm and an $\tilde O(n^{1/2+1/2k}+D)$-time $(8k\lceil \log (k+1) \rceil -1)$-approximation algorithm, for any integer $k\geq 1$, which follows from the result of Lenzen and Patt-Shamir (STOC 2013). (Note that Lenzen and Patt-Shamir in fact solve a harder problem, and we use $\tilde O(\cdot)$ to hide the $O(\poly\log n)$ term.) We present an $\tilde O(n^{1/2}D^{1/4}+D)$-time $(1+o(1))$-approximation algorithm for \sssp. This algorithm is {\em sublinear-time} as long as $D$ is sublinear, thus yielding a sublinear-time algorithm with almost optimal solution. When $D$ is small, our running time matches the lower bound of $\tilde Ω(n^{1/2}+D)$ by Das Sarma et al. (SICOMP 2012), which holds even when $D=Θ(\log n)$, up to a $\poly\log n$ factor.

cs.DS↗

arXiv2014

Brief Announcement: Almost-Tight Approximation Distributed Algorithm for Minimum Cut

In this short paper, we present an improved algorithm for approximating the minimum cut on distributed (CONGEST) networks. Let $λ$ be the minimum cut. Our algorithm can compute $λ$ exactly in $\tilde{O}((\sqrt{n}+D)\poly(λ))$ time, where $n$ is the number of nodes (processors) in the network, $D$ is the network diameter, and $\tilde{O}$ hides $\poly\log n$. By a standard reduction, we can convert this algorithm into a $(1+ε)$-approximation $\tilde{O}((\sqrt{n}+D)/\poly(ε))$-time algorithm. The latter result improves over the previous $(2+ε)$-approximation $\tilde{O}((\sqrt{n}+D)/\poly(ε))$-time algorithm of Ghaffari and Kuhn [DISC 2013]. Due to the lower bound of $\tildeΩ(\sqrt{n}+D)$ by Das Sarma et al. [SICOMP 2013], this running time is {\em tight} up to a $\poly\log n$ factor. Our algorithm is an extremely simple combination of Thorup's tree packing theorem [Combinatorica 2007], Kutten and Peleg's tree partitioning algorithm [J. Algorithms 1998], and Karger's dynamic programming [JACM 2000].

cs.DS↗

arXiv2014

Can Quantum Communication Speed Up Distributed Computation?

The focus of this paper is on {\em quantum distributed} computation, where we investigate whether quantum communication can help in {\em speeding up} distributed network algorithms. Our main result is that for certain fundamental network problems such as minimum spanning tree, minimum cut, and shortest paths, quantum communication {\em does not} help in substantially speeding up distributed algorithms for these problems compared to the classical setting. In order to obtain this result, we extend the technique of Das Sarma et al. [SICOMP 2012] to obtain a uniform approach to prove non-trivial lower bounds for quantum distributed algorithms for several graph optimization (both exact and approximate versions) as well as verification problems, some of which are new even in the classical setting, e.g. tight randomized lower bounds for Hamiltonian cycle and spanning tree verification, answering an open problem of Das Sarma et al., and a lower bound in terms of the weight aspect ratio, matching the upper bounds of Elkin [STOC 2004]. Our approach introduces the {\em Server model} and {\em Quantum Simulation Theorem} which together provide a connection between distributed algorithms and communication complexity. The Server model is the standard two-party communication complexity model augmented with additional power; yet, most of the hardness in the two-party model is carried over to this new model. The Quantum Simulation Theorem carries this hardness further to quantum distributed computing. Our techniques, except the proof of the hardness in the Server model, require very little knowledge in quantum computing, and this can help overcoming a usual impediment in proving bounds on quantum distributed algorithms.

cs.DC↗

arXiv2013

Graph Pricing Problem on Bounded Treewidth, Bounded Genus and k-partite graphs

Consider the following problem. A seller has infinite copies of $n$ products represented by nodes in a graph. There are $m$ consumers, each has a budget and wants to buy two products. Consumers are represented by weighted edges. Given the prices of products, each consumer will buy both products she wants, at the given price, if she can afford to. Our objective is to help the seller price the products to maximize her profit. This problem is called {\em graph vertex pricing} ({\sf GVP}) problem and has resisted several recent attempts despite its current simple solution. This motivates the study of this problem on special classes of graphs. In this paper, we study this problem on a large class of graphs such as graphs with bounded treewidth, bounded genus and $k$-partite graphs. We show that there exists an {\sf FPTAS} for {\sf GVP} on graphs with bounded treewidth. This result is also extended to an {\sf FPTAS} for the more general {\em single-minded pricing} problem. On bounded genus graphs we present a {\sf PTAS} and show that {\sf GVP} is {\sf NP}-hard even on planar graphs. We study the Sherali-Adams hierarchy applied to a natural Integer Program formulation that $(1+ε)$-approximates the optimal solution of {\sf GVP}. Sherali-Adams hierarchy has gained much interest recently as a possible approach to develop new approximation algorithms. We show that, when the input graph has bounded treewidth or bounded genus, applying a constant number of rounds of Sherali-Adams hierarchy makes the integrality gap of this natural {\sf LP} arbitrarily small, thus giving a $(1+ε)$-approximate solution to the original {\sf GVP} instance. On $k$-partite graphs, we present a constant-factor approximation algorithm. We further improve the approximation factors for paths, cycles and graphs with degree at most three.

cs.GT↗

arXiv2013

Independent Set, Induced Matching, and Pricing: Connections and Tight (Subexponential Time) Approximation Hardnesses

We present a series of almost settled inapproximability results for three fundamental problems. The first in our series is the subexponential-time inapproximability of the maximum independent set problem, a question studied in the area of parameterized complexity. The second is the hardness of approximating the maximum induced matching problem on bounded-degree bipartite graphs. The last in our series is the tight hardness of approximating the k-hypergraph pricing problem, a fundamental problem arising from the area of algorithmic game theory. In particular, assuming the Exponential Time Hypothesis, our two main results are: - For any r larger than some constant, any r-approximation algorithm for the maximum independent set problem must run in at least 2^{n^{1-ε}/r^{1+ε}} time. This nearly matches the upper bound of 2^{n/r} (Cygan et al., 2008). It also improves some hardness results in the domain of parameterized complexity (e.g., Escoffier et al., 2012 and Chitnis et al., 2013) - For any k larger than some constant, there is no polynomial time min (k^{1-ε}, n^{1/2-ε})-approximation algorithm for the k-hypergraph pricing problem, where n is the number of vertices in an input graph. This almost matches the upper bound of min (O(k), \tilde O(\sqrt{n})) (by Balcan and Blum, 2007 and an algorithm in this paper). We note an interesting fact that, in contrast to n^{1/2-ε} hardness for polynomial-time algorithms, the k-hypergraph pricing problem admits n^δ approximation for any δ>0 in quasi-polynomial time. This puts this problem in a rare approximability class in which approximability thresholds can be improved significantly by allowing algorithms to run in quasi-polynomial time.

cs.CC↗

arXiv2013

Distributed Random Walks

Performing random walks in networks is a fundamental primitive that has found applications in many areas of computer science, including distributed computing. In this paper, we focus on the problem of sampling random walks efficiently in a distributed network and its applications. Given bandwidth constraints, the goal is to minimize the number of rounds required to obtain random walk samples. All previous algorithms that compute a random walk sample of length $\ell$ as a subroutine always do so naively, i.e., in $O(\ell)$ rounds. The main contribution of this paper is a fast distributed algorithm for performing random walks. We present a sublinear time distributed algorithm for performing random walks whose time complexity is sublinear in the length of the walk. Our algorithm performs a random walk of length $\ell$ in $\tilde{O}(\sqrt{\ell D})$ rounds ($\tilde{O}$ hides $\polylog{n}$ factors where $n$ is the number of nodes in the network) with high probability on an undirected network, where $D$ is the diameter of the network. For small diameter graphs, this is a significant improvement over the naive $O(\ell)$ bound. Furthermore, our algorithm is optimal within a poly-logarithmic factor as there exists a matching lower bound [Nanongkai et al. PODC 2011]. We further extend our algorithms to efficiently perform $k$ independent random walks in $\tilde{O}(\sqrt{k\ell D} + k)$ rounds. We also show that our algorithm can be applied to speedup the more general Metropolis-Hastings sampling. Our random walk algorithms can be used to speed up distributed algorithms in applications that use random walks as a subroutine, such as computing a random spanning tree and estimating mixing time and related parameters. Our algorithm is fully decentralized and can serve as a building block in the design of topologically-aware networks.

cs.DC↗

arXiv2012

Dense Subgraphs on Dynamic Networks

In distributed networks, it is often useful for the nodes to be aware of dense subgraphs, e.g., such a dense subgraph could reveal dense subtructures in otherwise sparse graphs (e.g. the World Wide Web or social networks); these might reveal community clusters or dense regions for possibly maintaining good communication infrastructure. In this work, we address the problem of self-awareness of nodes in a dynamic network with regards to graph density, i.e., we give distributed algorithms for maintaining dense subgraphs that the member nodes are aware of. The only knowledge that the nodes need is that of the dynamic diameter $D$, i.e., the maximum number of rounds it takes for a message to traverse the dynamic network. For our work, we consider a model where the number of nodes are fixed, but a powerful adversary can add or remove a limited number of edges from the network at each time step. The communication is by broadcast only and follows the CONGEST model. Our algorithms are continuously executed on the network, and at any time (after some initialization) each node will be aware if it is part (or not) of a particular dense subgraph. We give algorithms that ($2 + ε$)-approximate the densest subgraph and ($3 + ε$)-approximate the at-least-$k$-densest subgraph (for a given parameter $k$). Our algorithms work for a wide range of parameter values and run in $O(D\log_{1+ε} n)$ time. Further, a special case of our results also gives the first fully decentralized approximation algorithms for densest and at-least-$k$-densest subgraph problems for static distributed graphs.

cs.DC↗

arXiv2012

Geometric Pricing: How Low Dimensionality Helps in Approximability

Consider the following toy problem. There are $m$ rectangles and $n$ points on the plane. Each rectangle $R$ is a consumer with budget $B_R$, who is interested in purchasing the cheapest item (point) inside R, given that she has enough budget. Our job is to price the items to maximize the revenue. This problem can also be defined on higher dimensions. We call this problem the geometric pricing problem. In this paper, we study a new class of problems arising from a geometric aspect of the pricing problem. It intuitively captures typical real-world assumptions that have been widely studied in marketing research, healthcare economics, etc. It also helps classify other well-known pricing problems, such as the highway pricing problem and the graph vertex pricing problem on planar and bipartite graphs. Moreover, this problem turns out to have close connections to other natural geometric problems such as the geometric versions of the unique coverage and maximum feasible subsystem problems. We show that the low dimensionality arising in this pricing problem does lead to improved approximation ratios, by presenting sublinear-approximation algorithms for two central versions of the problem: unit-demand uniform-budget min-buying and single-minded pricing problems. Our algorithm is obtained by combining algorithmic pricing and geometric techniques. These results suggest that considering geometric aspect might be a promising research direction in obtaining improved approximation algorithms for such pricing problems. To the best of our knowledge, this is one of very few problems in the intersection between geometry and algorithmic pricing areas. Thus its study may lead to new algorithmic techniques that could benefit both areas.

cs.GT↗

arXiv2012

Faster Algorithms for Semi-Matching Problems

We consider the problem of finding \textit{semi-matching} in bipartite graphs which is also extensively studied under various names in the scheduling literature. We give faster algorithms for both weighted and unweighted case. For the weighted case, we give an $O(nm\log n)$-time algorithm, where $n$ is the number of vertices and $m$ is the number of edges, by exploiting the geometric structure of the problem. This improves the classical $O(n^3)$ algorithms by Horn [Operations Research 1973] and Bruno, Coffman and Sethi [Communications of the ACM 1974]. For the unweighted case, the bound could be improved even further. We give a simple divide-and-conquer algorithm which runs in $O(\sqrt{n}m\log n)$ time, improving two previous $O(nm)$-time algorithms by Abraham [MSc thesis, University of Glasgow 2003] and Harvey, Ladner, Lovász and Tamir [WADS 2003 and Journal of Algorithms 2006]. We also extend this algorithm to solve the \textit{Balance Edge Cover} problem in $O(\sqrt{n}m\log n)$ time, improving the previous $O(nm)$-time algorithm by Harada, Ono, Sadakane and Yamashita [ISAAC 2008].

cs.DS↗

arXiv2011

Distributed Verification and Hardness of Distributed Approximation

We study the {\em verification} problem in distributed networks, stated as follows. Let $H$ be a subgraph of a network $G$ where each vertex of $G$ knows which edges incident on it are in $H$. We would like to verify whether $H$ has some properties, e.g., if it is a tree or if it is connected. We would like to perform this verification in a decentralized fashion via a distributed algorithm. The time complexity of verification is measured as the number of rounds of distributed communication. In this paper we initiate a systematic study of distributed verification, and give almost tight lower bounds on the running time of distributed verification algorithms for many fundamental problems such as connectivity, spanning connected subgraph, and $s-t$ cut verification. We then show applications of these results in deriving strong unconditional time lower bounds on the {\em hardness of distributed approximation} for many classical optimization problems including minimum spanning tree, shortest paths, and minimum cut. Many of these results are the first non-trivial lower bounds for both exact and approximate distributed computation and they resolve previous open questions. Moreover, our unconditional lower bound of approximating minimum spanning tree (MST) subsumes and improves upon the previous hardness of approximation bound of Elkin [STOC 2004] as well as the lower bound for (exact) MST computation of Peleg and Rubinovich [FOCS 1999]. Our result implies that there can be no distributed approximation algorithm for MST that is significantly faster than the current exact algorithm, for {\em any} approximation factor. Our lower bound proofs show an interesting connection between communication complexity and distributed computing which turns out to be useful in establishing the time complexity of exact and approximate distributed computation of many problems.

cs.DC↗

arXiv2011

A Tight Lower Bound on Distributed Random Walk Computation

We consider the problem of performing a random walk in a distributed network. Given bandwidth constraints, the goal of the problem is to minimize the number of rounds required to obtain a random walk sample. Das Sarma et al. [PODC'10] show that a random walk of length $\ell$ on a network of diameter $D$ can be performed in $\tilde O(\sqrt{\ell D}+D)$ time. A major question left open is whether there exists a faster algorithm, especially whether the multiplication of $\sqrt{\ell}$ and $\sqrt{D}$ is necessary. In this paper, we show a tight unconditional lower bound on the time complexity of distributed random walk computation. Specifically, we show that for any $n$, $D$, and $D\leq \ell \leq (n/(D^3\log n))^{1/4}$, performing a random walk of length $Θ(\ell)$ on an $n$-node network of diameter $D$ requires $Ω(\sqrt{\ell D}+D)$ time. This bound is {\em unconditional}, i.e., it holds for any (possibly randomized) algorithm. To the best of our knowledge, this is the first lower bound that the diameter plays a role of multiplicative factor. Our bound shows that the algorithm of Das Sarma et al. is time optimal. Our proof technique introduces a new connection between {\em bounded-round} communication complexity and distributed algorithm lower bounds with $D$ as a trade-off parameter, strengthening the previous study by Das Sarma et al. [STOC'11]. In particular, we make use of the bounded-round communication complexity of the pointer chasing problem. Our technique can be of independent interest and may be useful in showing non-trivial lower bounds on the complexity of other fundamental distributed computing problems.

cs.DC↗

arXiv2010

Efficient Distributed Random Walks with Applications

We focus on the problem of performing random walks efficiently in a distributed network. Given bandwidth constraints, the goal is to minimize the number of rounds required to obtain a random walk sample. We first present a fast sublinear time distributed algorithm for performing random walks whose time complexity is sublinear in the length of the walk. Our algorithm performs a random walk of length $\ell$ in $\tilde{O}(\sqrt{\ell D})$ rounds (with high probability) on an undirected network, where $D$ is the diameter of the network. This improves over the previous best algorithm that ran in $\tilde{O}(\ell^{2/3}D^{1/3})$ rounds (Das Sarma et al., PODC 2009). We further extend our algorithms to efficiently perform $k$ independent random walks in $\tilde{O}(\sqrt{k\ell D} + k)$ rounds. We then show that there is a fundamental difficulty in improving the dependence on $\ell$ any further by proving a lower bound of $Ω(\sqrt{\frac{\ell}{\log \ell}} + D)$ under a general model of distributed random walk algorithms. Our random walk algorithms are useful in speeding up distributed algorithms for a variety of applications that use random walks as a subroutine. We present two main applications. First, we give a fast distributed algorithm for computing a random spanning tree (RST) in an arbitrary (undirected) network which runs in $\tilde{O}(\sqrt{m}D)$ rounds (with high probability; here $m$ is the number of edges). Our second application is a fast decentralized algorithm for estimating mixing time and related parameters of the underlying network. Our algorithm is fully decentralized and can serve as a building block in the design of topologically-aware networks.

cs.DC↗

arXiv2009

Stackelberg Pricing is Hard to Approximate within $2-ε$

Stackelberg Pricing Games is a two-level combinatorial pricing problem studied in the Economics, Operation Research, and Computer Science communities. In this paper, we consider the decade-old shortest path version of this problem which is the first and most studied problem in this family. The game is played on a graph (representing a network) consisting of {\em fixed cost} edges and {\em pricable} or {\em variable cost} edges. The fixed cost edges already have some fixed price (representing the competitor's prices). Our task is to choose prices for the variable cost edges. After that, a client will buy the cheapest path from a node $s$ to a node $t$, using any combination of fixed cost and variable cost edges. The goal is to maximize the revenue on variable cost edges. In this paper, we show that the problem is hard to approximate within $2-ε$, improving the previous \APX-hardness result by Joret [to appear in {\em Networks}]. Our technique combines the existing ideas with a new insight into the price structure and its relation to the hardness of the instances.

cs.GT↗