# Showing papers in "ACM Transactions on Algorithms in 2012"

••

TL;DR: Chekuri and Pal as discussed by the authors gave a (2+e)-approximation algorithm for orienteering in undirected and directed graphs, which is the first algorithm to achieve a polylogarithmic approximation ratio.

Abstract: In this article, we consider the orienteering problem in undirected and directed graphs and obtain improved approximation algorithms. The point to point-orienteering problem is the following: Given an edge-weighted graph G=(V, E) (directed or undirected), two nodes s, t ∈ V and a time limit B, find an s-twalk in G of total length at most B that maximizes the number of distinct nodes visited by the walk. This problem is closely related to tour problems such as TSP as well as network design problems such as k-MST. Orienteering with time-windows is the more general problem in which each node v has a specified time-window [R(v), D(v)] and a node v is counted as visited by the walk only if v is visited during its time-window. We design new and improved algorithms for the orienteering problem and orienteering with time-windows. Our main results are the following:— A (2+e) approximation for orienteering in undirected graphs, improving upon the 3-approximation of Bansal et al. [2004].— An O(log2 OPT) approximation for orienteering in directed graphs, where OPT ≤ n is the number of vertices visited by an optimal solution. Previously, only a quasipolynomial-time algorithm due to Chekuri and Pal [2005] achieved a polylogarithmic approximation (a ratio of O(log OPT)).— Given an α approximation for orienteering, we show an O(α c max{log OPT, log lmax/lmin}) approximation for orienteering with time-windows, where lmax and lmin are the lengths of the longest and shortest time-windows respectively.

176 citations

••

TL;DR: It is proved that an optimal cache-oblivious algorithm designed for two levels of memory is also optimal for multiple levels and that the assumption of optimal replacement in the ideal-cache model can be simulated efficiently by LRU replacement.

Abstract: This article presents asymptotically optimal algorithms for rectangular matrix transpose, fast Fourier transform (FFT), and sorting on computers with multiple levels of caching. Unlike previous optimal algorithms, these algorithms are cache oblivious: no variables dependent on hardware parameters, such as cache size and cache-line length, need to be tuned to achieve optimality. Nevertheless, these algorithms use an optimal amount of work and move data optimally among multiple levels of cache. For a cache with size M and cache-line length B where M = Ω(B2), the number of cache misses for an m × n matrix transpose is Θ(1 + mn/B). The number of cache misses for either an n-point FFT or the sorting of n numbers is Θ(1 + (n/B)(1 + logM n)). We also give a Θ(mnp)-work algorithm to multiply an m × n matrix by an n × p matrix that incurs Θ(1 + (mn + np + mp)/B + mnp/B√M) cache faults.We introduce an “ideal-cache” model to analyze our algorithms. We prove that an optimal cache-oblivious algorithm designed for two levels of memory is also optimal for multiple levels and that the assumption of optimal replacement in the ideal-cache model can be simulated efficiently by LRU replacement. We offer empirical evidence that cache-oblivious algorithms perform well in practice.

149 citations

••

TL;DR: In this article, a non-convoyant algorithm for scheduling jobs with sublinear non-decreasing speedup curves on multiple processors with the objective of average response time is presented.

Abstract: We give a scalable ((1+e)-speed O(1)-competitive) nonclairvoyant algorithm for scheduling jobs with sublinear nondecreasing speedup curves on multiple processors with the objective of average response time.

82 citations

••

TL;DR: In this article, the authors give deterministic rendezvous algorithms for agents starting at arbitrary nodes of any anonymous connected graph (finite or infinite) and starting at any interior points with rational coordinates in any closed region of the plane with path-connected interior.

Abstract: Two mobile agents (robots) with distinct labels have to meet in an arbitrary, possibly infinite, unknown connected graph or in an unknown connected terrain in the plane. Agents are modeled as points, and the route of each of them only depends on its label and on the unknown environment. The actual walk of each agent also depends on an asynchronous adversary that may arbitrarily vary the speed of the agent, stop it, or even move it back and forth, as long as the walk of the agent is continuous, does not leave its route and covers all of it. Meeting in a graph means that both agents must be at the same time in some node or in some point inside an edge of the graph, while meeting in a terrain means that both agents must be at the same time in some point of the terrain. Does there exist a deterministic algorithm that allows any two agents to meet in any unknown environment in spite of this very powerful adversaryq We give deterministic rendezvous algorithms for agents starting at arbitrary nodes of any anonymous connected graph (finite or infinite) and for agents starting at any interior points with rational coordinates in any closed region of the plane with path-connected interior. In the geometric scenario agents may have different compasses and different units of length. While our algorithms work in a very general setting -- agents can, indeed, meet almost everywhere -- we show that none of these few limitations imposed on the environment can be removed. On the other hand, our algorithm also guarantees the following approximate rendezvous for agents starting at arbitrary interior points of a terrain as previously stated agents will eventually get to within an arbitrarily small positive distance from each other.

81 citations

••

TL;DR: In this article, the authors present two online algorithms for maintaining a topological order of a directed n-vertex acyclic graph as arcs are added, and detecting a cycle when one is created.

Abstract: We present two online algorithms for maintaining a topological order of a directed n-vertex acyclic graph as arcs are added, and detecting a cycle when one is created. Our first algorithm handles m arc additions in O(m3/2) time. For sparse graphs (m/n = O(1)), this bound improves the best previous bound by a logarithmic factor, and is tight to within a constant factor among algorithms satisfying a natural locality property. Our second algorithm handles an arbitrary sequence of arc additions in O(n5/2) time. For sufficiently dense graphs, this bound improves the best previous bound by a polynomial factor. Our bound may be far from tight: we show that the algorithm can take Ω(n22√2 lgn) time by relating its performance to a generalization of the k-levels problem of combinatorial geometry. A completely different algorithm running in Θ(n2 log n) time was given recently by Bender, Fineman, and Gilbert. We extend both of our algorithms to the maintenance of strong components, without affecting the asymptotic time bounds.

79 citations

••

TL;DR: In this article, the authors considered the problem of scheduling arbitrary wireless links in the physical model of interference to minimize the time for satisfying all requests, and gave an algorithm that achieves an approximation ratio of O(log n c log log Δ), where n is the number of links and Δ is the ratio between the longest and the shortest link length.

Abstract: We consider the scheduling of arbitrary wireless links in the physical model of interference to minimize the time for satisfying all requests. We study here the combined problem of scheduling and power control, where we seek both an assignment of power settings and a partition of the links so that each set satisfies the signal-to-interference-plus-noise (SINR) constraints.We give an algorithm that attains an approximation ratio of O(log n c log log Δ), where n is the number of links and Δ is the ratio between the longest and the shortest link length. Under the natural assumption that lengths are represented in binary, this gives the first approximation ratio that is polylogarithmic in the size of the input. The algorithm has the desirable property of using an oblivious power assignment, where the power assigned to a sender depends only on the length of the link. We give evidence that this dependence on Δ is unavoidable, showing that any reasonably behaving oblivious power assignment results in a Ω(log log Δ)-approximation.These results hold also for the (weighted) capacity problem of finding a maximum (weighted) subset of links that can be scheduled in a single time slot. In addition, we obtain improved approximation for a bidirectional variant of the scheduling problem, give partial answers to questions about the utility of graphs for modeling physical interference, and generalize the setting from the standard 2-dimensional Euclidean plane to doubling metrics. Finally, we explore the utility of graph models in capturing wireless interference.

79 citations

••

TL;DR: This work proves that the integrality gap of the configuration LP is no worse than 1/4, and provides a local search algorithm which finds the corresponding allocation, but is nonconstructive in the sense that this algorithm is not known to converge to a local optimum in a polynomial number of steps.

Abstract: We consider the restricted assignment version of the problem of max-min fair allocation of indivisible goods, also known as the Santa Claus problem. There are m items and n players. Every item has some nonnegative value, and every player is interested in only some of the items. The goal is to distribute the items to the players in a way that maximizes the minimum of the sum of the values of the items given to any player. It was previously shown via a nonconstructive proof that uses the Lovasz local lemma that the integrality gap of a certain configuration LP for the problem is no worse than some (unspecified) constant. This gives a polynomial-time algorithm to estimate the optimum value of the problem within a constant factor, but does not provide a polynomial-time algorithm for finding a corresponding allocation.We use a different approach to analyze the integrality gap. Our approach is based upon local search techniques for finding perfect matchings in certain classes of hypergraphs. As a result, we prove that the integrality gap of the configuration LP is no worse than 1/4. Our proof provides a local search algorithm which finds the corresponding allocation, but is nonconstructive in the sense that this algorithm is not known to converge to a local optimum in a polynomial number of steps.

78 citations

••

TL;DR: These represent the best time bounds known for the all-pairs-shortest-paths problem for an unweighted undirected graph with vertices and edges for all

