石子合并问题

原文：http://blog.csdn.net/acdreamers/article/details/18039073

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

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

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

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

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

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



[cpp] view
plaincopy





#include <iostream>

#include <string.h>

#include <stdio.h>

using namespace std;

const int INF = 1 << 30;

const int N = 205;

int dp

;

int sum
;

int a
;

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;

}

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

[cpp] view
plaincopy





#include <iostream>

#include <string.h>

#include <stdio.h>

using namespace std;

const int INF = 1 << 30;

const int N = 1005;

int dp

;

int p

;

int sum
;

int n;

int getMinval()

{

for(int i=1; i<=n; i++)

{

dp[i][i] = 0;

p[i][i] = i;

}

for(int len=1; len<n; len++)

{

for(int i=1; i+len<=n; i++)

{

int end = i+len;

int tmp = INF;

int k = 0;

for(int j=p[i][end-1]; j<=p[i+1][end]; j++)

{

if(dp[i][j] + dp[j+1][end] + sum[end] - sum[i-1] < tmp)

{

tmp = dp[i][j] + dp[j+1][end] + sum[end] - sum[i-1];

k = j;

}

}

dp[i][end] = tmp;

p[i][end] = k;

}

}

return dp[1]
;

}

int main()

{

while(scanf("%d",&n)!=EOF)

{

sum[0] = 0;

for(int i=1; i<=n; i++)

{

int val;

scanf("%d",&val);

sum[i] = sum[i-1] + val;

}

printf("%d\n",getMinval());

}

return 0;

}

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

分析：状态转移方程为：



其中有：



[cpp] view
plaincopy





#include <iostream>

#include <string.h>

#include <stdio.h>

using namespace std;

const int INF = 1 << 30;

const int N = 205;

int mins

;

int maxs

;

int sum
,a
;

int minval,maxval;

int n;

int getsum(int i,int j)

{

if(i+j >= n) return getsum(i,n-i-1) + getsum(0,(i+j)%n);

else return sum[i+j] - (i>0 ? sum[i-1]:0);

}

void Work(int a[],int n)

{

for(int i=0;i<n;i++)

mins[i][0] = maxs[i][0] = 0;

for(int j=1;j<n;j++)

{

for(int i=0;i<n;i++)

{

mins[i][j] = INF;

maxs[i][j] = 0;

for(int k=0;k<j;k++)

{

mins[i][j] = min(mins[i][j],mins[i][k] + mins[(i+k+1)%n][j-k-1] + getsum(i,j));

maxs[i][j] = max(maxs[i][j],maxs[i][k] + maxs[(i+k+1)%n][j-k-1] + getsum(i,j));

}

}

}

minval = mins[0][n-1];

maxval = maxs[0][n-1];

for(int i=0;i<n;i++)

{

minval = min(minval,mins[i][n-1]);

maxval = max(maxval,maxs[i][n-1]);

}

}

int main()

{

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

Work(a,n);

printf("%d %d\n",minval,maxval);

}

return 0;

}

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