Question

    public static int n;
    public static int w;
    public static int[] s;
    public static int[] p;

    static void Main(string[] args)
    {
        n = 5;
        w = 5;

        s = new int[n + 1];
        p = new int[n + 1];
        Random rnd = new Random();

        for (int i = 1; i <= n; i++)
        {

            s[i] = rnd.Next(1, 10);
            p[i] = rnd.Next(1, 10);
        }

        Console.WriteLine(F_recursion(n, w));
        Console.WriteLine(DP(n, w));
    }

    // recursive approach
    public static int F_recursion(int n, int w)
    {
        if (n == 0 || w == 0)
            return 0;
        else if (s[n] > w)
            return F_recursion(n - 1, w);
        else
        {                          
            return Math.Max(F_recursion(n - 1, w), (p[n] + F_recursion(n - 1, w - s[n])));
        }
    }

    // iterative approach
    public static int DP(int n, int w)
    {
        int result = 0;

        for (int i = 1; i <= n; i++)
        {

            if (s[i] > w)
            {
                continue;
            }
            else
            {                   
                result += p[i];
                w = w - s[i];
            }
        }

        return result;
    }

我需要将F_recursion函数转换为迭代。我目前编写了以下功能DP，有时可以工作但不总是。我知道问题出在F_recursion（n - 1， w - s [n] ）我不知道如何在迭代解决方案中使w-s [n]正常工作。如果将w - s [n]和w - s [i]改为w，则程序始终有效。

在控制台中：

s[i] = 2 p[i] = 3
-------
s[i] = 3 p[i] = 4
-------
s[i] = 5 p[i] = 3
-------
s[i] = 3 p[i] = 8
-------
s[i] = 6 p[i] = 6
-------
Recursive:11
Iteration:7

但有时可行

s[i] = 5 p[i] = 6
-------
s[i] = 8 p[i] = 1
-------
s[i] = 3 p[i] = 5
-------
s[i] = 3 p[i] = 1
-------
s[i] = 7 p[i] = 7
-------
Recursive:6
Iteration:6

Answer 1

当涉及更大的数字时（特别是对于s），以下方法可能会有用，因此二维数组将是不必要的，并且实际上只有少量w值用于计算结果。

这个想法：预先计算可能的w值，从w开始，每个i in [n, n-1, ..., 1]确定值w_[i]，其中w_[i+1] >= s[i]没有重复。然后在i_n上重复n并仅计算有效w_[i]值的子结果。

我选择了一个Dictionary数组作为数据结构，因为以这种方式设计稀疏数据相对容易。

public static int DP(int n, int w)
{
    // compute possible w values for each iteration from 0 to n
    Stack<HashSet<int>> validW = new Stack<HashSet<int>>();
    validW.Push(new HashSet<int>() { w });
    for (int i = n; i > 0; i--)
    {
        HashSet<int> validW_i = new HashSet<int>();
        foreach (var prevValid in validW.Peek())
        {
            validW_i.Add(prevValid);
            if (prevValid >= s[i])
            {
                validW_i.Add(prevValid - s[i]);
            }
        }
        validW.Push(validW_i);
    }

    // compute sub-results for all possible n,w values.
    Dictionary<int, int>[] value = new Dictionary<int,int>[n + 1];
    for (int n_i = 0; n_i <= n; n_i++)
    {
        value[n_i] = new Dictionary<int, int>();
        HashSet<int> validSubtractW_i = validW.Pop();
        foreach (var w_j in validSubtractW_i)
        {
            if (n_i == 0 || w_j == 0)
                value[n_i][w_j] = 0;
            else if (s[n_i] > w_j)
                value[n_i][w_j] = value[n_i - 1][w_j];
            else
                value[n_i][w_j] = Math.Max(value[n_i - 1][w_j], (p[n_i] + value[n_i - 1][w_j - s[n_i]]));
        }
    }

    return value[n][w];
}

了解一些空间和计算被浪费了很重要。为了预先计算可能的w值并支持稀疏数据结构。因此，对于s中具有小值的大型数据集，此方法可能会表现不佳，其中大多数w值都可能是子结果。

经过多次思考后，我意识到，如果空间是一个问题，你实际上可以丢弃除了前一个外循环迭代之外的所有内容的子结果，因为此算法中的递归遵循严格的n-1模式。但是，我暂时没有将其包含在我的代码中。

Answer 2

您的方法不起作用，因为您的动态programmig状态空间（显然只是一个变量）与递归方法的签名不匹配。动态编程方法的目标应该是定义和填充状态空间，以便在需要时提供所有评估结果。在检查递归方法时，请注意F_recursion的递归调用可能会更改两个参数n和w。这表明应该使用二维状态空间。

第一个参数（显然限制了项目范围）的范围可以从0到n，而第二个参数（显然是某个项目属性的总和）可以从0至w。

您应该定义二维状态空间

int[,] value = new int[n,w];

用于容纳价值观。接下来，您应该将值初始化为undefined;您可以使用值Int32.MaxValue，因为如果计算出具有不同值的最小值，它将以合适的方式运行。

接下来，该算法的迭代版本使用两个以转发方式迭代的循环，这与减少参数的递归迭代不同。

for (int i = 0; i < n; i++)
{
    for (int j = 0; j < w; j++)
    {
        // logic for the recurrence relation goes here
    }
}

在最里面的块中，您可以使用重复关系的修改版本。您可以访问存储在value中的值，而不是使用递归调用;您可以将值写入value。

，而不是返回值

从语义上讲，它与memoization相同，但不是使用实际的递归调用，而是评估的顺序断言必要的值总是存在，这使得额外的逻辑不再需要。

填充状态空间后，必须检查其最后一个状态（即第一个索引为n-1的数组部分），以确定整个输入的最大值。

使用动态编程递归到迭代转换

2 个答案: