Question

我对这个问题有点迷惑。因为算法帮我从包中找到了最大的利润。但是这个算法并没有告诉我应该拿哪个项目来获取我的最大利润。例如
n = 4项，背包容量M = 8，利润= [15,10,9,5]，权重分别为w = [1,5,3,4] 当我解决这个问题时，我获得的最大利润为29

这是解决方案[http://www.mafy.lut.fi/study/DiscreteOpt/DYNKNAP.pdf]

但是我想知道我应该拿哪个项目来赚取29的利润。我不想做所有的组合，因为如果有n个项目并且分别有N个权重和利润那么如何许多组合将使。所以我想知道是否有任何解决方案可以为这个或任何其他算法提供给我的利润总和最大的项目。请帮我。等待回复！谢谢

Answer 1

动态编程：

对于0/1背包，您可以拍摄整个物品或保留它完全。因此，您必须先计算所有可能的解决方案决定哪一个是最好的。

贪婪的方法

在另一个背包问题中，你可以采取一些项目，你可以按成本计算，即采取最高成本的项目并填写你的背包，直到你的背包满或没有更多的项目，然后转到第二个最昂贵的项目，依此类推......

Answer 2

如果您的问题仍然是“但我想知道我应该选择哪个项目”，这是一个打印实际项目的实现：

import java.util.ArrayList;
import java.util.List;

public class Knapsack
{

    private int counter = 0;
    private int[] values, weights;
    public Knapsack(int[] vs, int[] ws)
    {
        values = vs;
        weights = ws;
    }

    public Bag knap(int n, int w)
    {
        counter++;
        Bag ret = new Bag();
        if (n == -1) {
            return ret;
        }

        ret = knap(n - 1, w);
        assert ret.totalWeight() <= w;
        if (weights[n] > w) {
            // This weight alone is larger than our quota. Can't add any more.
            return ret;
        }
        int val1 = ret.totalValue();
        int weight1 = ret.totalWeight();
        int remain = w - weight1;
        if (weights[n] <= remain)
        {
            // We have space for this item. Add to bag.
            ret.add(n, values[n], weights[n]);
            return ret;
        }
        int max = w - weights[n];
        ArrayList<Integer> nitems2 = new ArrayList<Integer>();
        Bag ret2 = knap(n - 1, w - weights[n]);
        ret2.add(n, values[n], weights[n]);
        int val2 = ret2.totalValue();
        int weight2 = ret2.totalWeight();
        if (val1 > val2) {
            return ret;
        } else {
            return ret2;
        }
    }

    public static void main(String[] args)
    {
        int[] values = {15, 10, 9, 5};
        int[] weights = {1, 5, 3, 4};
        int M = 8;

        Knapsack ks = new Knapsack(values, weights);
        Bag ret = ks.knap(values.length - 1, M);
        System.out.println("Total value=" + ret.totalValue() + ", weight=" +
                       ret.totalWeight());
        List<Integer> items = ret.bagItems();
        System.out.print("Items: ");
        for (int i: items) {
            System.out.print(i + " ");
        }
        System.out.println();
    }
}

class Bag {
    private int weight;
    private int value;
    private ArrayList<Integer> items;
    public Bag()
    {
        weight = 0;
        value = 0;
        items = new ArrayList<Integer>();
    }

    public void add(int itemno, int v, int w)
    {
        items.add(itemno);
        weight += w;
        value += v;
    }

    public int totalWeight() { return weight; }
    public int totalValue() { return value; }
    public List<Integer> bagItems() { return items; }
}

Answer 3

0-1 Knapsack确实希望你权衡所有可能的组合，因为与分数背包不同，我们可以使用贪婪算法来获得最大利润，空白空间会降低每磅（重量）负载的有效利润。在0-1背包中，当我们考虑是否在背包中包含一个项目时，我们必须将解决方案与包含该项目的子问题进行比较，然后在我们可以做出选择之前将该项解决方案与排除该项目的子问题进行比较。

因此解决方案运行O(nW)，其中n是项目数，W是可放入背包中的项目的权重

希望它澄清！

0/1背包算法

3 个答案: