POJ 1191 && HDU 2517 棋盘分割（dp）

Description
将一个８*８的棋盘进行如下分割：将原棋盘割下一块矩形棋盘并使剩下部分也是矩形，再将剩下的部分继续如此分割，这样割了(n-1)次后，连同最后剩下的矩形棋盘共有n块矩形棋盘。(每次切割都只能沿着棋盘格子的边进行)

原棋盘上每一格有一个分值，一块矩形棋盘的总分为其所含各格分值之和。现在需要把棋盘按上述规则分割成n块矩形棋盘，并使各矩形棋盘总分的均方差最小。
均方差，其中平均值，xi为第i块矩形棋盘的总分。
请编程对给出的棋盘及n，求出O’的最小值。
Input
第1行为一个整数n(1 < n < 15)。
第2行至第9行每行为8个小于100的非负整数，表示棋盘上相应格子的分值。每行相邻两数之间用一个空格分隔。
Output
仅一个数，为O’（四舍五入精确到小数点后三位）。
Sample Input
3
1 1 1 1 1 1 1 3
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 0
1 1 1 1 1 1 0 3
Sample Output
1.633
Solution
dp+记忆化搜索
先将均方差公式变形：

由于均值一定，故只需使每个矩阵的总分的平方和最小即可
题目固定是8*8，用标号来表示矩形，对于最小的小方格，用(i,j)表示，即第i行第j列的小方格，注意不是点的坐标。所以对于一个矩形，我们用它左上角的小方格和右下角的小方格来表示。例如，整个棋盘就是(1,1,8,8)
按题目要求，每次分割出一个矩形后，剩下的也必须是矩形，那么其实每次分割只能切一刀，如果是切两刀得到的矩形，那么剩下的就不会是矩形了，所以只能横着切或者竖着切，而且一切的话要从头切到底（这很容易理解）
一刀切下去会得到两个矩形，选一个为本次切割得到的，以后只能切另一个，选出来的那个以后不能再切了
动态转移方程，大矩形dp值由小矩形dp值推得来，还要加上次数，dp[n][x1][y1][x2][y2]就是要令当前矩形分出n个小矩形，也就是切割n-1刀
我们要的目标值就是dp[n][1][1][8][8]
一：横着切，当前矩形将会分成上下两份
1.选上面：dp[k][x1][y1][x2][y2]=s[x1][y1][x][y2]+dp[k-1][x+1][y1][x2][y2];
2.选下面：dp[k][x1][y1][x2][y2]=s[x+1][y1][x2][y2]+dp[k-1][x1][y1][x][y2];（x1<=x<=x2）
二：竖着切，当前矩形将会分成左右两份
1.选左边：dp[k][x1][y1][x2][y2]=s[x1][y1][x2][y]+dp[k-1][x1][y+1][x2][y2];
2.选右边：dp[k][x1][y1][x2][y2]=s[x1][y+1][x2][y2]+dp[k-1][x1][y1][x2][y];（y1<=y<=y2）
显然这个DP用记忆化搜索来做更合适
注意：
1.dp数组全部初始化为-1，表示还没被计算，
2.dp[1][x1][y1][x2][y2]=s[x1][y1][x2][y2]，就是不用切的时候的dp值
3.若当前要求的是dp[k][x1][y1][x2][y2]，则一开始要赋初值为INF，再开始枚举切割方案，因为对于dp[k][x1][y1][x2][y2]，要分出k块矩形，但是不一定能分得到，可能根本不够分，所以当前状态如果分不出k个小矩形的话，这个状态是一个不可能的状态，为INF,整个枚举过程中它的值也不会更新
Code

#include<cstdio>
#include<cstring>
#include<cmath>
using namespace std;
#define min(a,b)  a<b?a:b
#define INF 0x3f3f3f3f
#define maxn 20
int dp[maxn][10][10][10][10];
int s[10][10][10][10];
int c[10][10];
int add(int x1,int y1,int x2,int y2)//计算一个矩形的总分 
{
    int res=0;
    for(int i=x1;i<=x2;i++)
        for(int j=y1;j<=y2;j++)
            res+=c[i][j];
    return res;
}
int dfs(int k,int x1,int y1,int x2,int y2)
{
    if(dp[k][x1][y1][x2][y2]!=-1)
        return dp[k][x1][y1][x2][y2];
    dp[k][x1][y1][x2][y2]=INF;
    if(x2>x1)//至少有两行才能横着切 
        //1.选上面:dp[k][x1][y1][x2][y2]=s[x1][y1][x][y2]+dp[k-1][x+1][y1][x2][y2];
        //2.选下面:dp[k][x1][y1][x2][y2]=s[x+1][y1][x2][y2]+dp[k-1][x1][y1][x][y2];
        for(int x=x1;x<x2;x++)
        {
            int t1=dfs(k-1,x+1,y1,x2,y2);//取上面则递归计算下面 
            int t2=dfs(k-1,x1,y1,x,y2);//取下面则递归计算上面 
            int t=min(t1+s[x1][y1][x][y2],t2+s[x+1][y1][x2][y2]);
            dp[k][x1][y1][x2][y2]=min(dp[k][x1][y1][x2][y2],t);
        }
    if(y2>y1)//至少有两列才能竖着切 
        //1.选左边:dp[k][x1][y1][x2][y2]=s[x1][y1][x2][y]+dp[k-1][x1][y+1][x2][y2];
        //2.选右边:dp[k][x1][y1][x2][y2]=s[x1][y+1][x2][y2]+dp[k-1][x1][y1][x2][y];
        for(int y=y1;y<y2;y++)
        {
            int t1=dfs(k-1,x1,y+1,x2,y2);//取左边则递归计算右边 
            int t2=dfs(k-1,x1,y1,x2,y);//取右边则递归计算左边 
            int t=min(t1+s[x1][y1][x2][y],t2+s[x1][y+1][x2][y2]);
            dp[k][x1][y1][x2][y2]=min(dp[k][x1][y1][x2][y2],t);
        }   
    return dp[k][x1][y1][x2][y2];
}
int main()
{
    int x1,x2,y1,y2,n;
    scanf("%d",&n);
    for(int i=1;i<=8;i++)
        for(int j=1;j<=8;j++)
            scanf("%d",&c[i][j]);
    memset(dp,-1,sizeof(dp));//初始化 
    for(x1=1;x1<=8;x1++)//初始化 
        for(x2=x1;x2<=8;x2++)
            for(y1=1;y1<=8;y1++)
                for(y2=y1;y2<=8;y2++)
                {
                    int temp=add(x1,y1,x2,y2);
                    dp[1][x1][y1][x2][y2]=s[x1][y1][x2][y2]=temp*temp;
                }
    dfs(n,1,1,8,8);
    double X,ans;
    X=1.0*add(1,1,8,8);//X即为每个矩形总分的最小平方和 
    X=(X/n)*(X/n);
    ans=sqrt(1.0*dp[n][1][1][8][8]/n-X);//计算方均差 
    printf("%.3f\n",ans);
    return 0;
}