我有一个代码，通过背包算法计算最佳值（bin packing NP-hard problem）：
int Knapsack::knapsack(std::vector<Item>& items, int W)
{
size_t n = items.size();
std::vector<std::vector<int> > dp(W + 1, std::vector<int>(n + 1, 0));
for (size_t j = 1; j <= n; j++)
{
for ( int w = 1; w <= W; w++)
{
if (items[j-1].getWeight() <= w)
{
dp[w][j] = std::max(dp[w][j-1], dp[w - items[j-1].getWeight()][j-1] + items[j-1].getWeight());
}
else
{
dp[w][j] = dp[w][j - 1];
}
}
}
return dp[W][n];
}
此外，我还需要显示包含的元素。我想创建一个数组，添加一个元素。所以问题在于添加这个添加的步骤，或者可能还有其他更有效的方法吗？
问题：我希望能够了解为我提供最佳解决方案的项目，而不仅仅是最佳解决方案的价值。
PS。对不起我的英语，这不是我的母语。
答案 0 :(得分：12)
从矩阵中获取您打包的元素可以使用矩阵中的数据完成，而无需存储任何其他数据。
伪代码：
line <- W
i <- n
while (i> 0):
if dp[line][i] - dp[line - weight(i)][i-1] == value(i):
the element 'i' is in the knapsack
i <- i-1 //only in 0-1 knapsack
line <- line - weight(i)
else:
i <- i-1
背后的想法：你迭代矩阵，如果权重差异正是元素的大小，它就在背包中。
如果不是：物品不在背包中，请在没有它的情况下继续。
答案 1 :(得分：2)
line <- W
i <- n
while (i> 0):
if dp[line][i] - dp[line - weight(i) ][i-1] == value(i):
the element 'i' is in the knapsack
cw = cw - weight(i)
i <- i-1
else if dp[line][i] > dp[line][i-1]:
line <- line - 1
else:
i <- i-1
记住当你添加项目i时你如何得到dp [line] [i]
dp[line][i] = dp[line - weight(i) ][i - 1] + value(i);
答案 2 :(得分：1)
重建有界 0/1 背包中物品的算法比该线程中的一些现有代码可能会让人相信更简单。这个答案旨在稍微揭开该过程的神秘面纱，并提供一个干净、直接的实现以及一个可行的示例。
从对应于表轴的两个索引开始：一个 weight 变量初始化为背包容量，一个索引 i 沿着项目轴在 DP 查找表上向后循环，在索引 1 处停止（该算法使用 i-1，因此在 1 处停止可避免越界访问）。
在循环中，如果T[weight][i] != T[weight][i-1]，则将项目i-1标记为选中状态，减去其权重并继续沿项目轴后退。
重建的时间复杂度为 O(length(items))。
以下是 Python 伪代码：
def reconstruct_taken_items(T, items, capacity):
taken = []
weight = capacity
for i in range(len(items), 0, -1): # from n downto 1 (inclusive)
if T[weight][i] != T[weight][i-1]:
taken.append(items[i-1])
weight -= items[i-1].weight
return taken
例如，考虑一个容量为 9 的背包和这些物品：
[item(weight=1, value=2),
item(weight=3, value=5),
item(weight=4, value=8),
item(weight=6, value=4)]
取第 0、1 和 2 项的最佳值是 15。
DP查找表是
items ---->
0 1 2 3 4
--------------+
0 0 0 0 0 | 0 capacity
0 2 2 2 2 | 1 |
0 2 2 2 2 | 2 |
0 2 5 5 5 | 3 v
0 2 7 8 8 | 4
0 2 7 10 10 | 5
0 2 7 10 10 | 6
0 2 7 13 13 | 7
0 2 7 15 15 | 8
0 2 7 15 15 | 9
在此运行重建算法：
0 0 0 0 0
0 2 2 2 2
0 2 2 2 2
0 2 5 5 5
0 2 7 8 8
0 2 7 10 10
0 2 7 10 10
0 2 7 13 13
0 2 7 15 15
0 2 7 15 15 <-- weight = capacity = 9
^ ^
| |
i-1 i = length(items) = 4
在上面的初始状态中，T[weight][i] == T[weight][i-1] (15 == 15) 所以 item[i-1] (item(weight=6, value=4)) 没有被采用。减少 i 并尝试使用相同容量的剩余项目。
0 0 0 0 0
0 2 2 2 2
0 2 2 2 2
0 2 5 5 5
0 2 7 8 8
0 2 7 10 10
0 2 7 10 10
0 2 7 13 13
0 2 7 15 15
0 2 7 15 15 <-- weight = 9
^
|
i = 3
这里，T[weight][i] != T[weight][i-1] (7 != 15) 所以 items[i-1]，即 items[2] 或 item(weight=4, value=8)，一定是被占用了。将剩余重量减少items[i-1].weight，或9 - 4 = 5，将item[i-1]从图片中取出后，尝试剩余重量较小的剩余物品。
0 0 0 0 0
0 2 2 2 2
0 2 2 2 2
0 2 5 5 5
0 2 7 8 8
0 2 7 10 10 <-- weight = 5
0 2 7 10 10
0 2 7 13 13
0 2 7 15 15
0 2 7 15 15
^
|
i = 2
在这种状态下，我们再次有 T[weight][i] != T[weight][i-1] (2 != 7)，所以我们必须取 items[i-1]，即 items[1] 或 item(weight=3, value=5)。将剩余重量减少 items[i-1].weight 或 5 - 3，然后移至下一项。
0 0 0 0 0
0 2 2 2 2
0 2 2 2 2 <-- weight = 2
0 2 5 5 5
0 2 7 8 8
0 2 7 10 10
0 2 7 10 10
0 2 7 13 13
0 2 7 15 15
0 2 7 15 15
^
|
i = 1
在这最后一步中，我们又得到了 T[weight][i] != T[weight][i-1] (0 != 2)，所以我们必须取 items[i-1]，即 items[0] 或 item(weight=1, value=2)。将剩余的权重减少 items[i-1].weight 或 2 - 1，并退出循环，因为 i == 0。
#include <iostream>
#include <vector>
class Knapsack {
public:
struct Item {
const int weight;
const int value;
};
private:
static std::vector<Item> reconstruct_taken_items(
const std::vector<std::vector<int> > &T,
const std::vector<Item> &items,
const int capacity
) {
std::vector<Item> taken;
int weight = capacity;
for (size_t i = items.size(); i > 0; i--) {
if (T[weight][i] != T[weight][i-1]) {
taken.emplace_back(items[i-1]);
weight -= items[i-1].weight;
}
}
return taken;
}
public:
static std::vector<Item> solve(
const std::vector<Item> &items,
const int capacity
) {
std::vector<std::vector<int> > T(
capacity + 1,
std::vector<int>(items.size() + 1, 0)
);
for (int i = 1; i <= capacity; i++) {
for (size_t j = 1; j <= items.size(); j++) {
const Item &item = items[j-1];
if (item.weight > i) {
T[i][j] = T[i][j-1];
}
else {
T[i][j] = std::max(
T[i-item.weight][j-1] + item.value,
T[i][j-1]
);
}
}
}
return reconstruct_taken_items(T, items, capacity);
}
};
int main() {
const int capacity = 9;
const std::vector<Knapsack::Item> items = {
{1, 2}, {3, 5}, {4, 8}, {6, 4}
};
for (const Knapsack::Item &item : Knapsack::solve(items, capacity)) {
std::cout << "weight: " << item.weight
<< ", value: " << item.value << "\n";
}
return 0;
}
答案 3 :(得分：0)
这是一个julia实现：
function knapsack!{F<:Real}(
selected::BitVector, # whether the item is selected
v::AbstractVector{F}, # vector of item values (bigger is better)
w::AbstractVector{Int}, # vector of item weights (bigger is worse)
W::Int, # knapsack capacity (W ≤ ∑w)
)
# Solves the 0-1 Knapsack Problem
# https://en.wikipedia.org/wiki/Knapsack_problem
# Returns the assigment vector such that
# the max weight ≤ W is obtained
fill!(selected, false)
if W ≤ 0
return selected
end
n = length(w)
@assert(n == length(v))
@assert(all(w .> 0))
###########################################
# allocate DP memory
m = Array(F, n+1, W+1)
for j in 0:W
m[1, j+1] = 0.0
end
###########################################
# solve knapsack with DP
for i in 1:n
for j in 0:W
if w[i] ≤ j
m[i+1, j+1] = max(m[i, j+1], m[i, j-w[i]+1] + v[i])
else
m[i+1, j+1] = m[i, j+1]
end
end
end
###########################################
# recover the value
line = W
for i in n : -1 : 1
if line - w[i] + 1 > 0 && m[i+1,line+1] - m[i, line - w[i] + 1] == v[i]
selected[i] = true
line -= w[i]
end
end
selected
end