【枚举暴力】【UVA11464】 Even Parity

传送门

Description

　　给你一个0/1矩阵，可以将矩阵中的0变成1，问最少经过多少此操作使得矩阵任意一元素四周的元素和为偶数。

Input

　第一行是一个整数T代表数据组数，每组数据包含以下内容：

• 第一行是一个整数n，代表矩阵的行列数
• 接下来n行每行n个用空格隔开的整数，代表矩阵元素。

Output

　对于每组数据输出一行，格式为Case X： ans

Sample Input

Sample Output

Case :
Case :
Case : -

Hint

1≤n≤15,数据不超过30组。

Solution

考虑爆搜，显然超时。

考虑如果我们知道了前i行的信息，为了保证第i行是合法的，那么第i+1行放什么元素就被唯一确定了。

换句话说，只要确定了第一行的元素，通过数学归纳法易证，整个矩阵都被唯一确定了。

考虑第一行，只有2ⁿ种可能，由于n≤15，完全可以进行枚举。后面依据前面的元素进行判断，复杂度为O(n²)，合并复杂度上届为O(2ⁿn²)，已经可以通过本题。

通过一些简单的剪纸，程序可以跑的飞快，40ms在lg rk1。

Code

#include<cstdio>
#include<cstring>
#define rg register
#define ci const int

inline void qr(int &x) {
    char ch=getchar(),lst=NULL;
    while(ch>''||ch<'') lst=ch,ch=getchar();
    while(ch>=''&&ch<='') x=(x<<)+(x<<)+(ch^),ch=getchar();
    if (lst=='-') x=-x;
}

char buf[];
inline void write(int x,const char aft,const bool pt) {
    if(x<) {putchar('-');x=-x;}
    int top=;
    do {
        buf[++top]=x%+'';
        x/=;
    } while(x);
    while(top) putchar(buf[top--]);
    if(pt) putchar(aft);
}

template <typename T>
inline T mmax(const T &a,const T &b) {if(a>b) return a;return b;}
template <typename T>
inline T mmin(const T &a,const T &b) {if(a<b) return a;return b;}
template <typename T>
inline T mabs(const T &a) {if(a<) return -a;return a;}

template <typename T>
inline void mswap(T &a,T &b) {T temp=a;a=b;b=temp;}

const int maxn = ;
const int INF = 0x3f3f3f3f;

int t,n,cnt,ans;
int MU[maxn][maxn];
int pos[maxn][maxn];

void clear();
void dfs(ci,ci);
void check(ci);

int main() {
    qr(t);
    while(t--) {
        clear();qr(n);
        for(rg int i=;i<=n;++i) for(int j=;j<=n;++j) qr(MU[i][j]);
        dfs(,);
        if(ans==INF) ans=-;
        printf("Case %d: %d\n",++cnt,ans);
    }
    return ;
}

void clear() {
    memset(MU,,sizeof MU);
    memset(pos,,sizeof pos);
    n=;ans=INF;
}

void dfs(ci k,ci x) {
    if(x>=ans) return;
    if(k>n) {check(x);return;}
    if(!MU[][k]) {
        pos[][k]=;dfs(k+,x);
        pos[][k]=;dfs(k+,x+);
    }
    else {
        pos[][k]=;dfs(k+,x);
    }
}

void check(int x) {
    for(rg int i=;i<=n;++i) {
        rg int di=i-;rg int ddi=di-;
        for(rg int j=;j<=n;++j) {
            if((pos[di][j-]+pos[di][j+]+pos[ddi][j])&) pos[i][j]=;else pos[i][j]=;
            if(pos[i][j]!=MU[i][j]) {
                if(MU[i][j]) return;
                ++x;
                if(x>=ans) return;
            }
        }
    }
    for(rg int i=;i<=n;++i) {
        if((pos[n][i-]+pos[n][i+]+pos[n-][i])&) return;
    }
    ans=x;
}

Summary

在答案依附于一个初始状态，且初始状态数可以枚举时，不妨考虑枚举初始状态，凭借此计算出终态。

这样做不仅应用于搜索题，事实上也应用于一部分DP中。