一探再探石子合并（ NYOJ 737）

石子合并

题目

Time Limit:1000MS Memory Limit:131072KB

• Description

现在有n堆石子，第i堆有ai个石子。现在要把这些石子合并成一堆，每次只能合并相邻两个，每次合并的代价是两堆石子的总石子数。求合并所有石子的最小代价。

• Input

第一行包含一个整数T（T<=50），表示数据组数。
每组数据第一行包含一个整数n（2<=n<=100），表示石子的堆数。
第二行包含n个正整数ai（ai<=100），表示每堆石子的石子数。

• Output

每组数据仅一行，表示最小合并代价。

• Sample Input

2
4
1 2 3 4
5
3 5 2 1 4

• Sample Output

19
33

分析

本题题意很简单，属于经典DP问题石子合并问题中的单线性合并。采用区间DP思想很容易得出，注意dp数组自身的初始化。
耗时：148ms
代码如下：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
int a[105];
int dp[105][105];
int sum[105];
const int M = 100000000;
int main()
{
    int T, n;
    scanf("%d", &T);
    while(T--)
    {
        scanf("%d", &n);
        sum[0] = 0;
        for(int i=1;i<=n;i++)
        {
            scanf("%d", a+i);
            sum[i] = sum[i-1] + a[i];

        }
        for(int l=2;l<=n;l++)
            for(int i=1;i<=n-l+1;i++)
            {
                int j = i+l-1;
                dp[i][j] = M;
                for(int k=i;k<j;k++)
                    dp[i][j] = min(dp[i][j], dp[i][k] + dp[k+1][j] + sum[j]- sum[i-1]);
            }
        printf("%d\n", dp[1][n]);
    }
    return 0;
}

显然三层循环使得时间复杂度为O(N^3),根据四边形不等式的优化，可将时间复杂度降为O（N^2）关键在于s[i][j-1]<=s[i][j]<=s[i+1][j]的运用，此处链接：定理证明
耗时：16ms
代码如下：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
int a[105];
int dp[105][105];
int s[105][105];
int sum[105];
const int M = 100000000;
int main()
{
    int T, n;
    scanf("%d", &T);
    while(T--)
    {
        scanf("%d", &n);
        sum[0] = 0;
        for(int i=1;i<=n;i++)
        {
            scanf("%d", a+i);
            sum[i] = sum[i-1] + a[i];
            dp[i][i] = 0;
            s[i][i] = i;
        }
        for(int l=2;l<=n;l++)
            for(int i=1;i<=n-l+1;i++)
            {
                int j = i+l-1;
                dp[i][j] = M;
                for(int k=s[i][j-1];k<=s[i+1][j];k++)
                    if(dp[i][j] > dp[i][k] + dp[k+1][j] + sum[j]- sum[i-1])
                    {
                        dp[i][j] = dp[i][k] + dp[k+1][j] + sum[j]- sum[i-1];
                        s[i][j] = k;
                    }
            }
        printf("%d\n", dp[1][n]);
    }
    return 0;
}

经过进一步探究发现，本题的时间复杂度可以再进一步优化为O(nlogn)，其中涉及到了GarsiaWachs算法（证明详见TAOCP，麻麻问我为什么跪着敲代码……）
基本思想是通过树的最优性得到一个节点间深度的约束，之后证明操作一次之后的解可以和原来的解一一对应，并保证节点移动之后他所在的深度不会改变。
耗时：0ms
代码如下：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
int a[105];
const int M = 100000000;
int main()
{
    int T, n;
    int ans, temp;
    scanf("%d", &T);
    while(T--)
    {
        scanf("%d", &n);
        for(int i=1;i<=n;i++)
            scanf("%d", a+i);
        a[0] = a[n+1] = M;
        ans = 0;
        while(n >= 2)
        {
            int i, j;
            for(i = 2; i <= n; i++)
                if(a[i-1] < a[i+1])
                    break;
            temp = a[i-1] + a[i];
            ans += temp;
            for(j = i-1; j && temp > a[j-1]; j--)
                a[j] = a[j-1];
            a[j] = temp;
            for(j = i; j <= n; j++)
                a[j] = a[j+1];
            n--;
        }
        printf("%d\n",ans);
    }
    return 0;
}