动态规划

Posted 2020-10-06 Barry

石子合并问题是最经典的DP问题。首先它有如下3种题型：

 

(1)有N堆石子，现要将石子有序的合并成一堆，规定如下：每次只能移动任意的2堆石子合并，合并花费为新合成的一堆石子的数量。求将这N堆石子合并成一堆的总花费最小（或最大）。

 

分析：当然这种情况是最简单的情况，合并的是任意两堆，直接贪心即可，每次选择最小的两堆合并。本问题实际上就是哈夫曼的变形。

 

 

(2)有N堆石子，现要将石子有序的合并成一堆，规定如下：每次只能移动相邻的2堆石子合并，合并花费为新合成的一堆石子的数量。求将这N堆石子合并成一堆的总花费最小（或最大）。

 

 

分析：我们熟悉矩阵连乘，知道矩阵连乘也是每次合并相邻的两个矩阵，那么石子合并可以用矩阵连乘的方式来解决。

 

设dp[i][j]表示第i到第j堆石子合并的最优值，sum[i][j]表示第i到第j堆石子的总数量。那么就有状态转移公式：

 

 

#include <iostream>
#include <string.h>
#include <stdio.h>

using namespace std;
const int INF = 1 << 30;
const int N = 205;

int dp[N][N];
int sum[N];
int a[N];

int getMinval(int a[],int n)
{
    for(int i=0;i<n;i++)
        dp[i][i] = 0;
    for(int v=1;v<n;v++)
    {
        for(int i=0;i<n-v;i++)
        {
            int j = i + v;
            dp[i][j] = INF;
            int tmp = sum[j] - (i > 0 ? sum[i-1]:0);
            for(int k=i;k<j;k++)
                dp[i][j] = min(dp[i][j],dp[i][k]+dp[k+1][j] + tmp);
        }
    }
    return dp[0][n-1];
}

int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=0;i<n;i++)
            scanf("%d",&a[i]);
        sum[0] = a[0];
        for(int i=1;i<n;i++)
            sum[i] = sum[i-1] + a[i];
        printf("%d\n",getMinval(a,n));
    }
    return 0;
}

　　

 

直线取石子问题的平行四边形优化：

 

 1 #include <iostream>
 2 #include <string.h>
 3 #include <stdio.h>
 4 
 5 using namespace std;
 6 const int INF = 1 << 30;
 7 const int N = 1005;
 8 
 9 int dp[N][N];
10 int p[N][N];
11 int sum[N];
12 int n;
13 
14 int getMinval()
15 {
16     for(int i=1; i<=n; i++)
17     {
18         dp[i][i] = 0;
19         p[i][i] = i;
20     }
21     for(int len=1; len<n; len++)
22     {
23         for(int i=1; i+len<=n; i++)
24         {
25             int end = i+len;
26             int tmp = INF;
27             int k = 0;
28             for(int j=p[i][end-1]; j<=p[i+1][end]; j++)
29             {
30                 if(dp[i][j] + dp[j+1][end] + sum[end] - sum[i-1] < tmp)
31                 {
32                     tmp = dp[i][j] + dp[j+1][end] + sum[end] - sum[i-1];
33                     k = j;
34                 }
35             }
36             dp[i][end] = tmp;
37             p[i][end] = k;
38         }
39     }
40     return dp[1][n];
41 }
42 
43 int main()
44 {
45     while(scanf("%d",&n)!=EOF)
46     {
47         sum[0] = 0;
48         for(int i=1; i<=n; i++)
49         {
50             int val;
51             scanf("%d",&val);
52             sum[i] = sum[i-1] + val;
53         }
54         printf("%d\n",getMinval());
55     }
56     return 0;
57 }

 

 

(3)问题(2)的是在石子排列是直线情况下的解法，如果把石子改为环形排列，又怎么做呢？

 

 

分析：状态转移方程为：

 

 

 

 

其中有：

 

 

 

 1 #include <iostream>
 2 #include <string.h>
 3 #include <stdio.h>
 4 
 5 using namespace std;
 6 const int INF = 1 << 30;
 7 const int N = 205;
 8 
 9 int mins[N][N];
10 int maxs[N][N];
11 int sum[N],a[N];
12 int minval,maxval;
13 int n;
14 
15 int getsum(int i,int j)
16 {
17     if(i+j >= n) return getsum(i,n-i-1) + getsum(0,(i+j)%n);
18     else return sum[i+j] - (i>0 ? sum[i-1]:0);
19 }
20 
21 void Work(int a[],int n)
22 {
23     for(int i=0;i<n;i++)
24         mins[i][0] = maxs[i][0] = 0;
25     for(int j=1;j<n;j++)
26     {
27         for(int i=0;i<n;i++)
28         {
29             mins[i][j] = INF;
30             maxs[i][j] = 0;
31             for(int k=0;k<j;k++)
32             {
33                 mins[i][j] = min(mins[i][j],mins[i][k] + mins[(i+k+1)%n][j-k-1] + getsum(i,j));
34                 maxs[i][j] = max(maxs[i][j],maxs[i][k] + maxs[(i+k+1)%n][j-k-1] + getsum(i,j));
35             }
36         }
37     }
38     minval = mins[0][n-1];
39     maxval = maxs[0][n-1];
40     for(int i=0;i<n;i++)
41     {
42         minval = min(minval,mins[i][n-1]);
43         maxval = max(maxval,maxs[i][n-1]);
44     }
45 }
46 
47 int main()
48 {
49     while(scanf("%d",&n)!=EOF)
50     {
51         for(int i=0;i<n;i++)
52             scanf("%d",&a[i]);
53         sum[0] = a[0];
54         for(int i=1;i<n;i++)
55             sum[i] = sum[i-1] + a[i];
56         Work(a,n);
57         printf("%d %d\n",minval,maxval);
58     }
59     return 0;
60 }

 

 

可以看出，上面的(2)(3)问题的时间复杂度都是O(n^3)，由于过程满足平行四边形法则，故可以进一步优化到O(n^2)。