# 0348. Design Tic-Tac-Toe

<https://leetcode.com/problems/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:

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.

**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?

## ac

```java
class TicTacToe {
    private int[] r1, r2, c1, c2, d1, d2;
    private int n;
    /** Initialize your data structure here. */
    public TicTacToe(int n) {
        this.n = n;
        r1 = new int[n];
        r2 = new int[n];
        c1 = new int[n];
        c2 = new int[n];
        d1 = new int[2];
        d2 = new int[2];
    }

    /** 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) {
        // compute slope
        double mid = (n - 1) / 2.0;
        double slope = col == mid ? Double.MAX_VALUE : (row - mid) / (col - mid);


        if (player == 1) {
            r1[row]++;
            c1[col]++;

            if (slope == 1) {
                d1[0]++;
            } else if (slope == -1) {
                d1[1]++;
            } else if (row == mid && col == mid) {
                d1[0]++;
                d1[1]++;
            }
            if (r1[row] == n || c1[col] == n || d1[0] == n || d1[1] == n) return 1;
        } else {
            r2[row]++;
            c2[col]++;

            if (slope == 1) {
                d2[0]++;
            } else if (slope == -1) {
                d2[1]++;
            } else if (row == mid && col == mid) {
                d2[0]++;
                d2[1]++;
            }

            if (r2[row] == n || c2[col] == n || d2[0] == n || d2[1] == n) return 2;
        }
        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);
 */
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://jaywin.gitbook.io/leetcode/solutions/0348-design-tic-tac-toe.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.