石子合并问题--动态规划;贪心

石子合并问题

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

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

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

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

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

任意合并

题目

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

分析

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

代码

/*************************************************************************
> File Name: 1.c
> Author: GatieMe
> Mail: gatieme@163.com
> Created Time: 2015年10月17日 星期六 19时29分22秒
************************************************************************/

#include <stdio.h>
#include <stdlib.h>

int Compare(const void *pleft, const void *pright)
{
int *left = (int *)pleft;
int *right = (int *)pright;

return (*left - *right);
}

#define SIZE 100
int N;
int W[SIZE];

int main(void)
{
while(scanf("%d", &N), N)
{
for(int i = 0; i < N; i++)
{
scanf("%d", &W[i]);
}

for(int i = 0; i < N; i++)
{

qsort(&W[i], N - i, sizeof(W[0]), Compare);

#ifdef DEBUG
for(int j = 0; j < N; j++)
{
printf("%4d", W[j]);
}
printf("\n");
#endif
// 此时num[i]和num[i + 1]就是最小的两个
W[i + 1] += W[i];

}

printf("%d\n", W[N - 1]);
}
}

相邻合并

题目

有N堆石子，现要将石子有序的合并成一堆，规定如下：

每次只能移动相邻的2堆石子合并

合并花费为新合成的一堆石子的数量。

求将这N堆石子合并成一堆的总花费最小（或最大）。

分析

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

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

代码

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

const int INF = 1 << 30;
#define MIN(a, b)  ((a) > (b) ? (a) : (b))
#define 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;
}

优化

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

const int INF = 1 << 30;
#define 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;
}

环形合并

题目

在一个圆形操场的四周摆放着n堆石子(n<= 100)，现要将石子有次序地合并成一堆。规定每次只能选取相邻的两堆合并成新的一堆,并将新的一堆的石子数,记为该次合并的得分。

编一程序，读入石子堆数n及每堆的石子数(<=20)。选择一种合并石子的方案,使得做n－1次合并,得分的总和最小；

比如有4堆石子：4 4 5 9 则最佳合并方案如下：

4 4 5 9 score: 0
8 5 9 score: 8
13 9 score: 8 + 13 = 21
22 score: 8 + 13 + 22 = 43

输入：

可能有多组测试数据。 当输入n=0时结束! 第一行为石子堆数n(1<=n<=100)；第二行为n堆的石子每堆的石子数,每两个数之间用一个空格分隔。

输出：

合并的最小得分，每个结果一行。

输入样例：

4 4 4 5 9

6 3 4 6 5 4 2

0

输出样例：

43

61

分析

假设有石头Ai,Ai+1,……,Ai+j-1共j堆需要合并,简记为A[i+0,i+j-1].如果设最后一次合并发生在Ak与Ak+1之间(i<=k <=i+j-1),则最后一个合并的得分为

Ai,Ai+1,……,Ai+j-1堆石头的个数的总和记为totalValue(i,j).(不管你最后一次合并发生在哪个位置,totalValue(i,j)的值都是一样的)因此总的得分等于

A[i,k]+A[k+1,i+j-1]+totalValue(i,j).





动态规划思路：

阶段i：石子的每一次合并过程，先两两合并，再三三合并，…最后N堆合并

状态s：每一阶段中各个不同合并方法的石子合并总得分。

决策：把当前阶段的合并方法细分成前一阶段已计算出的方法，选择其中的最优方案

具体来说我们应该定义一个数组s[i,j]用来表示合并方法，s[i][j]表示从第i堆开始数j堆进行合并，s[i,j]为合并的最优得分。

对例子(3 4 6 5 4 2)来说:
第一阶段：s[1,1]=0,s[2,1]=0,s[3,1]=0,s[4,1]=0,s[5,1]=0,s[6,1]=0，因为一开始还没有合并，所以这些值应该全部为0。
第二阶段：两两合并过程如下，其中sum(i,j)表示从i开始数j个数的和
s[1,2]=s[1,1]+s[2,1]+sum(1,2)
s[2,2]=s[2,1]+s[3,1]+sum(2,2)
s[3,2]=s[3,1]+s[4,1]+sum(3,2)
s[4,2]=s[4,1]+s[5,1]+sum(4,2)
s[5,2]=s[5,1]+s[6,1]+sum(5,2)
s[6,2]=s[6,1]+s[1,1]+sum(6,2)
第三阶段：三三合并可以拆成两两合并，拆分方法有两种，前两个为一组或后两个为一组
s[1,3]=s[1,2]+s[3,1]+sum(1,3)或s[1,3]=s[1,1]+s[2,2]+sum(1,3)，取其最优(最大或最小)
s[2,3]=s[2,2]+s[4,1]+sum(2,3)或s[1,3]=s[2,1]+s[3,2]+sum(2,3)，取其最优
第四阶段：四四合并的拆分方法用三种，同理求出三种分法的得分，取其最优即可。以后第五阶段、第六阶段依次类推，最后在第六阶段中找出最优答案即可。

