需要针对子集总和的优化技巧，例如具有大约束的问题

Question

给定一个数字 1 <= N <= 3*10^5，计算集合 {1, 2, ..., N-1} 中总和为 N 的所有子集。这本质上是子集总和的修改版本问题，但修改后元素的总和和数量相同，并且集合/数组线性增加 1 到 N-1。

我想我已经使用 dp ordered map 和包含/排除递归算法解决了这个问题，但是由于时间和空间的复杂性，我无法计算超过 10000 个元素。

#include <iostream>
#include <chrono>
#include <map>
#include "bigint.h"


using namespace std;

//2d hashmap to store values from recursion; keys- i & sum; value- count
map<pair<int, int>, bigint> hmap;

bigint counter(int n, int i, int sum){

    //end case
    if(i == 0){ 
        if(sum == 0){
            return 1;
        }
        return 0;
    }

    //alternative end case if its sum is zero before it has finished iterating through all of the possible combinations
    if(sum == 0){
        return 1;
    }

    //case if the result of the recursion is already in the hashmap
    if(hmap.find(make_pair(i, sum)) != hmap.end()){
        return hmap[make_pair(i, sum)];
    }

    //only proceed further recursion if resulting sum wouldnt be negative
    if(sum - i < 0){
        //optimization that skips unecessary recursive branches
        return hmap[make_pair(i, sum)] = counter(n, sum, sum);
    }
    else{
                                        //include the number   dont include the number
        return hmap[make_pair(i, sum)] = counter(n, i - 1, sum - i) + counter(n, i - 1, sum);
    }
}

function 的起始值为 N、N-1 和 N，表示元素的数量、迭代器（递减）和递归分支的总和（随着每个包含的值递减）。

这是计算子集数量的代码。 对于 3000 的输入，大约需要 22 秒才能得到 output 40 位长的结果。 由于数字太长，我不得不使用 rgroshanrg 的任意精度库 bigint，它适用于小于 ~10000 的值。 超出此范围的测试在第 28-29 行给我一个段错误，可能是由于存储的任意精度值变得太大并且在 map 中发生冲突。我需要以某种方式改进这段代码，以便它可以处理超过 10000 的值，但我被难住了它。 有什么想法或者我应该转向另一种算法和数据存储吗？

Answer 1

这是一个不同的算法，在 Evangelos Georgiadis 的论文“Computing Partition Numbers q(n)”中有所描述：

std::vector<BigInt> RestrictedPartitionNumbers(int n)
{
    std::vector<BigInt> q(n, 0);
    // initialize q with A010815
    for (int i = 0; ; i++)
    {
        int n0 = i * (3 * i - 1) >> 1;
        if (n0 >= q.size())
            break;
        q[n0] = 1 - 2 * (i & 1);
        int n1 = i * (3 * i + 1) >> 1;
        if (n1 < q.size())
            q[n1] = 1 - 2 * (i & 1);
    }
    // construct A000009 as per "Evangelos Georgiadis, Computing Partition Numbers q(n)"
    for (size_t k = 0; k < q.size(); k++)
    {
        size_t j = 1;
        size_t m = k + 1;
        while (m < q.size())
        {
            if ((j & 1) != 0)
                q[m] += q[k] << 1;
            else
                q[m] -= q[k] << 1;
            j++;
            m = k + j * j;
        }
    }
    return q;
}

这不是最快的算法，在我的电脑上用了大约半分钟n = 300000 。 但是您只需要执行一次（因为它会计算所有分区号直到某个界限）并且不需要很多 memory（超过 150MB）。

结果 go 直到但不包括n ，并且他们假设对于每个数字，该数字本身被允许是其自身的一个分区，例如集合{4}是数字 4 的一个分区，在您对排除的问题的定义中在这种情况下，您需要从结果中减去 1。

也许有更好的方式来表达 A010815，虽然那部分代码并不慢，但我只是觉得它看起来很糟糕。