LeetCode 0348. Design Tic-Tac-Toe Solution in Java, Python, C++, JavaScript, Go & Rust | Explanation + Code

Description

Assume the following rules are for the tic-tac-toe game on an n x n board between two players:

1. A move is guaranteed to be valid and is placed on an empty block.
2. Once a winning condition is reached, no more moves are allowed.
3. A player who succeeds in placing n of their marks in a horizontal, vertical, or diagonal row wins the game.

Implement the TicTacToe class:

• TicTacToe(int n) Initializes the object the size of the board n.
• int move(int row, int col, int player) Indicates that the player with id player plays at the cell (row, col) of the board. The move is guaranteed to be a valid move, and the two players alternate in making moves. Return
  • 0 if there is no winner after the move,
  • 1 if player 1 is the winner after the move, or
  • 2 if player 2 is the winner after the move.

 

Example 1:

Input
["TicTacToe", "move", "move", "move", "move", "move", "move", "move"]
[[3], [0, 0, 1], [0, 2, 2], [2, 2, 1], [1, 1, 2], [2, 0, 1], [1, 0, 2], [2, 1, 1]]
Output
[null, 0, 0, 0, 0, 0, 0, 1]

Explanation
TicTacToe ticTacToe = new TicTacToe(3);
Assume that player 1 is "X" and player 2 is "O" in the board.
ticTacToe.move(0, 0, 1); // return 0 (no one wins)
|X| | |
| | | |    // Player 1 makes a move at (0, 0).
| | | |

ticTacToe.move(0, 2, 2); // return 0 (no one wins)
|X| |O|
| | | |    // Player 2 makes a move at (0, 2).
| | | |

ticTacToe.move(2, 2, 1); // return 0 (no one wins)
|X| |O|
| | | |    // Player 1 makes a move at (2, 2).
| | |X|

ticTacToe.move(1, 1, 2); // return 0 (no one wins)
|X| |O|
| |O| |    // Player 2 makes a move at (1, 1).
| | |X|

ticTacToe.move(2, 0, 1); // return 0 (no one wins)
|X| |O|
| |O| |    // Player 1 makes a move at (2, 0).
|X| |X|

ticTacToe.move(1, 0, 2); // return 0 (no one wins)
|X| |O|
|O|O| |    // Player 2 makes a move at (1, 0).
|X| |X|

ticTacToe.move(2, 1, 1); // return 1 (player 1 wins)
|X| |O|
|O|O| |    // Player 1 makes a move at (2, 1).
|X|X|X|

 

Constraints:

• 2 <= n <= 100
• player is 1 or 2.
• 0 <= row, col < n
• (row, col) are unique for each different call to move.
• At most n2 calls will be made to move.

 

Follow-up: Could you do better than O(n2) per move() operation?

Solutions

Solution 1: Counting

We can use an array of length n × 2 + 2 to record the number of pieces each player has in each row, each column, and the two diagonals. We need two such arrays to record the number of pieces for the two players respectively.

When a player has n pieces in a certain row, column, or diagonal, that player wins.

In terms of time complexity, the time complexity of each move is O(1). The space complexity is O(n), where n is the length of the side of the chessboard.

PythonJavaC++GoTypeScript

class TicTacToe: def __init__(self, n: int): self.n = n self.cnt = [defaultdict(int), defaultdict(int)] def move(self, row: int, col: int, player: int) -> int: cur = self.cnt[player - 1] n = self.n cur[row] += 1 cur[n + col] += 1 if row == col: cur[n << 1] += 1 if row + col == n - 1: cur[n << 1 | 1] += 1 if any(cur[i] == n for i in (row, n + col, n << 1, n << 1 | 1)): return player return 0 # Your TicTacToe object will be instantiated and called as such: # obj = TicTacToe(n) # param_1 = obj.move(row,col,player)(code-box)

class TicTacToe { private int n; private int[][] cnt; public TicTacToe(int n) { this.n = n; cnt = new int[2][(n << 1) + 2]; } public int move(int row, int col, int player) { int[] cur = cnt[player - 1]; ++cur[row]; ++cur[n + col]; if (row == col) { ++cur[n << 1]; } if (row + col == n - 1) { ++cur[n << 1 | 1]; } if (cur[row] == n || cur[n + col] == n || cur[n << 1] == n || cur[n << 1 | 1] == n) { return player; } return 0; } } /** * Your TicTacToe object will be instantiated and called as such: * TicTacToe obj = new TicTacToe(n); * int param_1 = obj.move(row,col,player); */(code-box)

class TicTacToe { private: int n; vector<vector<int>> cnt; public: TicTacToe(int n) : n(n) , cnt(2, vector<int>((n << 1) + 2, 0)) { } int move(int row, int col, int player) { vector<int>& cur = cnt[player - 1]; ++cur[row]; ++cur[n + col]; if (row == col) { ++cur[n << 1]; } if (row + col == n - 1) { ++cur[n << 1 | 1]; } if (cur[row] == n || cur[n + col] == n || cur[n << 1] == n || cur[n << 1 | 1] == n) { return player; } return 0; } }; /** * Your TicTacToe object will be instantiated and called as such: * TicTacToe* obj = new TicTacToe(n); * int param_1 = obj->move(row,col,player); */(code-box)

type TicTacToe struct { n int cnt [][]int } func Constructor(n int) TicTacToe { cnt := make([][]int, 2) for i := range cnt { cnt[i] = make([]int, (n<<1)+2) } return TicTacToe{n, cnt} } func (this *TicTacToe) Move(row int, col int, player int) int { cur := this.cnt[player-1] cur[row]++ cur[this.n+col]++ if row == col { cur[this.n<<1]++ } if row+col == this.n-1 { cur[this.n<<1|1]++ } if cur[row] == this.n || cur[this.n+col] == this.n || cur[this.n<<1] == this.n || cur[this.n<<1|1] == this.n { return player } return 0 } /** * Your TicTacToe object will be instantiated and called as such: * obj := Constructor(n); * param_1 := obj.Move(row,col,player); */(code-box)

class TicTacToe { private n: number; private cnt: number[][]; constructor(n: number) { this.n = n; this.cnt = [Array((n << 1) + 2).fill(0), Array((n << 1) + 2).fill(0)]; } move(row: number, col: number, player: number): number { const cur = this.cnt[player - 1]; cur[row]++; cur[this.n + col]++; if (row === col) { cur[this.n << 1]++; } if (row + col === this.n - 1) { cur[(this.n << 1) | 1]++; } if ( cur[row] === this.n || cur[this.n + col] === this.n || cur[this.n << 1] === this.n || cur[(this.n << 1) | 1] === this.n ) { return player; } return 0; } } /** * Your TicTacToe object will be instantiated and called as such: * var obj = new TicTacToe(n) * var param_1 = obj.move(row,col,player) */(code-box)