Python：实现深度优先搜索Freecell Solitaire

Question

I've been trying so solve the Freecell Solitaire game with a DFS for well over a month now with only partial success. I'm a novice, with a non-CS background, that used classes and recursion for the first to solve a problem, mainly trying to imitate what I found through Google-searches and Stack Overflow posts. (general comments on code clarity etc are more than welcome)

The code for the game is here: https://pastebin.com/39KGZAW1 , which I hope is understandable. The idea behind it is:

• Create instances of the Board (class), something like snapshots in the game
• Find all possible moves
• Create one new instance per move and update (class function) the board with that move

The problems are:

• It seems to be taking too long (the computer ran out of memory when I tried saving every board, so I stopped and used a generator and a deque), never finding a solution
• When I tried using mini_stacks (a card deck with less than 13 cards, currently just 1s and 2s!) it doesn't seem to be finding any solutions either.
• The recursive approach seems faster (at least comparing how many Boards instances are created) than the two implementations of the while-loop

More details: After the game logic is coded, I mainly tried two approaches to the DFS. The first was with a recursive function:

def rec(board):

    if not board.moves:
        return 
    else:
        for i in board.moves:
            new = copy.deepcopy(board) # instead of a deep copy I also tried 
            # creating a new instance taking inputs directly from the board
            globals()["it"] += 1 # for lack of a better way
            new.tt = globals()["it"]
            new.update(i)
            if new._end == True:
                raise Exception("Solved!") # didn't focus on this yet
            boards.append(new)
            rec(new)

game = Board(mini_stacks) # or full_stacks, to initialize the recursion
rec(game) # start the recursion with the game

The second approach was using a while loop:

game = Board(mini_stacks)
boards = deque()
boards.append(game)
while boards:  

    current_search = boards.popleft()
    if current_search._end:
        print("Win")
        winning = copy.deepcopy(current_search)
        break # win

    if current_search.moves:
        for no,move in enumerate(current_search.moves):
            new = copy.deepcopy(current_search)
            it += 1
            new.tt = it
            new.update(move)
            boards.insert(no,new)

With a slight modification, I created a generator function (also new to the concept) and used it for the while loop, adding a stack (=deque?):

def next_generator(boards=boards):

    if boards[0].moves:
        for no,move in enumerate(boards[0].moves):
            new = copy.deepcopy(boards[0])
            globals()["it"] += 1
            new.tt = globals()["it"]
            new.update(move)
            boards.append(new)
        yield boards.popleft()

while True:

    current_search = next(next_generator())
    if current_search._end:
        print("Win")
        winning = copy.deepcopy(current_search)
        break # win 

game = Board(mini_stacks)
boards = deque()
boards.append(game)
next_generator()

Answer 1

So after taking a break I found it. As it seems, it was not the recurion nor the while loops. I did the following:

Major changes in the core code (pastebin link):

• Removed the part where I was checking if the first item in memory was in the slice [1:] and instead, in the add_moves function, just before appending a move to the self._moves I check if it already is in memory: if move not in self.memory: self._moves.append(move) (did this for every append)
  • Instead of hardcoding the win condition I now use the number of cards in the game (the maximum number found in the stacks)

Minor changes in the core code:

• Removed self.memory.append("move 0") , as it was not necessary
• In add_moves function I added a color to each card and stack, instead of just having a different shape. A simple: if card[2][1] in ["D","H"]: card_color = "red" and else: card_color = "black" (and another one for each card in the stacks, changing card to stack[-1][1]

Using the second approach ( while loop without function definitions) I tested for stacks of various sizes. When taking too much time, I stop the program, shuffle the deck and re-run. It found solutions relatively fast for sizes 2-6, and then for 7+ the time (as well as Board objects created) skyrockets. I tried with 9,11 and 13 cards but it didn't find a solution quickly and I got bored eventually.

Here you can see no of Boards created till solution (or stop) of 5 re-runs (shuffles) per deck size.