Rubik's Cube Algorithm

Transcription

1 Rubik's Cube Algorithm The assignment was to create an algorithm that would solve a randomly organized Rubik's Cube. While very simple on the surface, this problem turned out to be incredibly complex, much like the Rubik's Cube itself. The standard Rubik's Cube is a 3x3x3 brick with a total of six faces. The goal is quite simple, to maneuver all the like colors to be on the same side, however given approximately *10^20 possible combinations to choose from, this simple description betrays its true complexity. I began by searching the Internet forsome sort of common answer to this question as I have never been able to solve the Cube myself. What I found was a large number of accepted solutions. Most centered around some philosophy such as solve in layers or solve in progressively large bricks. It seemed that a number of them were also particularly well suited to speed solving or solving in very few total moves. I decided in the end, to choose an algorithm that used the fewest number of moves and also was well documented. I was daunted by the task of accounting for the incredible number of cases even in the simplified solution I had found, but was still confident I could do it. After I sat down to code, I my confidence soon wavered. The sheer number of possibilities was overwhelming. So I changed my tactic and decided to simply try to solve the problem in any way that I could. This lead me to the rather inefficient though effective method of brute force. Although I had decided on brute force, there were still a number of options to choose from. I ended up choosing a solution that mixed the iterative with a bit of recursion. What resulted was a solution broken into moves. In order that the algorithm be understand I will walk through it in plain English. Initially, the Rubik's Cube is declared and stored within a three dimensional array. The first dimension represents the face number. These run 0-5 to account for the six sides of the cube. The next two arrays create a 3x3 grid and simulate one face of the cube. Each element in the three dimensional array is the simply assigned as a value the number of its original face. Because of this, it is very easy to determine if the cube has been solved by comparing each element's location to its original value. After being initialized, the cube is scrambled x number of moves. This is accomplished by randomly generating a number and using this number to rotate a certain face in one of three directions x times. The legal turns are clockwise, counterclockwise and a half turn.

2 After scrambling the cube, the algorithm begins its work. For efficiency's sake I chose to read in n (the number of moves scrambled) to the solve algorithm. If this had not been done, the algorithm would have had to check to see if it had solved after every step. At this point two arrays are declared of depth equal to the number of moves the cube was scrambled. Each element in the arrays contain instructions for how to act at that particular move level. One array is used to store the face to be rotated and the other is to keep track of the type of rotation. Used in conjunction, the two arrays will give the correct move at any move level. For example, using rotation[3] and face[3] will yield the fourth action to take (because arrays are indexed from 0) in a series of moves. All that remains then is to update the move series after each trial so that each move pattern can be tried. What the algorithm really comes down to is almost as simple as binary counting. The first move is operated on first. Turn the first face clockwise then check for correctness. If it is not solved, revert to the scrambled cube. Initially I was reverting to the scrambled cube reversing the moves just applied, but this becomes impractical at higher move levels. After reverting, the type of turn is incremented to turn counter clockwise and the checks are again performed. After the last type of rotation is performed, the face to rotated is incremented. So now face 2 is turned clockwise and then is incremented to turn counter clockwise. The pattern continues in this way until all 18 possibilities have been tried for move number zero. When this happens, the behavior of move number one is changed. Move one now will rotate counter clockwise and move zero will again iterate through all 18 possibilities. Once this happens, move one is incremented again until it is time to increment move number 2. This call is done recursively so that no matter how many moves are to be made, the update function will keep calling itself. If the update function ever tries to increment move number n+1, we know the solution was not found and the solution can not be found in n moves. It is apparent that the solution will be found if the number of moves scrambled is correctly specified. Unfortunately, this algorithm is extremely poor to scale and on large numbers is too slow to be of any use. As is shown in the figures below, this algorithm scales very poorly.

3 Average Running Time (moves) Running Time (sec) Number of Iterations Row 38 Number of Moves Scrambled Time Elapsed (sec) Row 18 Number of Moves Scrambled Number of Moves Test # Seconds Elapsed Test #

4 There were a number of things that I learned from this assignment. First of all, we are not at a point yet, nor I don't think we ever will be, where efficiency of code can be made up for in the hardware. It seems that these days programmers do not need to crunch each byte to optimize their code and that is a good thing in most cases, but it can lead to sloppy code. In my case however, I simply did not have the time or patience to implement an efficient solution. So I reproved to myself as well that more time spent planning up front will lead to cleaner code in the end. I think my problem was that as the deadline approached and I did not have a concrete algorithm for solving even by brute force, I panicked a bit and began designing algorithms on the fly and coding them right off. I spent a large chunk of my time switching between various algorithms and wasted a lot of time that way. I switched between trying to solve the algorithm completely recursively to maintaining the current state via a two dimensional array to doing it all iteratively. The design I ended up with was actually I had scrapped earlier for its lack of potential. I think I just needed to design a solid design and stick with it. As a result of my lack of foresight, my code has a long way to go in terms of efficiency. Even looking at the code now, there are a number of changes I would like to make. For simplicity's sake, I decided that after every move I would revert to the scrambled cube I had been given instead of just going back one move. The algorithm I settled on is simply iterating through all possible solutions and so only the last move needs to change each time to accomplish this. But what I did was redo every move on every attempt and this surely cost a fair bit of time. I did think of doing it this way, but the problems involved in knowing how many moves to backtrack seemed difficult to deal with. Now I realize that I could return an integer from my update function to tell me how many move levels had been change, but at the time I was just trying to get code that functioned at all, let alone efficiently. One change that I did make was to replace my function for returning to the scrambled state. The old method would perform the moves it had just done in reverse order to give the original scrambled cube. The new way simply sets the cube's value back to the scrambled state stored in memory. Over the short term, the first method would be faster, but if done over too many moves, it becomes very slow and so I switched my method. In the future, I would try this algorithm recursively as it lends itself to a recursive solution. However, as it is unlikely that I will ever be tasked with this same problem ever again, I should just take away a few lessons. The first is that I also work better on a full complement of sleep. I

5 solved the bugs in my code in an hour after I slept whereas I had been spending hours debugging on little sleep. Secondly, and related to the first point, I probably should try and start as early as possible on projects because unforeseen problems always come up. Lastly, and most importantly, the design phase of any project needs to outlast the coding phase. A solid design leads to solid coding and a flawed design that can cause problems and rewrites for years to come.

6 Resources for Algorithm Development Lee, Jasmine. "Beginner Solution to the Rubik's Cube." 16 Jan April < Petrus, Lars. "Rubik's Cube Solution." 9 Mar April <

7 // RubiksCube program by Appendix // Here is the finished project :) // Note: The code for creating the cube and rotating was done in colaberation // with Joel and that group's work. // The code uses brute force to exhaust all possible move patterns given the number // of moves from solving. #include <iostream> #include <math.h> #include <ctime> using namespace std; class RubiksCube public: RubiksCube(); void rotateclockwise(int face, int cube[6][3][3]); void rotatecounter(int face, int cube[6][3][3]); void rotatehalf(int face, int cube[6][3][3]); void resetcube(int cube[6][3][3]); void scramblecube(int moves); void viewcube(int cube[6][3][3]); void solve(int moves); bool update (int rotation [], int face[6], int level, int moves); bool issolved(int cube[6][3][3]); private: int cubestore[6][3][3]; //cube[face][row][column] //cube is layed out like a die (opposite sides add up to 5) // 0 Top (3x3 matrix) // Middle order (wraps around) (3x3 matrix) // 5 Bottom (3x3 matrix) // Obviously the cube can be rotated but everything is relative ; RubiksCube::RubiksCube()

8 ; for(int i=0; i<6; i++) for(int j=0; j<3; j++) for(int k=0; k<3; k++) cubestore[i][j][k] = i; void RubiksCube::rotateClockwise(int face, int cube[6][3][3]) // Out of bounds checking done on other end int temp; //rotate the numbers on the face itself //corners temp = cube[face][0][0]; cube[face][0][0] = cube[face][2][0]; cube[face][2][0] = cube[face][2][2]; cube[face][2][2] = cube[face][0][2]; cube[face][0][2] = temp; //edges temp = cube[face][0][1]; cube[face][0][1] = cube[face][1][0]; cube[face][1][0] = cube[face][2][1]; cube[face][2][1] = cube[face][1][2]; cube[face][1][2] = temp; //rotate the other layer that is connected switch (face) case 0: for(int i = 0; i<3; i++) //rotating along the top layer temp = cube[1][0][i]; cube[1][0][i] = cube[2][0][i]; cube[2][0][i] = cube[4][0][i]; cube[4][0][i] = cube[3][0][i]; cube[3][0][i] = temp; case 1: for(int i=0; i<3; i++)

9 temp = cube[0][2][i]; cube[0][2][i] = cube[3][2-i][2]; cube[3][2-i][2] = cube[5][0][2-i]; cube[5][0][2-i] = cube[2][i][0]; cube[2][i][0] = temp; case 2: for(int i=0; i<3; i++) temp = cube[0][2-i][2]; cube[0][2-i][2] = cube[1][2-i][2]; cube[1][2-i][2] = cube[5][2-i][2]; cube[5][2-i][2] = cube[4][i][0]; cube[4][i][0] = temp; case 3: for(int i=0; i<3; i++) temp = cube[0][i][0]; cube[0][i][0] = cube[4][2-i][2]; cube[4][2-i][2] = cube[5][i][0]; cube[5][i][0] = cube[1][i][0]; cube[1][i][0] = temp; case 4: for(int i=0; i<3; i++) temp = cube[0][0][i]; cube[0][0][i] = cube[2][i][2]; cube[2][i][2] = cube[5][2][2-i]; cube[5][2][2-i] = cube[3][2-i][0]; cube[3][2-i][0] = temp; case 5: for(int i = 0; i<3; i++) //rotate bottom layer temp = cube[1][2][i]; cube[1][2][i] = cube[3][2][i]; cube[3][2][i] = cube[4][2][i]; cube[4][2][i] = cube[2][2][i]; cube[2][2][i] = temp;

10 ; return; void RubiksCube::rotateCounter(int face, int cube[6][3][3]) //Out of bounds checking done on other end int temp; //rotate the numbers on the face itself //corners temp = cube[face][0][0]; cube[face][0][0] = cube[face][0][2]; cube[face][0][2] = cube[face][2][2]; cube[face][2][2] = cube[face][2][0]; cube[face][2][0] = temp; //edges temp = cube[face][0][1]; cube[face][0][1] = cube[face][1][2]; cube[face][1][2] = cube[face][2][1]; cube[face][2][1] = cube[face][1][0]; cube[face][1][0] = temp; //rotate connected layer switch (face) case 0: for(int i = 0; i<3; i++) //rotating along the top layer temp = cube[1][0][i]; cube[1][0][i] = cube[3][0][i]; cube[3][0][i] = cube[4][0][i]; cube[4][0][i] = cube[2][0][i]; cube[2][0][i] = temp; case 1: for(int i=0; i<3; i++) temp = cube[0][2][i]; cube[0][2][i] = cube[2][i][0]; cube[2][i][0] = cube[5][0][2-i]; cube[5][0][2-i] = cube[3][2-i][2]; cube[3][2-i][2] = temp;

11 case 2: for(int i=0; i<3; i++) temp = cube[0][2-i][2]; cube[0][2-i][2] = cube[4][i][0]; cube[4][i][0] = cube[5][2-i][2]; cube[5][2-i][2] = cube[1][2-i][2]; cube[1][2-i][2] = temp; case 3: for(int i=0; i<3; i++) temp = cube[0][i][0]; cube[0][i][0] = cube[1][i][0]; cube[1][i][0] = cube[5][i][0]; cube[5][i][0] = cube[4][2-i][2]; cube[4][2-i][2] = temp; case 4: for(int i=0; i<3; i++) temp = cube[0][0][i]; cube[0][0][i] = cube[3][2-i][0]; cube[3][2-i][0] = cube[5][2][2-i]; cube[5][2][2-i] = cube[2][i][2]; cube[2][i][2] = temp; case 5: for(int i = 0; i<3; i++) //rotate bottom layer temp = cube[1][2][i]; cube[1][2][i] = cube[2][2][i]; cube[2][2][i] = cube[4][2][i]; cube[4][2][i] = cube[3][2][i]; cube[3][2][i] = temp; ; return; void RubiksCube::rotateHalf(int face, int cube[6][3][3])

12 rotateclockwise(face, cube); rotateclockwise(face, cube); return; void RubiksCube::resetCube(int cube[6][3][3]) for(int i=0; i<6; i++) for(int j=0; j<3; j++) for(int k=0; k<3; k++) cube[i][j][k] = cubestore[i][j][k]; void RubiksCube::scrambleCube(int moves) srand(time(0)); int face, type; for(int i=0; i<moves; i++) face = (rand() % 6); type = (rand() % 3); if(type == 0) rotateclockwise(face, cubestore); if(type == 1) rotatecounter(face, cubestore); if(type == 2) rotatehalf(face, cubestore); viewcube(cubestore); // Display cube after scramble for reference return; // Displays cube face by face in a line to take up less room // Positions 1-3 on the read out are the top layer; 4-6 are the middle; 7-9 the bottom; void RubiksCube::viewCube(int cube[6][3][3]) for (int i=0; i<6; i++)

13 cout << "Face: " << i << " -> "; for (int j=0; j<3; j++) for (int k=0; k<3; k++) cout << cube[i][j][k] << " "; cout << endl; cout << endl; return; bool RubiksCube::isSolved(int cube[6][3][3]) for (int i=0; i < 6; i++) for (int j=0; j<3; j++) for (int k=0; k<3; k++) if (cube[i][j][k]!= i) return false; return true; void RubiksCube::solve(int moves) bool solved = false; int test [6][3][3]; // Set test to equal cubestore's scrambled state resetcube(test); int rotation[moves]; for (int x = 0; x < moves; x++) rotation[x] = 0; int face[moves];

14 for (int x = 0; x < moves; x++) face[x] = 0; int counter = 0; // Counts number of tries at the puzzle int inc = -1; while (!solved) // Iterate through all possible combinations of moves if (!update (rotation, face, inc, moves)) cout << "This cube was more than " << moves; cout << " moves away from completion and was not solved" << endl; exit (1); // Do the rotations for (int m = 0; m < moves; m++) if (rotation[m] == 0) rotateclockwise(face[m], test); else if (rotation[m] == 1) rotatecounter(face[m], test); else // if (rotation[m] == 2) rotatehalf(face[m], test); if (issolved(test)) // Test for solved solved = true; cout << "Solved :) " << endl; cout << "Found answer on try number: " << counter << endl; viewcube(test); else // if the solution not found on this try //viewcube(test); // show cube for each failed attempt resetcube(test); // Put cube back to its scrambled state

15 return; counter++; // Count number of cycles performed // Recursively updates the two arrays that hold the type of moves for each level // so that all possible rotation patterns are found bool RubiksCube::update (int rotation [], int face[6], int inc, int moves) int next = inc + 1; if (next < moves) if (rotation[next] < 2) // Cycle through types of rotation // 0 - Clockwise; 1 - Counter; 2 - Half; rotation[next]++; else if (rotation[next] == 2) // After cycled through rotations... // Change which face is being rotated rotation[next] = 0; the next move if (face[next] < 5) face[next]++; else if (face[next] == 5) // After all faces rotated in every direction... // Change what happens on face[next] = 0; // Update next move level up if(!update(rotation, face, next, moves)) return false; else return false; // If move limit is exceeded return true;

16 int main() time_t start = time(0); int moves = 7; RubiksCube mycube; cout << "Scrambling..." << endl; cout << "----- Scrambled Cube -----" << endl; mycube.scramblecube(moves); cout << "Searching for answer..." << endl; mycube.solve(moves); time_t end = time(0); cout << "Solution took: " << end - start << " seconds" << endl; return 0;