TicTacToe AI Making Incorrect Decisions

Question

A little background: as a way to learn multinode trees in C++, I decided to generate all possible TicTacToe boards and store them in a tree such that the branch beginning at a n

Answer 1

The "naive" way to do this (for an arbitrary game where two players take turns doing a move) is to try each possible move recursively until you end up with a board where one is the winner, then back-track upwards in the tree marking the nodes as "O wins", "X wins" or "draw".

Each time you step up (one such step is usually called a ply), depending on who's move it is, assume the player chooses the move that is best for him/her. Since you are moving from the leaves and upwards, you will always know the optimum possible results for each child node.

When counting the number of possible winning or losing boards in a subtree, you are essentially assuming that each player will always make a random move. As you noted, this will not be very effective if you play against a smart player. The scheme I outlined above instead assumes that the opponent always makes a perfect move, trying to win.

Answer 2

The (usually) correct way to implement AI based on a decision tree is to use the "Minimax" algorithm:

1. Assign each leaf node a score (+1=player wins, -1=player loses, 0=tie)

2. Work your way up the tree, applying the following rules to each node:

   • For even depths (when the player would make a move), pick the child with the highest score, and copy that score to the node.
   • For odd depths (when the computer would make a move), pick the child with the lowest score, and copy that score to the node.

Of course, even and odd might need to be reversed, depending on who you decide goes first.

You can read more at:

• http://ai-depot.com/articles/minimax-explained/
• http://en.wikipedia.org/wiki/Minimax

Answer 3

Tic-Tac-Toe can be solved using a greedy algorithm and doesn't really require a decision tree.

If you want to continue using your current algorithm, do as patros suggests, and minimize the possibility of losing at each decision.

If you want a simpler approach have the AI do the following each turn:

1. Complete a winning Tic-Tac-Toe if possible.
2. Block an opposing Tic-Tac-Toe if possible.

3. Rate each square for its desirability, for each other taken square (by the AI) on a line, add one point of desirability for that square. For each square taken by the opponent, remove one point of desirability.

   For example, if the board is currently:

   _|O|X
   _|X|_
   O| |
   

   The top-left corner has a desirability of 0 (1 for the X in the same row, and 1 for the X in the diagonal, but -1 for each of the Os).

4. Play on the most desirable square. Breaking ties arbitrarily.

   In the example from above, the AI would choose the mid-right square, since it has a desirability of 2, which would lead to a win the following turn.

5. If the game has just begun, play the center square, if the center square is taken, choose a corner at random.

6. Win (or tie).

This was my grade 10 Visual Basic term project. It's impossible to beat and requires far less memory than storing a decision tree.

Answer 4

Your existing algorithm is good, except you are forgetting one thing. Never choose any path where a move by the other player results in you being unable to at least tie.

So basically, discard any branch where the players next move could result in an un-tieable situation and then run your existing algorithm. This results in the highest chance of winning against a non-perfect opponent, while removing the possibility of losing.