hdu2517棋盘分割

   先对均方差的公式化简，可发现只需求出sum（x[i]^2)的最小值，其中x[i]为一个矩形棋盘的总分。

很容易就想到动态规划了，dp[x1][y1][x2][y2][k]表示一个左上坐标为(x1,y1),右下坐标为（x2,y2)的矩形棋盘切割k次得到的最小sum（x[i]^2),则状态转移很明显，对于一个给定的矩形棋盘，只有两种切割方式，要么横切，要么纵切。

转态转移方程：

dp[x1][y1][x2][y2][k]=min(

                         min(dp[x1][y1][a][y2][k-1]+s(a+1,y1,x2,y2),dp[a+1][y1][x2][y2][k-1]+s(x1,y1,a,y2)),

                         min(dp[x1][y1][x2][b][k-1]+s(x1,b+1,x2,y2),dp[x1][b+1][x2][y2][k-1]+s(x1,y1,x2,b))

                     )    其中 x1<=a<x2, y1<=b<y2, s(x1,y1,x2,y2)为矩形棋盘的总分

时间复杂度为kn^4,但该题的数据范围很小，因此该算法非常快，下面直接贴代码了。

 

#include<iostream>
#include<cstdio>
#include<cmath>
using namespace std;

int map[8][8],n;
int dp[10][10][10][10][10];
int s[10][10][10][10];

inline int min(int a,int b)
{
	return a<b?a:b;
}

int squre_sum(int i,int j,int k,int t)
{
	if(s[i][j][k][t]!=-1)
		return s[i][j][k][t];
	if(i>k||j>t)
		return 0;
	int ans=0;
	for(int x=i;x<=k;x++)
		for(int y=j;y<=t;y++)
			ans+=map[x][y];
	return s[i][j][k][t]=ans*ans;
}

int dfs(int x1,int y1,int x2,int y2,int k)
{
	if(dp[x1][y1][x2][y2][k]!=-1)
		return dp[x1][y1][x2][y2][k];
	if(x1>x2||y1>y2)
		return 0;
	if(k==0)
		return squre_sum(x1,y1,x2,y2);
	dp[x1][y1][x2][y2][k]=7000;
	for(int a=x1;a<x2;a++)
		dp[x1][y1][x2][y2][k]=min(dp[x1][y1][x2][y2][k],min(dfs(a+1,y1,x2,y2,k-1)+squre_sum(x1,y1,a,y2),dfs(x1,y1,a,y2,k-1)+squre_sum(a+1,y1,x2,y2)));
	for(int b=y1;b<y2;b++)
		dp[x1][y1][x2][y2][k]=min(dp[x1][y1][x2][y2][k],min(dfs(x1,b+1,x2,y2,k-1)+squre_sum(x1,y1,x2,b),dfs(x1,y1,x2,b,k-1)+squre_sum(x1,b+1,x2,y2)));
	return dp[x1][y1][x2][y2][k];
}

int main()
{
	double ans;
	while(scanf("%d",&n)!=EOF)
	{
		for(int i=0;i<8;i++)
			for(int j=0;j<8;j++)
				scanf("%d",&map[i][j]);
		memset(dp,-1,sizeof(dp));
		memset(s,-1,sizeof(s));
		dfs(0,0,7,7,n-1);
		ans=sqrt((double)dp[0][0][7][7][n-1]/n-(double)squre_sum(0,0,7,7)/(n*n));
		printf("%.3lf\n",ans);
	}
	return 0;
}