SETH-Based Lower Bounds for Subset Sum and Bicriteria Path

TL;DR

This paper establishes tight SETH-based lower bounds for Subset Sum and Bicriteria Path problems, connecting their complexities and proving that certain classical algorithms cannot be significantly improved under SETH.

Contribution

It provides a tight reduction from k-SAT to dense Subset Sum, introduces a Direct-OR theorem for Subset Sum, and establishes new lower bounds for Bicriteria Path based on SETH.

Findings

No significantly faster algorithms for dense Subset Sum under SETH.

A new conditional lower bound for Bicriteria Path problem.

Connection between the complexities of Subset Sum and Bicriteria Path.

Abstract

Subset-Sum and k-SAT are two of the most extensively studied problems in computer science, and conjectures about their hardness are among the cornerstones of fine-grained complexity. One of the most intriguing open problems in this area is to base the hardness of one of these problems on the other. Our main result is a tight reduction from k-SAT to Subset-Sum on dense instances, proving that Bellman's 1962 pseudo-polynomial $O^{*}(T)$-time algorithm for Subset-Sum on $n$ numbers and target $T$ cannot be improved to time $T^{1-\varepsilon}\cdot 2^{o(n)}$ for any $\varepsilon>0$, unless the Strong Exponential Time Hypothesis (SETH) fails. This is one of the strongest known connections between any two of the core problems of fine-grained complexity. As a corollary, we prove a "Direct-OR" theorem for Subset-Sum under SETH, offering a new tool for proving conditional lower bounds: It is now possible to assume that deciding whether one out of $N$ given instances of Subset-Sum is a YES instance requires time $(N T)^{1-o(1)}$. As an application of this corollary, we prove a tight SETH-based lower bound for the classical Bicriteria s,t-Path problem, which is extensively studied in Operations Research. We separate its complexity from that of Subset-Sum: On graphs with $m$ edges and edge lengths bounded by $L$, we show that the $O(Lm)$ pseudo-polynomial time algorithm by Joksch from 1966 cannot be improved to $\tilde{O}(L+m)$, in contrast to a recent improvement for Subset Sum (Bringmann, SODA 2017).

Equations

$$z(x_1,1)$$

$$z(x_1,2)$$

$$z(x_2,1)$$

$$z(x_2,2)$$

$$z(x_3,1)$$

$$z(x_3,2)$$

$$z(C_1,1,1)$$

$$z(C_1,2,2)$$

$$z(C_2,1,2)$$

$$z(C_2,2,1)$$

$$z(C_3,1,1)$$

$$z(C_3,2,1)$$

$$z(C_3,2,2)$$

$$T=110|000|111111|000|0100|0100|0100|.$$

$$f({\alpha }_1)+\dots +f({\alpha }_{d(x)})-d(x)\cdot f(\alpha )+\lambda B,$$

$$\log T$$

$$\displaystyle O\big{(}\textup{poly}(n)2^{\varepsilon^{\prime}n}+2^{\varepsilon^{\prime}n}\cdot\big{(}2^{(1+2\varepsilon^{\prime})n}\big{)}^{1-\varepsilon}2^{\delta\cdot\tilde{c}_{k,\varepsilon^{\prime}}n}\big{)}$$

$$\displaystyle=O\big{(}2^{(\varepsilon^{\prime}+(1+2\varepsilon^{\prime})(1-5\varepsilon^{\prime})+\varepsilon^{\prime})n}\big{)}\leq O\big{(}2^{(1-\varepsilon^{\prime})n}\big{)},$$

$$\displaystyle O\big{(}N^{(1+\gamma)(1-\varepsilon)}\big{)}$$

$$\displaystyle=O\big{(}2^{(1-\varepsilon/2)n}\big{)},$$

$$T[v,i_1,\dots ,i_{\lambda }]=$$

$$\sum _{j=1}^k[a_j{]}_x\le {\left[\sum _{j=1}^k{a}_j\right]}_x\le k+\sum _{j=1}^k[a_j{]}_x.$$

$$[w_1(X){]}_x={\left[\sum _{j=1}^k{w}_1(v_j)\right]}_x$$

$$=w_1^{(i)}(X)+k$$

$$=T_1^{(i)}+k\le [T_1{]}_x-1,$$

$$w_1^{(i)}(X)=\sum _{j=1}^k[w_1(v_j){]}_x\le {\left[\sum _{j=1}^k{w}_1(v_j)\right]}_x\le [T_1{]}_x-k,$$

$$w_1^{(i)}(X)=\sum _{j=1}^k[w_1(v_j){]}_x\ge {\left[\sum _{j=1}^k{w}_1(v_j)\right]}_x-k\ge [T_1{]}_x-3k.$$

Full text

Our main result is a tight reduction from $k$-SAT to Subset Sum on dense instances, proving that Bellman’s 1962 pseudo-polynomial $O^{*}(T)$-time algorithm for Subset Sum on $n$ numbers and target $T$ cannot be improved to time $T^{1-\varepsilon}\cdot 2^{o(n)}$ for any $\varepsilon>0$, unless the Strong Exponential Time Hypothesis (SETH) fails.

As a corollary, we prove a “Direct-OR” theorem for Subset Sum under SETH, offering a new tool for proving conditional lower bounds: It is now possible to assume that deciding whether one out of $N$ given instances of Subset Sum is a YES instance requires time $(NT)^{1-o(1)}$. As an application of this corollary, we prove a tight SETH-based lower bound for the classical Bicriteria $s,t$-Path problem, which is extensively studied in Operations Research. We separate its complexity from that of Subset Sum: On graphs with $m$ edges and edge lengths bounded by $L$, we show that the $O(Lm)$ pseudo-polynomial time algorithm by Joksch from 1966 cannot be improved to $\tilde{O}(L+m)$, in contrast to a recent improvement for Subset Sum (Bringmann, SODA 2017).

1 Introduction

The field of fine-grained complexity is anchored around certain hypotheses about the exact time complexity of a small set of core problems. Due to dozens of reductions, we now know that the current algorithms for many important problems are optimal unless breakthrough algorithms for the core problems exist. A central challenge in this field is to understand the connections and relative difficulties among these core problems. In this work, we discover a new connection between two core problems: a tight reduction from $k$-SAT to Subset Sum.

In the first part of the introduction we discuss this new reduction and how it affects the landscape of fine-grained complexity. Then, in Section 1.2, we highlight a corollary of this reduction which gives a new tool for proving conditional lower bounds. As an application, in Section 1.3, we prove the first tight bounds for the classical Bicriteria $s,t$-Path problem from Operations Research.

Subset Sum.

Subset Sum is a fundamental problem in computer science. Its most basic form is the following: Given $n$ integers $x_{1},\ldots,x_{n}\in\mathbb{N}$, and a target value $T\in\mathbb{N}$, decide whether there is a subset of the numbers that sums to $T$. The two most classical algorithms for the problem are the pseudo-polynomial $O(Tn)$ algorithm using dynamic programming [28], and the $O(2^{n/2}\cdot\textup{poly}(n,\log{T}))$ algorithm via “meet-in-the-middle” [67]. A central open question in Exact Algorithms [114] is whether faster algorithms exist, e.g., can we combine the two approaches to get a $T^{1/2}\cdot n^{O(1)}$ time algorithm? Such a bound was recently found in a Merlin-Arthur setting [94].

Open Question 1

Is Subset Sum in time $T^{1-\varepsilon}\cdot 2^{o(n)}$ or $2^{(1-\varepsilon)\frac{n}{2}}\cdot T^{o(1)}$, for some $\varepsilon>0$?

The status of Subset Sum as a major problem has been established due to many applications, deep connections to other fields, and educational value. The $O(Tn)$ algorithm from 1957 is an illuminating example of dynamic programming that is taught in most undergraduate algorithms courses, and the NP-hardness proof (from Karp’s original paper [78]) is a prominent example of a reduction to a problem on numbers. Interestingly, one of the earliest cryptosystems by Merkle and Hellman was based on Subset Sum [92], and was later extended to a host of Knapsack-type cryptosystems111Cryptographers usually refer to Subset Sum as Knapsack. (see [106, 31, 97, 46, 69] and the references therein).

The version of Subset Sum where we ask for $k$ numbers that sum to zero (the $k$-Sum problem) is conjectured to have $n^{\lceil k/2\rceil\pm o(1)}$ time complexity. Most famously, the $k=3$ case is the 3-Sum conjecture highlighted in the seminal work of Gajentaan and Overmars [57]. It has been shown that this problem lies at the core and captures the difficulty of dozens of problems in computational geometry. Searching in Google Scholar for “3sum-hard” reveals more than 250 papers (see [80] for an incomplete list). More recently, these conjectures have become even more prominent as core problems in fine-grained complexity since their interesting consequences have expanded beyond geometry into purely combinatorial problems [102, 113, 38, 72, 12, 6, 83, 7, 62, 72]. Note that $k$-Sum inherits its hardness from Subset Sum, by a simple reduction that partitions items into $k$ groups: To answer Open Question 1 positively it is enough to solve $k$-Sum in time $T^{1-\varepsilon}\cdot n^{o(k)}$ (for all $k$) or in time $n^{k/2-\varepsilon}\cdot T^{o(1)}$ (for any $k$).

Entire books [91, 79] are dedicated to the algorithmic approaches that have been used to attack Subset Sum throughout many decades, and, quite astonishingly, major algorithmic advances are still being discovered in our days, e.g., [88, 68, 26, 51, 14, 108, 77, 61, 44, 15, 16, 85, 56, 22, 94, 82, 33], not to mention the recent developments on generalized versions (see [24]) and other computational models (see [107, 41]). At STOC’17 an algorithm was presented that beats the trivial $2^{n}$ bound while using polynomial space, under certain assumptions on access to random bits [22]. At SODA’17 we have seen the first improvements (beyond log factors [100]) over the $O(Tn)$ algorithm, reducing the bound to $\tilde{O}(T+n)$ [82, 33]. And a few years earlier, a surprising result celebrated by cryptographers [68, 26] showed that $2^{0.499}$ algorithms are possible on random instances. All this progress leads to the feeling that a positive resolution to Open Question 1 might be just around the corner.

SETH

$k$-SAT is an equally fundamental problem (if not more) but of a Boolean rather than numerical nature, where we are given a $k$-CNF formula on $n$ variables and $m$ clauses, and the task is to decide whether it is satisfiable. All known algorithms have a running time of the form $O(2^{(1-c/k)n})$ for some constant $c>0$ [99, 49, 8], and the Strong Exponential Time Hypothesis (SETH) of Impagliazzo and Paturi [70, 71, 39] states that no $O(2^{(1-\varepsilon)n})$ time algorithms are possible for $k$-SAT, for some $\varepsilon>0$ independent of $k$. Refuting SETH implies advances in circuit complexity [73], and is known to be impossible with popular techniques like resolution [25].

A seminal paper of Cygan, Dell, Lokshtanov, Marx, Nederlof, Okamoto, Paturi, Saurabh, and Wahlström [48] strives to classify the exact complexity of important NP-hard problems under SETH. The authors design a large collection of ingenious reductions and conclude that $2^{(1-\varepsilon)n}$ algorithms for problems like Hitting Set, Set Splitting, and Not-All-Equal SAT are impossible under SETH. Notably, Subset Sum is not in this list nor any problem for which the known algorithms are non-trivial (e.g., require dynamic programming). As the authors point out: “Of course, we would also like to show tight connections between SETH and the optimal growth rates of problems that do have non-trivial exact algorithms.”

Since the work of Cygan et al. [48], SETH has enjoyed great success as a basis for lower bounds in Parameterized Complexity [87] and for problems within P [112]. Some of the most fundamental problems on strings (e.g., [9, 17, 2, 35, 18, 34]), graphs (e.g., [86, 104, 6, 58]), curves (e.g., [32]), vectors [110, 111, 19, 29] and trees [1] have been shown to be SETH-hard: a small improvement to the running time of these problems would refute SETH. Despite the remarkable quantity and diversity of these results, we are yet to see a (tight) reduction from SAT to any problem like Subset Sum, where the complexity comes from the hardness of analyzing a search space defined by addition of numbers. In fact, all hardness results for problems of a more number theoretic or additive combinatoric flavor are based on the conjectured hardness of Subset Sum itself.

In this paper, we address an important open questions in the field of fine-grained complexity: Can we prove a tight SETH-based lower bound for Subset Sum?

The standard NP-hardness proofs imply loose lower bounds under SETH (in fact, under the weaker ETH) stating that $2^{o(\sqrt{n})}$ algorithms are impossible. A stronger but still loose result rules out $2^{o(n)}\cdot T^{o(1)}$-time algorithms for Subset Sum under ETH [75, 37]. Before that, Patrascu and Williams [98] showed that if we solve $k$-Sum in $n^{o(k)}\cdot T^{o(1)}$ time, then ETH is false. These results leave the possibility of $O(T^{0.001})$ algorithms. While it is open whether such algorithms imply new SAT algorithms, it has been shown that they would imply new algorithms for other famous problems. Bringmann [33] recently observed that an $O(T^{0.78})$ algorithm for Subset Sum implies a new algorithm for $k$-Clique, via a reduction of Abboud, Lewi, and Williams [5]. Cygan et al. [48] ruled out $O(T^{1-\varepsilon}\textup{poly}(n))$ algorithms for Subset Sum under the conjecture that the Set Cover problem on $m$ sets over a universe of size $n$ cannot be solved in $O(2^{(1-\varepsilon)n}\cdot\textup{poly}(m))$ time. Whether this conjecture can be replaced by the more popular SETH remains a major open question.

1.1 Main Result

We would like to show that SETH implies a negative resolution to Open Question 1. Our main result accomplishes half of this statement, showing a tight reduction from SAT to Subset Sum on instances where $T=2^{\delta n}$, also known as dense instances222The density of an instance is $n/\log_{2}\max{x_{i}}$., ruling out $T^{1-\varepsilon}\cdot 2^{o(n)}$ time algorithms under SETH.

Theorem 1.1

Assuming SETH, for any $\varepsilon>0$ there exists a $\delta>0$ such that Subset Sum is not in time $O(T^{1-\varepsilon}2^{\delta n})$, and $k$-Sum is not in time $O(T^{1-\varepsilon}n^{\delta k})$.

Thus, Subset Sum is yet another SETH-hard problem. This is certainly a major addition to this list. This also adds many other problems that have reductions from Subset Sum, e.g., the famous Knapsack problem, or from $k$-Sum (e.g., [54, 30, 4, 43, 81]). For some of these problems, to be discussed shortly, this even leads to better lower bounds.

Getting a reduction that also rules out $2^{(1-\varepsilon)n/2}\cdot T^{o(1)}$ algorithms under SETH is still a fascinating open question. Notably, the strongest possible reduction, ruling out $n^{\lceil k/2\rceil-\varepsilon}\cdot T^{o(1)}$ algorithms for $k$-Sum, is provably impossible under the Nondeterministic SETH of Carmosino et al. [42], but there is no barrier for an $n^{k/2-o(1)}$ lower bound.

A substantial technical barrier that we had to overcome when designing our reduction is the fact that there was no clear understanding of what the hard instances of Subset Sum should look like. Significant effort has been put into finding and characterizing the instances of Subset Sum and Knapsack that are hard to solve. This is challenging both from an experimental viewpoint (see the study of Pisinger [101]) and from the worst-case analysis perspective (see the discussion of Austrin et al. [16]). Recent breakthroughs refute the common belief that random instances are maximally hard [68, 26], and show that better upper bounds are possible for various classes of inputs. Our reduction is able to generate hard instances by crucially relying on a deep result on the combinatorics of numbers: the existence of dense average-free sets. A surprising construction of these sets from 1946 due to Behrend [27] (see also [52, 96]) has already lead to breakthroughs in various areas of theoretical computer science [45, 47, 10, 65, 50, 3]. These are very non-random-like structures in combinatorics (in particular they are regularly used as counterexamples in mathematics and thus they seem to be extremal and far from random), which allows our instances to bypass the easyness of random inputs. This leads us to a candidate distribution of hard instances for Subset Sum, which could be of independent interest: Start from hard instances of SAT (e.g., random formulas around the threshold) and map them with our reduction (the obtained distribution over numbers will be highly structured).

Recently, it was shown that the security of certain cryptographic primitives can be based on SETH [20, 21]. We hope that our SETH-hardness for an already popular problem in cryptography will lead to further interaction between fine-grained complexity and cryptography. In particular, it would be exciting if our hard instances could be used for a new Knapsack-type cryptosystem. Such schemes tend to be much more computationally efficient than popular schemes like RSA [31, 97, 69], but almost all known ones are not secure (as famously shown by Shamir [106]). Even more recently, Bennett, Golovnev, and Stephens-Davidowitz [29] proved SETH hardness for another central problem from cryptography, the Closest-Vector-Problem (CVP). While CVP is a harder problem than Subset Sum, their hardness result addresses a different regime of parameters, and rules out $O(2^{(1-\varepsilon)n})$ time algorithms (when the dimension is large).

1.2 A Direct-OR Theorem for Subset Sum

Some readers might find the above result unnecessary: What is the value in a SETH-based lower bound if we already believe the Set Cover Conjecture of Cygan et al.? The rest of this introduction discusses new lower bound results that, to our knowledge, would not have been possible without our new SETH-based lower bound. To clarify what we mean, consider the following “Direct-OR” version of Subset Sum: Given $N$ different and independent instances of Subset Sum, each on $n$ numbers and each with a different target $T_{i}\leq T$, decide whether any of them is a YES instance. It is natural to expect the time complexity of this problem to be $(NT)^{1-o(1)}$, but how do we formally argue that this is the case? If we could assume that this holds, it would be a very useful tool for conditional lower bounds (as we show in Section 1.3).

Many problems, like SAT, have a simple self-reduction proving that the “Direct-OR” version is hard, assuming the problem itself is hard: To solve a SAT instance on $n$ variables, it is enough to solve $2^{x}$ instances on $n-x$ variables. This is typically the case for problems where a brute force algorithm achieves the best known running time up to lower order factors. But what about Subset Sum or Set Cover? Can we use an algorithm that solves $N$ instances of Subset Sum in $O(N^{0.1}\cdot T)$ time to solve Subset Sum in $O(T^{1-\varepsilon})$ time? We cannot prove such statements; however, we can prove that such algorithms would refute SETH.

Corollary 1

Assuming SETH, for any $\varepsilon>0$ and $\gamma>0$ there exists a $\delta>0$ such that no algorithm can solve the OR of $N$ given instances of Subset Sum on target values $T_{1},\ldots,T_{N}=O(N^{\gamma})$ and at most $\delta\log N$ numbers each, in total time $O(N^{1+\gamma-\varepsilon})$.

1.3 The Fine-Grained Complexity of Bicriteria Path

The Bicriteria $s,t$-Path problem is the natural bicriteria variant of the classical $s,t$-Path problem where edges have two types of weights and we seek an $s,t$-path which meets given demands on both criteria. More precisely, we are given a directed graph $G$ where each edge $e\in E(G)$ is assigned a pair of non-negative integers $\ell(e)$ and $c(e)$, respectively denoting the length and cost of $e$, and two non-negative integers $L$ and $C$ representing our budgets. The goal is to determine whether there is an $s,t$-path $e_{1},\ldots,e_{k}$ in $G$, between a given source and a target vertex $s,t\in V(G)$, such that $\sum_{i=1}^{k}\ell(e_{i})\leq L$ and $\sum_{i=1}^{k}c(e_{i})\leq C$.

This natural variant of $s,t$-Path has been extensively studied in the literature, by various research communities, and has many diverse applications in several areas. Most notable of these are perhaps the applications in the area of transportation networks [60], and the quality of service (QoS) routing problem studied in the context of communication networks [89, 115]. There are also several applications for Bicriteria $s,t$-Path in Operations Research domains, in particular in the area of scheduling [36, 84, 93, 105], and in column generation techniques [66, 116]. Additional applications can be found in road traffic management, navigation systems, freight transportation, supply chain management and pipeline distribution systems [60].

A simple reduction proves that Bicriteria $s,t$-Path is at least as hard as Subset Sum (see Garey and Johnson [59]). In 1966, Joksch [76] presented a dynamic programming algorithm with pseudo-polynomial running time $O(Lm)$ (or $O(Cm)$) on graphs with $m$ edges. Extensions of this classical algorithm appeared in abundance since then, see e.g., [13, 63, 103] and the various FPTASs for the optimization variant of the problem [53, 60, 64, 90, 109]. The reader is referred to the survey by Garroppo et al. [60] for further results on Bicriteria $s,t$-Path.

Our SETH-based lower bound for Subset Sum easily transfers (using, e.g., the reduction in [59]) to show that an $O(L^{1-\varepsilon}2^{o(n)})$ time algorithm for Bicriteria $s,t$-Path refutes SETH. However, after the $O(Tn)$ algorithm for Subset Sum from 1960 was improved last year to $\tilde{O}(T+n)$, it is natural to wonder if the similar $O(Lm)$ algorithm for Bicriteria $s,t$-Path from 1966 can also be improved to $\tilde{O}(L+m)$ or even just to $O(Lm^{0.99})$. Such an improvement would be very interesting since the pseudo-polynomial algorithm is commonly used in practice, and since it would speed up the running time of the approximation algorithms. We prove that Bicriteria $s,t$-Path is in fact a harder problem than Subset Sum, and an improved algorithm would refute SETH. The main application of Corollary 1 that we report in this paper is a tight SETH-based lower bound for Bicriteria $s,t$-Path, which (conditionally) separates the time complexity of Bicriteria $s,t$-Path and Subset Sum.

Theorem 1.2

Assuming SETH, for any $\varepsilon>0$ and $\gamma>0$ no algorithm solves Bicriteria $s,t$-Path on sparse $n$-vertex graphs and budgets $L,C=\Theta(n^{\gamma})$ in time $O(n^{1+\gamma-\varepsilon})$.

Intuitively, our reduction shows how a single instance of Bicriteria $s,t$-Path can simulate multiple instances of Subset Sum and solve the “Direct-OR” version of it.

Our second application of Corollary 1 concerns the number of different edge-lengths and/or edge-costs in our given input graph. Let $\lambda$ denote the former parameter, and $\chi$ denote the latter. Note that $\lambda$ and $\chi$ are different from $L$ and $C$, and each can be quite small in comparison to the size of the entire input. In fact, in many of the scheduling applications for Bicriteria $s,t$-Path discussed above it is natural to assume that one of these is quite small. We present a SETH-based lower bound that almost matches the $O(n^{\min\{\lambda,\chi\}+2})$ upper bound for the problem.

Theorem 1.3

Bicriteria $s,t$-Path* can be solved in $O(n^{\min\{\lambda,\chi\}+2})$ time. Moreover, assuming SETH, for any constants $\lambda,\chi\geq 2$ and $\varepsilon>0$, there is no $O(n^{\min\{\lambda,\chi\}-1-\varepsilon})$ time algorithm for the problem.*

Finally, we consider the case where we are searching for a path that uses only $k$ internal vertices. This parameter is naturally small in comparison to the total input length in several applications of Bicriteria $s,t$-Path, for example the packet routing application discussed above. We show that this problem is equivalent to the $k$-Sum problem, up to logarithmic factors. For this, we consider an intermediate exact variant of Bicriteria $s,t$-Path, the Zero-Weight-$k$-Path problem, and utilize the known bounds for this variant to obtain the first improvement over the $O(n^{k})$-time brute-force algorithm, as well as a matching lower bound.

Theorem 1.4

Bicriteria $s,t$-Path* can be solved in $\tilde{O}(n^{\lceil(k+1)/2\rceil})$ time. Moreover, for any $\varepsilon>0$, there is no $\tilde{O}(n^{\lceil(k+1)/2\rceil-\varepsilon})$-time algorithm for the problem, unless $k$-Sum has an $\tilde{O}(n^{\lceil k/2\rceil-\varepsilon})$-time algorithm.*

2 Preliminaries

For a fixed integer $p$, we let $[p]$ denote the set of integers $\{1,\ldots,p\}$. All graphs in this paper are, unless otherwise stated, simple, directed, and without self-loops. We use standard graph theoretic notation, e.g., for a graph $G$ we let $V(G)$ and $E(G)$ denote the set of vertices and edges of $G$, respectively. Throughout the paper, we use the $O^{*}(\cdot)$ and $\tilde{O}(\cdot)$ notations to suppress polynomial and logarithmic factors.

Hardness Assumptions:

The Exponential Time Hypothesis (ETH) and its strong variant (SETH) are conjectures about running time of any algorithm for the $k$-SAT problem: Given a boolean CNF formula $\phi$, where each clause has at most $k$ literals, determine whether $\phi$ has a satisfying assignment. Let s_{k}=\inf\{\delta:\text{{k-SAT} can be solved in }O^{*}(2^{\delta n})\text{ time}\}. The Exponential Time Hypothesis, as stated by Impagliazzo, Paturi and Zane [71], is the conjecture that $s_{3}>0$. It is known that $s_{3}>0$ if and only if there is a $k\geq 3$ such that $s_{k}>0$ [71], and that if ETH is true, the sequence $\{s_{k}\}^{\infty}_{k=1}$ increases infinitely often [70]. The Strong Exponential Time Hypothesis, coined by Impagliazzo and Paturi [40, 70], is the conjecture that $\lim_{k\to\infty}s_{k}=1$. In our terms, this can be stated in the following more convenient manner:

Conjecture 1

For any $\varepsilon>0$ there exists $k\geq 3$ such that $k$-SAT on $n$ variables cannot be solved in time $O(2^{(1-\varepsilon)n})$.

We use the following standard tool by Impagliazzo, Paturi and Zane:

Lemma 1 (Sparsification Lemma [71])

For any $\varepsilon>0$ and $k\geq 3$, there exists $c_{k,\varepsilon}>0$ and an algorithm that, given a $k$-SAT instance $\phi$ on $n$ variables, computes $k$-SAT instances $\phi_{1},\ldots,\phi_{\ell}$ with $\ell\leq 2^{\varepsilon n}$ such that $\phi$ is satisfiable if and only if at least one $\phi_{i}$ is satisfiable. Moreover, each $\phi_{i}$ has $n$ variables, each variable in $\phi_{i}$ appears in at most $c_{k,\varepsilon}$ clauses, and the algorithm runs in time $\textup{poly}(n)2^{\varepsilon n}$.

The $k$-Sum Problem:

In $k$-Sum we are given sets $Z_{1},\ldots,Z_{k}$ of non-negative integers and a target $T$, and we want to decide whether there are $z_{1}\in Z_{1},\ldots,z_{k}\in Z_{k}$ such that $z_{1}+\ldots+z_{k}=T$. This problem can be solved in time $O(n^{\lceil k/2\rceil})$ [67], and it is somewhat standard by now to assume that this is essentially the best possible [4]. This assumption, which generalizes the more popular assumption of the $k=3$ case [57, 102], remains believable despite recent algorithmic progress [14, 23, 44, 77, 108].

Conjecture 2

$k$-Sum cannot be solved in time $\tilde{O}(n^{\lceil k/2\rceil-\varepsilon})$ for any $\varepsilon>0$ and $k\geq 3$.

3 From SAT to Subset Sum

In this section we present our main result, the hardness of Subset Sum and $k$-Sum under SETH. Our reduction goes through three main steps: We start with a $k$-SAT formula $\phi$ that is the input to our reduction. This formula is then reduced to subexponentially many Constraint Satisfaction Problems (CSP) with a restricted structure. The main technical part is then to reduce these CSP instances to equivalent Subset Sum instances. The last part of our construction, reducing Subset Sum to $k$-Sum, is rather standard. In the final part of the section we provide a proof for Corollary 1, showing that Subset Sum admits the “Direct-OR” property discussed in Section 1.2.

3.1 From $k$-SAT to Structured CSP

We first present a reduction from $k$-SAT to certain structured instances of Constraint Satisfaction Problems (CSP). This is a standard combination of the Sparsification Lemma with well-known tricks.

Lemma 2

Given a $k$-SAT instance $\phi$ on $n$ variables and $m$ clauses, for any $\varepsilon>0$ and $a\geq 1$ in time $\textup{poly}(n)2^{\varepsilon n}$ we can compute CSP instances $\psi_{1},\ldots,\psi_{\ell}$, with $\ell\leq 2^{\varepsilon n}$, such that $\phi$ is satisfiable if and only if some $\psi_{i}$ is satisfiable. Each $\psi_{i}$ has $\hat{n}=\lceil n/a\rceil$ variables over universe $[2^{a}]$ and $\hat{m}=\lceil n/a\rceil$ constraints. Each variable is contained in at most $\hat{c}_{k,\varepsilon}\cdot a$ constraints, and each constraint contains at most $\hat{c}_{k,\varepsilon}\cdot a$ variables, for some constant $\hat{c}_{k,\varepsilon}$ depending only on $k$ and $\varepsilon$.

Proof

Let $\phi$ be an instance of $k$-SAT with $n$ variables and $m$ clauses. We start by invoking the Sparsification Lemma (Lemma 1). This yields $k$-SAT instances $\phi_{1},\ldots,\phi_{\ell}$ with $\ell\leq 2^{\varepsilon n}$ such that $\phi$ is satisfiable if and only if some $\phi_{i}$ is satisfiable, and where each $\phi_{i}$ has $n$ variables, and each variable in $\phi_{i}$ appears in at most $c_{k,\varepsilon}$ clauses of $\phi_{i}$, for some constant $c_{k,\varepsilon}$. In particular, the number of clauses is at most $c_{k,\varepsilon}n$.

We combine multiple variables to a super-variable and multiple clauses to a super-constraint, which yields a certain structured CSP. Specifically, let $a\geq 1$, and partition the variables into $\lceil n/a\rceil$ blocks of length at most $a$. We replace each block of at most $a$ variables by one super-variable over universe $[2^{a}]$. Similarly, we partition the clauses into $\lceil n/a\rceil$ blocks, each containing at most $\gamma:=ac_{k,\varepsilon}$ clauses. We replace each block of $\gamma^{\prime}\leq\gamma$ clauses $C_{1},\ldots,C_{\gamma^{\prime}}$ by one super-constraint $C$ that depends on all super-variables containing variables appearing in $C_{1},\ldots,C_{\gamma^{\prime}}$.

Clearly, the resulting CSP $\psi_{i}$ is equivalent to $\phi_{i}$. Since each variable appears in at most $c_{k,\varepsilon}$ clauses in $\phi_{i}$, and we combine at most $a$ variables to obtain a variable of $\psi_{i}$, each variable appears in $\psi_{i}$ in at most $ac_{k,\varepsilon}$ constraints. Similarly, each clause in $\phi_{i}$ contains at most $k$ variables, and each super-constraint consists of at most $\gamma=ac_{k,\varepsilon}$ clauses, so each super-constraint contains at most $\hat{c}_{k,\varepsilon}a$ variables for $\hat{c}_{k,\varepsilon}=kc_{k,\varepsilon}$. This finishes the proof.

3.2 From Structured CSP to Subset Sum

Next we reduce to Subset Sum. Specifically, we show the following.

Theorem 3.1

For any $\varepsilon>0$, given a $k$-SAT instance $\phi$ on $n$ variables we can in time $\textup{poly}(n)2^{\varepsilon n}$ construct $2^{\varepsilon n}$ instances of Subset Sum on at most $\tilde{c}_{k,\varepsilon}n$ items and a target value bounded by $2^{(1+2\varepsilon)n}$ such that $\phi$ is satisfiable iff at least one of the Subset Sum instances is a YES-instance. Here $\tilde{c}_{k,\varepsilon}$ is a constant depending only on $k$ and $\varepsilon$.

As discussed in Section 1.1, our reduction crucially relies on a construction of average-free sets. For any $k\geq 2$, a set $S$ of integers is $k$-average-free iff for all $k^{\prime}\leq k$ and (not necessarily distinct) $x_{1},\ldots,x_{k^{\prime}+1}\in S$ with $x_{1}+\ldots+x_{k^{\prime}}=k^{\prime}\cdot x_{k^{\prime}+1}$ we have $x_{1}=\ldots=x_{k^{\prime}+1}$. A surprising construction by Behrend [27] has been slightly adapted in [5], showing the following.

Lemma 3

There exists a universal constant $c>0$ such that, given $\varepsilon\in(0,1)$, $k\geq 2$, and $n\geq 1$, a $k$-average-free set $S$ of size $n$ with $S\subset[0,k^{c/\varepsilon}n^{1+\varepsilon}]$ can be constructed in $\textup{poly}(n)$ time.

While it seems natural to use this lemma when working with an additive problem like Subset Sum, we are only aware of very few uses of this result in conditional lower bounds [5, 55, 74]. One example is a reduction from $k$-Clique to $k^{2}$-Sum on numbers in $n^{k+o(1)}$ [5]. Our result can be viewed as a significant boosting of this reduction, where we exploit the power of Subset Sum further. Morally, $k$-Clique is like Max-$2$-SAT, since faster algorithms for $k$-Clique imply faster algorithms for Max-$2$-SAT [110]. We show that even Max-$d$-SAT, for any $d$, can be reduced to $k$-Sum, which corresponds to a reduction from Clique on hyper-graphs to $k$-Sum.

Proof (Proof of Theorem 3.1)

We let $a\geq 1$ be a sufficiently large constant depending only on $k$ and $\varepsilon$. We need a $\lambda$-average-free set, with $\lambda:=\hat{c}_{k,\varepsilon}a$, where $\hat{c}_{k,\varepsilon}$ is the constant from Lemma 2. Lemma 3 yields a $\lambda$-average-free set $S$ of size $2^{a}$ consisting of non-negative integers bounded by $B:=\lambda^{c/\varepsilon}(2^{a})^{1+\varepsilon}$, for some universal constant $c>0$. We let $f\colon[2^{a}]\to S$ be any injective function. Note that since $a$ and $B$ are constants constructing $f$ takes constant time.

Run Lemma 2 to obtain CSP instances $\psi_{1},\ldots,\psi_{\ell}$ with $\ell\leq 2^{\varepsilon n}$, each with $\hat{n}=\lceil n/a\rceil$ variables over universe $[2^{a}]$ and $\hat{m}=\hat{n}$ constraints, such that each variable is contained in at most $\lambda$ constraints and each constraint contains at most $\lambda$ variables. Fix a CSP $\psi=\psi_{i}$. We create an instance $(Z,T)$ of Subset Sum, i.e., a set $Z$ of positive integers and a target value $T$. We define these integers by describing blocks of their bits, from highest to lowest. (The items in $Z$ are naturally partitioned, as for each variable $x$ of $\psi$ there will be $O_{k,\varepsilon}(1)$ items of type $x$, and for each clause $C$ of $\psi$ there will be $O_{k,\varepsilon}(1)$ items of type $C$.)

We first ensure that any correct solution picks exactly one item of each type. To this end, we start with a block of $O(\log\hat{n})$ bits where each item has value 1, and the target value is $\hat{n}+\hat{m}$, which ensures that we pick exactly $\hat{n}+\hat{m}$ items. This is followed by $O(\log\hat{n})$ many 0-bits to avoid overflow from the lower bits (we will have $O_{k,\varepsilon}(\hat{n})$ items overall). In the following $\hat{n}+\hat{m}$ bits, each position is associated to one type, and each item of that type has a 1 at this position and 0s at all other positions. The target $T$ has all these bits set to 1. Together, these $O(\log\hat{n})+\hat{n}+\hat{m}$ bits ensure that we pick exactly one item of each type (since choosing any duplicate type among the $\hat{n}+\hat{m}$ picked items leads to two bits that cancel, leaving just one carry bit, and therefore we could not cover all $\hat{n}+\hat{m}$ bits in the target $T$). We again add $O(\log\hat{n})$ many 0-bits to avoid overflow from the lower bits.

The remaining $\hat{n}$ blocks of bits correspond to the variables of $\psi$. For each variable we have a block consisting of $\lceil\log(2\lambda B+1)\rceil=\log B+\log\lambda+O(1)$ bits. The target number $T$ has bits forming the number $\lambda B$ in each block of each variable.

Now we describe the items of type $x$, where $x$ is a variable. For each assignment $\alpha\in[2^{a}]$ of $x$, there is an item $z(x,\alpha)$ of type $x$. In the block corresponding to variable $x$, the bits of $z(x,\alpha)$ form the number $\lambda B-d(x)\cdot f(\alpha)$, where $d(x)$ is the number of clauses containing $x$. In all blocks corresponding to other variables, the bits of $z(x,\alpha)$ are 0.

Next we describe the items of type $C$, where $C$ is a constraint. Let $x_{1},\ldots,x_{s}$ be the variables that are contained in $C$. For any assignment $\alpha_{1},\ldots,\alpha_{s}\in[2^{a}]$ of $x_{1},\ldots,x_{s}$ that satisfies the clause $C$, there is an item $z(C,\alpha_{1},\ldots,\alpha_{s})$ of type $C$. In the block corresponding to variable $x_{i}$ the bits of $z(C,\alpha_{1},\ldots,\alpha_{s})$ form the number $f(\alpha_{i})$, for any $1\leq i\leq s$. In all blocks corresponding to other variables, the bits are 0.

Example:

Suppose $a=1$ and $\hat{c}_{k,\varepsilon}=2$, and consider a CSP with variables $x_{1},x_{2},x_{3}$ over the universe $[2^{a}]=\{1,2\}$, and constraints $C_{1}=(x_{1}=x_{2})$, $C_{2}=(x_{2}\neq x_{3})$, and $C_{3}=(x_{1}=1\Rightarrow x_{3}=1)$. Note that $\lambda=2$. We construct the 2-average-free set $S=\{1,2\}$; in particular, we may set $B=2$, and use the injective mapping $f:[2^{a}]\to S$ defined by $f(x)=x$. The following items correspond to the CSP variables (the $|$-symbols mark block boundaries and have no other meaning):

[TABLE]

And the following items correspond to the constraints:

[TABLE]

We set the target to

[TABLE]

One can readily verify that $T$ sums up to $z(x_{1},2)+z(x_{2},2)+z(x_{2},1)+z(C_{1},2,2)+z(C_{2},2,1)+z(C_{3},2,1)$, and that no other subset sums up to $T$. That is, the subsets summing to $T$ are in one-to-one correspondence to the satisfying assignments of the CSP.

Correctness:

Recall that the first $O(\log\hat{n})+\hat{n}+\hat{m}$ bits ensure that we pick exactly one item of each type. Consider any variable $x$ and the corresponding block of bits. The item of type $x$ picks an assignment $\alpha$, resulting in the number $\lambda B-d(x)\cdot f(\alpha)$, where $d(x)$ is the degree of $x$. The $d(x)$ constraints containing $x$ pick assignments $\alpha_{1},\ldots,\alpha_{d(x)}$ and contribute $f(\alpha_{1})+\ldots+f(\alpha_{d(x)})$. Hence, the total contribution in the block is

[TABLE]

where $d(x)\leq\lambda$. Since $f$ maps to a $\lambda$-average-free set, we can only obtain the target $\lambda B$ if $f(\alpha_{1})=\ldots=f(\alpha_{d(x)})=f(\alpha)$. Since $f$ is injective, this shows that any correct solution picks a coherent assignment $\alpha$ for variable $x$. Finally, this coherent choice of assignments for all variables satisfies all clauses, since clause items only exist for assignments satisfying the clause. Hence, we obtain an equivalent Subset Sum instance.

Note that the length of blocks corresponding to variables is set so that there are no carries between blocks, which is necessary for the above argument. Indeed, the degree $d(x)$ of any variable $x$ is at most $\lambda$, so the clauses containing $x$ can contribute at most $\lambda\cdot B$ to its block, while the item of type $x$ also contributes $0\leq\lambda B-d(x)\cdot f(\alpha)\leq\lambda B$, which gives a number in $[0,2\lambda B]$.

Size Bounds:

Let us count the number of bits in the constructed numbers. We have $O(\log\hat{n})+\hat{n}+\hat{m}$ bits from the first part ensuring that we pick one item of each type, and $\hat{n}\cdot(\log B+\log\lambda+O(1))$ bits from the second part ensuring to pick coherent and satisfying assignments. This yields

[TABLE]

We now plug in $B=\lambda^{c/\varepsilon}(2^{a})^{1+\varepsilon}$ and $\lambda=\hat{c}_{k,\varepsilon}a$ and $\hat{n}=\hat{m}=\lceil n/a\rceil$ and we bound \hat{n}\log B=\big{(}\frac{n}{a}+O(1)\big{)}\big{(}\frac{c}{\varepsilon}\log\lambda+(1+\varepsilon)a\big{)}=(1+\varepsilon)n+O_{k,\varepsilon}(n\log(a)/a), to obtain

[TABLE]

where the hidden constant depends only on $k$ and $\varepsilon$. Since $(\log a)/a$ tends to 0 for $a\to\infty$, we can choose $a$ sufficiently large, depending on $k$ and $\varepsilon$, to obtain $\log T\leq(1+\varepsilon)n+\varepsilon n\leq(1+2\varepsilon)n$.

