題意

• 在一個n*m矩陣中，每個位置有一個權值，尋找一條從左上角到右下角的路徑，使得(n+m-1)^2倍的方差最小
• n,m和每個位置權值都不超過30

思路

• 此題破題關鍵是對方差有一些瞭解
• 不難算出，n個數的方差=sum(x^2)/n + sum^2(x) / n^2
• 所以本題求解的就是n * sum(x^2) + sum^2(x)是一個整數
• 由於平均值很小，sum不會到1800，所以我們可以列舉sum值
• 每次，從左上角到右下角dp在當前sum值下的最小方差，然後更新一下ans，最後就是結果
• 比較容易困惑的是，列舉的sum值就是真的這條路徑的sum值嗎？對於每次列舉來說當然不一定，但是對與求出最小方差值的那次就一定是了。因為如果不是，那我們一定可以找到另一個sum值，還是走這條路，它的方差更小。
• 求dp過程中，我滾動陣列了，不然會超時。。

實現

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;

int n,m;
const int maxn = 35;
int a[maxn][maxn];
int dp[maxn];
int aa[maxn];
int sumTrue[maxn];
int max1;

int main(){
    int T;
    cin>>T;

    for
 
 (int t=1;t<=T;t++){
        scanf("%d%d",&n,&m);
        max1 = 0;
        for (int i=1;i<=n;i++){
            for (int j=1;j<=m;j++){
                scanf("%d",&a[i][j]);
                max1 = max(a[i][j],max1);
            }
        }
        int ans = 0x3f3f3f3f;

        int
 
 len = n+m-1; 
        for (int sum=0;sum<=max1*(n+m-1)+1;sum++){
            dp[1] = abs(len*a[1][1] - sum);
            dp[1] *= dp[1];
            aa[1] = a[1][1] * a[1][1];
            sumTrue[1] = a[1][1];

            for (int j=2;j<=m;j++){
                int tmp = abs(len*a[1][j] - sum);
                dp[j] = tmp * tmp + dp[j-1];
                aa[j] = aa[j-1] + a[1][j] * a[1][j];
                sumTrue[j] = sumTrue[j-1] + a[1][j]; 
            }
            for (int i=2;i<=n;i++){
                for (int j=1;j<=m;j++){
                    int tmp = abs(len*a[i][j] - sum);
                    int y = j-1;
                    if (y < 1 || dp[j] <= dp[y]){
                        dp[j] += tmp*tmp;
                        aa[j] += a[i][j] * a[i][j];
                        sumTrue[j] +=  a[i][j];
                    }
                    else{
                        dp[j] = dp[j-1] + tmp*tmp;
                        aa[j] = aa[j-1] +  a[i][j] * a[i][j];
                        sumTrue[j] =  sumTrue[j-1] + a[i][j];
                    }
                }
            }
            ans = min(ans, len* aa[m] - sumTrue[m] * sumTrue[m]);
        }
        printf("Case #%d: %d\n",t,ans);
    }
    return 0;
}