分数背包问题的 C++ 程序

先决条件：分数背包问题

给定两个数组weight[]和利润 [] N件物品的权重和利润，我们需要将这些物品放入容量为W的背包中，以获得背包中的最大总值。
注意：与 0/1 背包不同，您可以破坏物品。

例子：

Input: weight[] = {10, 20, 30}, profit[] = {60, 100, 120}, N= 50
Output: Maximum profit earned = 240
Explanation: 
Decreasing p/w ratio[] = {6, 5, 4}
Taking up the weight values 10, 20, (2 / 3) * 30 
Profit = 60 + 100 + 120 * (2 / 3) = 240

Input: weight[] = {10, 40, 20, 24}, profit[] = {100, 280, 120, 120}, N = 60
Output: Maximum profit earned = 440
Explanation: 
Decreasing p/w ratio[] = {10, 7, 6, 5}
Taking up the weight values 10, 40, (1 / 2) * 120 
Profit = 100 + 280 + (1 / 2) * 120 = 440

方法 1 – 不使用 STL：想法是使用 Greedy Approach。以下是步骤：

1. 找出每个项目的比率值/重量，并根据此比率对项目进行排序。
2. 选择比例最高的项目并添加它们，直到我们无法整体添加下一个项目。
3. 最后，尽可能多地添加下一个项目。
4. 完成上述步骤后打印最大利润。

下面是上述方法的实现：

C++

// C++ program to solve fractional
// Knapsack Problem
#include 
  
using namespace std;
  
// Structure for an item which stores
// weight & corresponding value of Item
struct Item {
    int value, weight;
  
    // Constructor
    Item(int value, int weight)
        : value(value), weight(weight)
    {
    }
};
  
// Comparison function to sort Item
// according to val/weight ratio
bool cmp(struct Item a, struct Item b)
{
    double r1 = (double)a.value / a.weight;
    double r2 = (double)b.value / b.weight;
    return r1 > r2;
}
  
// Main greedy function to solve problem
double fractionalKnapsack(struct Item arr[],
                          int N, int size)
{
    // Sort Item on basis of ratio
    sort(arr, arr + size, cmp);
  
    // Current weight in knapsack
    int curWeight = 0;
  
    // Result (value in Knapsack)
    double finalvalue = 0.0;
  
    // Looping through all Items
    for (int i = 0; i < size; i++) {
  
        // If adding Item won't overflow,
        // add it completely
        if (curWeight + arr[i].weight <= N) {
            curWeight += arr[i].weight;
            finalvalue += arr[i].value;
        }
  
        // If we can't add current Item,
        // add fractional part of it
        else {
            int remain = N - curWeight;
            finalvalue += arr[i].value
                          * ((double)remain
                             / arr[i].weight);
  
            break;
        }
    }
  
    // Returning final value
    return finalvalue;
}
  
// Driver Code
int main()
{
    // Weight of knapsack
    int N = 60;
  
    // Given weights and values as a pairs
    Item arr[] = { { 100, 10 },
                   { 280, 40 },
                   { 120, 20 },
                   { 120, 24 } };
  
    int size = sizeof(arr) / sizeof(arr[0]);
  
    // Function Call
    cout << "Maximum profit earned = "
         << fractionalKnapsack(arr, N, size);
    return 0;
}

输出：

Maximum profit earned = 440

时间复杂度： O(N*log ₂ N)
辅助空间： O(1)

方法 2 – 使用 STL：

1. 创建一个地图，其中利润[i] / 权重[i]作为第一个元素，i 作为每个元素的第二个元素。
2. 定义一个变量max_profit = 0 。
3. 以相反的方式遍历地图：
   • 创建一个名为fraction 的变量，其值等于remaining_weight / weight[i]。
   • 如果剩余权重大于或等于 0 且其值大于weight[i]将当前利润添加到max_profit并通过 weight[i]减少剩余权重。
   • 否则，如果剩余权重小于 weight[i]，则将分数 * 利润 [i] 添加到max_profit并打破。
4. 打印max_profit 。

下面是上述方法的实现：

C++

// C++ program to Fractional Knapsack
// Problem using STL
#include 
using namespace std;
  
// Function to find maximum profit
void maxProfit(vector profit,
               vector weight, int N)
{
  
    // Number of total weights present
    int numOfElements = profit.size();
    int i;
  
    // Multimap container to store
    // ratio and index
    multimap ratio;
  
    // Variable to store maximum profit
    double max_profit = 0;
    for (i = 0; i < numOfElements; i++) {
  
        // Insert ratio profit[i] / weight[i]
        // and corresponding index
        ratio.insert(make_pair(
            (double)profit[i] / weight[i], i));
    }
  
    // Declare a reverse iterator
    // for Multimap
    multimap::reverse_iterator it;
  
    // Traverse the map in reverse order
    for (it = ratio.rbegin(); it != ratio.rend();
         it++) {
  
        // Fraction of weight of i'th item
        // that can be kept in knapsack
        double fraction = (double)N / weight[it->second];
  
        // if remaining_weight is greater
        // than the weight of i'th item
        if (N >= 0
            && N >= weight[it->second]) {
  
            // increase max_profit by i'th
            // profit value
            max_profit += profit[it->second];
  
            // decrement knapsack to form
            // new remaining_weight
            N -= weight[it->second];
        }
  
        // remaining_weight less than
        // weight of i'th item
        else if (N < weight[it->second]) {
            max_profit += fraction
                          * profit[it->second];
            break;
        }
    }
  
    // Print the maximum profit earned
    cout << "Maximum profit earned is:"
         << max_profit;
}
  
// Driver Code
int main()
{
    // Size of list
    int size = 4;
  
    // Given profit and weight
    vector profit(size), weight(size);
  
    // Profit of items
    profit[0] = 100, profit[1] = 280,
    profit[2] = 120, profit[3] = 120;
  
    // Weight of items
    weight[0] = 10, weight[1] = 40,
    weight[2] = 20, weight[3] = 24;
  
    // Capacity of knapsack
    int N = 60;
  
    // Function Call
    maxProfit(profit, weight, N);
}

输出：

Maximum profit earned is:440

时间复杂度： O(N)
辅助空间： O(N)