Let us also count the number of constructed items. We have one item for each variable $x$ and each assignment $\alpha\in[2^{a}]$, amounting to $2^{a}\hat{n}\leq 2^{a}n$ items. Moreover, we have one item for each clause $C$ and all assignments $\alpha_{1},\ldots,\alpha_{s}\in[2^{a}]$ that jointly satisfy the clause $C$, where $s\leq\lambda$ is the number of variables contained in $C$. This amounts to up to $2^{a\lambda}\hat{m}\leq 2^{a\lambda}n\leq 2^{\hat{c}_{k,\varepsilon}a^{2}}n$ items. Note that both factors only depend on $k$ and $\varepsilon$, since $a$ only depends on $k$ and $\varepsilon$. Thus, the number of items is bounded by $\tilde{c}_{k,\varepsilon}n$, where $\tilde{c}_{k,\varepsilon}$ only depends on $k$ and $\varepsilon$.

In total, we obtain a reduction that maps an instance $\phi$ of $k$-SAT on $n$ variables to $2^{\varepsilon n}$ instances of Subset Sum with target at most $2^{(1+2\varepsilon)n}$ on at most $\tilde{c}_{k,\varepsilon}n$ items. The running time of the reduction is clearly $\textup{poly}(n)2^{\varepsilon n}$.

Our main result (Theorem 1.1) now follows.

Proof (Proof of Theorem 1.1)

Subset Sum: For any $\varepsilon>0$ set $\varepsilon^{\prime}:=\varepsilon/5$ and let $k$ be sufficiently large so that $k$-SAT has no $O(2^{(1-\varepsilon^{\prime})n})$ algorithm; this exists assuming SETH. Set $\delta:=\varepsilon^{\prime}/\tilde{c}_{k,\varepsilon^{\prime}}$, where $\tilde{c}_{k,\varepsilon^{\prime}}$ is the constant from Theorem 3.1. Now assume that Subset Sum can be solved in time $O(T^{1-\varepsilon}2^{\delta n})$. We show that this contradicts SETH. Let $\phi$ be a $k$-SAT instance on $n$ variables, and run Theorem 3.1 with $\varepsilon^{\prime}$ to obtain $2^{\varepsilon^{\prime}n}$ instances of Subset Sum on at most $\tilde{c}_{k,\varepsilon^{\prime}}n$ items and target at most $2^{(1+2\varepsilon^{\prime})n}$. Using the assumed $O(T^{1-\varepsilon}2^{\delta n})$ algorithm on each Subset Sum instance, yields a total time for $k$-SAT of

[TABLE]

where we used the definitions of $\varepsilon^{\prime}$ and $\delta$ as well as $(1+2\varepsilon^{\prime})(1-5\varepsilon^{\prime})\leq 1-3\varepsilon^{\prime}$. This running time contradicts SETH, yielding the lower bound for Subset Sum.

$k$-Sum: The lower bound $O(T^{1-\varepsilon}n^{\delta k})$ for $k$-Sum now follows easily from the lower bound for Subset Sum. Consider a Subset Sum instance $(Z,T)$ on $|Z|=n$ items and target $T$. Partition $Z$ into sets $Z_{1},\ldots,Z_{k}$ of of equal size, up to $\pm 1$. For each set $Z_{i}$, enumerate all subset sums $S_{i}$ of $Z_{i}$, ignoring the subsets summing to larger than $T$. Consider the $k$-Sum instance $(S_{1},\ldots,S_{k},T)$, where the task is to pick items $s_{i}\in S_{i}$ with $s_{1}+\ldots+s_{k}=T$. Since $|S_{i}|\leq O(2^{n/k})$, an $O(T^{1-\varepsilon}n^{\delta k})$ time algorithm for $k$-Sum now implies an $O(T^{1-\varepsilon}2^{\delta n})$ algorithm for Subset Sum, thus contradicting SETH.

3.3 Direct-OR Theorem for Subset Sum

We now provide a proof for Corollary 1. We show that deciding whether at least one of $N$ given instances of Subset Sum is a YES-instance requires time $(NT)^{1-o(1)}$, where $T$ is a common upper bound on the target. Here we crucially use our reduction from $k$-SAT to Subset Sum, since the former has an easy self-reduction allowing us to tightly reduce one instance to multiple subinstances, while such a self-reduction is not known for Subset Sum.

Proof (Proof of Corollary 1)

Let $\varepsilon>0$ and $\gamma>0$, we will fix $\delta>0$ later. Assume that the OR of $N$ given instances of Subset Sum on target values $T_{1},\ldots,T_{N}=O(N^{\gamma})$ and at most $\delta\log N$ numbers each, can be solved in total time $O(N^{(1+\gamma)(1-\varepsilon)})$. We will show that SETH fails.

Let $\phi$ be an instance of $k$-SAT on $n$ variables. Split the set of variables into $X_{1}$ and $X_{2}$ of size $n_{1}$ and $n_{2}$, such that $n_{2}=\gamma\cdot n_{1}$ up to rounding. Specifically, we can set $n_{1}:=\lceil\frac{n}{1+\gamma}\rceil$ and $n_{2}:=\lfloor\frac{\gamma n}{1+\gamma}\rfloor$ and thus have $n_{2}\leq\gamma n_{1}$. Enumerate all assignments of the variables in $X_{1}$. For each such assignment $\alpha$ let $\phi_{\alpha}$ be the resulting $k$-SAT instance after applying the partial assignment $\alpha$.

For each $\phi_{\alpha}$, run the reduction from Theorem 3.1 with $\varepsilon^{\prime}=\min\{1/2,1/\gamma\}\cdot\varepsilon/2$, resulting in at most $2^{\varepsilon^{\prime}n_{2}}$ instances of Subset Sum on at most $\tilde{c}_{k,\varepsilon^{\prime}}n_{2}$ items and target at most $2^{(1+2\varepsilon^{\prime})n_{2}}$. In total, we obtain at most $2^{n_{1}+\varepsilon^{\prime}n_{2}}$ instances of Subset Sum, and $\phi$ is satisfiable iff at least one of these Subset Sum instances is a YES-instance. Set $N:=2^{(1+\varepsilon/2)n_{1}}$ and note that the number of instances is at most $2^{n_{1}+\varepsilon^{\prime}n_{2}}\leq 2^{(1+\gamma\varepsilon^{\prime})n_{1}}\leq N$, and that the target bound is at most $2^{(1+2\varepsilon^{\prime})n_{2}}\leq 2^{(1+2\varepsilon^{\prime})\gamma n_{1}}\leq N^{\gamma}$. Thus, we constructed at most $N$ instances of Subset Sum on target at most $N^{\gamma}$, each having at most $\tilde{c}_{k,\varepsilon^{\prime}}n_{2}\leq\tilde{c}_{k,\varepsilon^{\prime}}n$ items.

Using the assumed algorithm, the OR of these instances can be solved in total time $O(N^{(1+\gamma)(1-\varepsilon)})$. Since $(1+\gamma)n_{1}=(1+\gamma)\lceil\frac{n}{1+\gamma}\rceil\leq n+1+\gamma=n+O(1)$ and $(1+\varepsilon/2)(1-\varepsilon)\leq 1-\varepsilon/2$, this running time is

[TABLE]

which contradicts SETH. Specifically, assuming SETH for some $k=k(\varepsilon)$ this running time is less than the time required for $k$-SAT. Setting $\delta:=\tilde{c}_{k,\varepsilon^{\prime}}$ finishes the proof.

4 The Bicriteria $s,t$-Path Problem

In this section we apply the results of the previous section to the Bicriteria $s,t$-Path problem. We will show that the Bicriteria $s,t$-Path problem is in fact harder than Subset Sum, by proving that the classical pseudo-polynomial time algorithm for the problem cannot be improved on sparse graphs assuming SETH. We also prove Theorem 1.3 concerning a bounded number of different edge-lengths $\lambda$ and edge-costs $\chi$ in the input network, and Theorem 1.4 concerning a bounded number $k$ of internal vertices in a solution path.

4.1 Sparse networks

We begin with the case of sparse networks; i.e. input graphs on $n$ vertices and $O(n)$ edges. We embed multiple instances of Subset Sum into one instance of Bicriteria $s,t$-Path to prove Theorem 1.2, namely that there is no algorithm for Bicriteria $s,t$-Path on sparse graphs faster than the well-known $O(\min\{nL,nC\})$-time algorithm.

Proof (Proof of Theorem 1.2)

We show that for any $\varepsilon>0,\,\gamma>0$, an algorithm solving Bicriteria $s,t$-Path on sparse $n$-vertex graphs and budgets $L,C=\Theta(n^{\gamma})$ in time $O(n^{(1+\gamma)(1-\varepsilon)})$ contradicts SETH. As in Corollary 1, let $(Z_{1},T_{1}),\ldots,(Z_{N},T_{N})$ be instances of Subset Sum on targets $T_{i}\leq N^{\gamma}$ and number of items $|Z_{i}|\leq\delta\log N$ for all $i$. Without loss of generality, we can assume that all sets $Z_{i}$ have the same size $k=\delta\log N$ (e.g., by making $Z_{i}$ a multiset containing the number 0 multiple times).

Fix an instance $(Z_{i},T_{i})$ and let $Z_{i}=\{z_{1},\ldots,z_{k}\}$. We construct a graph $G_{i}$ whose vertex set is $\{s,v_{1},\ldots,v_{k},t\}$. Writing $v_{0}:=s$ for simplicity, for each $j\in[k]$ we add an edge from $v_{j-1}$ to $v_{j}$ with length $z_{j}$ and cost $N^{\gamma}-z_{j}$, and we add another333Note that parallel edges can be avoided by subdividing all constructed edges. edge from $v_{j-1}$ to $v_{j}$ with length 0 and cost $N^{\gamma}$. Finally, we add an edge from $v_{k}$ to $t$ with length $N^{\gamma}-T_{i}$ and cost $T_{i}$. Then the set of $s,t$-paths corresponds to the power set of $Z_{i}$, and the $s,t$-path corresponding to $Y\subseteq Z_{i}$ has total length $N^{\gamma}-T_{i}+\sum_{y\in Y}y$ and cost $kN^{\gamma}+T_{i}-\sum_{y\in Y}y$. Hence, setting the upper bound on the length to $L=N^{\gamma}$ and on the cost to $C=kN^{\gamma}$, there is an $s,t$-path respecting these bounds iff there is a subset $Y$ of $Z_{i}$ summing to $T_{i}$, i.e., iff $(Z_{i},T_{i})$ is a YES-instance.

