zoukankan      html  css  js  c++  java
  • Transformations 方块转换

    题目是中文题,就不做什么解释了,纯模拟题,主要要搞清楚这几种装换方式下标的变化:

    第一种:顺时针旋转90度:

        c[j][n-i+1]=a[i][j];

    第二种:旋转180度:

        c[n-i+1][n-j+1]=a[i][j];

    第三种:顺时针旋转270度:

        c[i][j]=a[j][n-i+1];

    第四种:反射

        c[i][n-j+1]=a[i][j];

    第五种:组合

        先反射:c[i][n-j+1]=a[i][j];

        然后再按照1到3之间的一种再次转换。

    第六种:不改变

        c[i][j]=a[i][j];

    第七种:其他

    如果有多种可用的转换方法,请选择序号最小的那个。

      1 #include <cstdio>
      2 #include <algorithm>
      3 #include <cstring>
      4 #include <iostream>
      5 using namespace std;
      6 int n;
      7 int type;
      8 char a[11][11],b[11][11],c[11][11];
      9 void input()
     10 {
     11     cin>>n;
     12     int i,j;
     13     getchar();
     14     for(i=1; i<=n; i++)
     15     {
     16         for(j=1; j<=n; j++)
     17             cin>>a[i][j];
     18     }
     19     for(i=1; i<=n; i++)
     20     {
     21         for(j=1; j<=n; j++)
     22             cin>>b[i][j];
     23     }
     24 }
     25 void judge()
     26 {
     27     int k;
     28     int flag=0;
     29     int i,j;
     30     for(k=1; k<=6; k++)
     31     {
     32         if(k==1)//转90度
     33         {
     34             flag=0;
     35             for(i=1; i<=n; i++)
     36             {
     37                 for(j=1; j<=n; j++)
     38                     c[j][n-i+1]=a[i][j];
     39             }
     40             for(i=1; i<=n; i++)
     41             {
     42                 for(j=1; j<=n; j++)
     43                 {
     44                     if(c[i][j]!=b[i][j])
     45                     {
     46                         flag=1;
     47                         break;
     48                     }
     49                 }
     50                 if(flag)
     51                     break;
     52             }
     53             if(i==n+1)
     54             {
     55                 type=k;
     56                 return;
     57             }
     58         }
     59         if(k==2)//转180度
     60         {
     61             flag=0;
     62             for(i=1; i<=n; i++)
     63             {
     64                 for(j=1; j<=n; j++)
     65                     c[n-i+1][n-j+1]=a[i][j];
     66             }
     67             for(i=1; i<=n; i++)
     68             {
     69                 for(j=1; j<=n; j++)
     70                 {
     71                     if(c[i][j]!=b[i][j])
     72                     {
     73                         flag=1;
     74                         break;
     75                     }
     76                 }
     77                 if(flag)
     78                     break;
     79             }
     80             if(i==n+1)
     81             {
     82                 type=k;
     83                 return;
     84             }
     85         }
     86         if(k==3)//转270度
     87         {
     88             flag=0;
     89             for(i=1; i<=n; i++)
     90             {
     91                 for(j=1; j<=n; j++)
     92                     c[i][j]=a[j][n-i+1];
     93             }
     94             for(i=1; i<=n; i++)
     95             {
     96                 for(j=1; j<=n; j++)
     97                 {
     98                     if(c[i][j]!=b[i][j])
     99                     {
    100                         flag=1;
    101                         break;
    102                     }
    103                 }
    104                 if(flag)
    105                     break;
    106             }
    107             if(i==n+1)
    108             {
    109                 type=k;
    110                 return;
    111             }
    112         }
    113         if(k==4)//反射
    114         {
    115             flag=0;
    116             for(i=1; i<=n; i++)
    117             {
    118                 for(j=1; j<=n; j++)
    119                     c[i][n-j+1]=a[i][j];
    120             }
    121             for(i=1; i<=n; i++)
    122             {
    123                 for(j=1; j<=n; j++)
    124                 {
    125                     if(c[i][j]!=b[i][j])
    126                     {
    127                         flag=1;
    128                         break;
    129                     }
    130                 }
    131                 if(flag)
    132                     break;
    133             }
    134             if(i==n+1)
    135             {
    136                 type=k;
    137                 return;
    138             }
    139         }
    140         if(k==5)//组合
    141         {
    142             flag=0;
    143             for(i=1; i<=n; i++)
    144             {
    145                 for(j=1; j<=n; j++)
    146                     c[i][n-j+1]=a[i][j];
    147             }
    148             for(i=1; i<=n; i++)
    149             {
    150                 for(j=1; j<=n; j++)
    151                     a[j][n-i+1]=c[i][j];
    152             }
    153             for(i=1; i<=n; i++)
    154             {
    155                 for(j=1; j<=n; j++)
    156                 {
    157                     if(a[i][j]!=b[i][j])
    158                     {
    159                         flag=1;
    160                         break;
    161                     }
    162                 }
    163                 if(flag)
    164                     break;
    165             }
    166             if(i==n+1)
    167             {
    168                 type=k;
    169                 return;
    170             }
    171             flag=0;
    172             for(i=1; i<=n; i++)
    173             {
    174                 for(j=1; j<=n; j++)
    175                     a[n-i+1][n-j+1]=c[i][j];
    176             }
    177             for(i=1; i<=n; i++)
    178             {
    179                 for(j=1; j<=n; j++)
    180                 {
    181                     if(a[i][j]!=b[i][j])
    182                     {
    183                         flag=1;
    184                         break;
    185                     }
    186                 }
    187                 if(flag)
    188                     break;
    189             }
    190             if(i==n+1)
    191             {
    192                 type=k;
    193                 return;
    194             }
    195             flag=0;
    196             for(i=1; i<=n; i++)
    197             {
    198                 for(j=1; j<=n; j++)
    199                     a[i][j]=c[j][n-i+1];
    200             }
    201             for(i=1; i<=n; i++)
    202             {
    203                 for(j=1; j<=n; j++)
    204                 {
    205                     if(a[i][j]!=b[i][j])
    206                     {
    207                         flag=1;
    208                         break;
    209                     }
    210                 }
    211                 if(flag)
    212                     break;
    213             }
    214             if(i==n+1)
    215             {
    216                 type=k;
    217                 return;
    218             }
    219         }
    220         if(k==6)//不改变
    221         {
    222             flag=0;
    223             for(i=1; i<=n; i++)
    224             {
    225                 for(j=1; j<=n; j++)
    226                 {
    227                     if(a[i][j]!=b[i][j])
    228                     {
    229                         flag=1;
    230                         break;
    231                     }
    232                 }
    233                 if(flag)
    234                     break;
    235             }
    236             if(i==n+1)
    237             {
    238                 type=k;
    239                 return;
    240             }
    241         }
    242     }
    243     if(k==7)//其他
    244         type=k;
    245 }
    246 void output()
    247 {
    248     printf("%d
    ",type);
    249 }
    250 int main()
    251 {
    252     input();
    253     judge();
    254     output();
    255     return 0;
    256 }
  • 相关阅读:
    106. Construct Binary Tree from Inorder and Postorder Traversal
    105. Construct Binary Tree from Preorder and Inorder Traversal
    449. Serialize and Deserialize BST
    114. Flatten Binary Tree to Linked List
    199. Binary Tree Right Side View
    173. Binary Search Tree Iterator
    98. Validate Binary Search Tree
    965. Univalued Binary Tree
    589. N-ary Tree Preorder Traversal
    eclipse设置总结
  • 原文地址:https://www.cnblogs.com/PJQOOO/p/4638159.html
Copyright © 2011-2022 走看看