NYOJ737石子合并&NKOJ 圆形操场

NYOJ737石子合并

状态:dp[i][j] 表示i..j堆石子合并成一堆，所需最小力气值

状态转移方程:dp[i][j]=min(dp[i][j-k]+dp[j-k+1][j])  +sum[i][j]条件:j-k>=i,k>=0

求解：dp[1][n]

#include<stdio.h>
#define M 201
#define INF 1000000000
int n,f[M][M],sum[M][M],stone[M];
int main()
{
	int i,j,k,t;
	while(~scanf("%d",&n))
    {
	for(i=1;i<=n;i++)
		scanf("%d",&stone[i]);

	for(i=1;i<=n;i++)
	{
		f[i][i]=0;
		sum[i][i]=stone[i];
		for(j=i+1;j<=n;j++)
			sum[i][j]=sum[i][j-1]+stone[j];
	}

	for(int len=2;len<=n;len++)//归并的石子长度
	{
		for(i=1;i<=n-len+1;i++)//i为起点，j为终点
		{
			j=i+len-1;
			f[i][j]=INF;
			for(k=i;k<=j-1;k++)//分割点
			{
				if(f[i][j]>f[i][k]+f[k+1][j]+sum[i][j])
					f[i][j]=f[i][k]+f[k+1][j]+sum[i][j];
			}
		}
	}
	printf("%d\n",f[1][n]);
    }
	return 0;
}

NKOJ 圆形操场

法一：

在一个圆形操场的四周摆放着n 堆石子。现要将石子有次序地合并成一堆。规

定每次只能选相邻的2 堆石子合并成新的一堆，并将新的一堆石子数记为该次合并的得分。试设计一个算法，计算出将n堆石子合并成一堆的最小得分和最大得分。

编程任务：
对于给定n堆石子,编程计算合并成一堆的最小得分和最大得分。

DP：因为石子绕成一个环，不是一条直线，所以dp[i][j]的含义应为从第i堆开始，合并j堆石子能得到的最优值

则易得状态转移方程为

dp1[i][j]=better(dp1[i][j],dp1[i][k]+dp1[(i+k-1)%n+1][j-k]+sum[i][j]);

#include<stdio.h>
#include<string.h>
const int INF = 1000000000;
#define M 110
int dp1[M][M],dp2[M][M];
int sum[M][M];
int num[M];
int min(int a,int b)
{
    return a<b?a:b;
}
int max(int a,int b)
{
    return a>b?a:b;
}
int main()
{
    int  n,i,j,k;
    while(scanf("%d",&n)!=EOF)
    {
        for(i=1;i<=n;i++) 
            scanf("%d",&num[i]);
        for(i=1;i<=n;i++)
            sum[i][1]=num[i];
        for(j=2;j<=n;j++)
            for(i=1;i<=n;i++)
                sum[i][j]=sum[i%n+1][j-1]+num[i];
            for(i=0;i<=n;i++)
                dp1[i][1]=dp2[i][1]=0;
            for(j=2;j<=n;j++)
            {
                for(i=1;i<=n;i++)
                {
                    dp1[i][j]=0;
                    dp2[i][j]=INF;
                    for(k=1;k<j;k++)
                    {
                        dp1[i][j]=max(dp1[i][j],dp1[i][k]+dp1[(i+k-1)%n+1][j-k]+sum[i][j]);
                        dp2[i][j]=min(dp2[i][j],dp2[i][k]+dp2[(i+k-1)%n+1][j-k]+sum[i][j]);
                    }
                }
            }
            int ansmi=INF,ansmx=0;
            for(i=1;i<=n;i++)
            {
                ansmx=max(ansmx,dp1[i][n]);
                ansmi=min(ansmi,dp2[i][n]);
            }
            printf("%d\n%d\n",ansmi,ansmx);
    }
    return 0;
}

法二：转

这道题有一个要注意的地方，那就是红字标注的圆形操场。因为石堆是圆形的，所以有n种合并方式，需要增加一层循环来依次枚举起始堆。这样，会大大增加时间复杂度。

解题思路是动态规划，不经优化的动态规划的时间复杂度是O(n^3)，如果再套一层循环，那么肯定会TLE。

因此需要进行优化。

首先可以构造如下的数组：

a[0],a[1],...,a[n-1],a[n],a[n+1],...,a[2n-2]

即：

a[0],a[1],...,a[n-1],a[0],a[1],...,a[n-2]

这样，经过一次DP就可以算出最值，从而去掉了循环，降低了一个维度。

对于DP，最小值可以用四边形不等式优化。注意：求最大值不能用四边形不等式，因为最大值不满足单调性，但最大值有一个性质，即总是在两个端点的最大者中取到。

即max[i][j] = max{max[i][j-1],max[i+1][j]| + sum[i][j] (sum[i][j]是第i堆到第j堆的石子总数)

经过优化，算法复杂度可以减少至O(n^2)。

#include 
#define MAXN 200
#define MAX_INT 0x7fffffff;
#define MIN_INT 0xffffffff;
int sum[MAXN][MAXN];
int s[MAXN][MAXN];      //最小值决策量s
int max[MAXN][MAXN];
int min[MAXN][MAXN];
int mmin,mmax;
void MergeStone(int n)
{
    int i,j,k,r; //r表示间距
    mmin = MAX_INT;
    mmax = MIN_INT;
    for(r = 2; r <= n; r++) //计算第i堆到第j堆的总石子数 间距到n为止
    {
        for (i = 0; i < 2*n-r; i++)
        {
            j = i + r - 1;
            sum[i][j] = sum[i][j-1] + sum[j][j];
            min[i][j]  = MAX_INT;
            for (k = s[i][j-1]; k <= s[i+1][j]; k++)
            {
                int t = min[i][k] + min[k+1][j] + sum[i][j];
                if (t
                {
                    min[i][j] = t;
                    s[i][j] = k;
                }
            }
            if (max[i][j-1] > max[i+1][j])
                max[i][j] = max[i][j-1] + sum[i][j];
            else
                max[i][j] = max[i+1][j] + sum[i][j];
            if (i == (j+1)%n)
            {
                if(max[i][j] > mmax)
                    mmax = max[i][j];
                if(min[i][j] < mmin)
                    mmin = min[i][j];
            }
        }
    }
}
int main()
{
    int n,i;
    while(scanf("%d",&n) && n)
    {
        mmax = 0;
        mmin = 0;
        for(i=0; i
        {
            scanf("%d",&sum[i][i]);
            min[i][i] = 0;
            max[i][i] = 0;
            s[i][i] = i;
        }
        for(i=n; i<2*n-1; i++)
        {
            min[i][i] = 0;
            max[i][i] = 0;
            s[i][i] = i;
            sum[i][i] = sum[i%n][i%n];
        }
        if (n>1)
            MergeStone(n);
        printf("%d %d\n",mmin,mmax);
    }
    return 0;
}