AtCoder Beginner Contest 283 E. Don‘t Isolate Elements(预支下一行状态的状压dp)

题目

孤立：若与a[i][j]四连通相邻的值，均与a[i][j]不同，则称a[i][j]这个位置是孤立的

n*m(2<=n,m<=1e3)的01矩阵，你可以执行以下操作若干次：

选中某一行，将这一行的01值翻转（即0变为1，1变为0）

求执行若干次操作后，没有任何位置是孤立的时候的最小操作次数

如果不能满足，输出-1

思路来源

SSRS、kimoyami代码

题解

E题1800，难度大于F，还巨难写，离大谱

感觉自己不妨将它称之为，预支下一行状态的状压dp

即第i行的合法，依赖于第i+1行的状态，但是第i+1状态只有0/1两个，

只考虑[1,i]行的时候把第i+1行的状态也压下来，就没有后效性了

dp[i][j][k]表示，考虑到第i行，前i-1行均合法时（即均不是孤立的），

第i-1行是否翻转，第i行是否翻转的最小操作次数

转移考虑枚举第i+1行是否翻转，作为代价

把当前的两行和之前的两行并在一起，形成三行，

考虑中间第i行是不是合法的，

当第i-1行、第i行、第i+1行翻不翻的状态都确定下来时，

第i行的合法性是唯一确定的，用第i+1行翻不翻作为代价转移

但是这样，当dp式算到第n行的时候，实际只是前n-1行均合法，

所以，需要多算一行dp式，相当于给原图又补了一行，

其中，这一行没有矛盾（即内部均合法），

且这行的值不能是01值（否则可能会影响到第n行的01的孤立性）

并且这一行无法翻转（其实翻转也可以，但是翻转会有1的代价，显然不是最优的）

这就把最后一行的情况，和之前的写法统一起来了，感觉也是dp的典中典写法

如果不加这最后一行，则需要最终校验一下dp状态，

根据第n行和第n-1行是否翻转，去check一下最后一行是不是合法的

感觉语言描述抽象且匮乏，还是不如实际看下代码

代码

#include<bits/stdc++.h>
using namespace std;
const int N=1e3+10,INF=0x3f3f3f3f;
//dp[i][j][k]:考虑到第i行，第i-1行翻/没翻，第i行翻/没翻的前i-1行均合法的最小操作次数
int n,m,a[N][N],dp[N][2][2];
int main(){
    cin>>n>>m;
    for(int i=1;i<=n;++i){
        for(int j=1;j<=m;++j){
            cin>>a[i][j];
        }
    }
    memset(dp,INF,sizeof dp);
    dp[1][0][0]=0;dp[1][0][1]=1;
    for(int i=1;i<=n;++i){
        for(int p=0;p<2;++p){//pre
            for(int c=0;c<2;++c){//cur
                for(int s=0;s<2;++s){//suf
                    bool ok=1;
                    for(int j=1;j<=m;++j){
                        bool ok2=0;
                        if(i-1>=1 && (a[i-1][j]^p)==(a[i][j]^c))ok2=1;
                        if(i+1<=n && (a[i+1][j]^s)==(a[i][j]^c))ok2=1;
                        if(j-1>=1 && (a[i][j-1]^c)==(a[i][j]^c))ok2=1;
                        if(j+1<=m && (a[i][j+1]^c)==(a[i][j]^c))ok2=1;
                        if(!ok2)ok=0;
                    }
                    if(ok)dp[i+1][c][s]=min(dp[i+1][c][s],dp[i][p][c]+s);
                }
            }
        }
    }
    int ans=min(dp[n+1][0][0],dp[n+1][1][0]);
    if(ans==INF)ans=-1;
    cout<<ans<<endl;
    return 0;
}