C++实现的背包分支与绑定

C++ implementation of knapsack branch and bound

本文关键字：绑定 分支 背包 实现 C++      更新时间：2023-10-16

我正在尝试使用分支和边界来实现这个背包问题的C++。这个网站上有一个Java版本：实现分支并绑定到背包

我正试图让我的C++版本打印出它应该打印的90，但它并没有这样做，相反，它打印出了5。

有人知道问题出在哪里，出在什么地方吗？

#include <queue>
#include <iostream>
using namespace std;
struct node
{
    int level;
    int profit;
    int weight;
    int bound;
};
int bound(node u, int n, int W, vector<int> pVa, vector<int> wVa)
{
    int j = 0, k = 0;
    int totweight = 0;
    int result = 0;
    if (u.weight >= W)
    {
        return 0;
    }
    else
    {
        result = u.profit;
        j = u.level + 1;
        totweight = u.weight;
        while ((j < n) && (totweight + wVa[j] <= W))
        {
            totweight = totweight + wVa[j];
            result = result + pVa[j];
            j++;
        }
        k = j;
        if (k < n)
        {
            result = result + (W - totweight) * pVa[k]/wVa[k];
        }
        return result;
    }
}
int knapsack(int n, int p[], int w[], int W)
{
    queue<node> Q;
    node u, v;
    vector<int> pV;
    vector<int> wV;
    Q.empty();
    for (int i = 0; i < n; i++)
    {
        pV.push_back(p[i]);
        wV.push_back(w[i]);
    }
    v.level = -1; 
    v.profit = 0;
    v.weight = 0;
    int maxProfit = 0;
    //v.bound = bound(v, n, W, pV, wV);
    Q.push(v);
    while (!Q.empty())
    {
        v = Q.front();
        Q.pop();
        if (v.level == -1)
        {
            u.level = 0;
        }
        else if (v.level != (n - 1))
        {
            u.level = v.level + 1;
        }
        u.weight = v.weight + w[u.level];
        u.profit = v.profit + p[u.level];
        u.bound = bound(u, n, W, pV, wV);
        if (u.weight <= W && u.profit > maxProfit)
        {
            maxProfit = u.profit;
        }
        if (u.bound > maxProfit)
        {
            Q.push(u);
        }
        u.weight = v.weight;
        u.profit = v.profit;
        u.bound = bound(u, n, W, pV, wV);
        if (u.bound > maxProfit)
        {
            Q.push(u);
        }
    }
    return maxProfit;
}
int main()
{
    int maxProfit;
    int n = 4;
    int W = 16;
    int p[4] = {2, 5, 10, 5};
    int w[4] = {40, 30, 50, 10};
    cout << knapsack(n, p, w, W) << endl;
    system("PAUSE");
}

我认为您将利润和权重值放错了向量。更改：

int p[4] = {2, 5, 10, 5};
int w[4] = {40, 30, 50, 10};

至：

int w[4] = {2, 5, 10, 5};
int p[4] = {40, 30, 50, 10};

您的程序将输出90。

我相信您正在实现的不是分支&精确地绑定算法。如果我必须将它与某些东西相匹配，它更像是一种基于估计的回溯。

算法中的问题在于您正在使用的数据结构。您所做的只是简单地首先推送所有第一级，然后推送所有第二级，然后将所有第三级推送到队列中，并按插入顺序将它们放回。你会得到你的结果，但这只是搜索整个搜索空间。

您需要做的不是按照插入顺序弹出元素，而是始终在具有最高估计边界的节点上进行分支。换言之，无论其估计边界如何，您总是在途中的每个节点上进行分支。分支机构&绑定技术通过每次只在一个节点上进行分支来获得其速度优势，这最有可能导致结果（具有最高的估计值）。

示例：在您的第一次迭代中，假设您已找到2个具有估计值的节点

节点1：110

节点2：80

你正在把它们都推到你的队列中。您的队列变成了"n2-n1-head"。在第二次迭代中，您在node1:上分支后又推送了两个节点

节点3：100

node4:95

并且你也将它们添加到你的队列中（"n4-n3-n2-head"。出现错误。在下一次迭代中，你将得到的将是node2，但它应该是具有最高估计值的node3。

因此，如果我没有在您的代码中遗漏一些内容，那么您的实现和java实现都是错误的。您应该使用优先级队列（堆）来实现真正的分支&跳跃

您将W设置为16，因此结果为5。你唯一能带进背包的物品是利润为5、重量为10的物品3。

        #include <bits/stdc++.h>
using namespace std;
struct Item
{
    float weight;
    int value;
};
struct Node
{
    int level, profit, bound;
    float weight;
};
bool cmp(Item a, Item b)
{
    double r1 = (double)a.value / a.weight;
    double r2 = (double)b.value / b.weight;
    return r1 > r2;
}
int bound(Node u, int n, int W, Item arr[])
{
    if (u.weight >= W)
        return 0;
    int profit_bound = u.profit;
    int j = u.level + 1;
    int totweight = u.weight;
    while ((j < n) && (totweight + arr[j].weight <= W))
    {
        totweight    = totweight + arr[j].weight;
        profit_bound = profit_bound + arr[j].value;
        j++;
    }
    if (j < n)
        profit_bound = profit_bound + (W - totweight) * arr[j].value /
                                         arr[j].weight;
    return profit_bound;
}
int knapsack(int W, Item arr[], int n)
{
    sort(arr, arr + n, cmp);
    queue<Node> Q;
    Node u, v;
    u.level = -1;
    u.profit = u.weight = 0;
    Q.push(u);
    int maxProfit = 0;
    while (!Q.empty())
    {
        u = Q.front();
        Q.pop();
        if (u.level == -1)
            v.level = 0;
        if (u.level == n-1)
            continue;
        v.level = u.level + 1;
        v.weight = u.weight + arr[v.level].weight;
        v.profit = u.profit + arr[v.level].value;
        if (v.weight <= W && v.profit > maxProfit)
            maxProfit = v.profit;
        v.bound = bound(v, n, W, arr);
        if (v.bound > maxProfit)
            Q.push(v);
        v.weight = u.weight;
        v.profit = u.profit;
        v.bound = bound(v, n, W, arr);
        if (v.bound > maxProfit)
            Q.push(v);
    }
    return maxProfit;
}
int main()
{
    int W = 55;   // Weight of knapsack
    Item arr[] = {{10, 60}, {20, 100}, {30, 120}};
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << "Maximum possible profit = "
         << knapsack(W, arr, n);
    return 0;
}
**SEE IF THIS HELPS**
相关文章：