# Tight Hardness for Shortest Cycles and Paths in Sparse Graphs

@article{Lincoln2018TightHF, title={Tight Hardness for Shortest Cycles and Paths in Sparse Graphs}, author={Andrea Lincoln and Virginia Vassilevska Williams and Richard Ryan Williams}, journal={ArXiv}, year={2018}, volume={abs/1712.08147} }

Fine-grained reductions have established equivalences between many core problems with $\tilde{O}(n^3)$-time algorithms on $n$-node weighted graphs, such as Shortest Cycle, All-Pairs Shortest Paths (APSP), Radius, Replacement Paths, Second Shortest Paths, and so on. These problems also have $\tilde{O}(mn)$-time algorithms on $m$-edge $n$-node weighted graphs, and such algorithms have wider applicability. Are these $mn$ bounds optimal when $m \ll n^2$?
Starting from the hypothesis that the…

## Figures and Tables from this paper

## 68 Citations

### New Techniques and Fine-Grained Hardness for Dynamic Near-Additive Spanners

- Computer ScienceSODA
- 2021

This paper develops fast dynamic algorithms for sparse spanner and emulator maintenance and provides evidence from fine-grained complexity that these algorithms are tight, and develops an algebraic spanner algorithm that improves over the update time for dense graphs.

### Deterministic Algorithms for Decremental Approximate Shortest Paths: Faster and Simpler

- Computer ScienceSODA
- 2020

This article develops several new techniques including improved decremental cover data structures for graphs, a more efficient notion of the heavy/light decomposition framework introduced by Chechik and Bernstein and the first clustering technique to maintain a dynamic \emph{sparse} emulator in the deterministic setting.

### Faster approximation algorithms for computing shortest cycles on weighted graphs

- Computer Science, MathematicsICALP
- 2019

The approach combines some new insights on the previous approximation algorithms for this problem with Hitting Set based methods that are used for approximate distance oracles and date back from (Thorup and Zwick, JACM'05).

### Faster Algorithms for All-Pairs Bounded Min-Cuts

- Computer ScienceICALP
- 2019

The results rule out that kAPMVC can be solved as efficiently as a transitive closure computation for all $k, and design a novel reduction showing a lower bound of $n^{\omega-1-o(1)} k^2$ for k APMVC assuming that $4$-Clique requires $n^{2-o (1)}$ time.

### Conditionally optimal approximation algorithms for the girth of a directed graph

- Computer Science, MathematicsICALP
- 2020

This paper shows that under a popular hardness assumption, any algorithm, even one that exploits fast matrix multiplication, would need to take at least at least $mn^{1-o(1)$ time for some sparsity $m$ if it achieves a $(2-\epsilon)-approximation for any $\ep silon>0$.

### Nearly Optimal Average-Case Complexity of Counting Bicliques Under SETH

- Mathematics, Computer ScienceSODA
- 2021

It is proved that the $K_{a,b}$ counting problem admits an $n^{a+o(1)}$-time algorithm if $a\geq 8$, while any-n-a-\epsilon algorithm fails to solve it even on random bipartite graph for any constant $\epsilons>0$ under the Strong Exponential Time Hypotheis.

### Nearly Optimal Time Bounds for kPath in Hypergraphs

- Mathematics, Computer ScienceArXiv
- 2018

A hierarchy of conditional lower bounds is presented assuming the Set Cover Conjecture for even undirected kHyperPath with \textit{explicit} constants in the exponents, where for growing values of $r$ the problem requires time that approaches $2^k\mathsf{poly}(m)$.

### Improved Distance Sensitivity Oracles with Subcubic Preprocessing Time

- Computer Science, MathematicsESA
- 2020

This work considers the problem of building Distance Sensitivity Oracles (DSOs), and constructs a DSO with preprocessing time $P+\tilde{O}(n^2)\cdot Q$ and query time $O(1)$.

### Approximation Algorithms and Hardness for n-Pairs Shortest Paths and All-Nodes Shortest Cycles

- Computer ScienceArXiv
- 2022

The question of whether approximate n -PSP can be solved faster than by using distance oracles or All Pair Shortest Paths (APSP) is asked and algorithmic results nearly matches an upper bound implied by the result of Agarwal (2014).

### Algorithms and Lower Bounds for Cycles and Walks: Small Space and Sparse Graphs

- Mathematics, Computer ScienceITCS
- 2020

A reduction is given that connects the running time of undirected 2k-cycle to finding directed odd cycles, s-t connectivity in directed graphs, and Max-3-SAT, and a space-efficient algorithms and conditional time lower bounds for finding cycles and walks in graphs are considered.

## References

SHOWING 1-10 OF 61 REFERENCES

### Fine-Grained Complexity and Conditional Hardness for Sparse Graphs

- Computer Science, MathematicsArXiv
- 2016

The notion of a sparse reduction which preserves the sparsity of graphs is introduced, and near linear-time sparse reductions between various pairs of graph problems in the $\tilde{O}(mn)$ class are presented.

### A Shortest Path Algorithm for Real-Weighted Undirected Graphs

- Computer ScienceSIAM J. Comput.
- 2005

The algorithm takes the hierarchy-based approach invented by Thorup, and, if the ratio between the maximum and minimum edge lengths is bounded by n(log n)O(1), it can solve the single-source problem in O(m + n log log n) time.

### Minimum Weight Cycles and Triangles: Equivalences and Algorithms

- Computer Science, Mathematics2011 IEEE 52nd Annual Symposium on Foundations of Computer Science
- 2011

The fundamental algorithmic problem of finding a cycle of minimum weight in a weighted graph is considered and efficient reductions imply the following surprising phenomenon: a minimum cycle with an arbitrary number of weighted edges can be ``encoded'' using only three edges within roughly the same weight interval.

### Faster all-pairs shortest paths via circuit complexity

- Computer ScienceSTOC
- 2014

A new randomized method for computing the min-plus product of two n × n matrices is presented, yielding a faster algorithm for solving the all-pairs shortest path problem (APSP) in dense n-node directed graphs with arbitrary edge weights.

### All pairs shortest paths in undirected graphs with integer weights

- Computer Science, Mathematics40th Annual Symposium on Foundations of Computer Science (Cat. No.99CB37039)
- 1999

We show that the all pairs shortest paths (APSP) problem for undirected graphs with integer edge weights taken from the range {1, 2, ..., M} can be solved using only a logarithmic number of distance…

### Fine-grained complexity for sparse graphs

- Computer ScienceSTOC
- 2018

The notion of MWC hardness is formulated, which is based on the assumption that a minimum weight cycle in a directed graph cannot be computed in time polynomially smaller than mn, and the framework using sparse reductions is very relevant to real-world graphs, which tend to be sparse.

### An O(nm) time algorithm for finding the min length directed cycle in a graph

- Computer ScienceSODA
- 2017

An O(nm) time algorithm to determine the minimum length directed cycle (also called the "minimum weight directed cycle") in a directed network with n nodes and m arcs and with no negative length directed cycles is introduced.

### Efficient algorithms for path problems in weighted graphs

- Computer Science, Mathematics
- 2008

The first truly subcubic algorithm for finding a maximum weight triangle in a node-weighted graph is obtained, the first to break the cubic barrier, and a nonalgebraic, combinatorial approach is considered more efficient in practice compared to methods based on fast matrix multiplication.

### On the All-Pairs-Shortest-Path Problem in Unweighted Undirected Graphs

- MathematicsJ. Comput. Syst. Sci.
- 1995

We present an algorithm, APD, that solves the distance version of the all-pairs-shortest-path problem for undirected, unweighted n-vertex graphs in time O(M(n) log n), where M(n) denotes the time…

### All pairs shortest paths using bridging sets and rectangular matrix multiplication

- Computer ScienceJACM
- 2002

Two new algorithms for solving the All Pairs Shortest Paths (APSP) problem for weighted directed graphs using fast matrix multiplication algorithms are presented.