Question

阅读器，好吧，我想我刚刚搞砸了一下。我实施了背包，我想到我实施过1次或2次暴力算法。所以我决定再做一个。而这就是我所痴迷的。

让我们决定W是最大权重，而w（min）是我们可以放入背包中的最小加权元素，如k=W/w(min)次。我解释这个是因为你，读者，更好地知道为什么我需要问我的问题。

现在。如果我们想象我们有三种类型的东西我们可以放入背包，我们的背包可以存储15个单位的质量，让我们分别计算每个单位重量的数量。所以我们可以放第1类15件，或第2类7件和第1类1件。但是，像22222221[7ed]和12222222[7ed]这样的组合对我们来说意味着相同。计算它们是浪费我们为决策付出的任何类型的资源。（这是一个笑话，如果我们有一个更便宜的算法，因为bf是浪费，但我非常感兴趣）

我猜我们需要经历所有可能组合的选择类型被称为＆＃34;重复组合＆＃34;。 C'(n,k)的数量计为(n+k-1)!/(n-1)!k!。（当我输入我的信息时，我刚刚在我的理论中发现了一个漏洞。我们可能需要添加一个空的，零加权零价格的项目以保持自由空间它可能只是将n增加1）

那么，问题是什么。

https://rosettacode.org/wiki/Combinations_with_repetitions

因为这个问题在这里有详细描述^我并不是真的想以这种方式使用堆栈，我想在单个周期中生成变量，这是from i=0 to i<C'(n,k)。

所以，如果我能做到，它是如何运作的？

we have
int prices[n]; //appear mystically

int weights[n]; // same as previous and I guess we place (0,0) in both of them.

int W, k; // W initialized by our lord and savior

k = W/min(weights);

int road[k], finalroad[k]; //all 0

int curP=curW=maxP=maxW=0;

    for (int i = 0; i<rCombNumber(n,k); i++)
{ 
   /*guys please help me to know how to generate this mask which is consists of indices from 0 to n (meaning of each element) and k is size of mask.*/

    curW=0;

   for (int j=0; j<k; j++)

    curW+=weights[road[j]];

if (curW<W)

{ 

   curP=0;

   for (int l=0; l<k; l++)

    curP+=prices[road[l]];

if (curP>maxP)
{
 maxP=curP;

 maxW=curW;

 finalroad = road;

}

}

}

mask，road - 是一个索引数组，每个索引可以等于0到n;并且必须通过每个选择中的k个元素从{0,1,2，...，n}生成C＆＃39;（n，k）（上面的链接）（与顺序不重要的重复组合）

是的。证明我错了或帮助我。非常感谢提前 _

是的，当然算法会花费很多时间，但它看起来应该有效。我非常感兴趣。

更新

我错过了什么？

http://pastexen.com/code.php?file=EMcn3F9ceC.txt

Answer 1

答案由Minoru在https://gist.github.com/Minoru/745a7c19c7fa77702332cf4bd3f80f9e提供，它足以仅增加第一个元素，然后我们计算所有进位，设置进位的位置，并将重置值计数为要重置和重置的元素的最大值。

这是我的代码：

#include <iostream>

using namespace std;
static long FactNaive(int n)
{
    long r = 1;
    for (int i = 2; i <= n; ++i)
        r *= i;
    return r;
}
static long long CrNK (long n, long k)
{
    long long u, l;
    u = FactNaive(n+k-1);
    l = FactNaive(k)*FactNaive(n-1);
    return u/l;
}

int main()
{
    int numberOFchoices=7,kountOfElementsInCombination=4;
    int arrayOfSingleCombination[kountOfElementsInCombination] = {0,0,0,0};
    int leftmostResetPos = kountOfElementsInCombination;
    int resetValue=1;

    for (long long iterationCounter = 0; iterationCounter<CrNK(numberOFchoices,kountOfElementsInCombination); iterationCounter++)
    {
        leftmostResetPos = kountOfElementsInCombination;

        if (iterationCounter!=0)
        {
            arrayOfSingleCombination[kountOfElementsInCombination-1]++;
            for (int anotherIterationCounter=kountOfElementsInCombination-1; anotherIterationCounter>0; anotherIterationCounter--)
            {
                if(arrayOfSingleCombination[anotherIterationCounter]==numberOFchoices)
                {
                    leftmostResetPos = anotherIterationCounter;
                    arrayOfSingleCombination[anotherIterationCounter-1]++;
                }
            }
        }

        if (leftmostResetPos != kountOfElementsInCombination)
        {
            resetValue = 1;

            for (int j = 0; j < leftmostResetPos; j++)
            {
                if (arrayOfSingleCombination[j] > resetValue)
                {
                    resetValue = arrayOfSingleCombination[j];
                }
            }

            for (int j = leftmostResetPos; j != kountOfElementsInCombination; j++)
            {
                arrayOfSingleCombination[j] = resetValue;
            }
        }

        for (int j = 0; j<kountOfElementsInCombination; j++)
        {
            cout<<arrayOfSingleCombination[j]<<" ";
        }
        cout<<"\n";

    }

    return 0;
}

非常感谢，Minoru

C ++蛮力背包的一部分

1 个答案: