• [LeetCode] 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.
    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 单词搜索

     

    All LeetCode Questions List 题目汇总

  • 相关阅读:
    函数指针
    指针和数组的关系
    const修饰指针的三种效果
    指针做函数参数 (间接赋值是指针存在的最大意义)
    野指针
    指针
    JSP九大内置对象
    Android--获取App应用程序的大小
    Android--获取标题栏,状态栏,屏幕高度
    Android--获取使用的总流量和每个App的上传、下载的流量
  • 原文地址:https://www.cnblogs.com/lightwindy/p/9649759.html
Copyright © 2020-2023  润新知