题目：

This is a very popular game for children. In this game, there's a cube, which consists of 3 * 3 * 3 small cubes. We can unwrap the cube, it will become like this:

      w w w
      w w w
      w w w
r r r g g g b b b o o o
r r r g g g b b b o o o
r r r g g g b b b o o o
      y y y
      y y y
      y y y

The letters means the color on the small cubes. For example, 'r' means red, 'g' means green, 'y' means yellow....The goal for this game is to rotate the faces of the cube to make each of the faces contains only one color. Note there're exact 6 kind of colors on the cube and there're exact 9 small rectangles totally in any time in the game.

Do you know how to rotate the faces? I think most of you have known it. But I would like to show it again. When a face is rotated, the configuration of colors in all the adjacent faces changes. For the cube above, after we rotate the green face clock-wise, the last line of 'w' face will become the left column of 'b' face, the left column of 'b' face will become the top line of 'y' face, etc. As you may know, reaching the final position from a scrambled configuration can be quite challenging.

In this problem, you are given a configuration of the cube, and asked to give a way to reach the final position. To reduce the difficulty, the steps required will never be greater than 5.

输入：

The input contains an integer in the first line, which indicates the number of the test cases. In each test case, there're exact 10 lines. The first line is an empty line. The next 9 lines contain a configuration. The format can be seen in the sample input. For simplicity, we give an index to each face as follows:

 

    /---\
    |   |
    | 4 |
    |   |
/---+---+---+---\
|   |   |   |   |
| 0 | 1 | 2 | 3 |
|   |   |   |   |
\---+---+---+---/
    |   |
    | 5 |
    |   |
    \---/

Note that there's a space between two adjacent letters.

输出：

For each test case, the first line of the output is the smallest count N of the steps to reach the winning position. If the winning position can't be reached in 5 steps, print -1 in this line. Otherwise print each step in one line in the following N lines. A step contains two integers, the first one means the face index, and the second one means the direction. 1 means clock-wise and -1 means counter clock-wise. If the given position is the winning position, print 0 for such test case simply. If there're multiple solutions, any one is acceptable.

样例：

分析：我。。。自闭了两天竟然是没有写>5输出-1(°ཀ°)，为什么我会默认测试点必然可以在5步内实现啊(#`Д´)ﾉ

只能说这个模拟太恶心了！！！

用IDA*优化，思路是计算每一个面有几个和中心方格颜色不一样的方格，6个面的总数除12并向上取整是最少剩余需要的步数（如果最理想的情况加上已走步数仍然大于5那肯定没戏啊）

模拟写得相当丑(灬ºωº灬)

  1.  #include<iostream>
  2.  #include<sstream>
  3.  #include<cstdio>
  4.  #include<cstdlib>
  5.  #include<string>
  6.  #include<cstring>
  7.  #include<algorithm>
  8.  #include<functional>
  9.  #include<iomanip>
  10.  #include<numeric>
  11.  #include<cmath>
  12.  #include<queue>
  13.  #include<vector>
  14.  #include<set>
  15.  #include<cctype>
  16.  #define PI acos(-1.0)
  17.  const int INF = 0x3f3f3f3f;
  18.  const int NINF = -INF - ;
  19.  typedef long long ll;
  20.  using namespace std;
  21.  char cube[][];
  22.  struct node
  23.  {
  24.      char maze[][];
  25.  };
  26.  struct cur
  27.  {
  28.      char maze[][];
  29.  };
  30.  node clockwise(node temp)
  31.  {
  32.      char gtm[][];
  33.      gtm[][] = temp.maze[][];
  34.      gtm[][] = temp.maze[][];
  35.      gtm[][] = temp.maze[][];
  36.      gtm[][] = temp.maze[][];
  37.      gtm[][] = temp.maze[][];
  38.      gtm[][] = temp.maze[][];
  39.      gtm[][] = temp.maze[][];
  40.      gtm[][] = temp.maze[][];
  41.      gtm[][] = temp.maze[][];
  42.      memcpy(temp.maze, gtm, sizeof(temp.maze));
  43.      return temp;
  44.  }
  45.  node cclockwise(node temp)
  46.  {
  47.      char gtm[][];
  48.      gtm[][] = temp.maze[][];
  49.      gtm[][] = temp.maze[][];
  50.      gtm[][] = temp.maze[][];
  51.      gtm[][] = temp.maze[][];
  52.      gtm[][] = temp.maze[][];
  53.      gtm[][] = temp.maze[][];
  54.      gtm[][] = temp.maze[][];
  55.      gtm[][] = temp.maze[][];
  56.      gtm[][] = temp.maze[][];
  57.      memcpy(temp.maze, gtm, sizeof(temp.maze));
  58.      return temp;
  59.  }
  60.  int bol, ans;
  61.  pair<int, int> P[];
  62.  void print()
  63.  {
  64.      for (int i = ; i < ans; ++i)
  65.          cout << P[i].first << ' ' << P[i].second << endl;
  66.  }
  67.  int hx(cur trans)
  68.  {
  69.      double sum = ;
  70.      for (int i = ; i < ; ++i)
  71.      {
  72.          for (int j = ; j < ; j += )
  73.              if (trans.maze[i][j] != trans.maze[][]) sum++;
  74.      }
  75.      for (int i = ; i < ; ++i)
  76.      {
  77.          for (int j = ; j < ; j += )
  78.              if (trans.maze[i][j] != trans.maze[][]) sum++;
  79.      }
  80.      for (int i = ; i < ; ++i)
  81.      {
  82.          for (int j = ; j < ; j += )
  83.              if (trans.maze[i][j] != trans.maze[][]) sum++;
  84.      }
  85.      for (int i = ; i < ; ++i)
  86.      {
  87.          for (int j = ; j < ; j += )
  88.              if (trans.maze[i][j] != trans.maze[][]) sum++;
  89.      }
  90.      for (int i = ; i < ; ++i)
  91.      {
  92.          for (int j = ; j < ; j += )
  93.              if (trans.maze[i][j] != trans.maze[][]) sum++;
  94.      }
  95.      for (int i = ; i < ; ++i)
  96.      {
  97.          for (int j = ; j < ; j += )
  98.              if (trans.maze[i][j] != trans.maze[][]) sum++;
  99.      }
  100.      return ceil(sum / );
  101.  }
  102.  void dfs(int rec, char pos[][], int deep)
  103.  {
  104.      if (rec > deep) return;
  105.      cur trans;
  106.      memcpy(trans.maze, pos, sizeof(trans.maze));
  107.      int h = hx(trans);
  108.      //cout << "test:" << h << endl;
  109.      if (h == )
  110.      {
  111.          ans = rec;
  112.          cout << rec << endl;
  113.          bol = ;
  114.          return;
  115.      }
  116.      if (h + rec > deep) return;
  117.      for (int i = ; i < ; ++i)
  118.      {
  119.          char tmp[][];
  120.          memcpy(tmp, pos, sizeof(tmp));
  121.          /*for (int j = 0; j < 9; ++j)
  122.              cout << tmp[j] << endl;
  123.          return;*/
  124.          node temp;
  125.          if (i == )
  126.          {
  127.              for (int k = , m = ; k < , m < ; ++k, ++m)
  128.              {
  129.                  for (int j = , n = ; j < , n < ; j += , ++n)
  130.                      temp.maze[m][n] = tmp[k][j];
  131.              }
  132.              temp = clockwise(temp);
  133.              /*for (int m = 0; m < 3; ++m)
  134.              {
  135.                  for (int n = 0; n < 3; ++n)
  136.                      cout << temp.maze[m][n] << ' ';
  137.                  cout << endl;
  138.              }*/
  139.              for (int k = , m = ; k < , m < ; ++k, ++m)
  140.              {
  141.                  for (int j = , n = ; j < , n < ; j += , ++n)
  142.                      tmp[k][j] = temp.maze[m][n];
  143.              }
  144.              char cpy[][];
  145.              memcpy(cpy, tmp, sizeof(cpy));
  146.              cpy[][] = tmp[][];
  147.              cpy[][] = tmp[][];
  148.              cpy[][] = tmp[][];
  149.              cpy[][] = tmp[][];
  150.              cpy[][] = tmp[][];
  151.              cpy[][] = tmp[][];
  152.              cpy[][] = tmp[][];
  153.              cpy[][] = tmp[][];
  154.              cpy[][] = tmp[][];
  155.              cpy[][] = tmp[][];
  156.              cpy[][] = tmp[][];
  157.              cpy[][] = tmp[][];
  158.              memcpy(tmp, cpy, sizeof(tmp));
  159.              /*for (int k = 0; k < 9; ++k)
  160.                  cout << tmp[k] << endl;
  161.              return;*/
  162.          }
  163.          else if (i == )
  164.          {
  165.              for (int k = , m = ; k < , m < ; ++k, ++m)
  166.              {
  167.                  for (int j = , n = ; j < , n < ; j += , ++n)
  168.                      temp.maze[m][n] = tmp[k][j];
  169.              }
  170.              temp = cclockwise(temp);
  171.              for (int k = , m = ; k < , m < ; ++k, ++m)
  172.              {
  173.                  for (int j = , n = ; j < , n < ; j += , ++n)
  174.                      tmp[k][j] = temp.maze[m][n];
  175.              }
  176.              char cpy[][];
  177.              memcpy(cpy, tmp, sizeof(cpy));
  178.              cpy[][] = tmp[][];
  179.              cpy[][] = tmp[][];
  180.              cpy[][] = tmp[][];
  181.              cpy[][] = tmp[][];
  182.              cpy[][] = tmp[][];
  183.              cpy[][] = tmp[][];
  184.              cpy[][] = tmp[][];
  185.              cpy[][] = tmp[][];
  186.              cpy[][] = tmp[][];
  187.              cpy[][] = tmp[][];
  188.              cpy[][] = tmp[][];
  189.              cpy[][] = tmp[][];
  190.              memcpy(tmp, cpy, sizeof(tmp));
  191.              /*for (int k = 0; k < 9; ++k)
  192.                  cout << tmp[k] << endl;
  193.              return;*/
  194.          }
  195.          else if (i == )
  196.          {
  197.              for (int k = , m = ; k < , m < ; ++k, ++m)
  198.              {
  199.                  for (int j = , n = ; j < , n < ; j += , ++n)
  200.                      temp.maze[m][n] = tmp[k][j];
  201.              }
  202.              temp = clockwise(temp);
  203.              for (int k = , m = ; k < , m < ; ++k, ++m)
  204.              {
  205.                  for (int j = , n = ; j < , n < ; j += , ++n)
  206.                      tmp[k][j] = temp.maze[m][n];
  207.              }
  208.              char cpy[][];
  209.              memcpy(cpy, tmp, sizeof(cpy));
  210.              cpy[][] = tmp[][];
  211.              cpy[][] = tmp[][];
  212.              cpy[][] = tmp[][];
  213.              cpy[][] = tmp[][];
  214.              cpy[][] = tmp[][];
  215.              cpy[][] = tmp[][];
  216.              cpy[][] = tmp[][];
  217.              cpy[][] = tmp[][];
  218.              cpy[][] = tmp[][];
  219.              cpy[][] = tmp[][];
  220.              cpy[][] = tmp[][];
  221.              cpy[][] = tmp[][];
  222.              memcpy(tmp, cpy, sizeof(tmp));
  223.              /*for (int k = 0; k < 9; ++k)
  224.                  cout << tmp[k] << endl;
  225.              return;*/
  226.          }
  227.          else if (i == )
  228.          {
  229.              for (int k = , m = ; k < , m < ; ++k, ++m)
  230.              {
  231.                  for (int j = , n = ; j < , n < ; j += , ++n)
  232.                      temp.maze[m][n] = tmp[k][j];
  233.              }
  234.              temp = cclockwise(temp);
  235.              for (int k = , m = ; k < , m < ; ++k, ++m)
  236.              {
  237.                  for (int j = , n = ; j < , n < ; j += , ++n)
  238.                      tmp[k][j] = temp.maze[m][n];
  239.              }
  240.              char cpy[][];
  241.              memcpy(cpy, tmp, sizeof(cpy));
  242.              cpy[][] = tmp[][];
  243.              cpy[][] = tmp[][];
  244.              cpy[][] = tmp[][];
  245.              cpy[][] = tmp[][];
  246.              cpy[][] = tmp[][];
  247.              cpy[][] = tmp[][];
  248.              cpy[][] = tmp[][];
  249.              cpy[][] = tmp[][];
  250.              cpy[][] = tmp[][];
  251.              cpy[][] = tmp[][];
  252.              cpy[][] = tmp[][];
  253.              cpy[][] = tmp[][];
  254.              memcpy(tmp, cpy, sizeof(tmp));
  255.              /*for (int k = 0; k < 9; ++k)
  256.                  cout << tmp[k] << endl;
  257.              return;*/
  258.          }
  259.          else if (i == )
  260.          {
  261.              for (int k = , m = ; k < , m < ; ++k, ++m)
  262.              {
  263.                  for (int j = , n = ; j < , n < ; j += , ++n)
  264.                      temp.maze[m][n] = tmp[k][j];
  265.              }
  266.              temp = clockwise(temp);
  267.              for (int k = , m = ; k < , m < ; ++k, ++m)
  268.              {
  269.                  for (int j = , n = ; j < , n < ; j += , ++n)
  270.                      tmp[k][j] = temp.maze[m][n];
  271.              }
  272.              char cpy[][];
  273.              memcpy(cpy, tmp, sizeof(cpy));
  274.              cpy[][] = tmp[][];
  275.              cpy[][] = tmp[][];
  276.              cpy[][] = tmp[][];
  277.              cpy[][] = tmp[][];
  278.              cpy[][] = tmp[][];
  279.              cpy[][] = tmp[][];
  280.              cpy[][] = tmp[][];
  281.              cpy[][] = tmp[][];
  282.              cpy[][] = tmp[][];
  283.              cpy[][] = tmp[][];
  284.              cpy[][] = tmp[][];
  285.              cpy[][] = tmp[][];
  286.              memcpy(tmp, cpy, sizeof(tmp));
  287.              /*for (int k = 0; k < 9; ++k)
  288.                  cout << tmp[k] << endl;
  289.              return;*/
  290.          }
  291.          else if (i == )
  292.          {
  293.              for (int k = , m = ; k < , m < ; ++k, ++m)
  294.              {
  295.                  for (int j = , n = ; j < , n < ; j += , ++n)
  296.                      temp.maze[m][n] = tmp[k][j];
  297.              }
  298.              temp = cclockwise(temp);
  299.              for (int k = , m = ; k < , m < ; ++k, ++m)
  300.              {
  301.                  for (int j = , n = ; j < , n < ; j += , ++n)
  302.                      tmp[k][j] = temp.maze[m][n];
  303.              }
  304.              char cpy[][];
  305.              memcpy(cpy, tmp, sizeof(cpy));
  306.              cpy[][] = tmp[][];
  307.              cpy[][] = tmp[][];
  308.              cpy[][] = tmp[][];
  309.              cpy[][] = tmp[][];
  310.              cpy[][] = tmp[][];
  311.              cpy[][] = tmp[][];
  312.              cpy[][] = tmp[][];
  313.              cpy[][] = tmp[][];
  314.              cpy[][] = tmp[][];
  315.              cpy[][] = tmp[][];
  316.              cpy[][] = tmp[][];
  317.              cpy[][] = tmp[][];
  318.              memcpy(tmp, cpy, sizeof(tmp));
  319.              /*for (int k = 0; k < 9; ++k)
  320.                  cout << tmp[k] << endl;
  321.              return;*/
  322.          }
  323.          else if (i == )
  324.          {
  325.              for (int k = , m = ; k < , m < ; ++k, ++m)
  326.              {
  327.                  for (int j = , n = ; j < , n < ; j += , ++n)
  328.                      temp.maze[m][n] = tmp[k][j];
  329.              }
  330.              temp = clockwise(temp);
  331.              for (int k = , m = ; k < , m < ; ++k, ++m)
  332.              {
  333.                  for (int j = , n = ; j < , n < ; j += , ++n)
  334.                      tmp[k][j] = temp.maze[m][n];
  335.              }
  336.              char cpy[][];
  337.              memcpy(cpy, tmp, sizeof(cpy));
  338.              cpy[][] = tmp[][];
  339.              cpy[][] = tmp[][];
  340.              cpy[][] = tmp[][];
  341.              cpy[][] = tmp[][];
  342.              cpy[][] = tmp[][];
  343.              cpy[][] = tmp[][];
  344.              cpy[][] = tmp[][];
  345.              cpy[][] = tmp[][];
  346.              cpy[][] = tmp[][];
  347.              cpy[][] = tmp[][];
  348.              cpy[][] = tmp[][];
  349.              cpy[][] = tmp[][];
  350.              memcpy(tmp, cpy, sizeof(tmp));
  351.              /*for (int k = 0; k < 9; ++k)
  352.                  cout << tmp[k] << endl;
  353.              return;*/
  354.          }
  355.          else if (i == )
  356.          {
  357.              for (int k = , m = ; k < , m < ; ++k, ++m)
  358.              {
  359.                  for (int j = , n = ; j < , n < ; j += , ++n)
  360.                      temp.maze[m][n] = tmp[k][j];
  361.              }
  362.              temp = cclockwise(temp);
  363.              for (int k = , m = ; k < , m < ; ++k, ++m)
  364.              {
  365.                  for (int j = , n = ; j < , n < ; j += , ++n)
  366.                      tmp[k][j] = temp.maze[m][n];
  367.              }
  368.              char cpy[][];
  369.              memcpy(cpy, tmp, sizeof(cpy));
  370.              cpy[][] = tmp[][];
  371.              cpy[][] = tmp[][];
  372.              cpy[][] = tmp[][];
  373.              cpy[][] = tmp[][];
  374.              cpy[][] = tmp[][];
  375.              cpy[][] = tmp[][];
  376.              cpy[][] = tmp[][];
  377.              cpy[][] = tmp[][];
  378.              cpy[][] = tmp[][];
  379.              cpy[][] = tmp[][];
  380.              cpy[][] = tmp[][];
  381.              cpy[][] = tmp[][];
  382.              memcpy(tmp, cpy, sizeof(tmp));
  383.              /*for (int k = 0; k < 9; ++k)
  384.                  cout << tmp[k] << endl;
  385.              return;*/
  386.          }
  387.          else if (i == )
  388.          {
  389.              for (int k = , m = ; k < , m < ; ++k, ++m)
  390.              {
  391.                  for (int j = , n = ; j < , n < ; j += , ++n)
  392.                      temp.maze[m][n] = tmp[k][j];
  393.              }
  394.              temp = clockwise(temp);
  395.              for (int k = , m = ; k < , m < ; ++k, ++m)
  396.              {
  397.                  for (int j = , n = ; j < , n < ; j += , ++n)
  398.                      tmp[k][j] = temp.maze[m][n];
  399.              }
  400.              char cpy[][];
  401.              memcpy(cpy, tmp, sizeof(cpy));
  402.              cpy[][] = tmp[][];
  403.              cpy[][] = tmp[][];
  404.              cpy[][] = tmp[][];
  405.              cpy[][] = tmp[][];
  406.              cpy[][] = tmp[][];
  407.              cpy[][] = tmp[][];
  408.              cpy[][] = tmp[][];
  409.              cpy[][] = tmp[][];
  410.              cpy[][] = tmp[][];
  411.              cpy[][] = tmp[][];
  412.              cpy[][] = tmp[][];
  413.              cpy[][] = tmp[][];
  414.              memcpy(tmp, cpy, sizeof(tmp));
  415.              /*for (int k = 0; k < 9; ++k)
  416.                  cout << tmp[k] << endl;
  417.              return;*/
  418.          }
  419.          else if (i == )
  420.          {
  421.              for (int k = , m = ; k < , m < ; ++k, ++m)
  422.              {
  423.                  for (int j = , n = ; j < , n < ; j += , ++n)
  424.                      temp.maze[m][n] = tmp[k][j];
  425.              }
  426.              temp = cclockwise(temp);
  427.              for (int k = , m = ; k < , m < ; ++k, ++m)
  428.              {
  429.                  for (int j = , n = ; j < , n < ; j += , ++n)
  430.                      tmp[k][j] = temp.maze[m][n];
  431.              }
  432.              char cpy[][];
  433.              memcpy(cpy, tmp, sizeof(cpy));
  434.              cpy[][] = tmp[][];
  435.              cpy[][] = tmp[][];
  436.              cpy[][] = tmp[][];
  437.              cpy[][] = tmp[][];
  438.              cpy[][] = tmp[][];
  439.              cpy[][] = tmp[][];
  440.              cpy[][] = tmp[][];
  441.              cpy[][] = tmp[][];
  442.              cpy[][] = tmp[][];
  443.              cpy[][] = tmp[][];
  444.              cpy[][] = tmp[][];
  445.              cpy[][] = tmp[][];
  446.              memcpy(tmp, cpy, sizeof(tmp));
  447.              /*for (int k = 0; k < 9; ++k)
  448.                  cout << tmp[k] << endl;
  449.              return;*/
  450.          }
  451.          else if (i == )
  452.          {
  453.              for (int k = , m = ; k < , m < ; ++k, ++m)
  454.              {
  455.                  for (int j = , n = ; j < , n < ; j += , ++n)
  456.                      temp.maze[m][n] = tmp[k][j];
  457.              }
  458.              temp = clockwise(temp);
  459.              for (int k = , m = ; k < , m < ; ++k, ++m)
  460.              {
  461.                  for (int j = , n = ; j < , n < ; j += , ++n)
  462.                      tmp[k][j] = temp.maze[m][n];
  463.              }
  464.              char cpy[][];
  465.              memcpy(cpy, tmp, sizeof(cpy));
  466.              cpy[][] = tmp[][];
  467.              cpy[][] = tmp[][];
  468.              cpy[][] = tmp[][];
  469.              cpy[][] = tmp[][];
  470.              cpy[][] = tmp[][];
  471.              cpy[][] = tmp[][];
  472.              cpy[][] = tmp[][];
  473.              cpy[][] = tmp[][];
  474.              cpy[][] = tmp[][];
  475.              cpy[][] = tmp[][];
  476.              cpy[][] = tmp[][];
  477.              cpy[][] = tmp[][];
  478.              memcpy(tmp, cpy, sizeof(tmp));
  479.              /*for (int k = 0; k < 9; ++k)
  480.                  cout << tmp[k] << endl;
  481.              return;*/
  482.          }
  483.          else if (i == )
  484.          {
  485.              for (int k = , m = ; k < , m < ; ++k, ++m)
  486.              {
  487.                  for (int j = , n = ; j < , n < ; j += , ++n)
  488.                      temp.maze[m][n] = tmp[k][j];
  489.              }
  490.              temp = cclockwise(temp);
  491.              for (int k = , m = ; k < , m < ; ++k, ++m)
  492.              {
  493.                  for (int j = , n = ; j < , n < ; j += , ++n)
  494.                      tmp[k][j] = temp.maze[m][n];
  495.              }
  496.              char cpy[][];
  497.              memcpy(cpy, tmp, sizeof(cpy));
  498.              cpy[][] = tmp[][];
  499.              cpy[][] = tmp[][];
  500.              cpy[][] = tmp[][];
  501.              cpy[][] = tmp[][];
  502.              cpy[][] = tmp[][];
  503.              cpy[][] = tmp[][];
  504.              cpy[][] = tmp[][];
  505.              cpy[][] = tmp[][];
  506.              cpy[][] = tmp[][];
  507.              cpy[][] = tmp[][];
  508.              cpy[][] = tmp[][];
  509.              cpy[][] = tmp[][];
  510.              memcpy(tmp, cpy, sizeof(tmp));
  511.              /*for (int k = 0; k < 9; ++k)
  512.                  cout << tmp[k] << endl;
  513.              return;*/
  514.          }
  515.          /*if (i == 1 && deep == 2)
  516.          {
  517.              cout << "first" << endl;
  518.              for (int k = 0; k < 9; ++k)
  519.                  cout << tmp[k] << endl;
  520.          }
  521.          if (i == 2 && deep == 2)
  522.          {
  523.              cout << "second" << endl;
  524.              for (int k = 0; k < 9; ++k)
  525.                  cout << tmp[k] << endl;
  526.          }*/
  527.          dfs(rec + , tmp, deep);
  528.          //if (i == 1) return;
  529.          if (bol)
  530.          {
  531.              P[rec].first = i / ;
  532.              if (i %  == ) P[rec].second = ;
  533.              else P[rec].second = -;
  534.              return;
  535.          }
  536.      }
  537.  }
  538.  int main()
  539.  {
  540.      int T;
  541.      cin >> T;
  542.      while (T--)
  543.      {
  544.          string nul;
  545.          getline(cin, nul);
  546.          for (int i = ; i < ; ++i)
  547.          {
  548.              char ss;
  549.              int num = ;
  550.              while ((ss = getchar()) != '\n')
  551.              {
  552.                  if (ss != ' ') cube[i][num++] = ss;
  553.                  else cube[i][num++] = ' ';
  554.              }
  555.              cube[i][num] = '\0';
  556.          }
  557.          /*for (int i = 0; i < 9; ++i)
  558.              cout << cube[i] << endl;*/
  559.          /*for (int i = 0; i < 3; ++i)
  560.          {
  561.              for (int j = 6; j < 11; j += 2)
  562.              {
  563.                  cout << cube[i][j] << ' ';
  564.              }
  565.              cout << endl;
  566.          }*/
  567.          /*cur gat;
  568.          memcpy(gat.maze, cube, sizeof(gat.maze));
  569.          int p = judge(gat);
  570.          cout << p << endl;*/
  571.          bol = , ans = ;
  572.          for (int i = ; i <= ; ++i)
  573.          {
  574.              //cout << "deep:" <<  i << endl;
  575.              dfs(, cube, i);
  576.              if (bol)
  577.              {
  578.                  print();
  579.                  break;
  580.              }
  581.          }
  582.          if (!bol) cout << - << endl;
  583.      }
  584.      return ;
  585.  }

ZOJ2477 Magic Cube的更多相关文章

  1. ZOJ 2477 Magic Cube（魔方）

    ZOJ 2477 Magic Cube(魔方) Time Limit: 2 Seconds      Memory Limit: 65536 KB This is a very popular gam ...

  2. ZOJ 2477 Magic Cube 暴力,模拟 难度:0

    http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=1477 用IDA*可能更好,但是既然时间宽裕数据简单,而且记录状态很麻烦,就直接 ...

  3. magic cube

    搜索题, 每个状态能扩展出12种状态,最多进行5次旋转12^5 要用到iddfs,或者我看到网上其他人用的ida* 我也是参考了别人的代码,而且这个题vj上有点问题,我看数据看了半天,愣是没看明白第二 ...

  4. 2019杭电多校二 F. Fantastic Magic Cube (FWT)

    大意: 给定$N^3$立方体, 每个单位立方体权值为三个坐标异或, 每次沿坐标轴切一刀, 得分为两半内权值和的乘积, 求切成$n^3$块的最大得分. 可以发现得分与切法无关, 假设每个点权值为$a_i ...

  5. sdutoj 2606 Rubik’s cube

    http://acm.sdut.edu.cn/sdutoj/problem.php?action=showproblem&problemid=2606 Rubik’s cube Time Li ...

  6. USACO 3.2 Magic Squares

    Magic SquaresIOI'96 Following the success of the magic cube, Mr. Rubik invented its planar version, ...

  7. 用DirectX实现魔方（一）

    关于魔方 魔方英文名字叫做Rubik's Cube,是由匈牙利建筑学教授和雕塑家Ernő Rubik于1974年发明,最初叫做Magic Cube(这大概也是中文名字的来历吧),1980年Ideal ...

  8. 一位学长的ACM总结（感触颇深）

    发信人: fennec (fennec), 信区: Algorithm 标 题: acm 总结 by fennec 发信站: 吉林大学牡丹园站 (Wed Dec 8 16:27:55 2004) AC ...

  9. ZOJ - 2477 dfs [kuangbin带你飞]专题二

    注意输入的处理,旋转操作打表.递增枚举可能步数,作为限制方便找到最短路. AC代码:90ms #include<cstdio> #include<cstring> char m ...

随机推荐

  1. HDU_1068_Girls and Boys_二分图匹配

    Girls and Boys Time Limit: 20000/10000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) ...

  2. js中关于new Object时传参的一些细节分析

    1, 参数是一个对象,核心js对象(native ECMAScript object)或宿主对象(host object),那么将直接返回该对象. 其生成的对象构造器仍然是所传参数对象的构造器.这样造 ...

  3. 2.Linux的用户、用户组、权限、文件系统管理及其网络配置

    2.1 Linux的用户及用户组 2.1.1 Linux的用户管理 用户账号管理包含以下三个方面: 用户账号的添加.删除.与修改 用户口令(密码)的管理 用户组的添加.删除管理 Linux系统中用户信 ...

  4. PHP服务搭建

    一.PHP二进制安装(下载路径http://cn2.php.net/get/php-5.5.32.tar.gz/from/a/mirror) 1.解压: tar xf php-5.5.32.tar.g ...

  5. ORM 操作

    官方文档 一.操作 基本操作 # 增 models.Tb1.objects.create(c1='xx', c2='oo') # 增加一条数据,可以接受字典类型数据 **kwargs obj = mo ...

  6. python最好用的IDE及查看源码的方法

    一.PyCharm 很多语言都有比较流行的开发工具,比如JAVA 的Eclipse, C#,C++的VisualStudio,最好的Python 开发IDE就是PyCharm 可以直接调试代码,试运行 ...

  7. 【模板】非旋转Treap

    Treap,也叫做树堆,是指有一个随机附加域满足堆的性质的二叉搜索树. 如果一棵二叉搜索树插入节点的顺序是随机的,那我们得到的二叉搜索树在大多数情况下是平衡的,期望高度是log(n). 但有些情况下我 ...

  8. BZOJ 1724 USACO 2006 Nov. 切割木板

    倒过来的合并果子? 做法与合并果子一样 维护一个小根堆,每次取出最小的两个数进行合并 #include<cstdio> #include<algorithm> #include ...

  9. 绿色地址栏扩展验证（EV）SSL证书、支持SGC 强制最低128位

      Pro With EV SSL证书,最严格的域名所有权和企业身份信息验证,属于最高信任级别.最高安全级别的 EV SSL证书,该证书可以使地址栏变成高安全绿色,并且在地址栏内显示您公司的名称,提高 ...

  10. BUPT2017 springtraining(16) #2 ——基础数据结构

    题目在这里 A.似乎是个并查集+??? B.10W的范围,似乎可以暴力来一发二分+sort? 但我猜正解可以O(nlogn)? C.单调队列入门题目 #include <cstdio> ] ...