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.
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?
Hint:
Could you trade extra space such that move() operation can be done in O(1)?
You need two arrays: int rows[n], int cols[n], plus two variables: diagonal, anti_diagonal.
解法1: 暴力解法，每走一步，对所走点的水平，竖直，对角线，反对角线进行检查是否满足条件。
解法2: 根据提示，分别建立水平，竖直两个数组，以及对角线，反对角线两个变量。每走一步分别对这几个进行判断，一个玩家加1，一个玩家-1，如果下棋子的点的水平或者垂直数组里的元素的值等于n, 或者对角线的值的绝对值等于n，那么就返回此时下棋子的选手赢。
Java:
public class TicTacToe {
int[][] matrix;
/** Initialize your data structure here. */
public TicTacToe(int n) {
matrix = new int[n][n];
}
/** Player {player} makes a move at ({row}, {col}).
@param row The row of the board.
@param col The column of the board.
@param player The player, can be either 1 or 2.
@return The current winning condition, can be either:
0: No one wins.
1: Player 1 wins.
2: Player 2 wins. */
public int move(int row, int col, int player) {
matrix[row][col]=player;
//check row
boolean win=true;
for(int i=0; i<matrix.length; i++){
if(matrix[row][i]!=player){
win=false;
break;
}
}
if(win) return player;
//check column
win=true;
for(int i=0; i<matrix.length; i++){
if(matrix[i][col]!=player){
win=false;
break;
}
}
if(win) return player;
//check back diagonal
win=true;
for(int i=0; i<matrix.length; i++){
if(matrix[i][i]!=player){
win=false;
break;
}
}
if(win) return player;
//check forward diagonal
win=true;
for(int i=0; i<matrix.length; i++){
if(matrix[i][matrix.length-i-1]!=player){
win=false;
break;
}
}
if(win) return player;
return 0;
}
}
Java:
public class TicTacToe {
int[] rows;
int[] cols;
int dc1;
int dc2;
int n;
/** Initialize your data structure here. */
public TicTacToe(int n) {
this.n=n;
this.rows=new int[n];
this.cols=new int[n];
}
/** Player {player} makes a move at ({row}, {col}).
@param row The row of the board.
@param col The column of the board.
@param player The player, can be either 1 or 2.
@return The current winning condition, can be either:
0: No one wins.
1: Player 1 wins.
2: Player 2 wins. */
public int move(int row, int col, int player) {
int val = (player==1?1:-1);
rows[row]+=val;
cols[col]+=val;
if(row==col){
dc1+=val;
}
if(col==n-row-1){
dc2+=val;
}
if(Math.abs(rows[row])==n
|| Math.abs(cols[col])==n
|| Math.abs(dc1)==n
|| Math.abs(dc2)==n){
return player;
}
return 0;
}
}
Python:
class TicTacToe(object):
def __init__(self, n):
"""
Initialize your data structure here.
:type n: int
"""
self.__size = n
self.__rows = [[0, 0] for _ in xrange(n)]
self.__cols = [[0, 0] for _ in xrange(n)]
self.__diagonal = [0, 0]
self.__anti_diagonal = [0, 0]
def move(self, row, col, player):
"""
Player {player} makes a move at ({row}, {col}).
@param row The row of the board.
@param col The column of the board.
@param player The player, can be either 1 or 2.
@return The current winning condition, can be either:
0: No one wins.
1: Player 1 wins.
2: Player 2 wins.
:type row: int
:type col: int
:type player: int
:rtype: int
"""
i = player - 1
self.__rows[row][i] += 1
self.__cols[col][i] += 1
if row == col:
self.__diagonal[i] += 1
if col == len(self.__rows) - row - 1:
self.__anti_diagonal[i] += 1
if any(self.__rows[row][i] == self.__size,
self.__cols[col][i] == self.__size,
self.__diagonal[i] == self.__size,
self.__anti_diagonal[i] == self.__size):
return player
return 0
C++:
class TicTacToe {
public:
/** Initialize your data structure here. */
TicTacToe(int n) {
board.resize(n, vector<int>(n, 0));
}
int move(int row, int col, int player) {
board[row][col] = player;
int i = 0, j = 0, n = board.size();
for (j = 1; j < n; ++j) {
if (board[row][j] != board[row][j - 1]) break;
}
if (j == n) return player;
for (i = 1; i < n; ++i) {
if (board[i][col] != board[i - 1][col]) break;
}
if (i == n) return player;
if (row == col) {
for (i = 1; i < n; ++i) {
if (board[i][i] != board[i - 1][i - 1]) break;
}
if (i == n) return player;
}
if (row + col == n - 1) {
for (i = 1; i < n; ++i) {
if (board[n - i - 1][i] != board[n - i][i - 1]) break;
}
if (i == n) return player;
}
return 0;
}
private:
vector<vector<int>> board;
};
C++:
class TicTacToe {
public:
/** Initialize your data structure here. */
TicTacToe(int n): rows(n), cols(n), N(n), diag(0), rev_diag(0) {}
int move(int row, int col, int player) {
int add = player == 1 ? 1 : -1;
rows[row] += add;
cols[col] += add;
diag += (row == col ? add : 0);
rev_diag += (row == N - col - 1 ? add : 0);
return (abs(rows[row]) == N || abs(cols[col]) == N || abs(diag) == N || abs(rev_diag) == N) ? player : 0;
}
private:
vector<int> rows, cols;
int diag, rev_diag, N;
};
类似题目：
[LeetCode] Valid Tic-Tac-Toe State 验证井字棋状态
[LeetCode] 79. Word Search 单词搜索