不能移动的石子合并问题

不能移动的石子合并

时间限制:1000MS  内存限制:1000K
提交次数:0 通过次数:0

题型: 编程题   语言: 无限制

Description

做如下两个模型的石子合并，如下模型石子都不能移动出列，且合并都仅发生在相邻两堆石子中：

（1）第一个模型：一行排列且相邻合并
有n堆石子形成一行(a1,a2,…,an，ai为第i堆石子个数)，相邻两堆可合并，合并的分值为新堆的石子数。求合并为一堆的最低得分和最高得分。

（2）第二个模型：一圈排列且相邻合并
有n堆石子形成首位相连的一个环形(a1,a2,…,an，ai为第i堆石子个数，an和a1相邻)，相邻两堆可合并，合并的分值为新堆的石子数。求合并为一堆的最低得分和最高得分。

例如4堆石子，每堆石子个数：9 4 4 5
若排成一行，最小分值：(4+4)+(8+5)+(9+13)=43，最大分值：(9+4)+(13+4)+(17+5)=52。
若排成圈状，最小分值：(4+4)+(8+5)+(9+13)=43，最大分值：(9+5)+(14+4)+(18+4)=54。

此题以第一模型的最低得分为例，很多同学想着采用总是从最小的相邻两堆下手的思想，认为最后获得的也就是最低得分。但这个贪心策略是不对的。
如下反例：

石子：9 4 6 1 5

贪心策略：
9 4 6 6      计分6
9 10 6       计分10
9 16         计分16
25           计分25
得分共计：6+10+16+25=57

但9 4 6 1 5 若如下方式合并：
13 6 1 5     计分13
13 6 6       计分6
13 12        计分12
25           计分25
13+6+12+25=56

或
9 4 6 6      计分6
9 4 12       计分12
13 12        计分13
25           计分25
6+12+13+25=56

后两种方式合并出的56都比贪心策略的57来的更低，因为总选择最小的相邻两堆去合并，并不能保证后续每步都可以最小，也许这轮最小导致后续几轮分值较大。

Input

两行。第一行n，第二行a1 a2 … an，每个ai(1<=i<=n)表示第i堆石子的个数，n<=100

Output

两行。第一行是第一个模型的最低得分和最高得分，中间空格相连，第二行是第二个模型的最低得分和最高得分，中间空格相连。

Code

#include<iostream>

using namespace::std;

int sum_ary(int i,int j,int n,int *a);

void merge_stones(int n,int *a,int **m){
for(int i=1;i<=n;++i)   m[i][i]=0;

for(int r=2;r<=n;++r)
	for(int i=1;i<=n-r+1;++i){
	int sum=0;
	int j=i+r-1;
	for(int t=i;t<=j;++t)
		sum+=a[t];
	m[i][j]=m[i+1][j]+sum;
    m[j][i]=m[j][i+1]+sum;
	for(int k=i+1;k<j;++k){
	int temp1=m[i][k]+m[k+1][j]+sum;                         //填满整个二维数组，主对角线之上为最小值子问题的表，之下为最大值子问题的表
	int temp2=m[k][i]+m[j][k+1]+sum;                         //从而对应m[1][n]为最小值最优解，而m[n][1]为最大值最优解
	if(temp1<m[i][j])  m[i][j]=temp1;
	if(temp2>m[j][i])  m[j][i]=temp2;
	}//for
	}//for
/*for(int i=1;i<=n;++i){
		for(int j=1;j<=n;++j)
			cout<<m[i][j]<<" ";                                       //注释部分为输出函数处理过后即m[i][j]填完后的数组
	cout<<endl;
	}*/
}//merge_stones

void merge_stonesCircle(int n,int *a,int **m){
   n=2*n;
 for(int i=1;i<=n;++i)   m[i][i]=0;

for(int r=2;r<=n/2;++r)
	for(int i=1;i<=n-r+1;++i){
	int sum=0;
	int j=i+r-1;
	for(int t=i;t<=j;++t)
		sum+=a[t];
	m[i][j]=m[i+1][j]+sum;
	m[j][i]=m[j][i+1]+sum;
	for(int k=i+1;k<j;++k){
	int temp1=m[i][k]+m[k+1][j]+sum;                         //填满整个二维数组，主对角线之上为最小值子问题的表，之下为最大值子问题的表
	int temp2=m[k][i]+m[j][k+1]+sum;                         //从而对应m[1][n]为最小值最优解，而m[n][1]为最大值最优解
	if(temp1<m[i][j])  m[i][j]=temp1;
	if(temp2>m[j][i])  m[j][i]=temp2;
	}//for
	}//for
/*	for(int i=1;i<=n;++i){
		for(int j=1;j<=n;++j)
			cout<<m[i][j]<<" ";                                         //注释部分为输出函数处理过后即m[i][j]填完后的数组
	cout<<endl;
	}*/
}

int main(){
int n;
cin>>n;
int *a=new int[n+1];
int *b=new int[2*n];                                                               //数组b为a的扩展数组  b[n+1...2*n-1]=a[1..n-1]

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

		cin>>a[i];
		b[i]=a[i];
}
for(int i=1;i!=n;++i){
     b[n+i]=a[i];
}
int **m=(int**)malloc((n+1)*sizeof(int*));                               //分配二位动态数组
for(int i=0;i<=n;++i){
	m[i]=(int*)malloc((n+1)*sizeof(int));
}
int **d=(int**)malloc((2*n)*sizeof(int*)); 
for(int i=0;i<=2*n;++i){
	d[i]=(int*)malloc((2*n)*sizeof(int));
}
merge_stones(n,a,m);
cout<<m[1][n]<<" "<<m[n][1]<<endl;
merge_stonesCircle(n,b,d);
int max=0;
int min=d[1][n];
for(int i=1;i<=2*n;++i)
	for(int j=1;j<=n;++j){
		if(d[i][j]>max)
			max=d[i][j];
	}

for(int i=1;i<=n;++i)
	   if(d[i][i+n-1]<min)
			min=d[i][i+n-1];

cout<<min<<" "<<max<<endl;
}

/*
Sample Input:
4
9 4 4 5
Sample Output:
43 52
43 54

标准输入数据:
5
1 3 7 9 2


标准输出答案:
   1|48 78
   2|44 78
*/

Sample Input

4
9 4 4 5

Sample Output

43 52
43 54