2

I have an image separated into a 3x3 grid. The grid is represented by an array. Each column or row can be rotated through. E.g, the top row [1,2,3] could become [3,1,2] etc.

The array needs to end up as:

[1,2,3]
[4,5,6]
[7,8,9]

And would start from something like:

[5,3,9]
[7,1,4]
[8,6,2]

It will always be solvable, so this doesn't need to be checked.

I've tried a long handed approach of looking for '1' and moving left then up to its correct place, and so on for 2, 3,... but end up going round in circles for ever.

Any help would be appreciated, even if you can just give me a starting point/reference... I can't seem to think through this one.

Alexander Pavlov
  • 31,598
  • 5
  • 67
  • 93
avalore
  • 103
  • 1
  • 9

2 Answers2

1

your problem is that the moves to shift one value will mess up others. i suspect with enough set theory you can work out an exact solution, but here's a heuristic that has more chance of working.

first, note that if every number in a row belongs to that row then it's either trivial to solve, or some values are swapped. [2,3,1] is trivial, while [3,2,1] is swapped, for example.

so an "easier" target than placing 1 top left is to get all rows into that state. how might we do that? let's look at the columns...

if the column contains one number from each row, then we are in a similar state to above (it's either trivial to shift so numbers are in the correct rows, or it's swapped).

so, what i would suggest is:

   for column in columns:
       if column is not one value from each row:
          pick a value from column that is from a duplicate row
          rotate that row
   for column in columns:
       as well as possible, shift until each value is in correct row
   for row in rows:
       as well as possible, shift until each value is in correct column

now, that is not guaranteed to work, although it will tend to get close, and can solve some set of "almost right" arrangements.

so what i would then do is put that in a loop and, on each run, record a "hash" of the state (for example, a string containing the values read row by row). and then on each invocation if i detect (by checking if the hash was one we had seen already) that the state has already occurred (so we are repeating ourselves) i would invoke a "random shuffle" that mixes things up.

so the idea is that we have something that has a chance of working once we are close, and a shuffle that we resort to when that gets stuck in a loop.

as i said, i am sure there are smarter ways to do this, but if i were desperate and couldn't find anything on google, that's the kind of heuristic i would try... i am not even sure the above is right, but the more general tactic is:

  • identify something that will solve very close solutions (in a sense, find out where the puzzle is "linear")
  • try repeating that
  • shuffle if it repeats

and that's really all i am saying here.

andrew cooke
  • 45,717
  • 10
  • 93
  • 143
1

Since the grid is 3x3, you can not only find the solution, but find the smallest number of moves to solve the problem.

You would need to use Breadth First Search for this purpose.

Represent each configuration as a linear array of 9 elements. After each move, you reach a different configuration. Since the array is essentially a permutation of numbers between 1-9, there would be only 9! = 362,880 different configurations possible.

If we consider each configuration as a node, and making each move is considered as taking an edge, we can explore the entire graph in O(n), where n is the number of configurations. We need to make sure, that we do not re-solve a configuration which we have already seen before, so you would need a visited array, which marks each configuration visited as it sees it.

When you reach the 'solved' configuration, you can trace back the moves taken by using a 'parent' array, which stores the configuration you came from.

Also note, if it had been a 4x4 grid, the problem would have been quite intractable, since n would equal (4x4)! = 16! = 2.09227899 × 10^13. But for smaller problems like this, you can find the solution pretty fast.

Edit:

TL;DR:

  • Guaranteed to work, and pretty fast at that. 362,880 is a pretty small number for today's computers
  • It will find the shortest sequence of moves.
reddragon
  • 961
  • 8
  • 17
  • this is nice, but you're understating the work involved slightly. for each state you have 12 arrows to related states ((3 rows + 3 columns) * 2 directions). so you need to enumerate 12 * 362,880 different moves (it doesn't change whether it's possible or not, but it's more than just running through each point). edit: but there's a factor of 2 easier in that you can avoid duplicating work if the arrow already exists "coming in". – andrew cooke Mar 06 '12 at 18:25
  • Oh, I didn't mean to do that. Yes, you are correct. That's also an example of how the order notation hides important constants. But, the problem still remains sufficiently tractable. – reddragon Mar 06 '12 at 18:48