Shortest Cycles With Monotone Submodular Costs

TL;DR

This paper presents a near-optimal approximation algorithm for finding the shortest cycle with a monotone submodular cost in a graph, along with matching lower bounds on query complexity, highlighting the problem's computational difficulty.

Contribution

Introduces a novel approximation algorithm for the monotone submodular shortest cycle problem and establishes tight lower bounds on query complexity.

Findings

Algorithm achieves (1+ε)-approximation in n^{O(log 1/ε)} time.

Lower bounds show (1+ε)-approximation requires n^{Ω(log 1/ε)} queries.

For integer-valued functions, a quasipolynomial-time algorithm finds minimum cost cycles.

Abstract

We introduce the following submodular generalization of the Shortest Cycle problem. For a nonnegative monotone submodular cost function $f$ defined on the edges (or the vertices) of an undirected graph $G$, we seek for a cycle $C$ in $G$ of minimum cost $\textsf{OPT}=f(C)$. We give an algorithm that given an $n$-vertex graph $G$, parameter $\varepsilon > 0$, and the function $f$ represented by an oracle, in time $n^{\mathcal{O}(\log 1/\varepsilon)}$ finds a cycle $C$ in $G$ with $f(C)\leq (1+\varepsilon)\cdot \textsf{OPT}$. This is in sharp contrast with the non-approximability of the closely related Monotone Submodular Shortest $(s,t)$-Path problem, which requires exponentially many queries to the oracle for finding an $n^{2/3-\varepsilon}$-approximation [Goel et al., FOCS 2009]. We complement our algorithm with a matching lower bound. We show that for every $\varepsilon > 0$, obtaining a $(1+\varepsilon)$-approximation requires at least $n^{\Omega(\log 1/ \varepsilon)}$ queries to the oracle. When the function $f$ is integer-valued, our algorithm yields that a cycle of cost $\textsf{OPT}$ can be found in time $n^{\mathcal{O}(\log \textsf{OPT})}$. In particular, for $\textsf{OPT}=n^{\mathcal{O}(1)}$ this gives a quasipolynomial-time algorithm computing a cycle of minimum submodular cost. Interestingly, while a quasipolynomial-time algorithm often serves as a good indication that a polynomial time complexity could be achieved, we show a lower bound that $n^{\mathcal{O}(\log n)}$ queries are required even when $\textsf{OPT} = \mathcal{O}(n)$.