两种石子归并

题目描述 Description

有n堆石子排成一列，每堆石子有一个重量w[i], 每次合并可以合并相邻的两堆石子，一次合并的代价为两堆石子的重量和w[i]+w[i+1]。问安排怎样的合并顺序，能够使得总合并代价达到最小。

输入描述 Input Description

第一行一个整数n（n<=100）

第二行n个整数w1,w2...wn  (wi <= 100)

输出描述 Output Description

一个整数表示最小合并代价

样例输入 Sample Input

4

4 1 1 4

样例输出 Sample Output

18

 首先我们先说比较简单的石子归并的版本——区间dp。

上面这道题可以说是区间dp的最经典的例题了，然而到今天我才真正的看明白这个题答案的真正意义。

首先我们很容易想到贪心的思路，就是每次将最小的两组和并，然而事实上是不可以的，利用贪心的是与这个题类似的合并果子，这两个题的区别就在于，此题必须是相邻的两组合并。这会导致什么，最小的两组不一定相邻，然后如果贪心就gg了。

那么说正解，我们可以将将这个数组看作一个区间，然后对这个区间进行划分，即将划分处进行合并，然后枚举划分的点，再对划分的点进行划分，取最优的划分点。区间成为两个时就别无选择。

怎么说出了递归搜索的感觉？没错，当时学长将这道题的时候，我的思路就是记忆化搜索，然而学长想讲的是递推。但我确实用记忆化搜索写出来了。

那么递推怎么写？

我们可以枚举区间左端点，再枚举区间长度，这样区间的左端点和右端点就都有了，然后再枚举划分点，取出不同划分点中的最大值。这样就完成了递推，

具体一点的看一下代码就懂了。

PS：昨天了解到，所有的记忆化搜索都可以写出递推式，但是记忆化搜索往往更好想。

附上代码

#include<iostream>
#include<cstring> 
#include<cstdio>
using namespace std;
int n,f[110][110],a[110],sum[110];
int ff(int x,int y)
{
    if(x==y) return f[x][y]=0;
    if(f[x][y]) return f[x][y];
    if(x==y-1) return f[x][y]=sum[y]-sum[x-1];
    f[x][y]=0x6fffff;
    for(int i=x;i<=y;++i)
    f[x][y]=min(f[x][y],ff(x,i)
    +ff(i+1,y)+sum[y]-sum[x-1]);
    return f[x][y];    
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;++i)
    {
        scanf("%d",&a[i]);
        sum[i]=a[i]+sum[i-1];
    }
    cout<<ff(1,n);
    return 0;
}

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
int a[110],n,sum[110],f[110][110];
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;++i)
    {
        scanf("%d",&a[i]);
        sum[i]=sum[i-1]+a[i];
    }
    for(int i=1;i<=n;++i)
    {
        for(int l=1,r=l+i;l+i<=n;++l,++r)
        {
            f[l][r]=0x7fffff;
            for(int j=l;j<=r;++j)
            {
                
                f[l][r]=min(f[l][r],f[l][j]+f[j+1][r]+sum[r]-sum[l-1]);
            }
        }
    }
    printf("%d",f[1][n]);
    return 0;
 } 

然后就进阶了

题目描述

在一个圆形操场的四周摆放N堆石子,现要将石子有次序地合并成一堆.规定每次只能选相邻的2堆合并成新的一堆，并将新的一堆的石子数，记为该次合并的得分。

试设计出1个算法,计算出将N堆石子合并成1堆的最小得分和最大得分.

输入输出格式

输入格式：

数据的第1行试正整数N,1≤N≤100,表示有N堆石子.第2行有N个数,分别表示每堆石子的个数.

输出格式：

输出共2行,第1行为最小得分,第2行为最大得分.

输入输出样例

输入样例#1： 

4
4 5 9 4

输出样例#1： 

43
54

#include<cstdio>
#include<iostream>
using namespace std;
const int N=110;
int f[N*2][N*2],a[N*2],n,ff[N*2][N*2],sum[N*2];
int main()
{
  scanf("%d",&n);
  for(int i=1;i<=n;++i)
  {
    scanf("%d",&a[i]);
    a[i+n]=a[i];
  }
  for(int i=1;i<=n*2;++i)
  {
    sum[i]=sum[i-1]+a[i];
  }
  for(int i=1;i<=n*2;++i)
    for(int j=1;j<=n*2;++j)
      {
        if(i==j) continue;
        f[i][j]=-0x7ffffff;
        ff[i][j]=0x7ffffff;
      }
  for(int len=2;len<=n;++len)
  {
    for(int l=1;l<=n*2;++l)
    {
      int r=l+len-1;
      if(r>n*2) break;
      for(int k=l;k<r;++k)
      {
        f[l][r]=max(f[l][r],f[l][k]+f[k+1][r]+sum[r]-sum[l-1]);
        ff[l][r]=min(ff[l][r],ff[l][k]+ff[k+1][r]+sum[r]-sum[l-1]);
      }
    }
  }
/*  for(int i=1;i<=n*2;++i)
  {
    for(int j=i;j<=n*2;++j)
    {
      printf("%d %d %d
",i,j,f[i][j]);
    }
  }*/
  int ansmin=0x7fffff,ansmax=-0x7ffffff;
  for(int i=1;i<=n;++i)
  {
    ansmin=min(ansmin,ff[i][i+n-1]);
    ansmax=max(ansmax,f[i][i+n-1]);
  }
  printf("%d
%d",ansmin,ansmax);
  return 0;
}