arXiv subjects

Vijaya Ramachandran

Publications and source records attributed to Vijaya Ramachandran.

At least 19 recordsLinked to original sources

arXiv2025

Algorithms for Distance Sensitivity Oracles and other Graph Problems on the PRAM

The distance sensitivity oracle (DSO) problem asks us to preprocess a given graph $G=(V,E)$ in order to answer queries of the form $d(x,y,e)$, which denotes the shortest path distance in $G$ from vertex $x$ to vertex $y$ when edge $e$ is removed. This is an important problem for network communication, and it has been extensively studied in the sequential settingand recently in the distributed CONGEST model. However, no prior DSO results tailored to the parallel setting were known. We present the first PRAM algorithms to construct DSOs in directed weighted graphs, that can answer a query in $O(1)$ time with a single processor after preprocessing. We also present the first work-optimal PRAM algorithms for other graph problems that belong to the sequential $\tilde{O}(mn)$ fine-grained complexity class: Replacement Paths, Second Simple Shortest Path, All Pairs Second Simple Shortest Paths and Minimum Weight Cycle.

cs.DS↗

arXiv2025

Distributed Distance Sensitivity Oracles

We present results for the distance sensitivity oracle (DSO) problem, where one needs to preprocess a given directed weighted graph $G=(V,E)$ in order to answer queries about the shortest path distance in $G$ from vertex $s$ to vertex $t$ avoiding edge $e$, for any $s,t \in V, e \in E$. DSO enables optimal re-routing under a link failure, and can serve as a key component for fault tolerance in a distributed setting. However, no non-trivial results for DSO are known in the distributed CONGEST model. We present DSO algorithms with different tradeoffs between preprocessing and query cost: one that optimizes query response rounds, and another that prioritizes preprocessing rounds. We complement these algorithms with unconditional CONGEST lower bounds for DSO. Our DSO lower bounds build on a lower bound we present for the $k$-source shortest paths problem ($k$-SSP), which may be of independent interest. Additionally, we present almost-optimal upper and lower bounds for the related all pairs second simple shortest path (2-APSiSP) problem.

cs.DS↗

arXiv2024

Improved Approximation Bounds for Minimum Weight Cycle in the CONGEST Model

Minimum Weight Cycle (MWC) is the problem of finding a simple cycle of minimum weight in a graph $G=(V,E)$. This is a fundamental graph problem with classical sequential algorithms that run in $\tilde{O}(n^3)$ and $\tilde{O}(mn)$ time where $n=|V|$ and $m=|E|$. In recent years this problem has received significant attention in the context of fine-grained sequential complexity as well as in the design of faster sequential approximation algorithms, though not much is known in the distributed CONGEST model. We present sublinear-round approximation algorithms for computing MWC in directed graphs, and weighted graphs. Our algorithms use a variety of techniques in non-trivial ways, such as in our approximate directed unweighted MWC algorithm that efficiently computes BFS from all vertices restricted to certain implicitly computed neighborhoods in sublinear rounds, and in our weighted approximation algorithms that use unweighted MWC algorithms on scaled graphs combined with a fast and streamlined method for computing multiple source approximate SSSP. We present $\tildeΩ(\sqrt{n})$ lower bounds for arbitrary constant factor approximation of MWC in directed graphs and undirected weighted graphs.

cs.DS↗

arXiv2024

Near Optimal Bounds for Replacement Paths and Related Problems in the CONGEST Model

We present several results in the CONGEST model on round complexity for Replacement Paths (RPaths), Minimum Weight Cycle (MWC), and All Nodes Shortest Cycles (ANSC). We study these fundamental problems in both directed and undirected graphs, both weighted and unweighted. Many of our results are optimal to within a polylog factor: For an $n$-node graph $G$ we establish near linear lower and upper bounds for computing RPaths if $G$ is directed and weighted, and for computing MWC and ANSC if $G$ is weighted, directed or undirected; near $\sqrt{n}$ lower and upper bounds for undirected weighted RPaths; and $Θ(D)$ bound for undirected unweighted RPaths. We also present lower and upper bounds for approximation versions of these problems, notably a $(2-(1/g))$-approximation algorithm for undirected unweighted MWC that runs in $\tilde{O}(\sqrt{n}+D)$ rounds, improving on the previous best bound of $\tilde{O}(\sqrt{ng}+D)$ rounds, where $g$ is the MWC length. We present a $(1+ε)$-approximation algorithm for directed weighted RPaths, which beats the linear lower bound for exact RPaths.

