Question

我一直在使用SQL Server 2008 R2来开发一个可以匹配拆分数量的存储过程。我遇到了算法问题;我开发的那个，我将描述，不能超过55项。如果备用解决方案可用，则算法的名称将起作用。我可以实现它。

问题：

我有一个数量列表，这些数字的某些子集的总和需要等于目标数量。数量不是唯一的。例如，假设您有数量：

1, 2, 3, 8

且目标数量为11.存在两种解决方案：1 + 2 + 8和3 + 8。找到哪个解决方案并不重要，我只需要 a 解决方案。

这就是我试图解决的问题（请记住，这是在SQL中）。为每个数量分配一个位掩码：

使用15到1的计数器并使用按位 - 然后，我们得到：

15:  1111: 1, 2, 3, 8     total: 14
14:  1110: 2, 3, 8        total: 13
13:  1101: 1, 2, 8        total: 11 (solution found)
...
2:   0010: 2
1:   0001: 1

当项目数小于56时，这很有用......此时，2 ^ 57会被截断。我使用decimal(38,0)作为我的数据类型，所以我有17个字节（136位）。我非常保证永远不会有超过125件物品，所以这很好。但在57岁时，我的位掩码策略失败了。

这有意义吗？如果我需要澄清算法，请发表评论。

问题1：此算法可以扩展到125吗？如果没有，或者另一种解决方案效率更高：

问题2：我可以实现的其他算法的名称是什么来解决问题？当然这种问题很常见，它有一个命名算法......对吧？

我的实施，感兴趣的人

取消注释foo的创建和填充以创建测试数据。

--create table foo
--(
--  ID          int         primary key identity(1,1),
--  Qty         int         not null
--)
--go

--create nonclustered index IX_FOO__Qty on foo (Qty) include (ID)
--go

--insert into foo (Qty) values (1)
--insert into foo (Qty) values (1)
--insert into foo (Qty) values (2)
--insert into foo (Qty) values (3)
--insert into foo (Qty) values (7)

declare @seek int = 9,
        @total int = 0,
        @n int,
        @oldn int = 0,
        @i int

select @i = SQUARE(count(1))-1 from foo     -- start counting down from the top

select 
    x.ID, 
    x.Qty, 
    x.v as flags, 
    0 isanswer,
    convert(varbinary(16), v) hex
into #tmp
from
(
    select f.ID, f.Qty, POWER(2, row_number() over(order by f.qty) - 1) v
    from foo f
) x

while @i > 0
begin
    select @total = sum(Qty), @n = count(ID) from #tmp t where flags & @i != 0

    if (@total = @seek and @oldn < @n)
    begin
        update #tmp set isanswer = case when flags & @i != 0 then 1 else 0 end
        select @oldn = @n
    end

    select @i = @i - 1
end


select * from #tmp where isanswer = 1
drop table #tmp

这有结果集：

ID  Qty     flags   isanswer   hex
1   1       1       1          0x00000001
2   1       2       1          0x00000002
5   7       16      1          0x00000010

有什么想法？我知道在C＃中这样做会更容易，但如果可以使用SQL解决方案......

Answer 1

此问题与knapsack problem和subset sum problem密切相关。

背包问题：给定一堆项目，每个项目都有权重和值，找到一个总权重低于某个目标并且总值最大的子集。您的问题可以被视为一个变量，其中每个项目的权重和价值相等。

子集和问题：给定一堆整数，找到一个非空子集，其总和等于0（或其他一些目标值）。您的问题可以被视为一种变体，其中包含所有整数均为正数的附加限制。

仅在项目数量方面查看时，这两个问题都是NP完全的。这意味着通常解决问题所需的时间是元素数量的指数。

但是，如果目标值受到限制，则存在 O（N * T）的动态编程解决方案，其中N是元素的数量，T是目标。所以当有125个元素时，如果目标值不是很大，那么问题就可以得到解决。

以下是伪代码中的算法：

function solve(quantities, target):

    possible[0 .. target+1] = array of booleans initialized to False
    choices[0 .. target+1] = array of IDs

    possible[0] = True

    -- compute solutions to all subproblems
    for each id:
        v = quantities[id]
        -- try to add v to all existing solutions
        for i = target down to v:
            if possible[i - v] and not possible[i]:
                possible[i] = True
                choices[i] = id

    if not possible[target]:
        fail

    -- backtrack to get the full solution
    soln = []
    while target != 0:
        id = choices[target]
        soln.append(id)
        target = target - quantities[id]
    return soln

Answer 2

不幸的是，subset sum problem是NP完全的，因此您不太可能找到对较大输入表现良好的精确算法。存在一种近似算法（在本文中进行了解释），其运行时间取决于您需要接近的距离。如果您需要精确的解决方案，本文中描述的动态编程可能会胜过您当前的解决方案。

如何将项目子集的总和与目标数字相匹配？

2 个答案: