C. Portal（dp优化二维前缀和)

https://codeforces.com/contest/1581/problem/C

正常的第一想法是：二维前缀和预处理+暴力。但是n是400过不去。

之前碰到一道利用最大子序和思想来优化的。这题类似。采用dp来优化。

枚举两行 ，再枚举1列。对列进行dp。

dp[k]：当前到k列的最小花费（注意这里是不包含第k列的）【后面解释】

f[k]=min(f[k−1]+加入第k行需要的修改次数，以i、j、k−3、k为边界的矩阵的修改次数)
每次用当前的f[k]+右边界需要的修改次数更新ans。

先解释下这个dp，由于是一个有至少大小的矩形，所以转移的时候考虑一下新形成的最小矩形，保证状态的正确性和完全性。

如果觉得不包含k影响理解，可以先看注释部分的代码。等下指出错误改正即可。

#include <bits/stdc++.h>
#define debug(a) cout<<#a<<"="<<a<<endl;
using namespace std;
const int maxn=420;
typedef int LL;
inline LL read(){LL x=0,f=1;char ch=getchar();	while (!isdigit(ch)){if (ch=='-') f=-1;ch=getchar();}while (isdigit(ch)){x=x*10+ch-48;ch=getchar();}
return x*f;}
LL dp[maxn],ma[maxn][maxn];
LL a[maxn][maxn],b[maxn][maxn];
LL find1(LL i,LL j,LL k){
   return  a[j][k]-a[i-1][k];
}
LL find0(LL i,LL j,LL k){
   return  b[j][k]-b[i-1][k];
}
int main(void){
   	cin.tie(0);std::ios::sync_with_stdio(false);
   	LL t;cin>>t;
   	while(t--){
        memset(a,0,sizeof(a));memset(b,0,sizeof(b));
        int n,m;cin>>n>>m;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                char c;cin>>c;
                ma[i][j]=c-'0';
                a[i][j]=a[i-1][j]+(ma[i][j]==1);
                b[i][j]=b[i-1][j]+(ma[i][j]==0);
            }
        }
        LL ans=INT_MAX;
        for(int i=1;i<=n;i++){
            for(int j=i+4;j<=n;j++){
                memset(dp,0x3f,sizeof(dp));
                ///这样定义的状态转移是不对的，比如第k-1列的代价要重算没法处理
//                for(int k=4;k<=m;k++){
//                    LL val=find0(i+1,j-1,k-3)+!ma[i][k-2]+!ma[i][k-1]+!ma[j][k-2]+!ma[j][k-1]+find1(i+1,j-1,k-2)+find1(i+1,j-1,k-1)+find0(i+1,j-1,k);
//                    dp[k]=min(val,dp[k-1]+find1(i+1,j-1,k-1)+!ma[i][k-1]+!ma[j][k-1]+find0(i+1,j-1,k));
//                    ans=min(ans,dp[k]);
//                }
                for(int k=4;k<=m;k++){
                    LL val=find0(i+1,j-1,k-3)+!ma[i][k-2]+!ma[i][k-1]+!ma[j][k-2]+!ma[j][k-1]+find1(i+1,j-1,k-2)+find1(i+1,j-1,k-1);
                    dp[k]=min(val,dp[k-1]+find1(i+1,j-1,k-1)+!ma[i][k-1]+!ma[j][k-1]);
                    ans=min(ans,dp[k]+find0(i+1,j-1,k));
                }
            }
        }
        cout<<ans<<endl;
   	}
   	return 0;
}

假如以第k列包含进来的dp状态。

若以dp[k]以dp[k-1]进行转移，则需要去掉k-1列被选定时花出的代价，再加回第k-1列变0的代价，再加上第k列变1的代价。

$dp[k]=min(val,dp[k-1]+find1(i+1,j-1,k-1)+!ma[i][k-1]+!ma[j][k-1]+find0(i+1,j-1,k));$

其中
$dp[k-1]=min(val1,dp[k-2]+find1(i+1,j-1,k-2)+!ma[i][k-2]+!ma[j][k-2]+find0(i+1,j-1,k-1));$

代入得
$dp[k]=min(val,val1,dp[k-2]+find1(i+1,j-1,k-2)+!ma[i][k-2]+!ma[j][k-2]+find0(i+1,j-1,k-1)+find1(i+1,j-1,k-1)+!ma[i][k-1]+!ma[j][k-1]+find0(i+1,j-1,k));$

• 可以看到我们对第k-1列即进行了找0又进行了找1.导致重复。

而我们想要的dp[k]应该是：
$dp[k]=min(val,val1,dp[k-2]+find1(i+1,j-1,k-2)+!ma[i][k-2]+!ma[j][k-2]+!ma[i][k-1]+!ma[j][k-1]+find0(i+1,j-1,k));$

但是上面的式子表明后面要有find0就会导致前面重复。

因此我们find0不在dp中加上。也就是改变dp的状态定义为不包含第k列的。计算答案时把单个的find0加上统计答案。