We combine the graphs $G_{1},\ldots,G_{N}$ into one graph $G$ by identifying all source vertices $s$, identifying all target vertices $t$, and then taking the disjoint union of the remainder. With the common length bound $L=N^{\gamma}$ and cost bound $C=kN^{\gamma}$, there is an $s,t$-path respecting these bounds in $G$ iff some instance $(Z_{i},T_{i})$ is a YES-instance. Furthermore, note that $G$ has $n=\Theta(N\log N)$ vertices, is sparse, and can be constructed in time $O(N\log N)$. Hence, an $O(n^{(1+\gamma)(1-\varepsilon)})$ time algorithm for Bicriteria $s,t$-Path would imply an $O(N^{(1+\gamma)(1-\varepsilon)}\textup{polylog}N)=O(N^{(1+\gamma)(1-\varepsilon/2)})$ time algorithm for deciding whether at least one of $N$ Subset Sum instances is a YES-instance, a contradiction to SETH by Corollary 1.

Finally, let us ensure that $L,C=\Theta(n^{\gamma})$. Note that the budgets $L$ and $C$ are both bounded by $O(N^{\gamma}\log N)$. If $\gamma\geq 1$, then add a supersource $s^{\prime}$ and one edge from $s^{\prime}$ to $s$ with length and cost equal to $N^{\gamma}\log^{\gamma}N$, and add $N^{\gamma}\log^{\gamma}N$ to $L$ and $C$. This results in an equivalent instance, and the new bounds $L,C$ are $\Theta(N^{\gamma}\log^{\gamma}N)=\Theta(n^{\gamma})$. If $\gamma<1$, then do the same where the length and cost from $s^{\prime}$ to $s$ is $N^{\gamma}\log N$, and then add $N\log^{1/\gamma}N$ dummy vertices to the graph to increase $n$ to $\Theta(N\log^{1/\gamma}N)$. Again we obtain budgets $L,C=\Theta(N^{\gamma}\log N)=\Theta((N\log^{1/\gamma}N)^{\gamma})=\Theta(n^{\gamma})$. In both cases, the same running time analysis as in the last paragraph goes through. This completes the proof of Theorem 1.2.

4.2 Few different edge-lengths or edge-costs

We next consider the parameters $\lambda$ (the number of different edge-lengths) and $\chi$ (the number of different edge-costs). We show that Bicriteria $s,t$-Path can be solved in $O(n^{\min\{\lambda,\chi\}+2})$ time, while its unlikely to be solvable in $O(n^{\min\{\lambda,\chi\}-1-\varepsilon})$ for any $\varepsilon>0$, providing a complete proof for Theorem 1.3. The upper bound of this theorem is quite easy, and is given in the following lemma.

Lemma 4

Bicriteria $s,t$-Path* can be solved in $O(n^{\min\{\lambda,\chi\}+2})$ time.*

Proof

It suffices to give an $O(n^{\lambda+2})$ time algorithm, as the case of time $O(n^{\chi+2})$ is symmetric, and a combination of these two algorithms yields the claim. Let $\tilde{\ell}_{1},\ldots,\tilde{\ell}_{\lambda}$ be all different edge-length values. We compute a table $T[v,i_{1},\ldots,i_{\lambda}]$, where $v\in V(G)$ and $i_{1},\ldots,i_{\lambda}\in\{0,\ldots,n\}$, which stores the minimum cost of any $s,v$-path that has exactly $i_{j}$ edges of length $\tilde{\ell}_{j}$, for each $j\in\{1,\ldots,\lambda\}$. For the base case of our computation, we set $T[s,0,\ldots,0]=0$ and $T[s,i_{1},\ldots,i_{\lambda}]=\infty$ for entries with some $i_{j}\neq 0$. The remaining entries are computed via the following recursion:

[TABLE]

It is easy to see that the above recursion is correct, since if $e_{1},\ldots,e_{k}$ is an optimal $s,v$-path corresponding to an entry $T[v,i_{1},\ldots,i_{\lambda}]$ in $T$, with $e_{k}=(u,v)$ and $\ell(e_{k})=\tilde{\ell}_{j}$ for some $j\in\{1,\ldots,\lambda\}$, then $e_{1},\ldots,e_{k-1}$ is an optimal $s,u$-path corresponding to the entry $T[u,i_{1},\ldots,i_{j}-1,\ldots,i_{\lambda}]$. Thus, after computing table $T$, we can determine whether there is a feasible $s,t$-path in $G$ by checking whether there is an entry $T[t,i_{1},\ldots,i_{\lambda}]$ with $\sum_{j=1}^{\lambda}i_{j}\cdot\tilde{\ell}_{j}\leq L$ and $T[t,i_{1},\ldots,i_{\lambda}]\leq C$. As there are $O(n^{\lambda+1})$ entries in $T$ in total, and each entry can be computed in $O(n)$ time, the entire algorithm requires $O(n^{\lambda+2})$ time.

We now turn to proving the lower-bound given in Theorem 1.3. The starting point is our lower bound for $k$-Sum ruling out $O(T^{1-\varepsilon}n^{\delta k})$ algorithms (Theorem 1.1). We present a reduction from $k$-Sum to Bicriteria $s,t$-Path, where the resulting graph in the Bicriteria $s,t$-Path instance has few different edge-lengths and edge-costs.

Let $(Z_{1},\ldots,Z_{k},T)$ be an instance of $k$-Sum with $Z_{i}\subset[0,T]$ and $|Z_{i}|\leq n$ for all $i$, and we want to decide whether there are $z_{1}\in Z_{1},\ldots,z_{k}\in Z_{k}$ with $z_{1}+\ldots+z_{k}=T$. We begin by constructing an acyclic multigraph $G^{*}$, using similar ideas to those used for proving Theorem 1.2. The multigraph $G^{*}$ has $k+1$ vertices $s=v_{0},\ldots,v_{k}=t$, and is constructed as follows: For each $i\in\{1,\ldots,k\}$, we add at most $n$ edges from $v_{i-1}$ to $v_{i}$, one for each element in $Z_{i}$. The length of an edge $e\in E(G^{*})$ corresponding to element $z_{i}\in Z_{i}$ is set to $\ell(e)=z_{i}$, and its cost is set to $c(e)=T-z_{i}$.

Lemma 5

$(Z_{1},\ldots,Z_{k},T)$* has a solution iff $G^{*}$ has an $s,t$-path of length at most $L=T$ and cost at most $C=T(k-1)$.*

Proof

Suppose there are $z_{1}\in Z_{1},\ldots,z_{k}\in Z_{k}$ that sum to $T$. Consider the $s,t$-path $e_{1},\ldots,e_{k}$ in $G^{*}$, where $e_{i}$ is the edge from $v_{i-1}$ to $v_{i}$ corresponding to $z_{i}$. Then $\sum_{i=1}^{k}\ell(e_{i})=\sum_{i=1}^{k}z_{i}=T=L$, and $\sum_{i=1}^{k}c(e_{i})=\sum_{i=1}^{k}T-z_{i}=kT-T=C$. Conversely, any $s,t$-path in $G^{*}$ has $k$ edges $e_{1},\ldots,e_{k}$, where $e_{i}$ is an edge from $v_{i-1}$ to $v_{i}$. If such a path is feasible, meaning that $\sum_{i=1}^{k}\ell(e_{i})\leq L=T$ and $\sum_{i=1}^{k}c(e_{i})\leq C=T(k-1)$, then these two inequalities must be tight because $c(e_{i})=T-\ell(e_{i})$ for each $i\in[k]$. This implies that the integers $z_{1},\ldots,z_{k}$ corresponding to the edges $e_{1},\ldots,e_{k}$ of $G^{*}$, sum to $T$.

Let $\tau\geq 1$ be any constant and let $B:=\lceil T^{1/\tau}\rceil$. We next convert $G^{*}$ into a graph $\tilde{G}$ which has $\tau+1$ different edge-lengths and $\tau+1$ different edge-costs, both taken from the set $\{0,B^{0},B^{1},\ldots,B^{\tau-1}\}$. Recall that $V(G^{*})=\{v_{0},\ldots,v_{k}\}$, and the length and cost of each edge in $G^{*}$ is non-negative and bounded by $T$. The vertex set of $\tilde{G}$ will include all vertices of $G^{*}$, as well as additional vertices.

For an edge $e\in E(G^{*})$, write its length as $\ell(e)=\sum_{i=0}^{\tau-1}a_{i}B^{i}$, and its cost as $c(e)=\sum_{i=0}^{\tau-1}b_{i}B^{i}$, for integers $a_{1},\ldots,a_{\tau-1},b_{1},\ldots,b_{\tau-1}\in\{0,\ldots,B-1\}$. We replace the edge $e$ of $G^{*}$ with a path in $\tilde{G}$ between the endpoints of $e$ that has $\sum_{i=0}^{\tau-1}(a_{i}+b_{i})$ internal vertices. For each $i\in\{0,\ldots,\tau-1\}$, we set $a_{i}$ edges in this path to have length $B^{i}$ and cost 0, and $b_{i}$ edges to have length 0 and cost $B^{i}$. Replacing all edges of $G^{*}$ by paths in this way, we obtain the graph $\tilde{G}$ which has $O(nB)$ vertices and edges (since $k$ and $\tau$ are constant). As any edge in $G^{*}$ between $v_{i}$ and $v_{i+1}$ corresponds to a path between these two vertices in $\tilde{G}$ with the same length and cost, we have:

Lemma 6

Any $s,t$-path in $G^{*}$ corresponds to an $s,t$-path in $\tilde{G}$ with same length and cost, and vice-versa.

Lemma 7

Assuming SETH, for any constant $\lambda,\chi\geq 2$ there is no $O(n^{\min\{\lambda,\chi\}-1-\varepsilon})$ algorithm for Bicriteria $s,t$-Path for any $\varepsilon>0$.

Proof

