12:变幻的矩阵

12:变幻的矩阵

• 查看
• 提交
• 统计
• 提问

总时间限制: 

1000ms

内存限制: 

65536kB

描述

有一个N x N（N为奇数，且1 <= N <= 10）的矩阵，矩阵中的元素都是字符。这个矩阵可能会按照如下的几种变幻法则之一进行变幻（只会变幻一次）。 

现在给出一个原始的矩阵，和一个变幻后的矩阵，请编写一个程序，来判定原始矩阵是按照哪一种法则变幻为目标矩阵的。 

1. 按照顺时针方向旋转90度； 
如： 

1 2 3        7 4 1
4 5 6 变幻为  8 5 2
7 8 9        9 6 3

2. 按照逆时针方向旋转90度； 
如：

1 2 3        3 6 9
4 5 6 变幻为  2 5 8
7 8 9        1 4 7 

3. 中央元素不变（如下例中的 5），其他元素（如下例中的3）与“以中央元素为中心的对应元素”（如下例中的7）互换； 
如：

1 2 3       9 8 7
4 5 6 变幻为 6 5 4
7 8 9       3 2 1 

4. 保持原始矩阵，不变幻； 

5. 如果 从原始矩阵 到 目标矩阵 的变幻，不符合任何上述变幻，请输出5

 

输入

第一行：矩阵每行/列元素的个数 N；
第二行到第N+1行：原始矩阵，共N行，每行N个字符；
第N+2行到第2*N+1行：目标矩阵，共N行，每行N个字符；

输出

只有一行，从原始矩阵 到 目标矩阵 的所采取的 变幻法则的编号。

样例输入

5
a b c d e
f g h i j
k l m n o
p q r s t
u v w x y
y x w v u
t s r q p
o n m l k
j i h g f
e d c b a

样例输出

3

  1 #include<iostream>
  2 #include<cstdio>
  3 #include<cmath>
  4 #include<cstring>
  5 using namespace std;
  6 char a[101][101];
  7 char b[101][101];
  8 int main()
  9 {
 10     int n,m; 
 11     cin>>n;
 12     for(int i=1;i<=n;i++)
 13     {
 14         for(int j=1;j<=n;j++)
 15         cin>>a[i][j];
 16     }
 17     for(int i=1;i<=n;i++)
 18     {
 19         for(int j=1;j<=n;j++)
 20         cin>>b[i][j];
 21     }
 22     int flag=0;
 23     for(int i=1;i<=n;i++)
 24     {
 25         for(int j=1;j<=n;j++)
 26         {
 27             if(i==n&&j==n&&a[i][j]==b[j][n-i+1])
 28             {
 29                 cout<<1;
 30                 return 0;
 31             }
 32             if(a[i][j]==b[j][n-i+1])
 33             {
 34                 continue;
 35             }
 36             else 
 37             {
 38                 flag=1;
 39                 break;
 40             }
 41             
 42         }
 43         if(flag==1)break;
 44     }
 45     flag=0;
 46     for(int i=1;i<=n;i++)
 47     {
 48         for(int j=1;j<=n;j++)
 49         {
 50             if(i==n&&j==n&&a[i][j]==b[n-j+1][i])
 51             {
 52                 cout<<2;
 53                 return 0;
 54             }
 55              if(a[i][j]==b[n-j+1][i])
 56             {
 57                 continue;
 58             }
 59             else 
 60             {
 61                 flag=1;
 62                 break;
 63             }
 64             
 65         }
 66         if(flag==1)break;
 67     }
 68     flag=0;
 69     for(int i=1;i<=n;i++)
 70     {
 71         for(int j=1;j<=n;j++)
 72         {
 73             if(i==n&&j==n&&a[i][j]==b[n-i+1][n-j+1])
 74             {
 75                 cout<<3;
 76                 return 0;
 77             }
 78              if(a[i][j]==b[n-i+1][n-j+1])
 79             {
 80                 continue;
 81             }
 82             else 
 83             {
 84                 flag=1;
 85                 break;
 86             }
 87             
 88         }
 89         if(flag==1)break;
 90     }
 91     flag=0;
 92     for(int i=1;i<=n;i++)
 93     {
 94         for(int j=1;j<=n;j++)
 95         {
 96             if(i==n&&j==n&&a[i][j]==b[i][j])
 97             {
 98                 cout<<4;
 99                 return 0;
100             }
101              if(a[i][j]==b[i][j])
102             {
103                 continue;
104             }
105             else 
106             {
107                 flag=1;
108                 break;
109             }
110             
111         }
112         if(flag==1)break;
113     }
114     
115     cout<<5;
116     /*int a1=a[1][1];
117     if(b[1][n]==a1)
118     {
119         cout<<1;
120         return 0;
121     }
122     else if(b[n][1]==a1)
123     {
124         cout<<2;
125         return 0;
126     }
127     else if(b[n][n]==a1)
128     {
129         cout<<3;
130         return 0;
131     }
132     else if(b[1][1]=a1)
133     {
134         cout<<4;
135         return 0;
136     }*/
137     
138     return 0;
139 }

 

标签：12,int,矩阵,变幻,原始,101,include
来源： https://blog.51cto.com/u_15239936/2864892