# Question

Formatted question description: https://leetcode.ca/all/348.html

```
348 Design Tic-Tac-Toe
Design a Tic-tac-toe game that is played between two players on a n x n grid.
You may assume the following rules:
A move is guaranteed to be valid and is placed on an empty block.
Once a winning condition is reached, no more moves is allowed.
A player who succeeds in placing n of their marks in a horizontal, vertical, or diagonal row wins the game.
Follow up:
Could you do better than O(n2) per move() operation?
Example:
Given n = 3, assume that player 1 is "X" and player 2 is "O" in the board.
TicTacToe toe = new TicTacToe(3);
toe.move(0, 0, 1); -> Returns 0 (no one wins)
|X| | |
| | | | // Player 1 makes a move at (0, 0).
| | | |
toe.move(0, 2, 2); -> Returns 0 (no one wins)
|X| |O|
| | | | // Player 2 makes a move at (0, 2).
| | | |
toe.move(2, 2, 1); -> Returns 0 (no one wins)
|X| |O|
| | | | // Player 1 makes a move at (2, 2).
| | |X|
toe.move(1, 1, 2); -> Returns 0 (no one wins)
|X| |O|
| |O| | // Player 2 makes a move at (1, 1).
| | |X|
toe.move(2, 0, 1); -> Returns 0 (no one wins)
|X| |O|
| |O| | // Player 1 makes a move at (2, 0).
|X| |X|
toe.move(1, 0, 2); -> Returns 0 (no one wins)
|X| |O|
|O|O| | // Player 2 makes a move at (1, 0).
|X| |X|
toe.move(2, 1, 1); -> Returns 1 (player 1 wins)
|X| |O|
|O|O| | // Player 1 makes a move at (2, 1).
|X|X|X|
Follow up:
Could you do better than O(n^2) per move() operation?
@tag-design
```

# Algorithm

The straightforward idea is, to create a board of size `nxn`

, where 0 means that there is no pawn at that position, 1 means that player 1 puts the stone, and 2 means player 2.

Then every time a piece is added to the board, we scan the current row, column, diagonal, and reverse diagonal to see if there are three pieces connected, if there are three pieces, return the corresponding player, if not, return 0.

But, we can do better.

Create a one-dimensional array rows and cols of size n, as well as variable diagonal diag and inverse diagonal rev_diag.

The idea of this method is,

- If player 1 puts a child in a certain column of the first row, then rows[0] will increment by 1,
- If player 2 puts a child in a certain column of the first row, rows[0] will decrement by 1,

Then only when rows[0] is equal to n or -n, it means that the children in the first row are all placed by a player, and then the game ends and returns to that player. The other rows and columns, the diagonal and the inverse diagonal are all in this way,

# Code

Java