Question

杆切割问题（有一个长度为n的杆，其中n> 0，n是一个整数，我们希望将其切割成整数长度，使得总价最大化），p是列表价格，n是杆的长度。我想要切割杆，以获得最大的价格，同时，我们还需要确保长度是unqiue，即如果我们已经切割了一个长度= 3，我们不能切割另一个长度= 3 。

例如，向量p = {1,5,8,9,10,12,17,20};给我最高价格：21和长度是：2,3,3。如上所述，不应该是双3.因此结果应为20，长度为8而不是2,3,3

我怎样才能修改我的代码，并保持时间复杂度O（n ^ 2）谢谢。

int n = 8;
vector<int> p = {1,5,8,9,10,12,17,20};

void cut_rod(vector<int>& p, int n){

    int r[n+1];
    int s[n+1];
    r[0] = 0;

    for (int j = 1; j<=n; j++){
        int q = INT_MIN;
        for (int i = 1; i <= j; i++){
            if(q < p[i-1] + r[j-i]){

                q = p[i-1] + r[j-i];
                s[j] = i;
            }
        }
        r[j] = q;
    }
    return r[n];

}

Answer 1

当您存储给定长度的碎片时，您可以使用n + 1乘n + 1矩阵。通过这种方式，您可以检查在恒定时间内是否具有相同大小的块并且复制行成本线性时间，因此总体上复杂度仍为O（n ^ 2），但现在您的空间复杂度为O（n ^ 2）。

我在下面通过geeksforgeeks修改了代码。

// A Dynamic Programming solution for Rod cutting problem
#include<stdio.h>
#include<limits.h>
using namespace std;
// A utility function to get the maximum of two integers
int max(int a, int b) { return (a > b)? a : b;}

/* Returns the best obtainable price for a rod of length n and
price[] as prices of different pieces */
int cutRod(int price[], int n)
{
   int pieces[n+1][n+1];    
   int val[n+1];
   val[0] = 0;
   int i, j;

   // Build the table val[] in bottom up manner and return the last entry
   // from the table
   for (i = 1; i<=n; i++)
   {
       int max_val = INT_MIN, ind = -1;
       for (j = 1; j <= i; j++) {
           if (max_val < price[j - 1] + val[i-j]) {
               if (pieces[i-j][j] != 1) {                   
                   max_val = price[j - 1] + val[i-j];
                   ind = j;
               }
           }
       }
       val[i] = max_val;
       for (int k = 0; k <= n; ++k) { // Copy the pieces
           pieces[i][k] = pieces[i-ind][k];
       }
       pieces[i][ind] = 1; // Add the piece of length ind (which is the max j)
   }
   return val[n];
}

/* Driver program to test above functions */
int main()
{
    int arr[] = {1,5,8,9,10,12,17,20};
    int size = sizeof(arr)/sizeof(arr[0]);
    printf("Maximum Obtainable Value is %dn", cutRod(arr, size));
    getchar();
    return 0;
}

DP算法保存在数组val的第i个位置，从0到n，长度为i的杆的最大价格。我们将长度为i的杆的切割保存为碎片[i]，这是一个从0到n的数组，如果我们在位置j处有1表示获得最大值val [i]你必须有一块长度为j。现在，对于某个长度的DP算法进行长度j的切割并计算长度j的价格和已经计算的剩余长度i-j的最大价格的总和。这个总和将有一些j的最大值，这意味着将有一些j，价格[j - 1] + val [i-j]将是max（其中j不是已经存在的切割）。所以现在长度我有一段长度j和长度i - j的碎片我们已经保存在碎片[i - j]。现在要获得碎片[i]我们必须复制碎片[i - j]并添加长度为j的碎片。

你可以得到像这样的作品的长度

for (int i = 0; i <= n; ++i) 
    if (pieces[n][i] == 1)  cout << i << ' ';

计算棒的最大总价，用独特的长度值切割

1 个答案: