Question

我确定这个问题有一个正式的名称，并且知道这个名字可能会帮助我找到解决方案，但我不知道，并且为Google提出的问题一直指向我Knapsack Problem，这不是一回事。

我想取一些值X并找到将该值拆分为N个整数整数的可能组合。

如果我的措辞令人困惑，这里是X = 4，N = 3

的例子

Stack -> 1 | 2 | 3 |
----------------------
#1-----> 4 | 0 | 0 |
----------------------
#2-----> 3 | 1 | 0 |
----------------------
#3-----> 2 | 1 | 1 |
----------------------
#4-----> 2 | 2 | 0 |

复制是可以接受的，因为它很容易删除，但理想情况下不会计算。解决问题的算法将是完美的，但即使找出问题的名称也会使研究更容易。感谢。

Answer 1

这些实际上是integer partitions作为删除的答案备注。使用Mathematica：

IntegerPartitions[4, 3] // PadRight //Grid

输出：

我找不到C＃实现，但这里有几个相关的问题：

Elegant Python code for Integer Partitioning

Integer Partition in Java

Algorithm for generating integer partitions

Google点击：

Integer Partition Algorithm by Jerome Kelleher

Integer Partition Algorithm by Daniel Scocco

Fast Algorithms for Generating Integer Partitions（PDF）（看起来很重要）

Stony Brook Algorithm Repository - Partitions

Answer 2

这似乎可以解决问题：

vector<vector<int> > partitions(int X, int N, int Y)
{
    vector<vector<int> > v;
    if(X<=1 || N==1)
    {
        if(X<=Y)
        {
            v.resize(1);
            v[0].push_back(X);
        }
        return v;
    }
    for(int y=min(X, Y); y>=1; y--)
    {
        vector<vector<int> > w = partitions(X-y, N-1, y);
        for(int i=0; i<w.size(); i++)
        {
          w[i].push_back(y);
          v.push_back(w[i]);
        }
    }
    return v;


   }

int main()
{
    vector<vector<int> > v = partitions(5, 3, 5);
    int i;
    for(i=0; i<v.size(); i++)
    {
        int x;
        for(x=0; x<v[i].size(); x++)
            printf("%d ", v[i][x]);
        printf("\n");
    }
    return 0;
}

Answer 3

这是用户434507在C＃中的答案：

class Program
{
    static void Main(string[] args)
    {
        var v = Partitions(5, 3, 5);

        for (int i = 0; i < v.Count; i++)
        {
            for (int x = 0; x < v[i].Count; x++)
                Console.Write(v[i][x] + " "); 
            Console.WriteLine();
        }
    }

    static private List<List<int>> Partitions(int total, int stacks, int max)
    {
        List<List<int>> partitions = new List<List<int>>();

        if (total <= 1 || stacks == 1)
        {
            if (total <= max)
            {
                partitions.Add(new List<int>());
                partitions[0].Add(total);
            }

            return partitions;
        }
        for (int y = Math.Min(total, max); y >= 1; y--)
        {
            var w = Partitions(total - y, stacks - 1, y);
            for (int i = 0; i < w.Count; i++)
            {
                w[i].Add(y);
                partitions.Add(w[i]);
            }
        }

        return partitions;
    }
}

X的每个可能组合分成N个堆栈

3 个答案: