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

最新推荐文章于 2025-07-05 10:12:23 发布

原创最新推荐文章于 2025-07-05 10:12:23 发布 · 574 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#AtCoder #AtCoderRegularContest

状态压缩动态规划同时被 3 个专栏收录

5 篇文章

订阅专栏

随机化

2 篇文章

订阅专栏

深度优先搜索

1 篇文章

订阅专栏

本文探讨了一种给定字符方阵通过行或列互换来实现矩阵对称的问题，提出了三种解决方案，包括随机化+状态压缩动态规划、深度优先搜索+状态压缩动态规划以及双重深度优先搜索，每种方法都有详细的步骤解析及代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目链接

【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;
}