cs.DS↗

arXiv2022

Fully Dynamic All Pairs All Shortest Paths

We consider the all pairs all shortest paths (APASP) problem, which maintains all of the multiple shortest paths for every vertex pair in a directed graph $G=(V,E)$ with a positive real weight on each edge. We present two fully dynamic algorithms for this problem in which an update supports either weight increases or weight decreases on a subset of edges incident to a vertex. Our first algorithm runs in amortized $O({ν^*}^2 \cdot \log^3 n)$ time per update, where $n = |V|$, and $ν^*$ bounds the number of edges that lie on shortest paths through any single vertex. Our APASP algorithm leads to the same amortized bound for the fully dynamic computation of betweenness centrality (BC), which is a parameter widely used in the analysis of large complex networks. Our method is a generalization and a variant of the fully dynamic algorithm of Demetrescu and Italiano [DI04] for unique shortest path, and it builds on our recent decremental APASP [NPR14]. Our second (faster) algorithm reduces the amortized cost per operation by a logarithmic factor, and uses new data structures and techniques that are extensions of methods in a fully dynamic algorithm by Thorup.

cs.DS↗

arXiv2021

Data Oblivious Algorithms for Multicores

As secure processors such as Intel SGX (with hyperthreading) become widely adopted, there is a growing appetite for private analytics on big data. Most prior works on data-oblivious algorithms adopt the classical PRAM model to capture parallelism. However, it is widely understood that PRAM does not best capture realistic multicore processors, nor does it reflect parallel programming models adopted in practice. In this paper, we initiate the study of parallel data oblivious algorithms on realistic multicores, best captured by the binary fork-join model of computation. We first show that data-oblivious sorting can be accomplished by a binary fork-join algorithm with optimal total work and optimal (cache-oblivious) cache complexity, and in O(log n log log n) span (i.e., parallel time) that matches the best-known insecure algorithm. Using our sorting algorithm as a core primitive, we show how to data-obliviously simulate general PRAM algorithms in the binary fork-join model with non-trivial efficiency. We also present results for several applications including list ranking, Euler tour, tree contraction, connected components, and minimum spanning forest. For a subset of these applications, our data-oblivious algorithms asymptotically outperform the best known insecure algorithms. For other applications, we show data oblivious algorithms whose performance bounds match the best known insecure algorithms. Complementing these asymptotically efficient results, we present a practical variant of our sorting algorithm that is self-contained and potentially implementable. It has optimal caching cost, and it is only a log log n factor off from optimal work and about a log n factor off in terms of span; moreover, it achieves small constant factors in its bounds.

cs.DC↗

arXiv2020

Faster Deterministic All Pairs Shortest Paths in Congest Model

We present a new deterministic algorithm for distributed weighted all pairs shortest paths (APSP) in both undirected and directed graphs. Our algorithm runs in $\tilde{O}(n^{4/3})$ rounds in the Congest models on graphs with arbitrary edge weights, and it improves on the previous $\tilde{O}(n^{3/2})$ bound of Agarwal et al. [ARKP18]. The main components of our new algorithm are a new faster technique for constructing blocker set deterministically and a new pipelined method for deterministically propagating distance values from source nodes to the blocker set nodes in the network. Both of these techniques have potential applications to other distributed algorithms. Our new deterministic algorithm for computing blocker set adapts the NC approximate hypergraph set cover algorithm in [BRS94] to the distributed construction of a blocker set. It follows the two-step process of first designing a randomized algorithm that uses only pairwise independence, and then derandomizes this algorithm using a sample space of linear size. This algorithm runs in almost the same number of rounds as the initial step in our APSP algorithm that computes $h$-hops shortest paths, and significantly improves on the deterministic blocker set algorithms in [ARKP18, AR19] by removing an additional $n\cdot |Q|$ term in the round bound, where Q is the blocker set. The other new component in our APSP algorithm is a deterministic pipelined approach to propagate distance values from source nodes to blocker nodes. We use a simple natural round-robin method for this step, and we show using a suitable progress measure that it achieve the $\tilde{O}(n^{4/3})$ bound on the number of rounds. It appears that the standard deterministic methods for efficiently broadcasting multiple values, and for sending or receiving messages using the routing schedule in [HPDG+19,LSP19] do not apply to this setting.

cs.DS↗

arXiv2019

Distributed Algorithms for Directed Betweenness Centrality and All Pairs Shortest Paths

The betweenness centrality (BC) of a node in a network (or graph) is a measure of its importance in the network. BC is widely used in a large number of environments such as social networks, transport networks, security/mobile networks and more. We present an O(n)-round distributed algorithm for computing BC of every vertex as well as all pairs shortest paths (APSP) in a directed unweighted network, where n is the number of vertices and m is the number of edges. We also present O(n)-round distributed algorithms for computing APSP and BC in a weighted directed acyclic graph (dag). Our algorithms are in the Congest model and our weighted dag algorithms appear to be the first nontrivial distributed algorithms for both APSP and BC. All our algorithms pay careful attention to the constant factors in the number of rounds and number of messages sent, and for unweighted graphs they improve on one or both of these measures by at least a constant factor over previous results for both directed and undirected APSP and BC.

cs.DS↗

arXiv2018

A Deterministic Distributed Algorithm for Weighted All Pairs Shortest Paths Through Pipelining

We present a new pipelined approach to compute all pairs shortest paths (APSP) in a directed graph with nonnegative integer edge weights (including zero weights) in the CONGEST model in the distributed setting. Our deterministic distributed algorithm computes shortest paths of distance at most $Δ$ for all pairs of vertices in at most $2 n \sqrtΔ + 2n$ rounds, and more generally, it computes h-hop shortest paths for k sources in $2\sqrt{nkh} + n + k$ rounds. The algorithm is simple, and it has some novel features and a nontrivial analysis.It uses only the directed edges in the graph for communication. This algorithm can be used as a base within asymptotically faster algorithms that match or improve on the current best deterministic bound of $\tilde{O}(n^{3/2})$ rounds for this problem when edge weights are $O(n)$ or shortest path distances are $\tilde{O}(n^{3/2})$.

cs.DS↗

arXiv2018

New and Simplified Distributed Algorithms for Weighted All Pairs Shortest Paths

We consider the problem of computing all pairs shortest paths (APSP) and shortest paths for k sources in a weighted graph in the distributed CONGEST model. For graphs with non-negative integer edge weights (including zero weights) we build on a recent pipelined algorithm to obtain $\tilde{O}(λ^{1/4}\cdot n^{5/4})$ in graphs with non-negative integer edge-weight at most $λ$, and $\tilde{O}(n \cdot \bigtriangleup^{1/3})$ rounds for shortest path distances at most $\bigtriangleup$. Additionally, we simplify some of the procedures in the earlier APSP algorithms for non-negative edge weights in [HNS17,ARKP18]. We also present results for computing h-hop shortest paths and shortest paths from $k$ given sources. In other results, we present a randomized exact APSP algorithm for graphs with arbitrary edge weights that runs in $\tilde{O}(n^{4/3})$ rounds w.h.p. in n, which improves the previous best $\tilde{O}(n^{3/2})$ bound, which is deterministic. We also present an $\tilde{O}(n/ε^2)$-round deterministic $(1+ε)$ approximation algorithm for graphs with non-negative $poly(n)$ integer weights (including zero edge-weights), improving results in [Nanongkai14,LP15] that hold only for positive integer weights.

cs.DS↗

arXiv2018

A Deterministic Distributed Algorithm for Exact Weighted All-Pairs Shortest Paths in $\tilde{O}(n^{3/2})$ Rounds

We present a deterministic distributed algorithm to compute all-pairs shortest paths(APSP) in an edge-weighted directed or undirected graph. Our algorithm runs in $\tilde{O}(n^{3/2})$ rounds in the Congest model, where $n$ is the number of nodes in the graph. This is the first $o(n^2)$ rounds deterministic distributed algorithm for the weighted APSP problem. Our algorithm is fairly simple and incorporates a deterministic distributed algorithm we develop for computing a `blocker set' \cite{King99}, which has been used earlier in sequential dynamic computation of APSP.

cs.DS↗

arXiv2017

Resource Oblivious Sorting on Multicores

We present a deterministic sorting algorithm, SPMS (Sample, Partition, and Merge Sort), that interleaves the partitioning of a sample sort with merging. Sequentially, it sorts $n$ elements in $O(n \log n)$ time cache-obliviously with an optimal number of cache misses. The parallel complexity (or critical path length) of the algorithm is $O(\log n \cdot \log\log n)$, which improves on previous bounds for optimal cache oblivious sorting. The algorithm also has low false sharing costs. When scheduled by a work-stealing scheduler in a multicore computing environment with a global shared memory and $p$ cores, each having a cache of size $M$ organized in blocks of size $B$, the costs of the additional cache misses and false sharing misses due to this parallel execution are bounded by the cost of $O(S\cdot M/B)$ and $O(S \cdot B)$ cache misses respectively, where $S$ is the number of steals performed during the execution. Finally, SPMS is resource oblivious in Athat the dependence on machine parameters appear only in the analysis of its performance, and not within the algorithm itself.

cs.DS↗

arXiv2017

Fine-Grained Complexity and Conditional Hardness for Sparse Graphs

We consider the fine-grained complexity of sparse graph problems that currently have $\tilde{O}(mn)$ time algorithms, where m is the number of edges and n is the number of vertices in the input graph. This class includes several important path problems on both directed and undirected graphs, including APSP, MWC (minimum weight cycle), and Eccentricities, which is the problem of computing, for each vertex in the graph, the length of a longest shortest path starting at that vertex. We introduce the notion of a sparse reduction which preserves the sparsity of graphs, and we present near linear-time sparse reductions between various pairs of graph problems in the $\tilde{O}(mn)$ class. Surprisingly, very few of the known nontrivial reductions between problems in the $\tilde{O}(mn)$ class are sparse reductions. In the directed case, our results give a partial order on a large collection of problems in the $\tilde{O}(mn)$ class (along with some equivalences). In the undirected case we give two nontrivial sparse reductions: from MWC to APSP, and from unweighted ANSC (all nodes shortest cycles) to APSP. The latter reduction also gives an improved algorithm for ANSC (for dense graphs). We propose the MWC Conjecture, a new conditional hardness conjecture that the weight of a minimum weight cycle in a directed graph cannot be computed in time polynomially smaller than mn. Our sparse reductions for directed path problems in the $\tilde{O}(mn)$ class establish that several problems in this class, including 2-SiSP (second simple shortest path), Radius, and Eccentricities, are MWCC hard. We also identify Eccentricities as a key problem in the $\tilde{O}(mn)$ class which is simultaneously MWCC-hard, SETH-hard and k-DSH-hard, where SETH is the Strong Exponential Time Hypothesis, and k-DSH is the hypothesis that a dominating set of size k cannot be computed in time polynomially smaller than n^k.

cs.DS↗

arXiv2017

Bounding Cache Miss Costs of Multithreaded Computations Under General Schedulers

We analyze the caching overhead incurred by a class of multithreaded algorithms when scheduled by an arbitrary scheduler. We obtain bounds that match or improve upon the well-known $O(Q+S \cdot (M/B))$ caching cost for the randomized work stealing (RWS) scheduler, where $S$ is the number of steals, $Q$ is the sequential caching cost, and $M$ and $B$ are the cache size and block (or cache line) size respectively.

cs.DC↗

arXiv2016

Finding $k$ Simple Shortest Paths and Cycles

The problem of finding multiple simple shortest paths in a weighted directed graph $G=(V,E)$ has many applications, and is considerably more difficult than the corresponding problem when cycles are allowed in the paths. Even for a single source-sink pair, it is known that two simple shortest paths cannot be found in time polynomially smaller than $n^3$ (where $n=|V|$) unless the All-Pairs Shortest Paths problem can be solved in a similar time bound. The latter is a well-known open problem in algorithm design. We consider the all-pairs version of the problem, and we give a new algorithm to find $k$ simple shortest paths for all pairs of vertices. For $k=2$, our algorithm runs in $O(mn + n^2 \log n)$ time (where $m=|E|$), which is almost the same bound as for the single pair case, and for $k=3$ we improve earlier bounds. Our approach is based on forming suitable path extensions to find simple shortest paths; this method is different from the `detour finding' technique used in most of the prior work on simple shortest paths, replacement paths, and distance sensitivity oracles. Enumerating simple cycles is a well-studied classical problem. We present new algorithms for generating simple cycles and simple paths in $G$ in non-decreasing order of their weights; the algorithm for generating simple paths is much faster, and uses another variant of path extensions. We also give hardness results for sparse graphs, relative to the complexity of computing a minimum weight cycle in a graph, for several variants of problems related to finding $k$ simple paths and cycles.

