蛮力背包的C 一部分

C++ Part of brute-force knapsack

本文关键字：一部分 背包      更新时间：2023-10-16

阅读器，好吧，我想我只是脑力了。我正在实施背包，我想到了我以1或2次实现了蛮力算法。所以我决定再做一个。这就是我陷入的。

让我们确定W是最大的重量，W（min）是我们可以将其放入k=W/w(min)次的背包中的最小加权元素。我之所以解释这一点，是因为您，读者，最好知道为什么我需要问我的问题。

现在。如果我们想象我们有三种类型的东西可以放在背包中，而我们的背包可以存储像15个质量的单位，那么让我们分别将每个单位重量视为其数字。因此，我们可以将15件类型的15件事或第二类类型的7件类型的东西放在。但是，诸如22222221[7ed]和12222222[7ed]之类的组合对我们来说也是如此。计算它们是浪费我们为决定支付的任何类型的资源。（这是个玩笑，因为如果我们有更便宜的算法，那么BF是浪费，但我非常感兴趣）

我猜想，我们需要进行所有可能组合的选择类型被称为"与重复"的组合。C'(n,k)的数量为(n+k-1)!/(n-1)!k!。（当我输入消息时，我只是发现了我的理论中的一个洞。我们可能需要添加一个空的，零加权的零定价物品来容纳可用空间

所以，怎么了。

https://rosettacode.org/wiki/combinations_with_repetitions

由于此问题在此处被很好地描述了^我真的不想以这种方式使用堆栈，所以我想在单个周期中生成变化，该变化正在 from i=0 to i<C'(n,k)。

所以，如果我能做到，它是如何工作的？我们有

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;
    }
  }
}

蒙版，道路 - 是一系列索引，每个索引可以等于0至n；并且必须从{0、1、2，...，...，n}中以每种选择中的k元素（与订单不重要的重复结合使用）

就是这样。证明我错了或帮助我。非常感谢 _

是的，算法当然会花很多时间，但是看起来应该有效。我对此很有趣。

更新：

我想念什么？

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

答案是由Minoru提供的https://gist.github.com/minoru/745a7c19c7777777777777770232cf4bd3f3f80f9e，仅递增第一个元素就足够了，然后我们计算所有运载物，将我们进行携带和计数重置值作为重置和重置的元素的最大元素。

。

这是我的代码：

#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

相关文章：