BZOJ3855: Light

一开始有些灯是灭的有些灯是亮的，每次选一个位置，翻转他四个相邻的灯的状态，他的状态可翻可不翻

轮廓线dp
有一个朴素的四进制状态，代表每个位置是否是亮的及操作次数的奇偶
但是4^n*n^2会T
考虑减少状态
注意到当前位置上一行的对应位置，如果是亮的，当前位置一定要操作，而一次操作之后不管上一行是否会翻转当前位置，因为操作时中心格可翻可不翻，他的两种状态都能够到达，所以当一个位置是亮的时候没有必要记录他翻转的奇偶性，就变成了三进制状态
注意这种限制关系仅限于不同行之间，还要加一维0/1状态表示当前轮廓线左边的格子翻转的奇偶性

n< m时交换一下，因为这题的多组数据很鬼畜..有好像1千组…..不注意一些细节优化很容易T….

code：

#include<set>
#include<map>
#include<deque>
#include<queue>
#include<stack>
#include<cmath>
#include<ctime>
#include<bitset>
#include<string>
#include<vector>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<climits>
#include<complex>
#include<iostream>
#include<algorithm>
#define ll long long
using namespace std;

const int maxn = 15;
const int mask = 61000;
inline void down(int &a,const int &b){if(a==-1||a>b)a=b;}

int pw[maxn];
int G(int x,int i) { return (x/pw[i-1])%3; }

int n,m,now,al;
char str[maxn];
int v[maxn][maxn];
int v2[maxn][maxn];

int f[2][mask][2];
int to[2],tol[3][2];

void clear(){ for(int i=0;i<al;i++) f[now][i][0]=f[now][i][1]=-1; }
int dp()
{
    al=1; for(int i=1;i<=m;i++) al*=3;

    clear();
    now=!now; clear(); f[now][0][0]=0;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            now=!now;
            for(int k=0;k<al;k++) for(int l=0;l<2;l++) if(f[!now][k][l]!=-1)
            {
                int &temp=f[!now][k][l];

                int las=G(k,j),tmp=k-las*pw[j-1];
                int l0=j>=2?G(tmp,j-1):0,l1=tol[l0][l];
                if(i==1||las!=2)
                {
                    int cc=v[i][j]^las^(l&(j>1));
                    int cc0=to[cc],cc1=to[!cc];
                    down(f[now][tmp+cc0*pw[j-1]][0],temp);
                    down(f[now][tmp+cc1*pw[j-1]][0],temp+2);
                    if(i==1)
                    {
                        int use=tmp+(j==1?0:(l1-l0)*pw[j-2]);
                        down(f[now][use+1*pw[j-1]][1],temp+1);
                        down(f[now][use+2*pw[j-1]][1],temp+1);
                    }
                }
                else
                {
                    int use=tmp+(j==1?0:(l1-l0)*pw[j-2]);
                    down(f[now][use+1*pw[j-1]][1],temp+1);
                    down(f[now][use+2*pw[j-1]][1],temp+1);
                }
                temp=-1;
            }
        }
    }
    int ans=-1;
    for(int i=0;i<al;i++) for(int l=0;l<2;l++) if(f[now][i][l]!=-1)
    {
        for(int j=1;j<=m;j++) if(G(i,j)==2) { f[now][i][l]=-1;break; }
        if(f[now][i][l]!=-1) down(ans,f[now][i][l]);
    }
    return ans;
}

int main()
{
    pw[0]=1;for(int i=1;i<maxn;i++) pw[i]=pw[i-1]*3;
    tol[0][0]=tol[1][1]=2,tol[2][0]=0,tol[2][1]=1;
    to[0]=2,to[1]=0;

    int tcase=0;
    while(scanf("%d%d",&n,&m)!=EOF&&n&&m)
    {
        for(int i=1;i<=n;i++)
        {
            scanf("%s",str+1);
            for(int j=1;j<=m;j++) v[i][j]=!(str[j]-'0');
        }
        if(n<m)
        {
            for(int i=1;i<=m;i++) for(int j=1;j<=n;j++)
                v2[i][j]=v[j][m-i+1];
            swap(n,m);
            for(int i=1;i<=n;i++) for(int j=1;j<=m;j++) v[i][j]=v2[i][j];
        }
        printf("Case #%d: %d\n",++tcase,dp());
    }

    return 0;
}