cs.DS↗

arXiv2015

A Faster Algorithm for Fully Dynamic Betweenness Centrality

We present a new fully dynamic algorithm for maintaining betweenness centrality (BC) of vertices in a directed graph $G=(V,E)$ with positive edge weights. BC is a widely used parameter in the analysis of large complex networks. We achieve an amortized $O((ν^*)^2 \log^2 n)$ time per update, where $n = |V| $ and $ν^*$ bounds the number of distinct edges that lie on shortest paths through any single vertex. This result improves on the amortized bound for fully dynamic BC in [Pontecorvi-Ramachandran2015] by a logarithmic factor. Our algorithm uses new data structures and techniques that are extensions of the method in the fully dynamic algorithm in Thorup [Thorup2004] for APSP in graphs with unique shortest paths. For graphs with $ν^* = O(n)$, our algorithm matches the fully dynamic APSP bound in [Thorup2004], which holds for graphs with $ν^* = n-1$, since it assumes unique shortest paths.

cs.DS↗

arXiv2014

Decremental All-Pairs ALL Shortest Paths and Betweenness Centrality

We consider the all pairs all shortest paths (APASP) problem, which maintains the shortest path dag rooted at every vertex in a directed graph G=(V,E) with positive edge weights. For this problem we present a decremental algorithm (that supports the deletion of a vertex, or weight increases on edges incident to a vertex). Our algorithm runs in amortized O(\vstar^2 \cdot \log n) time per update, where n=|V|, and \vstar bounds the number of edges that lie on shortest paths through any given vertex. Our APASP algorithm can be used for the decremental computation of betweenness centrality (BC), a graph parameter that is widely used in the analysis of large complex networks. No nontrivial decremental algorithm for either problem was known prior to our work. Our method is a generalization of the decremental algorithm of Demetrescu and Italiano [DI04] for unique shortest paths, and for graphs with \vstar =O(n), we match the bound in [DI04]. Thus for graphs with a constant number of shortest paths between any pair of vertices, our algorithm maintains APASP and BC scores in amortized time O(n^2 \log n) under decremental updates, regardless of the number of edges in the graph.

cs.DS↗

arXiv2013

Betweenness Centrality -- Incremental and Faster

We consider the incremental computation of the betweenness centrality of all vertices in a large complex network modeled as a graph G = (V, E), directed or undirected, with positive real edge-weights. The current widely used algorithm to compute the betweenness centrality of all vertices in G is the Brandes algorithm that runs in O(mn + n^2 log n) time, where n = |V| and m = |E|. We present an incremental algorithm that updates the betweenness centrality score of all vertices in G when a new edge is added to G, or the weight of an existing edge is reduced. Our incremental algorithm runs in O(m' n + n^2) time, where m' is the size of a certain subset of E*, the set of edges in G that lie on a shortest path. We achieve the same bound for the more general incremental update of a vertex v, where the edge update can be performed on any subset of edges incident to v. Our incremental algorithm is the first algorithm that is asymptotically faster on sparse graphs than recomputing with the Brandes algorithm. Our algorithm is also likely to be much faster than the Brandes algorithm on dense graphs since m*, the size of E*, is often close to linear in n. Our incremental algorithm is very simple and the only data structures it uses are arrays, lists, and stack. We give an efficient cache-oblivious implementation that incurs O(scan(n^2) + n sort(m')) cache misses, where scan and sort are well-known measures for efficient caching. We also give a static algorithm for computing betweenness centrality of all vertices that runs in time O(m* n + n^2 log n), which is faster than the Brandes algorithm on any graph with n log n = o(m) and m* = o(m).

cs.DS↗