*m*≪^{1.376}.Abstract: We revisit the all-pairs-shortest-paths problem for an unweighted undirected graph with n vertices and m edges. We present new algorithms with the following running times:l O(mn/log n) if m > n log n log log log nO(mn log log n/log n) if m > n log log nO(n2 log2 log n/log n) if m ≤ n log log n.These represent the best time bounds known for the problem for all mL n1.376. We also obtain a similar type of result for the diameter problem for unweighted directed graphs.

72 citations

••

TL;DR: It is shown that the traveling salesman problem in bounded-degree graphs can be solved in time

*O*((2-ε)*), where ε > 0 depends only on the degree bound but not on the number of cities.*^{n}Abstract: We show that the traveling salesman problem in bounded-degree graphs can be solved in time O((2-e)n), where e > 0 depends only on the degree bound but not on the number of cities, n. The algorithm is a variant of the classical dynamic programming solution due to Bellman, and, independently, Held and Karp. In the case of bounded integer weights on the edges, we also give a polynomial-space algorithm with running time O((2-e)n) on bounded-degree graphs. In addition, we present an analogous analysis of Ryser's algorithm for the permanent of matrices with a bounded number of nonzero entries in each column.

71 citations

••

TL;DR: This work presents fully dynamic algorithms for maintaining spanners in centralized as well as synchronized distributed environments designed for undirected unweighted graphs and use randomization in a crucial manner.

Abstract: Spanner of an undirected graph G = (V,E) is a subgraph that is sparse and yet preserves all-pairs distances approximately. More formally, a spanner with stretcht ∈ N is a subgraph (V,ES), ES ⊆ E such that the distance between any two vertices in the subgraph is at most t times their distance in G. Though G is trivially a t-spanner of itself, the research as well as applications of spanners invariably deal with a t-spanner that has as small number of edges as possible.We present fully dynamic algorithms for maintaining spanners in centralized as well as synchronized distributed environments. These algorithms are designed for undirected unweighted graphs and use randomization in a crucial manner.Our algorithms significantly improve the existing fully dynamic algorithms for graph spanners. The expected size (number of edges) of a t-spanner maintained at each stage by our algorithms matches, up to a polylogarithmic factor, the worst case optimal size of a t-spanner. The expected amortized time (or messages communicated in distributed environment) to process a single insertion/deletion of an edge by our algorithms is close to optimal.

70 citations

••

TL;DR: The first nontrivial algorithm for computing replacement paths in unweighted directed graphs (and in graphs with small integer weights) is presented and it is shown that computing a second simple shortest path may turn out to be an easier problem than computing the replacement paths, thus, the efforts to improve the simple shortest paths algorithm are focused on.

Abstract: Let G = (V,E) be a directed graph and let P be a shortest path from s to t in G. In the replacement paths problem, we are required to find, for every edge e on P, a shortest path from s to t in G that avoids e. The only known algorithm for solving the problem, even for unweighted directed graphs, is the trivial algorithm in which each edge on the path, in its turn, is excluded from the graph and a shortest paths tree is computed from s. The running time is O(mn + n2 log n).The replacement paths problem is strongly motivated by two different applications:(1) The fastest algorithm to compute the ksimple shortest paths between s and t in directed graphs [Yen 1971; Lawler 1972] computes the replacement paths between s and t. Its running time is O(mnk).(2) The replacement paths problem is used to compute the Vickrey pricing of edges in a distributed network. It was raised as an open problem by Nisan and Ronen [2001] whether it is possible to compute the Vickrey pricing faster than n computations of a shortest paths tree.In this article we present the first nontrivial algorithm for computing replacement paths in unweighted directed graphs (and in graphs with small integer weights). Our algorithm is Monte-Carlo and its running time is O(m√n). This result immediately improves the running time of the two applications mentioned above in a factor of √n.We also show how to reduce the problem of computing k simple shortest paths between s and t to O(k) computations of a second simple shortest path from s to t each time in a different subgraph of G. The importance of this result is that computing a second simple shortest path may turn out to be an easier problem than computing the replacement paths, thus, we can focus our efforts to improve the k simple shortest paths algorithm in obtaining a faster algorithm for the second shortest path problem.

••

TL;DR: It is proved that no acknowledgment-based protocol can be stable for injection rates larger than 3 1 + lg n, and the impossibility to achieve just stability by restricted protocols is proved.

Abstract: We study deterministic broadcasting on multiple access channels when packets are injected continuously. The quality of service is considered in the framework of adversarial queuing. An adversary is determined by injection rate and burstiness, the latter denoting the number of packets that can be injected simultaneously in a round. We consider only injection rates that are less than 1. A protocol is stable when the numbers of packets in queues stay bounded at all rounds, and it is of fair latency when waiting times of packets in queues are O(burstiness/rate). For channels with collision detection, we give a full-sensing protocol of fair latency for injection rates that are at most 1 2(⌈lg n⌉ + 1), where n is the number of stations, and show that fair latency is impossible to achieve for injection rates that are ω(1 log n). For channels without collision detection, we present a full-sensing protocol of fair latency for injection rates that are at most 1 c lg2n, for some c > 0. We show that there exists an acknowledgment-based protocol that has fair latency for injection rates that are at most 1 cn lg2n, for some c > 0, and develop an explicit acknowledgment-based protocol of fair latency for injection rates that are at most 1 27n2 ln n. Regarding impossibility to achieve just stability by restricted protocols, we prove that no acknowledgment-based protocol can be stable for injection rates larger than 3 1 + lg n.

••

TL;DR: The aim of power management policies is to reduce the amount of energy consumed by computer systems while maintaining a satisfactory level of performance, and it has been an open problem whether a schedule minimizing the overall energy consumption can be computed in polynomial time.

Abstract: The aim of power management policies is to reduce the amount of energy consumed by computer systems while maintaining a satisfactory level of performance. One common method for saving energy is to simply suspend the system during idle times. No energy is consumed in the suspend mode. However, the process of waking up the system itself requires a certain fixed amount of energy, and thus suspending the system is beneficial only if the idle time is long enough to compensate for this additional energy expenditure. In the specific problem studied in the article, we have a set of jobs with release times and deadlines that need to be executed on a single processor. Preemptions are allowed. The processor requires energy L to be woken up and, when it is on, it uses one unit of energy per one unit of time. It has been an open problem whether a schedule minimizing the overall energy consumption can be computed in polynomial time. We solve this problem in positive, by providing an O(n5)-time algorithm. In addition we provide an O(n4)-time algorithm for computing the minimum energy schedule when all jobs have unit length.

••

TL;DR: In this paper, the authors show that while probing yields significant improvement in the objective function, being adaptive about the probing is not beneficial beyond constant factors, whereas non-adaptive observations can be performed in parallel.

Abstract: In several applications such as databases, planning, and sensor networks, parameters such as selectivity, load, or sensed values are known only with some associated uncertainty. The performance of such a system (as captured by some objective function over the parameters) is significantly improved if some of these parameters can be probed or observed. In a resource constrained situation, deciding which parameters to observe in order to optimize system performance, itself becomes an interesting and important optimization problem. This general problem is the focus of this article.One of the most important considerations in this framework is whether adaptivity is required for the observations. Adaptive observations introduce blocking or sequential operations in the system whereas nonadaptive observations can be performed in parallel. One of the important questions in this regard is to characterize the benefit of adaptivity for probes and observation.We present general techniques for designing constant factor approximations to the optimal observation schemes for several widely used scheduling and metric objective functions. We show a unifying technique that relates this optimization problem to the outlier version of the corresponding deterministic optimization. By making this connection, our technique shows constant factor upper bounds for the benefit of adaptivity of the observation schemes. We show that while probing yields significant improvement in the objective function, being adaptive about the probing is not beneficial beyond constant factors.

••

[...]

TL;DR: It turns out that if the authors take

*P*as a graph with maximum independent set size no greater than*, then this definition gives a natural generalization of both chordal graphs and (*Abstract: In this article we study graphs with inductive neighborhood properties. Let P be a graph property, a graph G = (V, E) with n vertices is said to have an inductive neighborhood property with respect to P if there is an ordering of vertices v1, …, vn such that the property P holds on the induced subgraph G[N(vi)∩ Vi], where N(vi) is the neighborhood of vi and Vi = {vi, …, vn}. It turns out that if we take P as a graph with maximum independent set size no greater than k, then this definition gives a natural generalization of both chordal graphs and (k + 1)-claw-free graphs. We refer to such graphs as inductive k-independent graphs. We study properties of such families of graphs, and we show that several natural classes of graphs are inductive k-independent for small k. In particular, any intersection graph of translates of a convex object in a two dimensional plane is an inductive 3-independent graph; furthermore, any planar graph is an inductive 3-independent graph. For any fixed constant k, we develop simple, polynomial time approximation algorithms for inductive k-independent graphs with respect to several well-studied NP-complete problems. Our generalized formulation unifies and extends several previously known results.

••

TL;DR: A variant of both network creation games, in which each player desires to minimize α times the cost of its created links plus the maximum distance to the other players is introduced, and a constant upper bound for general α is proved, substantially reducing the range of α for which constant bounds have not been obtained.

Abstract: We study Nash equilibria in the setting of network creation games introduced recently by Fabrikant, Luthra, Maneva, Papadimitriou, and Shenker. In this game we have a set of selfish node players, each creating some incident links, and the goal is to minimize α times the cost of the created links plus sum of the distances to all other players. Fabrikant et al. proved an upper bound O(√α) on the price of anarchy: the relative cost of the lack of coordination. Albers, Eilts, Even-Dar, Mansour, and Roditty show that the price of anarchy is constant for α = O(√n) and for α g 12 n ⌈ lg n ⌉, and that the price of anarchy is 15(1+(min{α2/n, n2/α})1/3) for any α. The latter bound shows the first sublinear worst-case bound, O(n1/3), for all α. But no better bound is known for α between ω(√ n) and o(n lg n).Yet α a n is perhaps the most interesting range, for it corresponds to considering the average distance (instead of the sum of distances) to other nodes to be roughly on par with link creation (effectively dividing α by n). In this article, we prove the first o(ne) upper bound for general α, namely 2O(√ lg n). We also prove a constant upper bound for α = O(n1-e) for any fixed e > 0, substantially reducing the range of α for which constant bounds have not been obtained. Along the way, we also improve the constant upper bound by Albers et al. (with the lead constant of 15) to 6 for α n, we prove that the price of anarchy is Θ(n/√ α).Finally we introduce a variant of both network creation games, in which each player desires to minimize α times the cost of its created links plus the maximum distance (instead of the sum of distances) to the other players. This variant of the problem is naturally motivated by considering the worst case instead of the average case. Interestingly, for the original (unilateral) game, we show that the price of anarchy is at most 2 for α g n, O(min {4√lg n, (n/α)1/3}) for 2√ lg n l α l n, and O(n2/α) for α n.

••

TL;DR: An O(log opt) approximation is obtained for set systems of bounded VC-dimension, and an O(1) approximation for covering points by half-spaces in three dimensions and for some other classes of shapes.

Abstract: We consider the set multicover problem in geometric settings. Given a set of points P and a collection of geometric shapes (or sets) F, we wish to find a minimum cardinality subset of F such that each point p ∈ P is covered by (contained in) at least d(p) sets. Here, d(p) is an integer demand (requirement) for p. When the demands d(p) = 1 for all p, this is the standard set cover problem. The set cover problem in geometric settings admits an approximation ratio that is better than that for the general version. In this article, we show that similar improvements can be obtained for the multicover problem as well. In particular, we obtain an O(log opt) approximation for set systems of bounded VC-dimension, and an O(1) approximation for covering points by half-spaces in three dimensions and for some other classes of shapes.

••

TL;DR: A polynomial-time algorithm is described that addresses the problem of bounded degeneracy on graphs that do not have

*K*(the complete bipartite graph on (_{ij}*i) vertices, and has both FPT algorithms andPolynomial kernels in strictly more general classes of graphs.*

Abstract: We show that for every fixed j ≥ i ≥ 1, the k-Dominating Set problem restricted to graphs that do not have Kij (the complete bipartite graph on (i + j) vertices, where the two parts have i and j vertices, respectively) as a subgraph is fixed parameter tractable (FPT) and has a polynomial kernel. We describe a polynomial-time algorithm that, given a Ki,j-free graph G and a nonnegative integer k, constructs a graph H (the “kernel”) and an integer k' such that (1) G has a dominating set of size at most k if and only if H has a dominating set of size at most k', (2) H has O((j + 1)i + 1ki2) vertices, and (3) k' = O((j + 1)i + 1ki2).Since d-degenerate graphs do not have Kd+1,d+1 as a subgraph, this immediately yields a polynomial kernel on O((d + 2)d+2k(d + 1)2) vertices for the k-Dominating Set problem on d-degenerate graphs, solving an open problem posed by Alon and Gutner [Alon and Gutner 2008; Gutner 2009].The most general class of graphs for which a polynomial kernel was previously known for k-Dominating Set is the class of Kh-topological-minor-free graphs [Gutner 2009]. Graphs of bounded degeneracy are the most general class of graphs for which an FPT algorithm was previously known for this problem. Kh-topological-minor-free graphs are Ki,j-free for suitable values of i,j (but not vice-versa), and so our results show that k-Dominating Set has both FPT algorithms and polynomial kernels in strictly more general classes of graphs.Using the same techniques, we also obtain an O(jki) vertex-kernel for the k-Independent Dominating Set problem on Ki,j-free graphs.

*••*

TL;DR: In this article, a bicriteria O(log n, 1+e)-approximation algorithm was given for general metrics and a (1+e, 1 + e) approximation algorithm for tree metrics.

Abstract: In a Content Distribution Network (CDN), there are m servers storing the data; each of them has a specific bandwidth. All the requests from a particular client should be assigned to one server because of the routing protocol used. The goal is to minimize the total cost of these assignments—cost of each is proportional to the distance between the client and the server as well as the request size—while the load on each server is kept below its bandwidth limit. When each server also has a setup cost, this is an unsplittable hard-capacitated facility location problem. As much attention as facility location problems have received, there has been no nontrivial approximation algorithm when we have hard capacities (i.e., there can only be one copy of each facility whose capacity cannot be violated) and demands are unsplittable (i.e., all the demand from a client has to be assigned to a single facility). We observe it is NP-hard to approximate the cost to within any bounded factor in this case. Thus, for an arbitrary constant e>0, we relax the capacities to a 1+e factor. For the case where capacities are almost uniform, we give a bicriteria O(log n, 1+e)-approximation algorithm for general metrics and a (1+e, 1+e)-approximation algorithm for tree metrics. A bicriteria (α,β)-approximation algorithm produces a solution of cost at most α times the optimum, while violating the capacities by no more than a β factor. We can get the same guarantees for nonuniform capacities if we allow quasipolynomial running time. In our algorithm, some clients guess the facility they are assigned to, and facilities decide the size of the clients they serve. A straightforward approach results in exponential running time. When costs do not satisfy metricity, we show that a 1.5 violation of capacities is necessary to obtain any approximation.It is worth noting that our results generalize bin packing (zero connection costs and facility costs equal to one), knapsack (single facility with all costs being zero), minimum makespan scheduling for related machines (all connection costs being zero), and some facility location problems.

*••*

TL;DR: For the k-Leaf-Out-Branching problem, it was shown in this paper that no polynomial-sized kernel is possible unless coNP is in NP/poly.

Abstract: The k-Leaf Out-Branching problem is to find an out-branching, that is a rooted oriented spanning tree, with at least k leaves in a given digraph. The problem has recently received much attention from the viewpoint of parameterized algorithms. Here, we take a kernelization based approach to the k-Leaf-Out-Branching problem. We give the first polynomial kernel for Rooted k-Leaf-Out-Branching, a variant of k-Leaf-Out-Branching where the root of the tree searched for is also a part of the input. Our kernel with O(k3) vertices is obtained using extremal combinatorics.For the k-Leaf-Out-Branching problem, we show that no polynomial-sized kernel is possible unless coNP is in NP/poly. However, our positive results for Rooted k-Leaf-Out-Branching immediately imply that the seemingly intractable k-Leaf-Out-Branching problem admits a data reduction to n independent polynomial-sized kernels. These two results, tractability and intractability side by side, are the first ones separating Karp kernelization from Turing kernelization. This answers affirmatively an open problem regarding “cheat kernelization” raised by Mike Fellows and Jiong Guo independently.

*••*

Utrecht University

^{1}, University of Bergen^{2}, RWTH Aachen University^{3}, Metz^{4}, National and Kapodistrian University of Athens^{5}

TL;DR: In this article, the authors present a dynamic programming algorithm for computing the treewidth of a graph with running time Oa(2n) using only polynomial space.

Abstract: We give experimental and theoretical results on the problem of computing the treewidth of a graph by exact exponential-time algorithms using exponential space or using only polynomial space. We first report on an implementation of a dynamic programming algorithm for computing the treewidth of a graph with running time Oa(2n). This algorithm is based on the old dynamic programming method introduced by Held and Karp for the Traveling Salesman problem. We use some optimizations that do not affect the worst case running time but improve on the running time on actual instances and can be seen to be practical for small instances. We also consider the problem of computing Treewidth under the restriction that the space used is only polynomial and give a simple Oa(4n) algorithm that requires polynomial space. We also show that with a more complicated algorithm using balanced separators, Treewidth can be computed in Oa(2.9512n) time and polynomial space.

*••*

TL;DR: It is shown that Θ(n log log n) best responses are necessary and sufficient to achieve states that approximate the optimal solution by a constant factor, under the assumption that every O(n) steps each player performs a constant (and nonnull) number of best responses.

Abstract: We investigate the speed of convergence of best response dynamics to approximately optimal solutions in congestion games with linear delay functions. In Ackermann et al. [2008] it has been shown that the convergence time of such dynamics to Nash equilibrium may be exponential in the number of players n. Motivated by such a negative result, we focus on the study of the states (not necessarily being equilibria) reached after a limited number of players' selfish moves, and we show that Θ(n log log n) best responses are necessary and sufficient to achieve states that approximate the optimal solution by a constant factor, under the assumption that every O(n) steps each player performs a constant (and nonnull) number of best responses. We show that such result is tight also for the simplest case of singleton congestion games.

*••*

TL;DR: In this paper, the authors investigated the effect of Stackelberg routing and network tolls on the performance degradation due to selfish behavior in a network with arbitrary (convex) latency functions that are a function of edge traffic, and they showed that the worst-case ratio of the system delay caused by selfish behavior versus the delay of the optimal centralized solution may be unbounded even if the system consists of only two parallel links.

Abstract: It is well known that in a network with arbitrary (convex) latency functions that are a function of edge traffic, the worst-case ratio, over all inputs, of the system delay caused due to selfish behavior versus the system delay of the optimal centralized solution may be unbounded even if the system consists of only two parallel links. This ratio is called the price of anarchy (PoA). In this article, we investigate ways by which one can reduce the performance degradation due to selfish behavior. We investigate two primary methods (a) Stackelberg routing strategies, where a central authority, for example, network manager, controls a fixed fraction of the flow, and can route this flow in any desired way so as to influence the flow of selfish users; and (b) network tolls, where tolls are imposed on the edges to modify the latencies of the edges, and thereby influence the induced Nash equilibrium. We obtain results demonstrating the effectiveness of both Stackelberg strategies and tolls in controlling the price of anarchy.For Stackelberg strategies, we obtain the first results for nonatomic routing in graphs more general than parallel-link graphs, and strengthen existing results for parallel-link graphs. (i) In series-parallel graphs, we show that Stackelberg routing reduces the PoA to a constant (depending on the fraction of flow controlled). (ii) For general graphs, we obtain latency-class specific bounds on the PoA with Stackelberg routing, which give a continuous trade-off between the fraction of flow controlled and the price of anarchy. (iii) In parallel-link graphs, we show that for any given class L of latency functions, Stackelberg routing reduces the PoA to at most α + (1-α)cρ(L), where α is the fraction of flow controlled and ρ(L) is the PoA of class L (when α = 0).For network tolls, motivated by the known strong results for nonatomic games, we consider the more general setting of atomic splittable routing games. We show that tolls inducing an optimal flow always exist, even for general asymmetric games with heterogeneous users, and can be computed efficiently by solving a convex program. This resolves a basic open question about the effectiveness of tolls for atomic splittable games. Furthermore, we give a complete characterization of flows that can be induced via tolls.

*••*

TL;DR: A succinct representation of ordinal trees, based on that of Geary et al.

Abstract: Various methods have been used to represent a tree on n nodes in essentially the information-theoretic minimum space while supporting various navigational operations in constant time, but different representations usually support different operations. Our main contribution is a succinct representation of ordinal trees, based on that of Geary et al. [2006], that supports all the navigational operations supported by various succinct tree representations while requiring only 2n + o(n) bits. It also supports efficient level-order traversal, a useful ordering previously supported only with a very limited set of operations.Our second contribution expands on the notion of a single succinct representation supporting more than one traversal ordering, by showing that our method supports two other encoding schemes as abstract data types. In particular, it supports extracting a word (O(lg n) bits) of the balanced parenthesis sequence or depth first unary degree sequence in O(f(n)) time, using at most n/f(n)+o(n) additional bits, for any f(n) in O(lg n) and Ω(1).

*••*

TL;DR: This article is given a collection P of n uncertain points in ℝ, each represented by its one-dimensional probability density function (pdf), and aims to build a data structure on P such that, given a query interval I and a probability threshold τ, it can quickly report all points of P that lie in I with probability at least τ.

Abstract: Querying uncertain data has emerged as an important problem in data management due to the imprecise nature of many measurement data. In this article, we study answering range queries over uncertain data. Specifically, we are given a collection P of n uncertain points in ℝ, each represented by its one-dimensional probability density function (pdf). The goal is to build a data structure on P such that, given a query interval I and a probability threshold τ, we can quickly report all points of P that lie in I with probability at least τ. We present various structures with linear or near-linear space and (poly)logarithmic query time. Our structures support pdf's that are either histograms or more complex ones such as Gaussian or piecewise algebraic.

*••*

TL;DR: The aim of this article is to determine the probability that Cuckoo hashing produces no conflicts and give an upper bound for the construction time, that is linear in the size of the table.

Abstract: Cuckoo hashing was introduced by Pagh and Rodler in 2001. Its main feature is that it provides constant worst-case search time. The aim of this article is to present a precise average case analysis of Cuckoo hashing. In particular, we determine the probability that Cuckoo hashing produces no conflicts and give an upper bound for the construction time, that is linear in the size of the table. The analysis rests on a generating function approach to the so called Cuckoo Graph, a random bipartite graph, and an application of a double saddle point method to obtain asymptotic expansions. Furthermore, we provide some results concerning the structure of these kinds of random graphs. Our results extend the analysis of Devroye and Morin [2003]. Additionally, we provide numerical results confirming the mathematical analysis.

*••*

TL;DR: A new framework for designing online algorithms that can incorporate additional information about the input sequence, while maintaining a reasonable competitive ratio if the additional information is incorrect is introduced.

Abstract: We introduce a new framework for designing online algorithms that can incorporate additional information about the input sequence, while maintaining a reasonable competitive ratio if the additional information is incorrect. Within this framework, we present online algorithms for several problems including allocation of online advertisement space, load balancing, and facility location.

*••*

TL;DR: In this paper, the authors considered distributed multicommodity flow problems with multiple agents operating in a cooperative but uncoordinated manner, and proposed a (1 + e)-approximation algorithm with convergence time linear in the maximal path length.

Abstract: We consider solutions for distributed multicommodity flow problems, which are solved by multiple agents operating in a cooperative but uncoordinated manner. We show first distributed solutions that allow (1 + e) approximation and whose convergence time is essentially linear in the maximal path length, and is independent of the number of commodities and the size of the graph. Our algorithms use a very natural approximate steepest descent framework, combined with a blocking flow technique to speed up the convergence in distributed and parallel environment. Previously known solutions that achieved comparable convergence time and approximation ratio required exponential computational and space overhead per agent.

*••*

TL;DR: The objective is to maximize the sum of the weights of the packets that are sent by their deadlines, and the main results include an optimal, competitive deterministic online algorithm, a (4/3 ≈ 1.33)-competitive randomized online algorithm against an oblivious adversary, and a 2-speed 1-competitive deterministicOnline algorithm.

Abstract: This article concerns an online packet scheduling problem that arises as a natural model for buffer management at a network router. Packets arrive at a router at integer time steps, and are buffered upon arrival. Packets have non-negative weights and integer deadlines that are (weakly) increasing in their arrival times. In each integer time step, at most one packet can be sent. The objective is to maximize the sum of the weights of the packets that are sent by their deadlines. The main results include an optimal (φ := (1 + √ 5)/2 a 1.618)-competitive deterministic online algorithm, a (4/3 a 1.33)-competitive randomized online algorithm against an oblivious adversary, and a 2-speed 1-competitive deterministic online algorithm. The analysis does not use a potential function explicitly, but instead modifies the adversary's buffer and credits the adversary to account for these modifications.

*••*

TL;DR: This work provides alabeled routing scheme that, after a stretch--5 handshaking step (similar to DNS lookup in TCP/IP), routes messages along stretch--3 paths and obtains the first analytical bound coupled to the parameter of the power-law graph model for a compact routing scheme.

Abstract: Compact routing addresses the tradeoff between table sizes and stretch, which is the worst-case ratio between the length of the path a packet is routed through by the scheme and the length of an actual shortest path from source to destination. We adapt the compact routing scheme by Thorup and Zwick [2001] to optimize it for power-law graphs. We analyze our adapted routing scheme based on the theory of unweighted random power-law graphs with fixed expected degree sequence by Aiello et al. [2000]. Our result is the first analytical bound coupled to the parameter of the power-law graph model for a compact routing scheme.Let n denote the number of nodes in the network. We provide a labeled routing scheme that, after a stretch--5 handshaking step (similar to DNS lookup in TCP/IP), routes messages along stretch--3 paths. We prove that, instead of routing tables with O(n1/2) bits (O suppresses factors logarithmic in n) 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(n1+γ log n), with γ = τ-22/τ-3 + e, where τ∈(2,3) is the power-law exponent and e 0 (which implies e