动态规划思想：石子合并问题

描述：

在一个圆形操场的四周摆放着n 堆石子。现要将石子有次序地合并成一堆。 规定每次只能选相邻的2 堆石子合并成新的一堆，并将新的一堆石子数记为该次合并的得分。 试设计一个算法，计算出将n堆石子合并成一堆的最小得分和最大得分。



开始以为通过贪心算法可能很快解决问题，可是是行不通的。 首先我们可以把这么堆石子看成一列 , 我们假如5堆的石子，其中石子数分别为7，6，5，7，100

•按照贪心法，合并的过程如下：

每次合并得分

第一次合并 7 6 5 7 100 =11

　 第二次合并 7 11 7 100=18

　 第三次合并 18 7 100 =25

第四次合并 25 100 =125

总得分＝11＋18＋25+125＝179

•另一种合并方案

每次合并得分

　 　第一次合并 7 6 5 7 100 ->13

第二次合并 13 5 7 100->12

第三次合并 13 12 100 ->25

第四次合并 25 100 ->125

总得分＝13＋12＋25+125＝175

显然利用贪心来做是错误的，贪心算法在子过程中得出的解只是局部最优,而不能保证使得全局的值最优。

#include<stdio.h>

#define N 100

  /*
  *求合并过程中
  *最少合并堆数目
  **/
int MatrixChain_min(int p
,int n)
{
         //定义二维数组m[i][j]来记录i到j的合并过成中最少石子数目
         //此处赋值为-1
 	int x,z; 
         int m

;
          for(x=1;x<=n;x++)
         for(z=1;z<=n;z++)
         {
             m[x][z]=-1;           
         }
 
      int min=0;
	int g; 
                                                           //当一个单独合并时，m[i][i]设为0，表示没有石子
      for(g = 1;g<=n;g++) m[g][g]=0;
 
                                                           //当相邻的两堆石子合并时，此时的m很容易可以看出是两者之和
	int i;
      for(i=1;i<=n-1;i++)
     {
         int j=i+1;
         m[i][j]=p[i-1]+p[j-1];
     }
 
                                                           //当相邻的3堆以及到最后的n堆时，执行以下循环
	int r,b,k;
     for(r=3; r<=n;r++)
          for(i=1;i<=n-r+1;i++)
          {
              int j = i+r-1;                               //j总是距离i   r-1的距离
              int sum=0;
                                                           //当i到j堆石子合并时最后里面的石子数求和得sum
              for(b=i;b<=j;b++)
                  sum+=p[b-1];
 
              // 此时m[i][j]为i~j堆石子间以m[i][i]+m[i+1][j]+sum结果，这是其中一种可能，不一定是最优
              //要与下面的情况相比较，唉，太详细了
 
              m[i][j] = m[i+1][j]+sum;
 
              //除上面一种组合情况外的其他组合情况
              for(k=i+1;k<j;k++)
              {
                  int t=m[i][k]+m[k+1][j]+sum;
                  if(t<m[i][j])
                      m[i][j] = t;
 
              }
          }

           //最终得到最优解
          min=m[1]
;
          return min;
}
 
 /*
  *求合并过程中
  *最多合并堆数目
  **/
 
int  MatrixChain_max(int p
,int n)
{
        int m

;
	int x,z;
          for(x=1;x<=n;x++)
         for(z=1;z<=n;z++)
         {
             m[x][z]=-1;           
         }
 
 
      int max=0;
	int g,i;
      //一个独自组合时
     for(g = 1;g<=n;g++) m[g][g]=0;
     //两个两两组合时
     for(i=1;i<=n-1;i++)
     {
         int j=i+1;
         m[i][j]=p[i-1]+p[j-1];
     }
	int r,b,k; 
     for(r=3; r<=n;r++)
          for(i=1;i<=n-r+1;i++)
          {
              int j = i+r-1;
              int sum=0;
              for(b=i;b<=j;b++)
                  sum+=p[b-1];
              m[i][j] = m[i+1][j]+sum;
              
              for(k=i+1;k<j;k++)
              {
                  int t=m[i][k]+m[k+1][j]+sum;
                  if(t>m[i][j])
                      m[i][j] = t;
 
              }
          }
 
          max=m[1]
;
          return max;
}

int main()
{
       //int stone
;
       int min=0;
       int max=0;
       int n;
	int i;
       /*scanf("%d",&n);
       for(i=1;i<=n;i++)
           scanf("%d",&stone[i]); */
   	n = 4;
	//stone[6] = {9,-7,,1,5,13 };
	int 	stone
 = { 9, -7 , 2 ,1 };
 
	for (i = 0;i < n; i ++)
	{
		printf("%d ",stone[i]);
	}
	printf("\n\n");
       	min= MatrixChain_min(stone,n);
       	max= MatrixChain_max(stone,n);
 
       //因为题目要求圆的原因，要把所有情况都要考虑到，总共有n种情况。
	int j,k;
       for(j=1;j<=n-1;j++)
       {
            int min_cache=0;
            int max_cache=0;
            int cache= stone[0];
            for(k=1;k< n;k++)
            {
                stone[k-1]=stone[k];
            }
            stone[n-1]=cache;
            min_cache= MatrixChain_min(stone,n);
	printf("%d \n",min_cache);
            max_cache= MatrixChain_max(stone,n);
	printf("%d \n",max_cache);
            if(min_cache<min)
                min=min_cache;
            if(max_cache>max)
                max=max_cache;
       }
    
     printf("%d\n",min);
     printf("%d\n",max);
 
     return 1; 
}