如何将这个递归转化为迭代DP

How do I convert this recursion into iterative DP?

本文关键字：迭代 DP 递归      更新时间：2023-10-16

我想解决这个问题:TRT。以下是我到目前为止所做的:我为给定的问题设计了一个递归，并使用记忆法使解决方案被接受。

int recur(int l,int r,int level)
{
    if(l==r)
      return level*a[l];
    if(dp[l][r])
      return dp[l][r];
     return dp[l][r]=max(level*a[l]+recur(l+1,r,level+1),level*a[r]+recur(l,r-1,level+1));
}

我正试图通过自下而上的动态规划来解决这个问题，但我想不出这个方法，这种情况发生在我正在解决的大多数动态规划问题上，我能够设计递归，但在构建迭代dp时失败。有谁能在我弄清楚递归后告诉我迭代dp解的方法吗?

编辑:基于Tempux的解释，我自下而上的DP解决方案:

int solve()
{
   REP(i,n)
   {
      dp[i][i]=n*a[i];
   }
   REPP(i,1,n)
   {
        for(int j=0;j+i<n;j++)
        {
            dp[j][j+i]=max((n-i)*a[j]+dp[j+1][j+i],(n-i)*a[j+i]+dp[j][j+i-1]);
        }
   }
   return dp[0][n-1];
}

一般来说，您只需要首先填充独立的值(基本情况)。然后填写依赖于您之前填写的值的值。

在这种情况下，当l==r你有一个独立的值。所以你先填满这些:[0][0][1][1][2][2]……(n - 1) (n - 1) 。

现在你可以看到,价值 [l] [r] 取决于 [l + 1] [r] 和 [l] (r1) 。现在你可以填充[0][1][1][2][2][3]的值…[n] (n - 1) 。

[0][1] is dependent on [0][0] and [1][1] which you have filled before
[1][2] is dependent on [1][1] and [2][2] which you have filled before
....

现在你认识到一个模式了。如果按对角线操作，可以填满整个表。

0 * * * *       0 1 * * *       0 1 2 * *     0 1 2 3 *
* 0 * * *       * 0 1 * *       * 0 1 2 *     * 0 1 2 3
* * 0 * *       * * 0 1 *       * * 0 1 2     * * 0 1 2
* * * 0 *       * * * 0 1       * * * 0 1     * * * 0 1
* * * * 0       * * * * 0       * * * * 0     * * * * 0

这是一个可能的实现:

for ( int d=0; d<=n-1; ++d ){
    for ( int l=0; l<=n-1; ++l ){
        int r = l+d;
        if ( r >= n )
            break;
        int level = n-(r-l);
        if ( l==r ){
            dp[l][r] = level*v[l];
        } else {
            dp[l][r] = max( level*v[l] + dp[l+1][r],
                            level*v[r] + dp[l][r-1] );
        }
    }
}
相关文章：