yasuo👀️

此题难点在于void xz(旋转)

1.为了方便在函数内修改a,因此我们将a设为全局变量

2.设数位对应的四个坐标,n=3 格式: x,y(xi)

0,0(x1) 0,2(x4)

2,0(x2) 2,2(x3)

观察下来:

下一行的解释,先别看---(为什么n-1-x1(x)呢 0-2,我们都知道有0,1,2三个,但我们从0加到2,只有2(1,2),因此,以最高点2-x1(x),就可得知x2(x))

x1到x2, x2(x,y) = n-1-x1(x),x1(y)

x2到x3, x3(x,y)= x2(x),n-1-x2(y)

x3到x4, x4(x,y)= n-1-x1(x),x3(y)

x4到x1, x1(x,y)= x4(x),n-1-x3(y)

现在你看到相同之处了吧 n-1-xi(x/y)

同时

x1到x2, x2(y)=x1(x/y)

x2到x3, x3(x)=x2(x)

x3到x4, x4(y)=x3(x/y)

x4到x1, x1(x)=x4(x)

现在你看到相同之处了吧 xi(x)

(因为y在有的坐标中没有,所以舍弃y,因此可以说xi+1(x/y)=xi(x),代码上是a[q-1-j][i]中的a[i]而不是a[j]你最好把i看成x;j看成y)

再看我标斜体的地方y(2,0) x(2,2) y(0,2) x(0,0)

因此我们可以不管x因为[n-1-y]==[x](正反都是一样的既可以(x,y)a[x][q-1-y]也可以(y,x)a[q-1-y][x])

从而只需去符合y的格式a[q-1-y][x]

x2(2,0) = n-1-x1(x),x1(y)

x4(0,2)= n-1-x1(x),x3(y)

(2,0) (0,2) 不同,所以是y,要去符合它的格式

所以代码可以转化为a[q-1-y][x]

3.因为a[i][j]=a[q-1-j][i];会把当前的a[i][j]覆盖掉,因此我们用t[i][j]=a[q-1-j][i];,这样可以确保a[i][j]不会改动

希望对你有所帮助😄 累死我了

#include <iostream>
int q,a[15][15],t[15][15],z[15][15];
int same(){
    for(int i=0;i<q;i++) for(int j=0;j<q;j++) if(a[i][j]!=z[i][j]) return 0;
    return 1;}
void xz(){
    for (int i=0;i<q;i++) for(int j=0;j<q;j++) t[i][j]=a[q-1-j][i];
    for (int i=0;i<q;i++) for (int j=0;j<q;j++) a[i][j]=t[i][j];}
int main(){
    std::cin>>q;
    for(int i=0;i<q;i++) for(int j=0;j<q;j++) std::cin>>a[i][j];
    for(int i=0;i<q;i++) for(int j=0;j<q;j++) std::cin>>z[i][j];
    for(int z=0;z<4;z++){xz();if(same()){std::cout<<"Yes";return 0;}}
    std::cout<<"No";return 0;}

解析：

一个矩阵一共能旋转四次，回到原来的位置，那么求两个矩阵能不能通过旋转重合，只要对其中一个矩阵旋转4次，不能和另一个相同，说明，它们永远不可能重合。

矩阵旋转，可以理解为(i, j)位置上的数，转到了(n + 1 - j, i)的位置。

题解

#include <bits/stdc++.h>
using namespace std;
int n;
int a[15][15], b[15][15];
int temp[15][15];
int main()
{
    cin >> n;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            cin >> a[i][j];
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            cin >> b[i][j];
    // 旋转一次
    for (int t = 1; t <= 4; t++)
    {
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++)
                temp[i][j] = a[n + 1 - j][i];
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++)
                a[i][j] = temp[i][j];
        /*
        //查看一下旋转后长得对不对
        cout<<"-------\n";
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
                cout<<a[i][j]<<" ";
            cout<<"\n";
        }
        */
        bool flag = true;
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++)
                if (a[i][j] != b[i][j])
                    flag = false;
        if (flag)
        {
            cout << "Yes\n";
            return 0;
        }
    }
    cout << "No\n";
    return 0;
}

先说思路：

要判断数组旋转后是否与另一个数组相等，换个意思就是将这个数组每次旋转90°，旋转4次，看一下有没有一次是相等的

也就是说，重点在于如何旋转

我们可以先列一个3 * 3的数组来看一下（也就是说，n = 3）

1 2 3

4 5 6

7 8 9

旋转后得到

7 4 1

8 5 2

9 6 3

我们可以发现，旋转数组实际上就是将数组的每一行旋转一次

接下来，看一下前两行每个数的位置的具体变化

数字1：(1,1)变为(1,3)

数字2：(1,2)变为(2,3)

数字3：(1,3)变为(3,3)

接下来，把i和j分别代入行和列

出现一个好像能用的规律：(i,j)变为(j,n)

但我们再去看第二排

数字4：(2,1)变为(1,2)

数字5：(2,2)变为(2,2)

数字6：(2,3)变为(3,2)

规律又用不了了，但别急，我们接着研究，把行和列换为i和j，可以发现第二条规律：(i,j)变为(j,n - i + 1)

把这条规律代入其它两排，发现依然成立，再代入其它数组，发现也成立

归纳一下，用a表示原来的数组，用new_a表示旋转后的数组，可以得出：

a[i][j]等于new_a[j][n - i + 1]

至此，规律就找出来了

其它部分可以去看注释

题解：

#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n,a[15][15] = {0},b[15][15] = {0};
    cin >> n;
    for(int i = 1;i <= n;i++)
    {
        for(int j = 1;j <= n;j++)
            cin >> a[i][j];
    }

    for(int i = 1;i <= n;i++)
    {
        for(int j = 1;j <= n;j++)
            cin >> b[i][j];
    }
    
    for(int x = 1;x <= 4;x++)//重复4次，也就是旋转4次
    {
        int new_a[15][15] = {0};//创建旋转后的数组
        for(int i = 1;i <= n;i++)
        {
            for(int j = 1;j <= n;j++)
                new_a[j][n - i + 1] = a[i][j];//按规律填入原数组旋转后对应位置上的对应数字
        }
        //判断两个数组是否相等
        int flag = 0;
        for(int i = 1;i <= n;i++)
        {
            for(int j = 1;j <= n;j++)
            {
            //遍历两个数组
                if(new_a[i][j] != b[i][j])//如果有一个值不相等，也就是说，如果两个数组不相等
                {
                    flag = 1;//将flag设为1，结束循环
                    break;
                }
            }
            if(flag == 1)//如果flag为1，也就是说，如果两个数组已经判断出来是不相等的了
                break;//结束循环
        }
        if(flag == 0)//如果判断完以后，flag为0，说明两个数组一样
        {
            cout << "Yes";
            return 0;
            //输出yes，结束程序
        }
        else if(x != 4)//否则，如果这不是第四次旋转，那么将new_a里面的值全部赋值给a，然后进行下一次旋转，不然的话下一次旋转出来的数组与第一次是一样的
        {
            for(int i = 1;i <= n;i++)
            {
                for(int j = 1;j <= n;j++)
                    a[i][j] = new_a[i][j];
            }
        }
        //如果这是第四次且两个数组不相等
        if(x == 4 && flag == 1)
        {
            cout << "No";
            return 0;
            //说明两个数组在旋转以后不可能相等，输出并结束程序
        }
    }
}

#include <iostream>
int q,a[15][15],t[15][15],z[15][15];
int same(){
    for(int i=0;i<q;i++) for(int j=0;j<q;j++) if(a[i][j]!=z[i][j]) return 0;
    return 1;}
void xz(){
    for (int i=0;i<q;i++) for(int j=0;j<q;j++) t[i][j]=a[q-1-j][i];
    for (int i=0;i<q;i++) for (int j=0;j<q;j++) a[i][j]=t[i][j];}
int main(){
    std::cin>>q;
    for(int i=0;i<q;i++) for(int j=0;j<q;j++) std::cin>>a[i][j];
    for(int i=0;i<q;i++) for(int j=0;j<q;j++) std::cin>>z[i][j];
    for(int z=0;z<4;z++){xz();if(same()){std::cout<<"Yes";return 0;}}
    std::cout<<"No";return 0;}

重点在四次旋转是否相同的判断，flag1旋转90度，flag2旋转180度，flag3旋转270度，flag4旋转360度都不相同则不能实现，有一种相同则能实现。🚀️ 🚀️ 😄 😄 🎉️ 🎉️

#include <bits/stdc++.h>
using namespace std;
int n;
int a[15][15], b[15][15];
int main()
{
    cin >> n;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            cin >> a[i][j];
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            cin >> b[i][j];
    //flag1旋转90度，flag2旋转180度，flag3旋转270度，flag4旋转360度都不相同则不能实现，有一种相同则能实现。
    bool flag1=true,flag2=true,flag3=true,flag4=true;        
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++) {
            if (a[i][j]!=b[j][n-i+1]) flag1=false;
            if (a[i][j]!=b[n-i+1][n-j+1]) flag2=false;
            if (a[i][j]!=b[n-j+1][i]) flag3=false;
            if (a[i][j]!=b[i][j]) flag4=false;
        }
    if (flag1 || flag2 || flag3 || flag4)  cout << "Yes";
    else cout << "No";
    return 0;
}