石子合并问题

石子合并问题

 想了N久，想原创性的从另一个角度分析问题。。。然后没想出来。。。

再然后就无耻的把别人的copy了一份（原文）：

时限：

1000ms 内存限制：10000K  总时限：3000ms

描述：

在一个圆形操场的四周摆放着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[N];//取代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[N];//重要：sum()函数中i=N时,取num[0]
       for (n=2;n<=N;n++)//合并的石子的堆数
       {
           for (i=1;i<=N;i++)//合并起始位置
           {
               score[i][n]=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][n]) 
                        score[i][n] = temp;//从第i开始的k堆是：第i+0堆到第(i+k-1)%N堆
               }
               score[i][n]+=sum(i,n);
           }
       }  
       int min=2147483647;   
       for (i=1;i<=N;i++)
       {    if (min>score[i][N])           
                  min=score[i][N];//取从第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;
}

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

（注：考虑调用sum函数处会有重复的计算，所以这里采用了计算推迟的方法，这一招在一些算法题中也出现过。）

#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][n]=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][n])
                    score[i][n]=temp;//取(i,n)划分两部分的得分
            }
            for(k=i;k<i+n;k++)
                score[i][n]+=num[k];//加上此次合并得分
        }
    }
    int min=2147483647;//int(4位)最大值为2147483647
    for(i=0;i<N;i++)
    {
        if(score[i][N]<min)
            min=score[i][N];//从第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;
}

（其他部分原文解释得很清楚了。。。）

此外，在此之前考虑了一个简单的模型，原以为关系很大，其实区别很大；

考虑：如果没有环形的条件又是如何解呢？这个显然要简单多了：

君可曾记得算法导论的“矩阵连乘”问题么？（代码也和矩阵连乘基本一致，就是写得太凑合了）

int func33(int a[], int n)
{
    int i,j, k,l,cnt;
    
    int *m, tmp;
    
    assert(n>=2);
    
    m = new int[n*n];

    
    for (i=0; i<n*n; ++i)
    {
        m[i] = 0;
    }
    
    for (j=0; j< n; j++)
    {
        for (i=j; i>=0; i--)
        {
            if (i==j)
            {
                m[i*n+j] = 0;
                continue;
            }
            cnt = 0;
            for (l=i; l<=j; l++)
            {
                cnt += a[l];
            }
            for (k=i; k<j; k++)
            {                
                tmp = m[i*n+k] + m[(k+1)*n+j] + cnt;
                if (m[i*n+j] < tmp)
                {
                    m[i*n+j] = tmp;
                }
            }
        }
    }
    
    tmp = m[0*n+ n-1];
    
    delete[] m;
    
    return tmp;
}

 

P.S. 今天阿里的笔试题出了一道题，让我认为和本题类似，结果发现其很不一样：“仓库运输问题”；

毕