Suppose Bicriteria $s,t$-Path has a $O(n^{\min\{\lambda,\chi\}-1-\varepsilon})$ time algorithm. We use this algorithm to obtain a fast algorithm for $k$-Sum, contradicting SETH by Theorem 1.1. On a given input $(Z_{1},\ldots,Z_{k},T)$ of $k$-Sum on $n$ items, for $\tau:=\min\{\lambda,\chi\}-1$ we construct the instance $(\tilde{G},s,t,L,C)$ described above. Then $\tilde{G}$ is a directed acyclic graph with $\tau+1=\min\{\lambda,\chi\}$ different edge-lengths and edge-costs $\{0,B^{0},B^{1},\ldots,B^{\tau-1}\}$. Moreover, due to Lemmas 5 and 6, there are $z_{1}\in Z_{1},\ldots,z_{k}\in Z_{k}$ summing to $T$ iff $\tilde{G}$ has a feasible $s,t$-path. Thus, we can use our assumed Bicriteria $s,t$-Path algorithm on $(\tilde{G},s,t,L,C)$ to solve the given $k$-Sum instance. As $\tilde{G}$ has $O(nB)$ vertices and edges, where $B=\lceil T^{1/\tau}\rceil$, an $O(n^{\min\{\lambda,\chi\}-1-\varepsilon})$ algorithm runs in time $O((nB)^{\tau-\varepsilon})=O(T^{1-\varepsilon/\tau}n^{\tau})$ time on $(\tilde{G},s,t,L,C)$. For $\delta:=\delta(\varepsilon/\tau)$ from Theorem 1.1 and $k$ set to $\tau/\delta$, this running time is $O(T^{1-\varepsilon/\tau}n^{\delta(\varepsilon/\tau)k})$ and thus contradicts SETH by Theorem 1.1.

4.3 Solution paths with few vertices

In this section we investigate the complexity of Bicriteria $s,t$-Path with respect to the number of internal vertices $k$ in a solution path. Assuming $k$ is fixed and bounded, we obtain a tight classification of the time complexity for the problem, up to sub-polynomial factors, under Conjecture 2.

Our starting point is the Exact $k$-Path problem: Given an integer $T\in\{0,\ldots,W\}$, and a directed graph $G$ with edge weights, decide whether there is a simple path in $G$ on $k$ vertices in which the sum of the weights is exactly $T$. Thus, this is the ”exact” variant of Bicriteria $s,t$-Path on graphs with a single edge criterion, and no source and target vertices. The Exact $k$-Path problem can be solved in $\tilde{O}(n^{\lceil(k+1)/2\rceil})$ time by a “meet-in-the-middle” algorithm [4], where the $\tilde{O}(\cdot)$ notation suppresses poly-logarithmic factors in $W$. It is also known that Exact $k$-Path has no $\tilde{O}(n^{\lceil(k+1)/2\rceil-\varepsilon})$ time algorithm, for any $\varepsilon>0$, unless the $k$-Sum conjecture is false [4]. We will show how to obtain similar bounds for Bicriteria $s,t$-Path by implementing a very efficient reduction between the two problems.

To show that Exact $k$-Path can be used to solve Bicriteria $s,t$-Path, we will combine multiple ideas. The first is the observation that Exact $k$-Path can easily solve the Exact Bicriteria $k$-Path problem, a variant which involves bicriteria edge weights: Given a pair of integers $(T_{1},T_{2})$, and a directed graph $G$ with two edge weight functions $w_{1}(\cdot)$ and $w_{2}(\cdot)$, decide whether there is a simple path in $G$ on $k$ vertices in which the sum of the $w_{i}$-weights is exactly $T_{i}$ for $i\in\{1,2\}$.

Lemma 8

There is an $O(n^{2})$ time reduction that reduces an instance of Exact Bicriteria $k$-Path with edge weights in $\{0,1,\ldots,W\}^{2}$ to an instance of Exact $k$-Path with edge weights in $\{0,1,\ldots,2kW^{2}+W\}$.

Proof

Define a mapping of a pairs in $\{0,1,\ldots,W\}^{2}$ to single integers $\{0,\ldots,2kW^{2}+W\}$ by setting $f(w_{1},w_{2})=w_{2}+w_{1}\cdot 2kW$ for each $w_{1},w_{2}\in\{0,\ldots,W\}$. Observe that for any $k$ pairs $(w^{1}_{1},w^{1}_{2}),\ldots,(w^{k}_{1},w^{k}_{2})$, we have $(\sum_{i=1}^{k}w^{i}_{1}=T_{1}\wedge\sum_{i=1}^{k}w^{i}_{2}=T_{2})$ iff $\sum_{i=1}^{k}f(w^{i}_{1},w^{i}_{2})=f(T_{1},T_{2})$. Therefore, given a graph as in the statement, we can map each pair of edge weights into a single edge weight, thus reducing to Exact $k$-Path without changing the answer.

The next and more difficult step is to reduce Bicriteria $s,t$-Path to Exact Bicriteria $k$-Path. This requires us to reduce the question of whether there is a path of length and cost at most $L$ and $C$, to questions about the existence of paths with length and cost equalling exactly $T_{1}$ and $T_{2}$. A naive approach would be to check if there is a path of exact length and cost $(T_{1},T_{2})$ for all values $T_{1}\leq L$ and $T_{2}\leq C$. Such a reduction will incur a very large $O(LC)$ overhead. We will improve this to $O(\log^{O(1)}{(L+C)})$.

In the remainder of this section, let $W$ be the maximum of $L$ and $C$. The idea behind our reduction is to look for the smallest $x,y\in[\log{W}]$ such that if we restrict all edge lengths $\ell$ to the $x$ most significant bits of $\ell$, and all edge costs $c$ to the $y$ most significant bits of $c$, then there is a path that satisfies the threshold constraints with equality. To do this, we can check for every pair $x,y$, whether after restricting edge lengths and costs, there is a $k$-path with total weight exactly equal to the restriction of the vector $(L,C)$, possibly minus the carry from the removed bits. Since the carry from summing $k$ numbers can be at most $k$, and we have to consider this carry for the length and the cost, we will not have to check more than $O(k^{2})$ “targets” per pair $x,y\in[\log{W}]$.

To implement this formally, we will need the following technical lemma. The proof uses a bit scaling technique that is common in approximation algorithms. Previously, tight reductions that use this technique were presented by Vassilevska and Williams [113] (in a very specific setting), and by Nederlof et al. [95] (who proved a general statement). We will need a generalization of the result of [95] in which we introduce a parameter $k$, and show that the overhead depends only on $k$ and $W$, and does not depend on $n$.

Lemma 9

Let $U$ be a universe of size $n$ with weight functions $w_{1},w_{2}:U\to\{0,\ldots,W\}$, and let $T_{1},T_{2}\in\{0,\ldots,W\}$ be integers. Then there is a polynomial time algorithm that returns a set of weight functions $w_{1}^{(i)},w_{2}^{(i)}:U\to\{0,\ldots,W\}$ and integers $T_{1}^{(i)},T_{2}^{(i)}\in\{0,\ldots,W\}$, for $i\in[q]$ and $q=O(k^{2}\log^{2}{W})$, such that: For every subset $X\subseteq U$ of size $|X|=k$ we have $(w_{1}(X)\leq T_{1}\wedge w_{2}(X)\leq T_{2})$ if and only if there exists an $i\in[q]$ with $(w^{(i)}_{1}(X)=T^{(i)}_{1}\wedge w^{(i)}_{2}(X)=T^{(i)}_{2})$.

Proof

Note that for any subset $X\subseteq U$ with $|X|=k$ we have $w_{1}(X),w_{2}(X)\in\{0,\ldots,kW\}$. We will assume that a number in $\{0,\ldots,kW\}$ is encoded in binary with $\log(kW)$ bits in the standard way. For numbers $a\in\{0,\ldots,kW\}$ and $x\in[\log{W}]$ we let $[a]_{x}=\lfloor a/2^{x}\rfloor$, that is, we remove the $x$ least significant bits of $a$. In what follows, we will construct weight functions and targets for each dimension independently and in a similar way. We will present the construction for the $w_{1}$’s.

First, we add the weight functions $w_{1}^{(i)}=w_{1}$, with target $T^{(i)}_{1}=T_{1}-a$ for any $a\in[4k]$. Call these the initial $(i)$’s. Then, for any $x\in[\log{W}]$ and $a\in[2k]$, we add the weight function $w_{1}^{(i)}(e)=[w_{1}(e)]_{x}$, and set the target to $T_{1}^{(i)}=[T_{1}]_{x}-k-a$. This defines $O(k\log{W})$ new functions and targets, and we will show below that for any subset $X\subseteq U$ we have that $w_{1}(X)\leq T_{1}$ iff for some $i$ we have $w_{1}^{(i)}(X)=T_{1}^{(i)}$. Then, we apply the same construction for $w_{2}$, and take every pair of constructed functions and targets, to obtain a set of $O(k^{2}\log^{2}{W})$ functions and targets that satisfy the required property.

The correctness will be based on the following bound, which follows because when summing $k$ numbers the carry from removed least significant bits cannot be more than $k$. In particular, for any $x\in[\log W]$ and $a_{1},\ldots,a_{k}\in\{0,\ldots,W\}$, we have

[TABLE]

Fix some $X\subset U$. For the first direction, assume that for some $i$, $w_{1}^{(i)}(X)=T^{(i)}_{1}$. If it is one of the initial $(i)$’s, then we immediately have $w_{1}(X)\leq T_{1}$. Otherwise, if $X=\{v_{1},\ldots,v_{k}\}$ then

[TABLE]

which implies that $w_{1}(X)<T_{1}$.

For the other direction, assume that $w_{1}(X)\leq T_{1}$. If $w_{1}(X)\geq T_{1}-4k$ then for one of the initial $(i)$’s we will have $w_{1}^{(i)}(X)=w_{1}(X)=T_{1}-a=T_{1}^{(i)}$ for some $a\in[4k]$. Otherwise, let $x$ be the largest integer in $[\log W]$ for which $[w_{1}(X)]_{x}\leq[T_{1}]_{x}-k$. Because $x$ is the largest, we also know that $[w_{1}(X)]_{x}\geq[T_{1}]_{x}-2k$. Therefore,

[TABLE]

and

[TABLE]

It follows that for some $a\in[2k]$, we have $w_{1}^{(i)}(X)=[T_{1}]_{x}-k-a=T_{1}^{(i)}$.

We are now ready to present the main reduction of this section. Let $(G,s,t,L,C)$ be a given instance of Bicriteria $s,t$-Path. Our reduction follows three general steps that proceed as follows:

Color coding: At the first step, we use the derandomized version of the color coding technique [11] to obtain $p^{\prime}=2^{O(k)}\log n=O_{k}(\log n)$ partitions of the vertex set $V(G)\setminus\{s,t\}$ into $k$ classes $V^{(\alpha)}_{1},\ldots,V^{(\alpha)}_{k}$, $\alpha\in[p^{\prime}]$, with the following property: If there is a feasible $s,t$-path $P$ with $k$ internal vertices in $G$, we are guaranteed that for at least one partition we will have $|V(P)\cap V^{(\alpha)}_{i}|=1$ for each $i\in[k]$. By trying out all possible $O_{k}(1)$ orderings of the classes in each partition, we can assume that if $P=s,v_{1},\ldots,v_{k},t$, then $V(P)\cap V^{(\alpha)}_{i}=\{v_{i}\}$ for each $i\in[k]$.

Let $p$ denote the total number of ordered partitions. For each ordered partition $\alpha\in[p]$, we remove all edges between vertices inside the same class, and all edges $(u,v)$ where $u\in V^{(\alpha)}_{i}$, $v\in V^{(\alpha)}_{j}$, and $j\neq i+1$. We also remove all edges from $s$ to vertices not in $V^{(\alpha)}_{1}$, and all edges to $t$ from vertices not in $V_{k}$. Let $G_{\alpha}$ denote the resulting graph, with $\alpha\in[p]$ for $p=O_{k}(\log n)$. 2. 2.

Removal of $s$ and $t$: Next, we next remove $s$ and $t$ from each $G_{\alpha}$. For every vertex $v\in V_{1}^{(\alpha)}$, if $v$ was connected with an edge from $s$ of length $\ell$ and cost $c$, then we remove this edge and add this length $\ell$ and cost $c$ to all the edges outgoing from $v$. Similarly, we remove the edge from $v\in V^{(\alpha)}_{k}$ to $t$, and add its length and cost to all edges ingoing to $v$. Finally, any vertex in $V^{(\alpha)}_{1}$ that was not connected with an edge from $s$ is removed from the graph, and every vertex in $V^{(\alpha)}_{k}$ that was not connected to $t$ is removed. 3. 3.

Inequality to equality reduction: Now, for each $G_{\alpha}$, we apply Lemma 9 with the universe $U$ being the edges of $G_{\alpha}$, and $w_{1},w_{2}:U\to\{0,\ldots,W\}$ being the lengths and costs of the edges. We get a set of $q=O_{k}(\log^{2}{W})$ weight functions and targets. For $\beta\in[q]$, let $G_{\alpha,\beta}$ be the graph obtained from $G$ by replacing the lengths and costs with new functions $w^{(\beta)}_{1},w^{(\beta)}_{2}$. The final Exact Bicriteria $k$-Path is then constructed as $(G_{\alpha,\beta},T^{(\beta)}_{1},T^{(\beta)}_{2})$.

Thus, we reduce our Bicriteria $s,t$-Path instance to at most $O_{k}(\log{n}\log^{2}{W})$ instances of Exact Bicriteria $k$-Path. Note that if $G$ contains a feasible $s,t$-path $P=s,v_{1},\ldots,v_{k},t$ of length $\ell_{P}\leq L$ and cost $c_{P}$, then by correctness of the color coding technique, there is some $\alpha\in[p]$ such that $G_{\alpha}$ contains $P$ with $V(P)\cap V^{(\alpha)}_{i}=\{v_{i}\}$ for each $i\in[k]$. Moreover, the total weight of $v_{1},\ldots,v_{k}$ in $G_{\alpha}$ is $(\ell_{P},c_{P})$. By Lemma 9, there is some $\beta\in[q]$ for which the total weight of $v_{1},\ldots,v_{k}$ in $G_{\alpha,\beta}$ is $(T^{(\beta)}_{1},T^{(\beta)}_{2})$. Thus, $P$ is a solution for $(G_{\alpha,\beta},T^{(\beta)}_{1},T^{(\beta)}_{2})$. Conversely, by the same line of arguments, any solution path for some Exact Bicriteria $k$-Path instance $(G_{\alpha,\beta},T^{(\beta)}_{1},T^{(\beta)}_{2})$ corresponds to a feasible $s,t$-path in $G$ with $k$ internal vertices.

Thus, we have obtained a reduction from Bicriteria $s,t$-Path to Exact Bicriteria $k$-Path. Combining this with reduction from Exact Bicriteria $k$-Path to Exact $k$-Path given in Lemma 8, we obtain the following.

Lemma 10

Fix $k\geq 1$, and let $(G,s,t,L,C)$ be an instance of Bicriteria $s,t$-Path where $G$ has $n$ vertices. Set $W=\max\{L,C\}$. Then one can determine whether $(G,s,t,L,C)$ has a solution with $k$ internal vertices by solving $O_{k}(\log{n}\log^{2}{W})$ instances of Exact $k$-Path on graphs with $O(n)$ vertices and edge weights bounded by $O_{k}(W^{2})$.

Corollary 2

For any fixed $k\geq 1$ there is an algorithm solving Bicriteria $s,t$-Path on $k$ vertices in $\tilde{O}(n^{\lceil(k+1)/2\rceil})$ time.

Proof

By Lemma 10, an instance of Bicriteria $s,t$-Path can be reduced to $O(\log{n}\log^{2}{W})$ instances of Exact $k$-Path. Using the algorithm in [4], each of these Exact $k$-Path instances can be solved in $\tilde{O}(n^{\lceil(k+1)/2\rceil})$ time.

We next turn to proving our lower bound for Bicriteria $s,t$-Path. For this, we show a reduction in the other direction, from Exact $k$-Path to Bicriteria $s,t$-Path.

Lemma 11

Let $\varepsilon>0$ and $k\geq 1$. There is no $\tilde{O}(n^{\lceil(k+1)/2\rceil-\varepsilon})$ time algorithm for Bicriteria $s,t$-Path on $k$ vertices unless the $k$-Sum conjecture (Conjecture 2) is false.

Proof

We show a reduction from Exact $k$-Path to Bicriteria $s,t$-Path. This proves the claim, as it is known that an $\tilde{O}(n^{\lceil(k+1)/2\rceil-\varepsilon})$ time algorithm for Exact $k$-Path, for any $\varepsilon>0$, implies that the $k$-Sum conjecture is false [4]. Let $(G,T)$ be an instance of Exact $k$-Path, where $G$ is an edge-weighted graph and $T\in\{0,\ldots,W\}$ is the target. We proceed as follows: As in the upper-bound reduction, we first apply the color-coding technique [11] to obtain $p=O(\log{n})$ vertex-partitioned graphs $G_{1},\ldots,G_{p}$, where $V(G_{\alpha})$ is the disjoint union $V^{(\alpha)}_{1}\uplus\cdots\uplus V^{(\alpha)}_{k}$ for each $\alpha\in[p]$, such that $G$ has a solution path $P=v_{1},\ldots,v_{k}$ iff for at least one graph $G_{\alpha}$ we have $V(P)=V^{(\alpha)}_{i}\cap\{v_{i}\}$ for each $i\in[k]$.

We then construct a new graph $H_{\alpha}$ from each graph $G_{\alpha}$ as follows: We first remove from $G_{\alpha}$ all edges inside the same vertex class $V^{(\alpha)}_{i}$, and all edges between vertices in $V^{(\alpha)}_{i}$ and vertices in $V^{(\alpha)}_{j}$ with $j\neq i+1$. We then replace each remaining edge with weight $x\in\{0,\ldots,W\}$ in $G_{\alpha}$ with an edge with length $x$ and cost $W-x$ in $H_{\alpha}$. Then, we add vertices $s,t$ to $H_{\alpha}$, connect $s$ to all the vertices in $V^{(\alpha)}_{1}$, connect all the vertices in $V^{(\alpha)}_{k}$ to $t$, and set the length and cost of all these edges to [math]. To complete the proof, we argue that $G$ has a simple path of weight exactly $T$ iff some $H_{\alpha}$ contains a feasible $s,t$-path for $L=T$ and $C=(k-1)W-T$.

Suppose $P=v_{1},\ldots,v_{k}$ is a simple path in $G$ with $w(P)=T$. Then there is some $\alpha\in[p]$ such that $P$ is a path in $G_{\alpha}$ with $V(P)=V^{(\alpha)}_{i}\cap\{v_{i}\}$ for each $i\in[k]$. By construction of $H_{\alpha}$, $P^{\prime}=s,v_{1},\ldots,v_{k},t$ is a path in $H_{\alpha}$, and it has total length $\ell(P^{\prime})=w(P)=T\leq L$, and total cost $c(P^{\prime})=(k-1)W-w(P)=(k-1)W-T\leq C$. Conversely, if $P^{\prime}=s,v_{1},\ldots,v_{k},t$ is a feasible $s,t$-path in some $H_{\alpha}$ with length $\ell(P^{\prime})\leq L$ and cost $c(P^{\prime})\leq C$, then $P=v_{1},\ldots,v_{k}$ is path in $G$. We know that the weight of $P$ in $G$ is bounded by above by $w(P)=\ell(P^{\prime})\leq L=T$. Furthermore, we have $(k-1)W-w(P)=(k-1)W-\ell(P^{\prime})=c(P^{\prime})\leq C=(k-1)W-T$, implying that $w(P)\geq T$. These two inequalities imply $w(P)=T$, and thus $P$ is a solution for $(G,T)$.

Thus, we can solve $(G,T)$ by solving $O(\log n)$ instances of Bicriteria $s,t$-Path. This means that an $\tilde{O}(n^{\lceil(k+1)/2\rceil-\varepsilon})$ algorithm for Bicriteria $s,t$-Path, for $\varepsilon>0$, would imply an algorithm with the same running time for Exact $k$-Path. By the reductions in [4], this refutes the $k$-Sum conjecture.

Theorem 1.4 now immediately follows from the upper and lower bounds given in Corollary 2 and Lemma 11 for finding a solution for a Bicriteria $s,t$-Path instance that has $k$ internal vertices.

Acknowledgements

We would like to thank Jesper Nederlof for an inspiring discussion on Subset Sum.

A.A. was supported by the grants of Virginia Vassilevska Williams: NSF Grants CCF-1417238, CCF-1528078 and CCF-1514339, and BSF Grant BSF:2012338. K.B.: This work is part of the project TIPEA that has received funding from the European Research Council (ERC) under the European Unions Horizon 2020 research and innovation programme (grant agreement No. 850979). D.H. has received funding from the People Programme (Marie Curie Actions) of the European Union’s Seventh Framework Programme (FP7/2007-2013) under REA grant agreement number 631163.11, and by the ISRAEL SCIENCE FOUNDATION (grant No. 551145/).