代码

#include<iostream>
using namespace std;
int N;//石子的堆数
int num[100]={0};//每堆石子个数

int sum(int begin,int n)
{
int total=0;
for (int i=begin;i<=begin+n-1;i++)
{   if(i==N)
total=total+num
;//取代num[0]
else
total=total+num[i%N];
}
return total;
}
int stone_merge()
{
int score[100][100];//score[i][j]:从第i堆石子开始的j堆石子合并后最小得分
int n,i,k,temp;
for (i=1;i<=N;i++)
score[i][1]=0;//一堆石子，合并得分为0

//num[0]=num
;//重要：sum()函数中i=N时,取num[0]
for (n=2;n<=N;n++)//合并的石子的堆数
{
for (i=1;i<=N;i++)//合并起始位置
{
score[i]
=score[i][1]+score[(i+1-1)%N+1][n-1];
for (k=2;k<=n-1;k++)//截断位置
{
temp=score[i][k]+score[(i+k-1)%N+1][n-k];
if(temp <score[i]
)
score[i]
= temp;//从第i开始的k堆是：第i+0堆到第(i+k-1)%N堆
}
score[i]
+=sum(i,n);
}
}
int min=2147483647;
for (i=1;i<=N;i++)
{    if (min>score[i]
)
min=score[i]
;//取从第i堆开始的N堆的最小者
}
return min;
}

int main()
{
int min_count=0;
cin>>N;//石子的堆数
while(N!=0)
{
for (int i=1;i<=N;i++)
cin>>num[i];//每堆石子的数量//从1开始,num[0]不用
min_count=stone_merge();
cout<<min_count<<endl;

for(i=0;i<N;i++)//准备下一轮
num[i]=0;
min_count=0;
cin>>N;
}
return 0;
}

数据围成一个环，而实际存储是线性的，这里简化环形取数据，得到新的一种解决方法

优化

#include<stdio.h>
int N;//最多100堆石子:N=100
int num[200]={0};

int stone_merge()
{
int score[200][101]={0};//l[i][j]:从第i堆石子起合并n堆石子的最小得分
int n,i,k,temp;
for(i=0;i<2*N;i++)
score[i][1]=0;//一堆石子合并得分为0
for(n=2;n<=N;n++)//合并n堆石子
{
for(i=0;i<=2*N-n;i++)//从第i对开始合并(有一次重复运算，但省去了循环取数，简化了程序)
{
score[i]
=score[i][1]+score[i+1][n-1];
for(k=2;k<n;k++)//划分
{   temp=score[i][k]+score[k+i][n-k];
if(temp<score[i]
)
score[i]
=temp;//取(i,n)划分两部分的得分
}
for(k=i;k<i+n;k++)
score[i]
+=num[k];//加上此次合并得分
}
}
int min=2147483647;//int(4位)最大值为2147483647
for(i=0;i<N;i++)
{
if(score[i]
<min)
min=score[i]
;//从第i堆开始取N堆石子，的最小合并得分
}
return min;
}

int main()
{
int min_count;
scanf("%d",&N);//N堆石子
while(N!=0)
{
for(int i=0;i<N;i++)
scanf("%d",&num[i]);//每堆石子的数量
for(i=N;i<2*N;i++)
num[i]=num[i-N];//复制一倍，化简环形计算（N堆石子是围成一个环的）
if(N==1)    min_count=0;
else if(N==2)    min_count=num[0]+num[1];
else    min_count=stone_merge();
printf("%d\n",min_count);

for(i=0;i<200;i++)    num[i]=0;//准备下一轮
min_count=0;
scanf("%d",&N);
}
return 0;
}