Algorithm 找到能带来最大利润的组合

假设我有一张这样的桌子：

ID |成本|利润

1 | 0.55 | 1.24

2 | 0.23 | 3.11

3 | 0.19 | 2.21

4 | 0.53 | 1.49

。。。等等

如果我的预算具有一定价值，我如何找到最大利润？ie：找到成本为1.12的最大利润。如果从上表中选择，我应该从ID 2+3+4中选择项目以实现利润最大化

我试图用谷歌搜索LP，运筹学的一些东西，但我真的是盲目地用谷歌搜索，我不知道我应该找什么关键词。请帮忙

你需要的是！我从您给出的示例中假设，您需要将项目作为一个整体，而不是项目的一部分。否则，选择默认（分数）背包

了解一下，然后是分数背包动态规划风格的解决方案，然后是0/1背包！这就是你应该学会解决这个问题的方法

如果您还需要其他信息，请告诉我。

这里有一个

O（2n+排序）

算法，在大多数情况下都会产生很好的结果

计算每个项目的收益率（

item.yield=item.利润/item.cost

）

按收益率对项目进行排序（最高收益率优先）

迭代已排序的项目，同时

剩余预算>0

采购

项目数量=最低（剩余预算/项目成本）

项目id，从

剩余成本中减去
项目数量*项目成本

如果您是离散操作，它不会总是捕获所有边缘情况，例如，假设您有

预算=100

，一个

A

项目的

成本=51，收益率=1.5

，另一个

B

项目的

成本=50，收益率=1.4

• 100-51=49

  +

  51*1.5=76.5

  =

  125

  ，
  一个

  A

  产生

  25.5

  利润

• 100-2*50=0

  +

  2*

  50*1.4=70

  =

  140

  ，
  两个

  B

  s产生

  40

  利润，
  i、 e.由于更有效地使用整个预算，因此购买两个单独较差的更好

但如果你继续运营，随着预算不再是一个限制因素，它将开始提高性能

---

优化可能包括

• 在排序时计算产量，在整个数据结构上少迭代一次
• 删除排序步骤，而不是在迭代过程中“丢弃”更糟糕的选择，这可能需要更长的时间才能完成
• 当

  剩余预算

  时结束迭代，例如，如果有很多高/中成本，但没有/很少有低成本，您可以提前停止迭代

---

这里有一个结构数组选项代码，您可以为3d值数组修改它。这里我使用struct函数来运行这个程序

struct item
{
    double w,p,u;
};

你可以用

//Fractional Knapsack
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
struct item
{
    double w,p,u;
};
bool compare( item a, item b)
{
    return a.u>b.u;
}
int main()
{
    int n,w;
    item arry[100];
    cin>>n>>w;
    for(int i=0; i<n; i++)
    {
        cin>>arry[i].w>>arry[i].p;
        arry[i].u = arry[i].p/arry[i].w;
    }
    sort(&arry[0],&arry[n],compare);
    int p=0;
    for (int i=0; i<n; i++)
    {
        if(w>arry[i].w)
        {
            p=p+arry[i].p;
            w=w-arry[i].w;
        }
        else{
            p=p+w*arry[i].u;
            w=0;
        }
    }
    cout<<"Total Profit: "<<p<<endl;
}

//分数背包
#包括
#包括
#包括
使用名称空间std；
结构项
{
双w，p，u；
};
bool比较（项目a、项目b）
{
返回a.u>b.u；
}
int main（）
{
int n，w；
项目arry[100]；
cin>>n>>w；
对于（inti=0；i>arry[i].w>>arry[i].p；
arry[i].u=arry[i].p/arry[i].w；
}
排序（&arry[0]，&arry[n]，比较）；
int p=0；
对于（int i=0；iarry[i].w）
{
p=p+arry[i].p；
w=w-arry[i].w；
}
否则{
p=p+w*arry[i].u；
w=0；
}
}
库特