一种时间复杂度为O(2ⁿ)、空间复杂度为O(n)的子集和问题的算法

子集和问题（Subset-Sum Problem, SSP）是说给定一个有$n$个元素的自然数集合 S = { a 1 , a 2 , ⋯   , a n } S=\{a_1,a_2,\cdots,a_n\} S={ a1​,a2​,⋯,an​}和一个自然数$s$，问是否存在$S$的一个子集$T$使得$T$中的所有元素之和等于$s$。

令$t$等于$S$中所有元素之和（$t=\sum _{j=1}^n{a}_j$）。显然，当$s>t$时，满足要求的子集$T$不存在，直接输出False；当$s=t$时，$T=S$就是满足条件的子集，直接输出True；当$s=0$时，因为空集$\varnothing$是$S$的子集且空集的元素之和为$0$，也直接输出True。所以，我们只需要考虑$0<s<t$的情况。

目前有两种流行的解法，一种是搜索（时间复杂度$O\left(2^n\right)$、空间复杂度$O(n)$），另一种是动态规划（把问题归约为背包问题，时间复杂度$O(nt)$，滚动数组优化后空间复杂度$O(n+t)$）。前者的优点是时间复杂度不依赖于$t$的大小，但是最坏情况下的时间复杂度是指数级的；后者的优点是当$t$比较小（$t<2^n$）时比搜索要快，缺点是当$t\ge 2^n$时比搜索还慢，而且占用的空间较大（一般$t$远大于$n$）。本文给出了一种能够替代动态规划的策略，使得时间复杂度为$O(nt)$的同时空间复杂度只有$O(n)$。当$t$较大时，我们仍然采用搜索；当$t$较小时，我们采用这种新的策略进行计算。这样，面对$t$较小的情况时，我们就有了一种高效的且占用空间较少的方法。

我们的新策略的主要思想是利用复数单位根的性质。在我前面的一篇文章里我介绍了如何用单位根巧妙地解决一个数学问题（关于单位根的性质及证明请参见那篇文章），那么在本文中我们将用这个思想给出一个子集和问题的算法。

考虑函数$$f(x)=\prod _{j=1}^n\left(1+x^{a_j}\right)$$将它展开为多项式$$f(x)=c_0+c_{1}x+c_2{x}^2+\cdots +c_t{x}^t$$其中每项的系数$c_p$等于集合 S = { a 1 , a 2 , ⋯   , a n } S=\{a_1,a_2,\cdots,a_n\} S={ a1​,a2​,⋯,an​}的所有和为$p$的子集的个数（ c p = ∣ { T ∣ T ⊆ S ,   s u m ( T ) = p } ∣ c_p=\left|\left\{T|T\subseteq S,\,\mathrm{sum}(T)=p\right\}\right| cp​=∣{ T∣T⊆S,sum(T)=p}∣）。那么我们要求解的问题本质上就是判断$c_s$是否等于$0$。将$f(x)$除以$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}$$现在我们在复数域上考虑问题。令$z\in \mathbb{C}$，代入上式得$$z^{-s}f(z)=\sum _{j=0}^t{c}_j{z}^{j-s}$$下面考虑利用单位根的性质。设$\omega =e^{\frac{2\pi i}{m}}=\cos \frac{2\pi }{m}+i\sin \frac{2\pi }{m}$是$m$次单位根，满足${\omega }^m=1$。我们又知道$$\sum _{k=0}^{m-1}{\left({\omega }^k\right)}^u=\{\begin{array}{ll}0,& u\text{不是}m\text{的倍数}\\ m,& u\text{是}m\text{的倍数}\end{array}$$对于任何整数$u$（不论正负）都成立。这给了我们分离出系数$c_s$的可能。考虑求和$$\sum _{k=0}^{m-1}{\left({\omega }^k\right)}^{-s}f\left({\omega }^k\right)=\sum _{j=0}^t\left[\sum _{k=0}^{m-1}{c}_j{\left({\omega }^k\right)}^{j-s}\right]$$我们希望在$j-s\ne 0$时方括号里的值为$0$，仅当$j-s=0$即$j=s$时不为$0$，这样上式的值就会变成$m{c}_s$，我们由此可以求出$c_s$的值。而$j-s$的跨度是从$-s$到$t-s$，我们希望$-s>-m$，$t-s<m$，这样除了$j=s$时以外方括号里的值都一定为$0$。

因此有$m>s$且$m>t-s$。为了方便计算，$m$应越小越好，所以我们取$m=\max (s,t-s)+1$。这样，我们就能计算出$$\begin{array}{rl}{c}_s& =\frac{1}{m}\sum _{k=0}^{m-1}{\omega }^{-ks}f\left({\omega }^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)$需要$O(n)$的时间，求和需要$O(m)$的时间，所以总共需要花费$O(nm)$的时间。又$m\le t$，故最坏情况下需要花费$O(nt)$的时间。计算过程中我们只花了$O(1)$的空间，所以程序花费的总空间是存储$a_1,a_2,\cdots ,a_n$所用的$O(n)$的空间。这样，相比于背包问题的动态规划解法，我们节约了大量的空间。

总的来说，我们的算法是这样设计的：首先特判$s=0$，$s=t$，$s>t$的情况。接下来求出$m=\max (s,t-s)+1$的值，若$m>2^n$调用搜索算法求解，若$m\le 2^m$调用蓝色式子求解。注意在计算复数的过程中我们反复利用了欧拉公式$e^{i\theta }=\cos \theta +i\sin \theta$。计算函数$f$时我的思路是传入$\theta =\frac{2\pi k}{m}$作为参数（而不是直接传入复数$z=e^{i\theta }$），而$f(z)=\prod _{j=1}^n\left(1+z^{a_j}\right)$，所以$z^{a_j}=\cos a_j\theta +i\sin a_j\theta$，这样就避免了直接求复数$z$的$a_j$次方，从而降低了误差。最终，我们得到$c_s$后，理论上来讲如果和为$s$的子集不存在那么$c_s$应该为$0$，但是因为计算过程中有舍入误差的存在，所以我们把子集不存在的条件放宽为$|c_s|<\frac{1}{2}$，这样可以很大程度上避免误差带来的问题。同时，当$c_s$计算的比较精确时，它实际上就等于和为$s$的子集的个数。

完整的Python代码如下：

# 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())

这个算法在绝大多数情况下都可以正常运行，除非出现一些特别极端的情况，比如$f(z)$的模长特别大（接近$2^n$），则会放大舍入误差，造成结果不准确。不过经过我的测试，这种情况出现的概率微乎其微（我的测试数据还没有出现过这种情况），所以不必担心。