348. Design Tic-Tac-Toe π ο
Descriptionο
Assume the following rules are for the tic-tac-toe game on an n x n board between two players:
- A move is guaranteed to be valid and is placed on an empty block.
- Once a winning condition is reached, no more moves are allowed.
- A player who succeeds in placing
nof 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 boardn.int move(int row, int col, int player)Indicates that the player with idplayerplays 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. Return0if there is no winner after the move,1if player 1 is the winner after the move, or2if 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
1or2. 0 <= row, col < n(row, col)are unique for each different call tomove.- At most
n2calls will be made tomove.
Follow-up: Could you do better than O(n2) per move() operation?
Solutionsο
Solution 1: Countingο
We can use an array of length $n \times 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.
Python3ο
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)
Javaο
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);
*/
C++ο
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);
*/
Goο
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);
*/
TypeScriptο
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)
*/