Question

我正在尝试解决此问题：TRT。这是我到目前为止所做的：我为给定的问题设计了一个递归，并使用memoization来接受解决方案。

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解决方案吗？

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

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];
}

Answer 1

通常，您只需填写首先独立的值（基本情况）。然后填写依赖于之前填充的值的值。

在这种情况下，当 l == r 时，您有一个独立的值。所以你先填写这些： [0] [0] [1] [1] [2] [2] ... [n-1] [n-1] 。

现在您可以看到 [l] [r] 的值取决于 [l + 1] [r] 和 [l] [r -1] 。所以现在你可以填写 [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] );
        }
    }
}

如何将此递归转换为迭代DP？

1 个答案: