152 research outputs found
A short note on Merlin-Arthur protocols for subset sum
In the subset sum problem we are given n positive integers along with a
target integer t. A solution is a subset of these integers summing to t. In
this short note we show that for a given subset sum instance there is a proof
of size of what the number of solutions is that can be
constructed in time and can be probabilistically verified in time
with at most constant error probability. Here, the
notation omits factors polynomial in the input size .Comment: 2 page
On the Fine-Grained Parameterized Complexity of Partial Scheduling to Minimize the Makespan
We study a natural variant of scheduling that we call partial scheduling: In this variant an instance of a scheduling problem along with an integer k is given and one seeks an optimal schedule where not all, but only k jobs, have to be processed.
Specifically, we aim to determine the fine-grained parameterized complexity of partial scheduling problems parameterized by k for all variants of scheduling problems that minimize the makespan and involve unit/arbitrary processing times, identical/unrelated parallel machines, release/due dates, and precedence constraints. That is, we investigate whether algorithms with runtimes of the type f(k)n^?(1) or n^?(f(k)) exist for a function f that is as small as possible.
Our contribution is two-fold: First, we categorize each variant to be either in ?, NP-complete and fixed-parameter tractable by k, or ?[1]-hard parameterized by k. Second, for many interesting cases we further investigate the run time on a finer scale and obtain run times that are (almost) optimal assuming the Exponential Time Hypothesis. As one of our main technical contributions, we give an ?(8^k k(|V|+|E|)) time algorithm to solve instances of partial scheduling problems minimizing the makespan with unit length jobs, precedence constraints and release dates, where G = (V,E) is the graph with precedence constraints
Finding Large Set Covers Faster via the Representation Method
The worst-case fastest known algorithm for the Set Cover problem on universes with n elements still essentially is the simple O^*(2^n)-time dynamic programming algorithm, and no non-trivial consequences of an O^*(1.01^n)-time algorithm are known. Motivated by this chasm, we study the following natural question: Which instances of Set Cover can we solve faster than the simple dynamic programming algorithm? Specifically, we give a Monte Carlo algorithm that determines the existence of a set cover of size sigma*n in O^*(2^{(1-Omega(sigma^4))n}) time. Our approach is also applicable to Set Cover instances with exponentially many sets: By reducing the task of finding the chromatic number chi(G) of a given n-vertex graph G to Set Cover in the natural way, we show there is an O^*(2^{(1-Omega(sigma^4))n})-time randomized algorithm that given integer s = sigma*n, outputs NO if chi(G) > s and YES with constant probability if chi(G) <= s - 1.
On a high level, our results are inspired by the "representation method" of Howgrave-Graham and Joux~[EUROCRYPT\u2710] and obtained by only evaluating a randomly sampled subset of the table entries of a dynamic programming algorithm
A Tight Lower Bound for Counting Hamiltonian Cycles via Matrix Rank
For even , the matchings connectivity matrix encodes which
pairs of perfect matchings on vertices form a single cycle. Cygan et al.
(STOC 2013) showed that the rank of over is
and used this to give an
time algorithm for counting Hamiltonian cycles modulo on graphs of
pathwidth . The same authors complemented their algorithm by an
essentially tight lower bound under the Strong Exponential Time Hypothesis
(SETH). This bound crucially relied on a large permutation submatrix within
, which enabled a "pattern propagation" commonly used in previous
related lower bounds, as initiated by Lokshtanov et al. (SODA 2011).
We present a new technique for a similar pattern propagation when only a
black-box lower bound on the asymptotic rank of is given; no
stronger structural insights such as the existence of large permutation
submatrices in are needed. Given appropriate rank bounds, our
technique yields lower bounds for counting Hamiltonian cycles (also modulo
fixed primes ) parameterized by pathwidth.
To apply this technique, we prove that the rank of over the
rationals is . We also show that the rank of
over is for any prime
and even for some primes.
As a consequence, we obtain that Hamiltonian cycles cannot be counted in time
for any unless SETH fails. This
bound is tight due to a time algorithm by Bodlaender et
al. (ICALP 2013). Under SETH, we also obtain that Hamiltonian cycles cannot be
counted modulo primes in time , indicating
that the modulus can affect the complexity in intricate ways.Comment: improved lower bounds modulo primes, improved figures, to appear in
SODA 201
Speeding-up Dynamic Programming with Representative Sets - An Experimental Evaluation of Algorithms for Steiner Tree on Tree Decompositions
Dynamic programming on tree decompositions is a frequently used approach to
solve otherwise intractable problems on instances of small treewidth. In recent
work by Bodlaender et al., it was shown that for many connectivity problems,
there exist algorithms that use time, linear in the number of vertices, and
single exponential in the width of the tree decomposition that is used. The
central idea is that it suffices to compute representative sets, and these can
be computed efficiently with help of Gaussian elimination.
In this paper, we give an experimental evaluation of this technique for the
Steiner Tree problem. A comparison of the classic dynamic programming algorithm
and the improved dynamic programming algorithm that employs the table reduction
shows that the new approach gives significant improvements on the running time
of the algorithm and the size of the tables computed by the dynamic programming
algorithm, and thus that the rank based approach from Bodlaender et al. does
not only give significant theoretical improvements but also is a viable
approach in a practical setting, and showcases the potential of exploiting the
idea of representative sets for speeding up dynamic programming algorithms
Sharper Upper Bounds for Unbalanced Uniquely Decodable Code Pairs
Two sets form a Uniquely Decodable Code Pair
(UDCP) if every pair , yields a distinct sum , where
the addition is over . We show that every UDCP , with and , satisfies . For sufficiently small , this bound significantly
improves previous bounds by Urbanke and Li~[Information Theory Workshop '98]
and Ordentlich and Shayevitz~[2014, arXiv:1412.8415], which upper bound
by and , respectively, as approaches .Comment: 11 pages; to appear at ISIT 201
Improving Schroeppel and Shamir's Algorithm for Subset Sum via Orthogonal Vectors
We present an time and
space randomized algorithm for solving
worst-case Subset Sum instances with integers. This is the first
improvement over the long-standing time and
space algorithm due to Schroeppel and Shamir (FOCS
1979).
We breach this gap in two steps: (1) We present a space efficient reduction
to the Orthogonal Vectors Problem (OV), one of the most central problem in
Fine-Grained Complexity. The reduction is established via an intricate
combination of the method of Schroeppel and Shamir, and the representation
technique introduced by Howgrave-Graham and Joux (EUROCRYPT 2010) for designing
Subset Sum algorithms for the average case regime. (2) We provide an algorithm
for OV that detects an orthogonal pair among given vectors in
with support size in time . Our
algorithm for OV is based on and refines the representative families framework
developed by Fomin, Lokshtanov, Panolan and Saurabh (J. ACM 2016).
Our reduction uncovers a curious tight relation between Subset Sum and OV,
because any improvement of our algorithm for OV would imply an improvement over
the runtime of Schroeppel and Shamir, which is also a long standing open
problem.Comment: STOC 2021, 38 pages, 3 figure
Equal-Subset-Sum Faster Than the Meet-in-the-Middle
In the Equal-Subset-Sum problem, we are given a set S of n integers and the problem is to decide if there exist two disjoint nonempty subsets A,B subseteq S, whose elements sum up to the same value. The problem is NP-complete. The state-of-the-art algorithm runs in O^*(3^(n/2)) <= O^*(1.7321^n) time and is based on the meet-in-the-middle technique. In this paper, we improve upon this algorithm and give O^*(1.7088^n) worst case Monte Carlo algorithm. This answers a question suggested by Woeginger in his inspirational survey.
Additionally, we analyse the polynomial space algorithm for Equal-Subset-Sum. A naive polynomial space algorithm for Equal-Subset-Sum runs in O^*(3^n) time. With read-only access to the exponentially many random bits, we show a randomized algorithm running in O^*(2.6817^n) time and polynomial space
- …