hdu5492 2015ACM合肥网赛题 最小方差路径 枚举+简单dp

题意

• 在一个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;
}