C# 递归算法中的大数时的StackOverflowException。优化？

任务：我需要将一批包裹分配到不同容量的容器中

每个容量都有限制：最小和最大包数

包裹计数应等于或小于所选容器容量之和

容量存储在数据库中。软件包总和由用户提示，可以是十进制

结果应该是每个容器的容器容量的集合。 结果计数没有限制

我有一个用C#编写的递归解决方案，但它会与StackOverflowException一起崩溃，从而导致大的包数

// returns all combinations of capacity max and min values which package sum could include
static IEnumerable<List<int>> GetCombinations(int[] set, int sum, List<int> values)
{
    for (var i = 0; i < set.Length; i++)
    {
        var left = sum - set[i];
        var vals = new List<int>(values);
        vals.Add(set[i]);

        if (left == 0)
        {
            yield return vals;
        }
        else
        {
            int[] possible = set.Where(n => n <= sum).ToArray();
            if (possible.Length > 0)
            {
                foreach (var s in GetCombinations(possible, left, vals))
                {
                    yield return s;
                }
            }
        }
    }
}

---

堆栈溢出绝不是代码的唯一问题，但让我们从这里开始

getcombines

递归地调用自身。当你接到成百上千的电话时，你就没钱了。在这种情况下，您不能使用系统堆栈，您需要更大的数据存储

您在这里只寻找一个解决方案，但编写代码显然是为了返回所有不同的集合。但你应该重新考虑这个方法。生成所有变体，然后拾取唯一集并丢弃其余的。这个很贵。比如，更糟的是几个数量级。您应该直接生成不同的集合。比如，如果你有数字6，下一个数字可以是6、5或4，但不能是7

下一个大问题是没有解决方案的情况。你可以很快找到一些解决方案，如果它存在的话。但如果不是，您将在许多组合中循环。您可以使用动态规划来解决这个问题。它会告诉你哪些数量的容器是有效的，哪些不是。您可以使用它来进一步提高递归的效率

每次从函数返回时，您都会创建新的

列表。这是一种安全的方法。但您通常可以返回相同的列表并对其进行修改。对于像
getcombines（…）.Count（）这样的情况，它更有效。让我们把它放在一起

static IEnumerable<List<int>> GetCombinations(int[] set, int sum)
{
    var orderedSet = set.Distinct().OrderByDescending(o => o).ToArray();

    bool[] valid = new bool[sum + 1];
    valid[0] = true;
    for (int i = 0; i < sum; ++i)
    {
        if (valid[i])
        {
            for (int j = 0; j < orderedSet.Length; ++j)
            {
                int next = i + orderedSet[j];
                if (next < valid.Length)
                {
                    valid[next] = true;
                }
            }
        }
    }

    if (!valid[sum])
    {
        return new List<int>[0]; //no solution
    }

    return GetCombinationsRecurse(orderedSet, sum, new List<int>(), valid, 0);
    //return GetCombinationsNoRecurse(orderedSet, sum, valid);
}      

static IEnumerable<List<int>> GetCombinationsRecurse(int[] set, int sum, 
    List<int> values, bool[] valid, int setIterator)
{
    for (var i = setIterator; i < set.Length; i++)
    {
        var left = sum - set[i];
        if (left < 0 || !valid[left])
        {
            continue;
        }

        values.Add(set[i]);

        if (left == 0)
        {
            yield return values;
        }
        else
        {
            foreach (var s in GetCombinationsRecurse(set, left, values, valid, i))
            {
                yield return s;
            }
        }
        values.RemoveAt(values.Count - 1);
    }
}

静态IEnumerable GetCombinations（int[]集，int和）
{
var orderedSet=set.Distinct（）.OrderByDescending（o=>o.ToArray（）；
bool[]valid=新bool[sum+1]；
有效[0]=true；
对于（int i=0；i

我在这里给出了递归版本，因为它与您的原始代码相匹配，并且更易于遵循。但大数字的堆栈溢出显然仍然存在。递归函数总是可以重写为非递归版本。您需要使用一些数据结构，而不是系统堆栈。要么是堆栈，要么是数组，或者别的什么。但它往往并不漂亮

static IEnumerable<List<int>> GetCombinationsNoRecurse(int[] set, int sum, bool[] valid)
{
    List<int> sums = new List<int>() { 0 };
    List<int> setIterators = new List<int>() { 0 };
    int iter = 0;
    List<int> values = new List<int>() { set[iter] };

    while (true)
    {
        int actSum = sums[iter] + values[iter];
        int left = sum - actSum;
        if (left == 0)
        {
            yield return values;
        }

        if (left <= 0 || !valid[left])
        {
            while (++setIterators[iter] >= set.Length)
            {
                if (--iter < 0) { yield break; }
                values.RemoveAt(values.Count - 1);
            }
            values[iter] = set[setIterators[iter]];
            continue;
        }

        { // left > 0
            if (sums.Count > iter + 1)
            {
                sums[iter + 1] = actSum;
                setIterators[iter + 1] = setIterators[iter];
            }
            else
            {
                sums.Add(actSum);
                setIterators.Add(setIterators[iter]);
            }

            values.Add(values[iter]);
            iter++;
        }
    }
}

static IEnumerable GetCombinationsNoRecurse（int[]set，int-sum，bool[]valid）
{
列表总和=新列表（）{0}；
List setIterators=new List（）{0}；
int-iter=0；
列表值=新列表（）{set[iter]}；
while（true）
{
int actSum=总和[iter]+数值[iter]；
int left=总和-实际总和；
如果（左==0）
{
收益回报值；
}
如果（左=设置长度）
{
如果（-iter<0）{屈服断裂；}
values.RemoveAt（values.Count-1）；
}
值[iter]=set[setIterators[iter]]；
继续；
}
{//左>0
如果（sums.Count>iter+1）
{
总和[iter+1]=实际总和；
集合迭代器[iter+1]=集合迭代器[iter]；
}
其他的
{
总和。加上（actSum）；
Add（setIterators[iter]）；
}
添加（数值[iter]）；
iter++；
}
}
}
我无法运行您的代码。你能把问题编辑成包含一个please吗？这是一个递归问题。我不太理解您的代码的实用性，但您显然正在使用对GetCombinations的递归调用耗尽堆栈。我认为您必须关注的问题是，为什么在第二种情况下
if（mably.Length>0）
永远不为0，这样它就可以停止递归。
var svc = new ContainerGenerationService1();
svc.GenerateContainersWorks(); // works
svc.GenerateContainersFails(); // fails with StackOverflowException

static IEnumerable<List<int>> GetCombinations(int[] set, int sum)
{
    var orderedSet = set.Distinct().OrderByDescending(o => o).ToArray();

    bool[] valid = new bool[sum + 1];
    valid[0] = true;
    for (int i = 0; i < sum; ++i)
    {
        if (valid[i])
        {
            for (int j = 0; j < orderedSet.Length; ++j)
            {
                int next = i + orderedSet[j];
                if (next < valid.Length)
                {
                    valid[next] = true;
                }
            }
        }
    }

    if (!valid[sum])
    {
        return new List<int>[0]; //no solution
    }

    return GetCombinationsRecurse(orderedSet, sum, new List<int>(), valid, 0);
    //return GetCombinationsNoRecurse(orderedSet, sum, valid);
}      

static IEnumerable<List<int>> GetCombinationsRecurse(int[] set, int sum, 
    List<int> values, bool[] valid, int setIterator)
{
    for (var i = setIterator; i < set.Length; i++)
    {
        var left = sum - set[i];
        if (left < 0 || !valid[left])
        {
            continue;
        }

        values.Add(set[i]);

        if (left == 0)
        {
            yield return values;
        }
        else
        {
            foreach (var s in GetCombinationsRecurse(set, left, values, valid, i))
            {
                yield return s;
            }
        }
        values.RemoveAt(values.Count - 1);
    }
}

static IEnumerable<List<int>> GetCombinationsNoRecurse(int[] set, int sum, bool[] valid)
{
    List<int> sums = new List<int>() { 0 };
    List<int> setIterators = new List<int>() { 0 };
    int iter = 0;
    List<int> values = new List<int>() { set[iter] };

    while (true)
    {
        int actSum = sums[iter] + values[iter];
        int left = sum - actSum;
        if (left == 0)
        {
            yield return values;
        }

        if (left <= 0 || !valid[left])
        {
            while (++setIterators[iter] >= set.Length)
            {
                if (--iter < 0) { yield break; }
                values.RemoveAt(values.Count - 1);
            }
            values[iter] = set[setIterators[iter]];
            continue;
        }

        { // left > 0
            if (sums.Count > iter + 1)
            {
                sums[iter + 1] = actSum;
                setIterators[iter + 1] = setIterators[iter];
            }
            else
            {
                sums.Add(actSum);
                setIterators.Add(setIterators[iter]);
            }

            values.Add(values[iter]);
            iter++;
        }
    }
}