An Algorithm for the Subset Sum Problem with O(2ⁿ) Time Complexity and O(n) Space Complexity

Subset and problem (Subset-Sum Problem, SSP) is to say that a given one has nnA set of natural numbers with$n$ elements S = { a 1 , a 2 , ⋯ , an } S=\{a_1,a_2,\cdots,a_n\}S={ a1​,a2​,⋯,an​} and a natural number$s$ , asks if there isSSA subset of$S$$T$ makesTTThe sum of all elements in$T$$s$。

make $t$ is equal toSSThe sum of all elements in$S$$t=\sum _{j=1}^n{a}_j$). Obviously, when $s>When\; t$ , the subset$T$ does not exist, output directlyFalse; when$s=When\; t$ ,$T=S$ is a subset that satisfies the conditions and is output directlyTrue; when$s=0$ , because the empty set$\varnothing$ isSSA subset of$S$$0$ , also output directlyTrue. So, we only need to consider$0<s<the\; case\; of\; t$ .

There are currently two popular solutions, one is search (time complexity $O\left(2^n\right)$, space complexity$O\left(n\right)$ ), the other isdynamic programming(reducing the problem to a knapsack problem, time complexity$O\left(nt\right)$ , the space complexity after rolling array optimization is$O(n+t)$ ). The former has the advantage that the time complexity does not depend on$the\; size\; of\; t$ , but the worst-case time complexity is exponential; the advantage of the latter is that when$t$ is relatively small ($t<2^n$ ) is faster than search, the disadvantage is that when$t\ge 2^n$ is slower than search, and takes up a lot of space (generally$t$ is much larger than$n$ ). This paper presents a strategy that can replace dynamic programming, making the time complexityO ( nt ) O(nt)The simultaneous space complexity of$O$$($$n$$t$$)$$O\left(n\right)$ . when$When\; t$ is large, we still use search; when$When\; t$ is small, we use this new strategy for calculation. In this way, facing$When\; t$ is small, we have an efficient and less space-consuming method.

The main idea of ​​our new strategy is to exploit the property of roots of unity of complex numbers. In my previous article, I introduced how to use the unit root to cleverly solve a mathematical problem (see that article for the nature and proof of the unit root), so in this article we will use this idea to give a subset and algorithms for the problem.

Consider the function $$f(x)=\prod _{j=1}^n\left(1+x^{a_j}\right)$$ to expand it into a polynomial$$f\left(x\right)=c_0+c_{1}x+c_2{x}^2+\cdots +c_t{x}^{}$$The coefficient cp c_pof each term in$${}^t$$$c_p$Equal to set S = { a 1 , a 2 , ⋯ , an } S=\{a_1,a_2,\cdots,a_n\}S={ a1​,a2​,⋯,an​} all sum toppThe number of subsets of$p$ ( cp = ∣ { T ∣ T ⊆ S , sum ( T ) = p } ∣ c_p=\left|\left\{T|T\subseteq S,\,\mathrm{sum}( T)=p\right\}\right|cp​=∣{ T∣T⊆S,sum(T)=p } ∣ ). Then the problem we want to solve is essentially to judge$c_s$Is it equal to $0$ . Put$f\left(x\right)$ divided by$x^s$得$$\frac{f(x)}{x^s}=c_0{x}^{-s}+c_1{x}^{1-s}+\cdots +c_s+c_{s+1}x+\cdots +c_t{x}^{t-s}$$ Now we consider the problem in the field of complex numbers. Let$z\in C$ , substitute into the above formula to get$$z^{-s}f(z)=\sum _{j=0}^t{c}_j{z}^{j-s}$$ Next, consider using the property of the unit root. Let$oh=e^{\frac{2\pi i}{m}}=\cos \frac{2}{m}+i\sin \frac{2}{m}$is $m$ times unit root, satisfying${oh}^m=1$ . We also know that$$\sum _{k=0}^{m-1}{\left({oh}^k\right)}^u=\{\begin{array}{ll}0,& u\text{is not}\text{a multiple of}m\\ m,& u\text{is}\end{array}$$for any integer $u$ (whether positive or negative) holds. This gives us to separate out the coefficients$c_s$Definitely $$\sum _{k=0}^{m-1}{\left({oh}^k\right)}^{-s}f\left({oh}^k\right)=\sum _{j=0}^t\left[\sum _{k=0}^{m-1}{c}_j{\left({oh}^k\right)}^{j-s}\right]$$We hope that at$j-s\ne$When$0$ , the value in square brackets$0$ , only when$j-s=0$ is$j=s$ is not$0$ , so the value of the above formula will become$m{c}_s$, we can find $c_s$value. And $j-The\; span\; of\; s$ is from$-s$ to$t-s$ , we hope$-s>-m$，$t-s<m$ , so that except$j=$The values ​​in square bracketsother than$s$ must be$0$ .

Therefore$m>s$且$m>t-s$ . For the convenience of calculation,$m$ should be as small as possible, so we take$m=\max (s,t-s)+1$。 Determine, find the field field$$\begin{array}{rl}{c}_s& =\frac{1}{m}\sum _{k=0}^{m-1}{oh}^{-ks}f\left({oh}^k\right)\\ & =\frac{1}{m}\sum _{k=0}^{m-1}{e}^{-\frac{2\pi isk}{m}}f\left(e^{\frac{2\pi ik}{m}}\right)\end{array}$$计算$f\left(e^{\frac{2\pi ik}{m}}\right)$ demand$O\left(n\right)$ time, summing takes$O\left(m\right)$ time, so a total cost of$O\left(nm\right)$ time. And$m\le t$ , so in the worst case it takes$O\left(nt\right)time$ . We only spent$O\left(1\right)$ space, so the total space spent by the program is to store$a_1,a_2,\cdots ,a_n$O ( n ) O(n) used$O\left(n\right)$ space. In this way, we save a lot of space compared to the dynamic programming solution of the knapsack problem.

In general, our algorithm is designed as follows: firstly, the judgment $s=0$，$s=t$，$s>the\; case\; of\; t$ . Next find$m=\max (s,t-s)+Value\; of\; 1$ if$m>2^n$ calls the search algorithm to solve, if$m\le 2^m$ callsthe blue formulato solve. Note that in the process of calculating complex numbers, we repeatedly use Euler's formula$e^{i\theta }=\cos i+i\sin \theta$ . Calculation function$When\; f$ , my idea is to pass in$i=\frac{2\pi k}{m}$As a parameter (instead of passing in the complex number $z=e^{i\theta }$），而$f(z)=\prod _{j=1}^n\left(1+z^{a_j}\right)$，所以$z^{a_j}=\cos a_{j}i+i\sin a_j\theta$ , thus avoiding the direct calculation of the complex number$z$的$a_j$power, thereby reducing the error. Eventually, we get $c_s$Finally, in theory, if the sum is ssA subset of$s$$c_s$should be $0$ , but because there are rounding errors in the calculation process, we relax the condition that the subset does not exist as$|c_s|<\frac{1}{2}$, so that the problems caused by errors can be avoided to a large extent. At the same time, when $c_s$When the calculation is more accurate, it is actually equal to and is ssThe number of subsets of$s\; .$

The complete Pythoncode is as follows:

# encoding: utf-8

import math
from typing import *

class SubsetSumSolver:
    def __init__(self, a: List[int], s: int):
        self.a = a
        self.s = s
        self.n = len(a)
        self.t = sum(a)
    def search(self, u: int, m: int) -> bool: # search method (m>2^n)
        if m == 0:
            return True
        if u == 0:
            return False
        if m >= self.a[u - 1] and self.search(u - 1, m - self.a[u - 1]):
            return True
        return self.search(u - 1, m)
    def f(self, theta: float) -> complex:
        r = 1.
        for h in self.a: # h: a_j
            arg = h * theta # a_j*θ
            r  *= 1 + math.cos(arg) + 1j * math.sin(arg) # r*=(1+e^(i*a_j*θ))
        return r
    def complex_method(self) -> complex:
        m = max(self.s, self.t - self.s) + 1
        r = 0 # result
        for k in range(m):
            theta = 2 * math.pi * k / m
            f_result = self.f(theta) # f(e^(2πik/m))
            theta *= -self.s
            zs = math.cos(theta) + 1j * math.sin(theta) # e^(2πisk/m)
            r += zs * f_result
        r /= m
        return r
    def solve(self) -> bool:
        if self.s > self.t:
            return False
        if self.s == self.t:
            return True
        if self.s == 0:
            return True
        if max(self.s, self.t - self.s) + 1 > 2 ** self.n: # see if m>2^n
            return self.search(self.n, self.s)
        else:
            return abs(self.complex_method()) > 0.5

a = [73383, 66729, 31459, 76611, 70029, 11389, 10089, 63531, \
    87311, 64114, 1566, 30601, 45294, 92796, 57129, 18475, 17759, \
    25253, 93402]
s = 242514 # test data
solver = SubsetSumSolver(a, s)
print(solver.solve())

This algorithm works well in most cases, except for some extreme cases, such as f ( z ) f(z)The modulus length of$f$$($$z$$)$$2^n$ ), it will magnify the rounding error, resulting in inaccurate results. However, after my test, the probability of this situation is very small (this situation has not occurred in my test data), so don't worry.