C Programming - Checking all valid solutions of a game board - c

Question

Ok so I'm to create a code in C which outputs all the possible solutions of a board. The board is a nxn board with a row looking like this(3x3): AA BA BB.
The objective of the game is to visit every position in the board by only going vertically or horizontally across the board. Also, you can only go to the next position if the first or second letter is the same so I can go from AA to BA but not from AA to BB and you can only visit each position once. The starting position is always the upper left corner or the 00 position.
Anyway, I thought of an algorithm where the computer starts at 00 and checks the next valid position, let's say 01. Then the computer checks all possible solutions using the chain of 00 and 01 as starting positions. When there's no more, the computer checks a new chain lets say 00, 10 and so on. How do you know not to repeat the previous solutions? I was thinking something with recursion. Are there more efficient path-finding algorithms other than mine?

Answer 1

Re: How do you know not to repeat the previous solutions?
A part of the depth first search algorithm involves marking the visited nodes so as not to visit them twice. This can be done in various ways: spare bits on the nodes themselves, initialized before every search, or a dynamic set data structure external to the graph being searched.
The problem is related to Gray code, by the way, which is a way of arranging the codes of a binary word so that only one bit changes between successive codes. E.g. 000 001 011 010 110 100 101 111.
What this means is that in your board, you can navigate to a neighboring square if and only if it is a two bit Gray code successor or predecessor.
But Gray code forms a sequence. So the problem is isomorphic to one in which there is a simple numbering from 0 to 3, and you are allowed from N to a N+1 successor or N-1 predecessor.
This can help you think about the problem.

Answer 2

Here's a very inefficient solution in Python. You should be able to follow along. I didn't want to just give away the answer in your own language :P
class Finder:
def __init__(self, board, n, x, y):
self.board = board
self.n = n
# Create a copy of the board.
self.copy = []
for i in range(n):
row = []
self.copy += [row]
for j in range(n):
row += [False]
# The best move sequence (longest).
self.best = []
# The current move sequence.
self.move = []
self.find(x, y)
def valid_move(self,x1, y1, x2, y2):
# Don't move off the board!
if x2 < 0 or x2 > self.n - 1 or y2 < 0 or y2 > self.n - 1:
return False
# Don't go somewhere we've gone before!
if self.copy[y2][x2]:
return False
# See if this is a valid move.
a = self.board[y1][x1]
b = self.board[y2][x2]
return a[0] == b[0] or \
a[0] == b[1] or \
a[1] == b[0] or \
a[1] == b[1]
def find(self,x, y):
self.move += [(x, y, board[y][x])]
self.copy[y][x] = True
# If this is the best path, then create a copy.
if len(self.move) > len(self.best):
self.best = list(self.move)
# Short-circuit if the optimal route is found.
if len(self.best) == self.n * self.n:
return
newX = x - 1
newY = y
if self.valid_move(x, y, newX, newY):
self.find(newX, newY)
newX = x
newY = y - 1
if self.valid_move(x, y, newX, newY):
self.find(newX, newY)
newX = x + 1
newY = y
if self.valid_move(x, y, newX, newY):
self.find(newX, newY)
newX = x
newY = y + 1
if self.valid_move(x, y, newX, newY):
self.find(newX, newY)
# Clean up by removing the last move.
self.move = self.move[:-1]
self.copy[y][x] = False
# The board
board = \
[["AB", "XX", "DE"],
["BB", "FE", "DD"],
["BC", "CC", "CD"],
]
# The size of the board.
n = 3
# Find!!
finder = Finder(board, n, 0, 0)
for row in board:
print(row)
# Print empty line.
print()
for move in finder.best:
print(move)
Here's the output:
['AB', 'XX', 'DE']
['BB', 'FE', 'DD']
['BC', 'CC', 'CD']
(0, 0, 'AB')
(0, 1, 'BB')
(0, 2, 'BC')
(1, 2, 'CC')
(2, 2, 'CD')
(2, 1, 'DD')
(2, 0, 'DE')