区间dp，分割棋盘

#include <bits/stdc++.h>
using namespace std;

const int N = 10,M = 16;
const double INF = 1e9;
int s[N][N],n;

double X;

double get_s(int rup,int rdown,int cl, int cr){
    double x = s[rdown][cr] - s[rdown][cl-1] - s[rup-1][cr] + s[rup-1][cl-1] - X;
    return (double)x*x/n;
}


double f[N][N][N][N][M];

int main(){
    scanf("%d",&n);
    for(int i = 1; i <= 8; ++i){
        for(int j =  1; j <= 8; ++j){
            scanf("%d",&s[i][j]);
            s[i][j] += s[i-1][j] + s[i][j-1] - s[i-1][j-1];
        }
    }
    X  = (double)s[8][8] / n;

    for(int k = 0; k < n; ++k){
        for(int lenr = 1; lenr <= 8; ++lenr){
            for(int rup = 1; rup +lenr-1 <= 8; rup++){
                int rdown = rup + lenr - 1;
                for(int lenc = 1; lenc <= 8; ++lenc){
                    for(int cl = 1; cl + lenc - 1 <= 8; ++cl){
                        int cr = cl + lenc - 1;
                       
                            if(k == 0){
                                f[rup][rdown][cl][cr][k] = get_s(rup,rdown,cl,cr);
                            }
                            else{
                                f[rup][rdown][cl][cr][k] = INF;
                                for(int kr = rup; kr < rdown;kr++){
                                    f[rup][rdown][cl][cr][k] = min(f[rup][rdown][cl][cr][k],f[rup][kr][cl][cr][k-1]+get_s(kr+1,rdown,cl,cr));
                                    f[rup][rdown][cl][cr][k] = min(f[rup][rdown][cl][cr][k],f[kr+1][rdown][cl][cr][k-1]+get_s(rup,kr,cl,cr));
                                }
                                for(int kc = cl; kc < cr; kc++){
                                    f[rup][rdown][cl][cr][k] = min(f[rup][rdown][cl][cr][k],f[rup][rdown][cl][kc][k-1]+get_s(rup,rdown,kc+1,cr));
                                    f[rup][rdown][cl][cr][k] = min(f[rup][rdown][cl][cr][k],f[rup][rdown][kc+1][cr][k-1]+get_s(rup,rdown,cl,kc));
                                }
                                
                            }
                        
                    }
                }
            }
        }
    }
    printf("%.3lf",sqrt(f[1][8][1][8][n-1]));
    return 0;
}

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
// 记忆化搜索

const int N = 10,M = 16;
int K;
double f[N][N][N][N][M];
double X;
int s[N][N];

double get(int up,int down, int l, int r){
    double x = s[down][r] - s[down][l-1] - s[up-1][r] + s[up-1][l-1] - X;
    return x * x;
}

double dp(int k,int up, int down,int l, int r){
    if(k == 0)return get(up,down,l,r);
    if(f[up][down][l][r][k] > -1)return f[up][down][l][r][k];
    f[up][down][l][r][k] = 2e9;
    for(int i = up; i < down; ++i){
        f[up][down][l][r][k] = min(f[up][down][l][r][k],dp(k-1,up,i,l,r)+get(i+1,down,l,r));
        f[up][down][l][r][k] = min(f[up][down][l][r][k],dp(k-1,i+1,down,l,r)+get(up,i,l,r));
    }
    for(int i = l; i < r;++i){
        f[up][down][l][r][k] = min(f[up][down][l][r][k],dp(k-1,up,down,l,i)+get(up,down,i+1,r));
        f[up][down][l][r][k] = min(f[up][down][l][r][k],dp(k-1,up,down,i+1,r)+get(up,down,l,i));
        
    }
    return f[up][down][l][r][k];
}

int main(){
    scanf("%d",&K);
    for(int i = 1; i <= 8; ++i){
        for(int j = 1; j <= 8; ++j){
            scanf("%d",&s[i][j]);
            s[i][j] += s[i-1][j] + s[i][j-1] - s[i-1][j-1];
        }
    }
    X = (double)s[8][8] / K;
    memset(f,-1,sizeof(f));
    printf("%.3lf",sqrt(dp(K-1,1,8,1,8)/K));
    return 0;
}