「一题多解」【ARC 095E】Symmetric Grid

题目链接

【ARC 095E】Symmetric Grid

---

题目大意

给定一个字符方阵，每次可以任意交换两行或两列，求是否有一种方案，使得字符矩阵变得对称。对称的定义如下：
对于任意的$1\le i,j\le n$都有$s[i][j]==s[n+1-i][n+1-j]$

---

题解

首先，我们发现行和列的顺序都可以任意打乱，所以我们就可以将行和列分开考虑。

方法一：随机化+状态压缩动态规划（1877ms）
我们先考虑如果行的状态确定了，如何判断只交换列是否有可行方案。
考虑状态压缩动态规划。
令$b[x][y]$表示第$x$行和第$y$列是否对称，即$col[x]==reverse(col[y])$。
$dp[msk]$表示$msk$状态中的列是否可以两两匹配。
转移：$dp[msk|(1<<i)|(1<<j)]|=dp[msk]$&$b[i][j]$。
直接使用深度优先搜索来枚举行会超时，因为状态数是$n!$级别的。
我们考虑如何减少行的枚举量。
很简单，只需随机打乱行约$10^5$次即可。我们还需要一个高效的随机打乱函数，详见代码。

代码：

#include <ctime>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
using namespace std;
#define ui unsigned int
#define rui register ui
#define inl inline
#define rep(i,l,r) for(rui i=l,_=r;i<_;i++)
#define mxn 12
ui n,m,x,p[mxn];
bool f[1<<mxn],b[mxn][mxn];
char a[mxn][mxn];
inl ui rnd() {
    x^=x<<13;
    x^=x>>17;
    x^=x<<5;
    return x;
}
inl void rsh() {
    rep(i,1,n)
        swap(p[i],p[rnd()%i]);
}
int main() {
    srand(time(0));
    x=rand();
    scanf("%d%d",&n,&m);
    rep(i,0,n)  p[i]=i;
    rep(i,0,n)  scanf("%s",a[i]);
    ui y=CLOCKS_PER_SEC*15;
    while(clock()<<3<=y) {
        rsh();
        memset(b,1,sizeof(b));
        rep(i,0,m)  rep(j,i,m)  rep(k,0,n)
            if(a[p[k]][i]!=a[p[n-k-1]][j])
                b[i][j]=0;
        memset(f,0,sizeof(f));
        f[0]=1;
        rep(k,0,1<<m)   if(f[k])
            rep(i,0,m)  rep(j,i+1,m)
                if(!(1<<i&k)&&!(1<<j&k)&&b[i][j])
                    f[k|(1<<i)|(1<<j)]=1;
        bool chk=0;
        if(!(m&1))
            chk=f[(1<<m)-1];
        else    rep(i,0,m)
            chk|=f[(1<<m)-1-(1<<i)];
        if(chk) {
            puts("YES");
            return 0;
        }
    }
    puts("NO");
    return 0;
}

方法二：深度优先搜索+状态压缩动态规划（2ms）
刚才的随机化方法似乎没有优化余地，我们换一种思路。
考虑“对称”的性质：每一行和它的对应行必须由完全相同的字符构成。
于是，我们就可以利用此性质进行深度优先搜索。这样可以将搜索状态开根，此时的状态数量就比较容易接受了。

代码：

#include <cstdio>
#include <string>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#define mxn 15
using namespace std;
char s[mxn][mxn];
bool e[mxn][mxn],f[1<<mxn];
int n,m,p[mxn],a[mxn];
string t[mxn];
bool mirror(int l,int r) {
    for(int i=0;i<n;i++)
        if(s[i][l]!=s[p[i]][r])
            return 0;
    return 1;
}
void dpcol(bool b) {
    for(int i=0;i<m;i++)
        for(int j=i;j<m;j++)
            e[i][j]=mirror(i,j);
    memset(f,0,sizeof(f)),f[0]=1;
    for(int k=0;k<1<<m;k++) if(f[k])
        for(int i=0;i<m;i++)
            for(int j=i+1;j<m;j++)
                if(!(1<<i&k)&&!(1<<j&k)&&e[i][j])
                    f[k|(1<<i)|(1<<j)]=1;
    bool chk=0; if(!b)  chk=f[(1<<m)-1];
    else for(int i=0;i<m;i++)   chk|=e[i][i]&&f[(1<<m)-1-(1<<i)];
    if(chk) {   puts("YES");    exit(0);    }
}
void dfsrow(int d,bool b) {
    if(d==n) {  dpcol(m&1); return; }
    if(~p[d]) {    dfsrow(d+1,b);  return; }
    for(int i=d+1;i<n;i++)
        if(p[i]==-1&&t[d]==t[i]) {
            p[d]=i,p[i]=d;
            dfsrow(d+1,b);
            p[d]=-1,p[i]=-1;
        }
    if(b)   p[d]=d,dfsrow(d+1,0),p[d]=0;
}
int main() {
    memset(p,-1,sizeof(p));
    memset(a,-1,sizeof(a));
    scanf("%d%d",&n,&m);
    for(int i=0;i<n;i++) {
        scanf("%s",s[i]);
        for(int j=0;j<m;j++)
            t[i]+=s[i][j];
        sort(t[i].begin(),t[i].end());
    }
    dfsrow(0,n&1);
    puts("NO");
    return 0;
}

方法三：双重深度优先搜索（1ms）
既然枚举行都使用深度优先搜索了，那枚举列怎么不可以使用深度优先搜索呢？

代码：

#include <cstdio>
#include <string>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#define mxn 20
#define mxm 26
using namespace std;
char s[mxn][mxn];
int n,m,p[mxn],a[mxn];
string t[mxn];
bool mirror(int l,int r) {
    for(int i=0;i<n;i++)
        if(s[i][l]!=s[p[i]][r])
            return 0;
    return 1;
}
void dfscol(int d,bool b) {
    if(d==m) {  puts("YES");    exit(0);    }
    if(~a[d]) {    dfscol(d+1,b);  return; }
    for(int i=d+1;i<m;i++)
        if(a[i]==-1&&mirror(d,i)) {
            a[d]=i,a[i]=d;
            dfscol(d+1,b);
            a[d]=-1,a[i]=-1;
        }
    if(b&&mirror(d,d))  a[d]=d,dfscol(d+1,0),a[d]=0;
}
void dfsrow(int d,bool b) {
    if(d==n) {  dfscol(0,m&1);  return; }
    if(~p[d]) {    dfsrow(d+1,b);  return; }
    for(int i=d+1;i<n;i++)
        if(p[i]==-1&&t[d]==t[i]) {
            p[d]=i,p[i]=d;
            dfsrow(d+1,b);
            p[d]=-1,p[i]=-1;
        }
    if(b)   p[d]=d,dfsrow(d+1,0),p[d]=0;
}
int main() {
    memset(p,-1,sizeof(p));
    memset(a,-1,sizeof(a));
    scanf("%d%d",&n,&m);
    for(int i=0;i<n;i++) {
        scanf("%s",s[i]);
        for(int j=0;j<m;j++)
            t[i]+=s[i][j];
        sort(t[i].begin(),t[i].end());
    }
    dfsrow(0,n&1);
    puts("NO");
    return 0;
}

---

总结

遇到此类题目，要先分析题目和条件中蕴含的性质，往往就可以抓住题目的关键。