分区编号 N分为M个分区

Question

我正在尝试一个必须对一个分区进行分区的问题。 N尽可能分成M个分区。

例：

N = 1 M = 3，将1分成3部分

0 0 1
0 1 0
1 0 0

N = 3 M = 2，将3分成2部分

2 1
1 2
3 0
0 3

N = 4 M = 4，将4分成4部分

0 0 0 4
0 0 4 0
0 4 0 0
4 0 0 0
0 0 1 3
0 1 0 3
0 1 3 0
。
。
。

等等。

我确实编写了回溯算法。 它会逐步生成所有可能的合成，但是会占用较大的输入。因为许多合成只是在零件排序上有所不同。我想减少这一点。任何人都可以帮助您提供一种更有效的方法。

我的方法：

void backt(int* part,int pos,int n) //break N into M parts
{
    if(pos==M-1)
    {
        part[pos]=n;
        ppart(part);   //print part array
        return;
    }

    if(n==0)
    {
        part[pos]=0;
        backt(part,pos+1,0);
        return;
    }

    for(int i=0;i<=n;i++)
    {
        part[pos]=i;

        backt(part,pos+1,n-i);
    }
}

在我的算法中。 n为N，它为N的每个可能分区填充数组part []。

我想知道的是一旦生成一个合成，我想计算该合成将以不同顺序发生多少次。例如：对于N = 1，M = 3 :::合成只有一个：<0,0,1 >，但发生3次。 那就是我想知道的每种可能的独特构图。

再举一个例子：N = 4 M = 4

组成<0 0 0 4>被重复4次。 同样，对于每种独特的成分，我都想确切知道它将发生多少次。

看起来我也可以通过在这里解释来理解它。

谢谢。

Answer 1

您可以将int转换为分区，如下所示：

vector<int> part(int i, int n, int m)
{
    int r = n; // r is num items remaining to be allocated

    vector<int> result(m, 0); // m entries inited to 0

    for (int j = 0; j < m-1; j++)
    {
        if (r == 0) // if none left stop
            break;

        int k = i % r; // mod out next bucket
        i /= r; // divide out bucket
        result[j] = k; // assign bucket
        r -= k; // remove assigned items from remaining
    }

    result[m-1] = r; // put remainder in last bucket

    return result;
}

因此，您可以按以下方式使用它：

for (int i = 0; true; i++)
{
    vector<int> p = part(i, 3, 4);

    if (i != 0 && p.back() == 3) // last part
       break;

    ... // use p

};

由此也应该清楚如何制作零件的增量版本。

Answer 2

一种更简单，更数学的方法：

此问题等效于在表达式f（x）=（1 + x + x ^ 2 + x ^ 3 + .... + x ^ N）^ M中找到x ^ N的系数

f（x）=（（x ^（N-1）-1）/（x-1））^ M将其微分M倍（d ^ Nf（x）/ dx ^ N）且系数为（ 1 / n！）*（d ^ Nf（x）/ dx ^ N）x = 0;

可以使用任何数值微分技术来完成微分。 因此，算法的复杂度为O（N * complexity_of_differentiation）。