Algorithm 0/1背包-关于Wiki的一些澄清';s伪码
以下是维基百科关于背包问题的文章的代码:Algorithm 0/1背包-关于Wiki的一些澄清';s伪码,algorithm,dynamic-programming,knapsack-problem,Algorithm,Dynamic Programming,Knapsack Problem,以下是维基百科关于背包问题的文章的代码: // Input: // Values (stored in array v) // Weights (stored in array w) // Number of distinct items (n) // Knapsack capacity (W) for w from 0 to W do m[0, w] := 0 end for for i from 1 to n do for j from 0 to W do if j >
// Input:
// Values (stored in array v)
// Weights (stored in array w)
// Number of distinct items (n)
// Knapsack capacity (W)
for w from 0 to W do
m[0, w] := 0
end for
for i from 1 to n do
for j from 0 to W do
if j >= w[i] then
m[i, j] := max(m[i-1, j], m[i-1, j-w[i]] + v[i])
else
m[i, j] := m[i-1, j]
end if
end for
end for
我有两点是我疲惫的大脑无法解决的。我敢肯定,它们是次要的,但我真的需要帮助
•m[]阵列的大小是多少?m[n,W]?如果是,伪代码是否会忽略最后一行和最后一列,因为它用零填充整个第一行(for()循环使用m[0,w]:=0),然后从1循环到n,从0循环到w。例如,对于3个不同的项(n==3)和4个容量(w==3),是m[3,4]还是m[4,5]
•在某处是否有更好的动态背包算法示例?数组的大小为(n+1)×(W+1),因为值的范围从[0,0]到[n,W]不等
对网格的解释如下:位置[k,w]表示使用前k个项目(假设项目编号为1,2,…,n)且总重量不超过w时可获得的最大值
将第一行完全设置为0的原因是[0,w]形式的任何条目都对应于使用前0个项目可以获得的最大值,并且最多携带w个重量。这始终为零,因为不拾取任何项目永远无法获得任何值。这与递归的基本情况相对应
使用以下方法填充第一个项目后的行:如果要尝试拾取第k个项目,首先需要确保您有能力持有它(意味着w必须至少为w[k])。如果你拿不住它,你最好的选择是根据你当前的重量限制最大限度地利用前k-1个项目(因此你最好去掉对应于m[k-1,w]的值)。如果你能拿着这个项目,你的选择是要么不拿(和以前一样,尽量利用其他项目,得到m[k-1,w]),或将其用于最大化剩余物品的剩余承载能力。这将为您提供值v[k]+m[k-1,w-w[k]]
希望这有帮助!我知道它已经得到了回答,只是在c#中添加了代码版本,仅供参考(对于简化背包,您可以参考:): 第1版。使用动态编程解决问题(类似于wiki)-自下而上(列表方法) 第2版。使用动态编程解决问题,但从上到下(记忆化-惰性) 第3版。递归(仅使用递归解决方案,不使用重叠子问题或允许使用DP的最优子结构属性) 第4版。蛮力(通过所有组合) 参考文献: 表格-DP-版本(O(nW)-伪多项式-O(nW)内存-自底向上
public int Knapsack_0_1_DP_Tabular_Bottom_Up(int[] weights, int[] values, int maxWeight)
{
this.ValidataInput_Knapsack_0_1(weights, values, maxWeight);
int[][] DP_Memoization_Max_Value_Cache = new int[values.Length + 1][];
for (int i = 0; i <= values.Length; i++)
{
DP_Memoization_Max_Value_Cache[i] = new int[maxWeight + 1];
for (int j = 0; j <= maxWeight; j++)
{
DP_Memoization_Max_Value_Cache[i][j] = 0; //yes, its default -
}
}
/// f(i, w) = f(i-1, w) if Wi > w
/// Or, max (f(i-1, w), f(i-1, w-Wi) + Vi
/// Or 0 if i < 0
for(int i = 1; i<=values.Length; i++)
{
for(int w = 1; w <= maxWeight; w++)
{
//below code can be refined - intentional as i just want it
//look similar to other 2 versions (top_to_bottom_momoization
//and recursive_without_resuing_subproblem_solution
int maxValueWithoutIncludingCurrentItem =
DP_Memoization_Max_Value_Cache[i - 1][w];
if (weights[i - 1] > w)
{
DP_Memoization_Max_Value_Cache[i][w] = maxValueWithoutIncludingCurrentItem;
}
else
{
int maxValueByIncludingCurrentItem =
DP_Memoization_Max_Value_Cache[i - 1][w - weights[i - 1]]
+ values[i-1];
int overAllMax = maxValueWithoutIncludingCurrentItem;
if(maxValueByIncludingCurrentItem > overAllMax)
{
overAllMax = maxValueByIncludingCurrentItem;
}
DP_Memoization_Max_Value_Cache[i][w] = overAllMax;
}
}
}
return DP_Memoization_Max_Value_Cache[values.Length][maxWeight];
}
单元测试2
[TestMethod]
public void Knapsack_0_1_Brute_Force_Tests()
{
int[] benefits = new int[] { 60, 100, 120 };
int[] weights = new int[] { 10, 20, 30 };
this.Knapsack_0_1_BruteForce_2_Power_N(weights, values: benefits, maxWeight: 50);
Assert.IsTrue(this._maxValue == 220);
Assert.IsTrue(this._valueIndices.Contains(1));
Assert.IsTrue(this._valueIndices.Contains(2));
Assert.IsTrue(this._valueIndices.Length == 2);
this._maxValue = int.MinValue;
this._valueIndices = null;
benefits = new int[] { 3, 4, 5, 8, 10 };
weights = new int[] { 2, 3, 4, 5, 9 };
this.Knapsack_0_1_BruteForce_2_Power_N(weights, values: benefits, maxWeight: 20);
Assert.IsTrue(this._maxValue == 26);
Assert.IsTrue(this._valueIndices.Contains(0));
Assert.IsTrue(this._valueIndices.Contains(2));
Assert.IsTrue(this._valueIndices.Contains(3));
Assert.IsTrue(this._valueIndices.Contains(4));
Assert.IsTrue(this._valueIndices.Length == 4);
}
哈利西,你是疲惫甜点中的绿洲。
public int Knapsack_0_1_DP_Tabular_Bottom_Up(int[] weights, int[] values, int maxWeight)
{
this.ValidataInput_Knapsack_0_1(weights, values, maxWeight);
int[][] DP_Memoization_Max_Value_Cache = new int[values.Length + 1][];
for (int i = 0; i <= values.Length; i++)
{
DP_Memoization_Max_Value_Cache[i] = new int[maxWeight + 1];
for (int j = 0; j <= maxWeight; j++)
{
DP_Memoization_Max_Value_Cache[i][j] = 0; //yes, its default -
}
}
/// f(i, w) = f(i-1, w) if Wi > w
/// Or, max (f(i-1, w), f(i-1, w-Wi) + Vi
/// Or 0 if i < 0
for(int i = 1; i<=values.Length; i++)
{
for(int w = 1; w <= maxWeight; w++)
{
//below code can be refined - intentional as i just want it
//look similar to other 2 versions (top_to_bottom_momoization
//and recursive_without_resuing_subproblem_solution
int maxValueWithoutIncludingCurrentItem =
DP_Memoization_Max_Value_Cache[i - 1][w];
if (weights[i - 1] > w)
{
DP_Memoization_Max_Value_Cache[i][w] = maxValueWithoutIncludingCurrentItem;
}
else
{
int maxValueByIncludingCurrentItem =
DP_Memoization_Max_Value_Cache[i - 1][w - weights[i - 1]]
+ values[i-1];
int overAllMax = maxValueWithoutIncludingCurrentItem;
if(maxValueByIncludingCurrentItem > overAllMax)
{
overAllMax = maxValueByIncludingCurrentItem;
}
DP_Memoization_Max_Value_Cache[i][w] = overAllMax;
}
}
}
return DP_Memoization_Max_Value_Cache[values.Length][maxWeight];
}
public int Knapsack_0_1_OverlappedSubPromblems_OptimalSubStructure(int[] weights, int[] values, int maxWeight)
{
this.ValidataInput_Knapsack_0_1(weights, values, maxWeight);
int v = this.Knapsack_0_1_OverlappedSubPromblems_OptimalSubStructure_Recursive(weights, values, index: weights.Length-1, weight: maxWeight);
return v;
}
/// <summary>
/// f(i, w) = f(i-1, w) if Wi > w
/// Or, max (f(i-1, w), f(i-1, w-Wi) + Vi
/// Or 0 if i < 0
/// </summary>
int Knapsack_0_1_OverlappedSubPromblems_OptimalSubStructure_Recursive(int[] weights, int[] values, int index, int weight)
{
if (index < 0)
{
return 0;
}
Debug.Assert(weight >= 0);
int maxValueWithoutIncludingCurrentItem = this.Knapsack_0_1_OverlappedSubPromblems_OptimalSubStructure_Recursive(weights,
values, index - 1, weight);
if(weights[index] > weight)
{
//current item weight is more, so we cant include - so, just return
return maxValueWithoutIncludingCurrentItem;
}
int overallMaxValue = maxValueWithoutIncludingCurrentItem;
int maxValueIncludingCurrentItem = this.Knapsack_0_1_OverlappedSubPromblems_OptimalSubStructure_Recursive(weights,
values, index - 1, weight - weights[index]) + values[index];
if(maxValueIncludingCurrentItem > overallMaxValue)
{
overallMaxValue = maxValueIncludingCurrentItem;
}
return overallMaxValue;
}
private int _maxValue = int.MinValue;
private int[] _valueIndices = null;
public void Knapsack_0_1_BruteForce_2_Power_N(int[] weights, int[] values, int maxWeight)
{
this.ValidataInput_Knapsack_0_1(weights, values, maxWeight);
this._maxValue = int.MinValue;
this._valueIndices = null;
this.Knapsack_0_1_BruteForce_2_Power_N_Rcursive(weights, values, maxWeight, 0, 0, 0, new List<int>());
}
private void Knapsack_0_1_BruteForce_2_Power_N_Rcursive(int[] weights, int[] values, int maxWeight, int index, int currentWeight, int currentValue, List<int> currentValueIndices)
{
if(currentWeight > maxWeight)
{
return;
}
if(currentValue > this._maxValue)
{
this._maxValue = currentValue;
this._valueIndices = currentValueIndices.ToArray();
}
if(index == weights.Length)
{
return;
}
Debug.Assert(index < weights.Length);
var w = weights[index];
var v = values[index];
//see if the current value, conributes to max value
currentValueIndices.Add(index);
Knapsack_0_1_BruteForce_2_Power_N_Rcursive(weights, values, maxWeight, index + 1, currentWeight + w,
currentValue + v, currentValueIndices);
currentValueIndices.Remove(index);
//see if current value, does not contribute to max value
Knapsack_0_1_BruteForce_2_Power_N_Rcursive(weights, values, maxWeight, index + 1, currentWeight, currentValue,
currentValueIndices);
}
[TestMethod]
public void Knapsack_0_1_Tests()
{
int[] benefits = new int[] { 60, 100, 120 };
int[] weights = new int[] { 10, 20, 30 };
this.Knapsack_0_1_BruteForce_2_Power_N(weights, values: benefits, maxWeight: 50);
Assert.IsTrue(this._maxValue == 220);
int v = this.Knapsack_0_1_OverlappedSubPromblems_OptimalSubStructure(weights,
values: benefits, maxWeight: 50);
Assert.IsTrue(v == 220);
v = this.Knapsack_0_1_DP_Memoization_Top_To_Bottom_Lazy(weights,
values: benefits, maxWeight: 50);
Assert.IsTrue(v == 220);
v = this.Knapsack_0_1_DP_Tabular_Bottom_Up(weights,
values: benefits, maxWeight: 50);
Assert.IsTrue(v == 220);
benefits = new int[] { 3, 4, 5, 8, 10 };
weights = new int[] { 2, 3, 4, 5, 9 };
this.Knapsack_0_1_BruteForce_2_Power_N(weights, values: benefits, maxWeight: 20);
Assert.IsTrue(this._maxValue == 26);
v = this.Knapsack_0_1_OverlappedSubPromblems_OptimalSubStructure(weights, values: benefits,
maxWeight: 20);
Assert.IsTrue(v == 26);
v = this.Knapsack_0_1_DP_Memoization_Top_To_Bottom_Lazy(weights,
values: benefits, maxWeight: 20);
Assert.IsTrue(v == 26);
v = this.Knapsack_0_1_DP_Tabular_Bottom_Up(weights,
values: benefits, maxWeight: 20);
Assert.IsTrue(v == 26);
benefits = new int[] { 3, 4, 5, 6};
weights = new int[] { 2, 3, 4, 5 };
this.Knapsack_0_1_BruteForce_2_Power_N(weights, values: benefits, maxWeight: 5);
Assert.IsTrue(this._maxValue == 7);
v = this.Knapsack_0_1_OverlappedSubPromblems_OptimalSubStructure(weights, values: benefits,
maxWeight: 5);
Assert.IsTrue(v == 7);
v = this.Knapsack_0_1_DP_Memoization_Top_To_Bottom_Lazy(weights,
values: benefits, maxWeight: 5);
Assert.IsTrue(v == 7);
v = this.Knapsack_0_1_DP_Tabular_Bottom_Up(weights,
values: benefits, maxWeight: 5);
Assert.IsTrue(v == 7);
}
[TestMethod]
public void Knapsack_0_1_Brute_Force_Tests()
{
int[] benefits = new int[] { 60, 100, 120 };
int[] weights = new int[] { 10, 20, 30 };
this.Knapsack_0_1_BruteForce_2_Power_N(weights, values: benefits, maxWeight: 50);
Assert.IsTrue(this._maxValue == 220);
Assert.IsTrue(this._valueIndices.Contains(1));
Assert.IsTrue(this._valueIndices.Contains(2));
Assert.IsTrue(this._valueIndices.Length == 2);
this._maxValue = int.MinValue;
this._valueIndices = null;
benefits = new int[] { 3, 4, 5, 8, 10 };
weights = new int[] { 2, 3, 4, 5, 9 };
this.Knapsack_0_1_BruteForce_2_Power_N(weights, values: benefits, maxWeight: 20);
Assert.IsTrue(this._maxValue == 26);
Assert.IsTrue(this._valueIndices.Contains(0));
Assert.IsTrue(this._valueIndices.Contains(2));
Assert.IsTrue(this._valueIndices.Contains(3));
Assert.IsTrue(this._valueIndices.Contains(4));
Assert.IsTrue(this._valueIndices.Length == 4);
}