Question

我花了很多时间来学习使用迭代实现/可视化动态编程问题，但我发现很难理解，我可以使用memoization的递归实现相同的但是与迭代相比它很慢。

有人可以通过硬问题的例子或使用一些基本概念来解释相同的问题。像矩阵链乘法，最长的回文子序列和其他。我可以理解递归过程，然后记住重叠子问题的效率，但我无法理解如何使用迭代来做同样的事情。

谢谢！

Answer 1

动态编程就是解决子问题以解决更大问题。递归方法和迭代方法之间的区别在于前者是自上而下，后者是自下而上。换句话说，使用递归，你可以从你想要解决的大问题开始，然后将其分解为更小的子问题，在这个问题上你重复这个过程，直到你达到子问题这么小，你可以解决。这样做的好处是，您只需解决绝对需要的子问题，并使用memoization记住结果。自下而上的方法首先解决所有子问题，使用制表来记住结果。如果我们没有做额外的工作来解决不需要的子问题，那么这是一种更好的方法。

更简单的例子，让我们看看Fibonacci序列。假设我们想要计算F(101)。在递归地执行此操作时，我们将从我们的大问题开始 - F(101)。为此，我们注意到我们需要计算F(99)和F(100)。然后，对于F(99)，我们需要F(97)和F(98)。我们继续，直到我们达到最小的可解决的子问题，即F(1)，并记住结果。当迭代地执行时，我们从最小的子问题F(1)开始并一直向上，将结果保存在表中（所以基本上它只是一个简单的for循环，从1到101）这种情况）。

让我们来看看您请求的矩阵链乘法问题。我们将从一个简单的递归实现开始，然后是递归DP，最后是迭代DP。它将在C / C ++汤中实现，但即使您不熟悉它们，您也应该能够继续学习。

/* Solve the problem recursively (naive)

   p - matrix dimensions
   n - size of p
   i..j - state (sub-problem): range of parenthesis */
int solve_rn(int p[], int n, int i, int j) {
    // A matrix multiplied by itself needs no operations
    if (i == j) return 0;

    // A minimal solution for this sub-problem, we
    // initialize it with the maximal possible value
    int min = std::numeric_limits<int>::max();

    // Recursively solve all the sub-problems
    for (int k = i; k < j; ++k) {
        int tmp = solve_rn(p, n, i, k) + solve_rn(p, n, k + 1, j) + p[i - 1] * p[k] * p[j];
        if (tmp < min) min = tmp;
    }

    // Return solution for this sub-problem
    return min;
}

为了计算结果，我们从一个大问题开始：

solve_rn(p, n, 1, n - 1)

DP的关键是要记住子问题的所有解决方案，而不是忘记它们，因此我们不需要重新计算它们。为了实现这一目标，对上述代码进行一些调整是微不足道的：

/* Solve the problem recursively (DP)

   p - matrix dimensions
   n - size of p
   i..j - state (sub-problem): range of parenthesis */
int solve_r(int p[], int n, int i, int j) {
    /* We need to remember the results for state i..j.
       This can be done in a matrix, which we call dp,
       such that dp[i][j] is the best solution for the
       state i..j. We initialize everything to 0 first.

       static keyword here is just a C/C++ thing for keeping
       the matrix between function calls, you can also either
       make it global or pass it as a parameter each time.

       MAXN is here too because the array size when doing it like
       this has to be a constant in C/C++. I set it to 100 here.
       But you can do it some other way if you don't like it. */
    static int dp[MAXN][MAXN] = {{0}};

    /* A matrix multiplied by itself has 0 operations, so we
       can just return 0. Also, if we already computed the result
       for this state, just return that. */
    if (i == j) return 0;
    else if (dp[i][j] != 0) return dp[i][j];

    // A minimal solution for this sub-problem, we
    // initialize it with the maximal possible value
    dp[i][j] = std::numeric_limits<int>::max();

    // Recursively solve all the sub-problems
    for (int k = i; k < j; ++k) {
        int tmp = solve_r(p, n, i, k) + solve_r(p, n, k + 1, j) + p[i - 1] * p[k] * p[j];
        if (tmp < dp[i][j]) dp[i][j] = tmp;
    }

    // Return solution for this sub-problem
    return dp[i][j];;
}

我们也从一个大问题开始：

solve_r(p, n, 1, n - 1)

迭代解决方案只是迭代所有状态，而不是从顶部开始：

/* Solve the problem iteratively

   p - matrix dimensions
   n - size of p

   We don't need to pass state, because we iterate the states. */
int solve_i(int p[], int n) {
    // But we do need our table, just like before
    static int dp[MAXN][MAXN];

    // Multiplying a matrix by itself needs no operations
    for (int i = 1; i < n; ++i)
        dp[i][i] = 0;

    // L represents the length of the chain. We go from smallest, to
    // biggest. Made L capital to distinguish letter l from number 1
    for (int L = 2; L < n; ++L) {
        // This double loop goes through all the states in the current
        // chain length.
        for (int i = 1; i <= n - L + 1; ++i) {
            int j = i + L - 1;
            dp[i][j] = std::numeric_limits<int>::max();

            for (int k = i; k <= j - 1; ++k) {
                int tmp = dp[i][k] + dp[k+1][j] + p[i-1] * p[k] * p[j];
                if (tmp < dp[i][j])
                    dp[i][j] = tmp;
            }
        }
    }

    // Return the result of the biggest problem
    return dp[1][n-1];
}

要计算结果，只需调用它：

solve_i(p, n)

最后一个例子中循环计数器的说明：

我们需要优化4个矩阵的乘法：A B C D。我们正在进行迭代方法，因此我们将首先计算长度为2的链：(A B) C D，A (B C) D和A B (C D)。然后是三个链：(A B C) D和A (B C D)。这就是L，i和j的用途。

L表示链长，从2到n - 1（在这种情况下n为4，因此3 }）。

i和j代表链的起始和结束位置。如果L = 2，i从1转到3，j从2转到4：

(A B) C D     A (B C) D     A B (C D)
 ^ ^             ^ ^             ^ ^
 i j             i j             i j

如果L = 3 i从1转到2，j从3转到4：

(A B C) D     A (B C D)
 ^   ^           ^   ^
 i   j           i   j

通常，i从1转到n - L + 1，而j是i + L - 1。

现在，让我们继续算法，假设我们处于(A B C) D的步骤。我们现在需要考虑子问题（已经计算过）：((A B) C) D和(A (B C)) D。这就是k的用途。它遍历i和j之间的所有位置，并计算子问题。

我希望我能帮忙。

Answer 2

递归问题是需要推送/弹出的大量堆栈帧。这很快就会成为瓶颈。

Fibonacci系列可以使用迭代DP或带有记忆的递归来计算。如果我们在DP中计算F（100），我们需要的是长度为100的数组，例如int[100]这是我们用过的记忆的胆量。我们计算阵列预填充f[0]和f[1]的所有条目，因为它们被定义为1。每个值都取决于前两个。

如果我们使用递归解决方案，我们从fib(100)开始解决问题。从100下降到0的每个方法调用都被压入堆栈， AND 检查它是否已被记忆。这些操作加起来并且迭代不会受到这些操作中的任何一个的影响。在迭代（自下而上）中，我们已经知道所有以前的答案都是有效的。更大的影响可能是堆栈帧;并且给定一个更大的输入，你可能会得到一个StackOverflowException来解决迭代DP方法所带来的微不足道的问题。

使用迭代的动态编程问题

2 个答案: