Computer Science

In this paper we give fast distributed graph algorithms for detecting and listing small subgraphs, and for computing or approximating the girth. Our algorithms improve upon the state of the art by polynomial factors, and for girth, we obtain an constant-time algorithm for additive +1 approximation in the Congested Clique, and the first parametrized algorithm for exact computation in CONGEST. In the Congested Clique, we develop a technique for learning small neighborhoods, and apply it to obtain an O(1) -round algorithm that computes the girth with only an additive +1 error. Next, we introduce a new technique (the partition tree technique) allowing for efficiently and deterministically listing all copies of any subgraph, improving upon the state-of the-art for non-dense graphs. We give two applications of this technique: First we show that for constant k , C 2k -detection can be solved in O(1) rounds in the Congested Clique, improving on prior work which used matrix multiplication and had polynomial round complexity. Second, we show that in triangle-free graphs, the girth can be exactly computed in time polynomially faster than the best known bounds for general graphs. In CONGEST, we describe a new approach for finding cycles, and apply it in two ways: first we show a fast parametrized algorithm for girth with round complexity O ~ (min(g??n 1??/?(g) ,n)) for any girth g ; and second, we show how to find small even-length cycles C 2k for k=3,4,5 in O( n 1??/k ) rounds, which is a polynomial improvement upon the previous running times. Finally, using our improved C 6 -freeness algorithm and the barrier on proving lower bounds on triangle-freeness of Eden et al., we show that improving the current Ω ~ ( n ??????) lower bound for C 6 -freeness of Korhonen et al. by any polynomial factor would imply strong circuit complexity lower bounds.

We revisit the Subset Sum problem over the finite cyclic group Z m for some given integer m . A series of recent works has provided near-optimal algorithms for this problem under the Strong Exponential Time Hypothesis. Koiliaris and Xu (SODA'17, TALG'19) gave a deterministic algorithm running in time O ~ ( m 5/4 ) , which was later improved to O(m log 7 m) randomized time by Axiotis et al. (SODA'19). In this work, we present two simple algorithms for the Modular Subset Sum problem running in near-linear time in m , both efficiently implementing Bellman's iteration over Z m . The first one is a randomized algorithm running in time O(m log 2 m) , that is based solely on rolling hash and an elementary data-structure for prefix sums; to illustrate its simplicity we provide a short and efficient implementation of the algorithm in Python. Our second solution is a deterministic algorithm running in time O(m polylog m) , that uses dynamic data structures for string manipulation. We further show that the techniques developed in this work can also lead to simple algorithms for the All Pairs Non-Decreasing Paths Problem (APNP) on undirected graphs, matching the near-optimal running time of O ~ ( n 2 ) provided in the recent work of Duan et al. (ICALP'19).

A graph is Helly if every family of pairwise intersecting balls has a nonempty common intersection. The class of Helly graphs is the discrete analogue of the class of hyperconvex metric spaces. It is also known that every graph isometrically embeds into a Helly graph, making the latter an important class of graphs in Metric Graph Theory. We study diameter, radius and all eccentricity computations within the Helly graphs. Under plausible complexity assumptions, neither the diameter nor the radius can be computed in truly subquadratic time on general graphs. In contrast to these negative results, it was recently shown that the radius and the diameter of an n -vertex m -edge Helly graph G can be computed with high probability in O ~ (m n ??????) time (i.e., subquadratic in n+m ). In this paper, we improve that result by presenting a deterministic O(m n ??????) time algorithm which computes not only the radius and the diameter but also all vertex eccentricities in a Helly graph. Furthermore, we give a parameterized linear-time algorithm for this problem on Helly graphs, with the parameter being the Gromov hyperbolicity δ . More specifically, we show that the radius and a central vertex of an m -edge δ -hyperbolic Helly graph G can be computed in O(δm) time and that all vertex eccentricities in G can be computed in O( δ 2 m) time. To show this more general result, we heavily use our new structural properties obtained for Helly graphs.

We give an O( k 3 n polylog(nC)) -time algorithm for computing maximum integer flows in planar graphs with integer arc and vertex capacities bounded by C , and k sources and sinks. This improves by a factor of k 2 over the fastest algorithm previously known for this problem [Wang, SODA 2019]. The speedup is obtained by two independent ideas. First we replace an iterative procedure of Wang that uses k invocations of a maximum flow algorithm in a planar graph with k apices [Borradaile et al., FOCS 2012, SICOMP 2017], by an alternative procedure that only makes one invocation of the algorithm of Borradaile et al. Second, we introduce a new variant of the push-relabel algorithm of Goldberg and Tarjan and use it to find a maximum flow in the k -apex graphs that arise in Wang's procedure, faster than the algorithm of Borradaile et al.

Given a weighted undirected graph G=(V,E,w) , a hopset H of hopbound β and stretch (1+ϵ) is a set of edges such that for any pair of nodes u,v∈V , there is a path in G∪H of at most β hops, whose length is within a (1+ϵ) factor from the distance between u and v in G . We provide a decremental algorithm for maintaining hopsets with a polylogarithmic hopbound, with a total update time that matches the best known static algorithm up to polylogarithmic factors. Previously, the best known decremental hopset algorithm had a hopbound of 2 O ~ ( log 3/4 n) [HKN, FOCS'14]. Our decremental hopset algorithm allows us to obtain the following improved decremental algorithms for maintaining shortest paths. - (1+ϵ) -approximate single source shortest paths in amortized update time of 2 O ~ ( logn √ ) . This improves super-polynomially over the best known amortized update time of 2 O ~ ( log 3/4 n) by [HKN, FOCS'14]. - (1+ϵ) -approximate shortest paths from a set of s sources in O ~ (s) amortized update time, assuming that s= n Ω(1) , and |E|= n 1+Ω(1) . In this regime, we give the first decremental algorithm, whose running time matches, up to polylogarithmic factors, the best known static algorithm. - (2k−1)(1+ϵ) -approximate all-pairs shortest paths (for any constant k≥2) , in O ~ ( n 1/k ) amortized update time and O(k) query time. This improves over the best-known amortized update time of O ~ ( n 1/k )⋅(1/ϵ ) O( logn √ ) [Chechik, FOCS'18]. Moreover, we reduce the query time from O(loglog(nW)) to a constant O(k) , and hence eliminate the dependence on n and the aspect ratio W .

Graph burning is a process of information spreading through the network by an agent in discrete steps. The problem is to find an optimal sequence of nodes which have to be given information so that the network is covered in least number of steps. Graph burning problem is NP-Hard for which two approximation algorithms and a few heuristics have been proposed in the literature. In this work, we propose three heuristics, namely, Backbone Based Greedy Heuristic (BBGH), Improved Cutting Corners Heuristic (ICCH) and Component Based Recursive Heuristic (CBRH). These are mainly based on Eigenvector centrality measure. BBGH finds a backbone of the network and picks vertex to be burned greedily from the vertices of the backbone. ICCH is a shortest path based heuristic and picks vertex to burn greedily from best central nodes. The burning number problem on disconnected graphs is harder than on the connected graphs. For example, burning number problem is easy on a path where as it is NP-Hard on disjoint paths. In practice, large networks are generally disconnected and moreover even if the input graph is connected, during the burning process the graph among the unburned vertices may be disconnected. For disconnected graphs, ordering of the components is crucial. Our CBRH works well on disconnected graphs as it prioritizes the components. All the heuristics have been implemented and tested on several bench-mark networks including large networks of size more than 50 K nodes. The experimentation also includes comparison to the approximation algorithms. The advantages of our algorithms are that they are much simpler to implement and also several orders faster than the heuristics proposed in the literature.

We study fast algorithms for computing fundamental properties of a positive semidefinite kernel matrix K??R n?n corresponding to n points x 1 ,?? x n ??R d . In particular, we consider estimating the sum of kernel matrix entries, along with its top eigenvalue and eigenvector. We show that the sum of matrix entries can be estimated to 1+ϵ relative error in time sublinear in n and linear in d for many popular kernels, including the Gaussian, exponential, and rational quadratic kernels. For these kernels, we also show that the top eigenvalue (and an approximate eigenvector) can be approximated to 1+ϵ relative error in time subquadratic in n and linear in d . Our algorithms represent significant advances in the best known runtimes for these problems. They leverage the positive definiteness of the kernel matrix, along with a recent line of work on efficient kernel density estimation.

We address the problem of computing the distribution of induced connected subgraphs, aka \emph{graphlets} or \emph{motifs}, in large graphs. The current state-of-the-art algorithms estimate the motif counts via uniform sampling, by leveraging the color coding technique by Alon, Yuster and Zwick. In this work we extend the applicability of this approach, by introducing a set of algorithmic optimizations and techniques that reduce the running time and space usage of color coding and improve the accuracy of the counts. To this end, we first show how to optimize color coding to efficiently build a compact table of a representative subsample of all graphlets in the input graph. For 8 -node motifs, we can build such a table in one hour for a graph with 65 M nodes and 1.8 B edges, which is 2000 times larger than the state of the art. We then introduce a novel adaptive sampling scheme that breaks the ``additive error barrier'' of uniform sampling, guaranteeing multiplicative approximations instead of just additive ones. This allows us to count not only the most frequent motifs, but also extremely rare ones. For instance, on one graph we accurately count nearly 10.000 distinct 8 -node motifs whose relative frequency is so small that uniform sampling would literally take centuries to find them. Our results show that color coding is still the most promising approach to scalable motif counting.

In fault-tolerant distance labeling we wish to assign short labels to the vertices of a graph G such that from the labels of any three vertices u,v,f we can infer the u -to- v distance in the graph G?�{f} . We show that any directed weighted planar graph (and in fact any graph in a graph family with O( n ??????) -size separators, such as minor-free graphs) admits fault-tolerant distance labels of size O( n 2/3 ) . We extend these labels in a way that allows us to also count the number of shortest paths, and provide additional upper and lower bounds for labels and oracles for counting shortest paths.

The overwhelming majority of survivable (fault-tolerant) network design models assume a uniform fault model. Such a model assumes that every subset of the network resources (edges or vertices) of a given cardinality k may fail. While this approach yields problems with clean combinatorial structure and good algorithms, it often fails to capture the true nature of the scenario set coming from applications. One natural refinement of the uniform model is obtained by partitioning the set of resources into vulnerable and safe resources. The scenario set contains every subset of at most k faulty resources. This work studies the Fault-Tolerant Path (FTP) problem, the counterpart of the Shortest Path problem in this fault model and the Fault-Tolerant Flow problem (FTF), the counterpart of the ℓ -disjoint Shortest s - t Path problem. We present complexity results alongside exact and approximation algorithms for both models. We emphasize the vast increase in the complexity of the problem with respect to the uniform analogue, the Edge-Disjoint Paths problem.