Don't like ads? PRO users don't see any ads ;-)
Public Pastes
Guest

Сube

By: a guest on May 22nd, 2012  |  syntax: None  |  size: 6.38 KB  |  hits: 87  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. #include <iostream>
  2. #include <cstdio>
  3. #include <vector>
  4. #include <memory>
  5. #include <cstdlib>
  6. using namespace std;
  7.  
  8. int cnt=0;
  9.  
  10. enum E_Turn{
  11.     E_NULL,
  12.     E_VR,
  13.     E_VL,
  14.     E_SN,
  15.     E_SF,
  16.     E_HT,
  17.     E_HB,
  18. };
  19.  
  20. class Cube{
  21.     private:
  22.     char Data[24];
  23.     vector < int > WayToGet;
  24.    
  25.     void BasicTurn(char &a,char &b,char &c,char &d){
  26.         char tmp;
  27.         tmp = a;
  28.         a=b;
  29.         b=c;
  30.         c=d;
  31.         d=tmp;
  32.         return;
  33.     }
  34.    
  35.     void VR(){
  36.          BasicTurn(Data[15], Data[11], Data[7], Data[3]);
  37.          BasicTurn(Data[12], Data[8], Data[4], Data[0]);
  38.          BasicTurn(Data[21], Data[22], Data[23], Data[20]);
  39.     }
  40.    
  41.     void VL(){
  42.         BasicTurn(Data[14], Data[10], Data[6], Data[2]);
  43.         BasicTurn(Data[13], Data[9], Data[5], Data[1]);
  44.         BasicTurn(Data[16], Data[19], Data[18], Data[17]);
  45.     }
  46.    
  47.     void HB(){
  48.         BasicTurn(Data[14], Data[18], Data[4], Data[22]);
  49.         BasicTurn(Data[15], Data[19], Data[5], Data[23]);
  50.         BasicTurn(Data[8], Data[9], Data[10], Data[11]);
  51.     }
  52.    
  53.     void HT(){
  54.         BasicTurn(Data[12], Data[16], Data[6], Data[20]);
  55.         BasicTurn(Data[13], Data[17], Data[7], Data[21]);
  56.         BasicTurn(Data[2], Data[1], Data[0], Data[3]);
  57.     }
  58.    
  59.     void SN(){
  60.         BasicTurn(Data[22], Data[9], Data[16], Data[3]);
  61.         BasicTurn(Data[21], Data[8], Data[19], Data[2]);
  62.         BasicTurn(Data[15], Data[14], Data[13], Data[12]);
  63.     }
  64.    
  65.     void SF(){
  66.         BasicTurn(Data[23], Data[10], Data[17], Data[0]);
  67.         BasicTurn(Data[20], Data[11], Data[18], Data[1]);
  68.         BasicTurn(Data[7], Data[6], Data[5], Data[4]);
  69.     }
  70.    
  71.     public:
  72.     //E_Turn LastRotate;
  73.    
  74.     Cube(){
  75.        for (int i=0; i<4; i++){
  76.             Data[i]='G';
  77.             Data[i+4]='O';
  78.             Data[i+8]='U';
  79.             Data[i+12]='R';
  80.             Data[i+16]='B';
  81.             Data[i+20]='Y';
  82.        }
  83.        WayToGet.resize(0);
  84.     }
  85.     Cube( char STR[24]){
  86.         for (int i=0; i<24; i++){
  87.             Data[i]=STR[i];
  88.         }
  89.         WayToGet.resize(0);
  90.     }
  91.    
  92.     void PrintCube(){
  93.         printf("\n\t%c %c\n", Data[1], Data[0]);
  94.         printf("\t%c %c\n", Data[2], Data[3]);
  95.         printf("    %c %c %c %c %c %c\n", Data[17], Data[16], Data[13], Data[12], Data[21], Data[20]);
  96.         printf("    %c %c %c %c %c %c\n", Data[18], Data[19], Data[14], Data[15], Data[22], Data[23]);
  97.         printf("\t%c %c\n", Data[9], Data[8]);
  98.         printf("\t%c %c\n", Data[10], Data[11]);
  99.         printf("\t%c %c\n", Data[5], Data[4]);
  100.         printf("\t%c %c\n", Data[6], Data[7]);
  101.  
  102.     }
  103.     void PrintWay(){
  104.         //printf("\n");
  105.         for (int i=0; i<WayToGet.size(); i++){
  106.         if (WayToGet[i]==1)
  107.             printf("VR ");
  108.         if (WayToGet[i]==2)
  109.             printf("VL ");
  110.         if (WayToGet[i]==3)
  111.             printf("SN ");
  112.         if (WayToGet[i]==4)
  113.             printf("SF ");
  114.         if (WayToGet[i]==5)
  115.             printf("HT ");
  116.         if (WayToGet[i]==6)
  117.             printf("HB ");
  118.         }
  119.         //printf("\n");
  120.     }
  121.    
  122.     void PrintInvertedWay(){
  123.         for (int i = WayToGet.size()-1; i>=0; i--){
  124.         if (WayToGet[i]==1)
  125.             printf("VR VR VR ");
  126.         if (WayToGet[i]==2)
  127.             printf("VL VL VL ");
  128.         if (WayToGet[i]==3)
  129.             printf("SN SN SN ");
  130.         if (WayToGet[i]==4)
  131.             printf("SF SF SF ");
  132.         if (WayToGet[i]==5)
  133.             printf("HT HT HT ");
  134.         if (WayToGet[i]==6)
  135.             printf("HB HB HB ");
  136.            
  137.         }
  138.     }
  139.    
  140.     bool operator <(const Cube &B) const{
  141.         for (int i=0; i<24; i++){
  142.             if(Data[i]!=B.Data[i])
  143.                 return (Data[i]<B.Data[i]);
  144.         }
  145.         return false;
  146.     }
  147.    
  148.     Cube Turn(E_Turn Flag){
  149.         if (Flag==E_VR){
  150.             (*this).VR();
  151.             (this->WayToGet).push_back(E_VR);
  152.             return *this;
  153.             }
  154.         if (Flag==E_VL){
  155.             (*this).VL();
  156.             (this->WayToGet).push_back(E_VL);
  157.             return *this;
  158.             }
  159.         if (Flag==E_SN){
  160.             (*this).SN();
  161.             (this->WayToGet).push_back(E_SN);
  162.             return *this;
  163.             }
  164.          if (Flag==E_SF){
  165.             (*this).SF();
  166.             (this->WayToGet).push_back(E_SF);
  167.             return *this;
  168.             }
  169.          if (Flag==E_HT){
  170.             (*this).HT();
  171.             (this->WayToGet).push_back(E_HT);
  172.             return *this;
  173.             }
  174.          if (Flag==E_HB){
  175.             (*this).HB();
  176.             (this->WayToGet).push_back(E_HB);
  177.             return *this;
  178.             }
  179.  
  180.     }
  181.    
  182. };
  183. void WriteAnswer(const int flag, Cube T1, Cube T2){
  184.     if (flag){
  185.         printf("\n");
  186.         T1.PrintWay();
  187.         T2.PrintInvertedWay();
  188.     }
  189.     else {
  190.         printf("\n");
  191.         T2.PrintWay();
  192.         T1.PrintInvertedWay();
  193.     }
  194. }
  195.  
  196. void AddAllRotation(Cube Curr, vector <Cube> &V){
  197.    
  198.     for (int i = 1; i<7; i++){
  199.         V.push_back(Curr.Turn((E_Turn)i));
  200.     }
  201.    
  202. }
  203.  
  204. void AddStepOfBFS(vector <Cube> &V, int &i_begin, int &i_end){
  205.     for(; i_begin <= i_end; i_begin++)
  206.         AddAllRotation(V[i_begin], V);
  207.     i_begin++;
  208.     i_end=V.size()-1;
  209. }
  210.  
  211. int Find(Cube Curr, vector <Cube> &V){
  212.     for (int i = 0; i<V.size(); i++)
  213.         if (!((Curr < V[i]) || (V[i] < Curr)))
  214.             return i;
  215.     return -1;
  216. }
  217.  
  218. void ComparingStepOfBFS(vector <Cube> &V1, vector <Cube> &V2,const int i_begin,const int i_end, const int flag){
  219.     int index;
  220.     for(int i = i_begin; i <= i_end; i++){
  221.         index = Find(V1[i], V2);
  222.         if ( index != -1){
  223.             WriteAnswer( flag, V1[i], V2[index]);
  224.             exit(0);
  225.             }
  226.     }
  227. }
  228.  
  229. void DoubleBFS( vector <Cube> &V1, vector <Cube> &V2){
  230.     int i1 = 0;
  231.     int i2 = 0;
  232.     int j1 = 0;
  233.     int j2 = 0;
  234.     for(int i=0; i < 40; i++){
  235.         AddStepOfBFS(V1, i1, i2);
  236.         ComparingStepOfBFS(V1, V2, i1, i2, true);
  237.         AddStepOfBFS(V2, j1, j2);
  238.         ComparingStepOfBFS(V2, V1, j1, j2, false);
  239.     }
  240.     exit(2);
  241. };
  242.  
  243.  
  244. int main(){
  245.     char DataIn[24];
  246.     for (int i=0; i<24; i++){
  247.         cin >> DataIn[i];
  248.         }
  249.     Cube Desorded(DataIn);
  250.     Cube Orded;
  251.     vector <Cube> V1;
  252.     vector <Cube> V2;
  253.     V1.push_back(Desorded);
  254.     V2.push_back(Orded);
  255.     DoubleBFS(V1,V2);
  256. }
create a new version of this paste RAW Paste Data