Minimax Game AI - Problem

Implement a minimax algorithm with alpha-beta pruning for Tic-Tac-Toe to create an unbeatable AI player.

The AI should analyze all possible future game states and choose the move that maximizes its chances of winning while minimizing the opponent's chances. Your implementation should include:

Minimax algorithm - recursively evaluate all possible moves
Alpha-beta pruning - optimize by cutting off branches that won't affect the final decision
Game state evaluation - determine if a position is winning, losing, or drawn

Given a Tic-Tac-Toe board state and whose turn it is, return the [row, col] coordinates of the best move for the current player.

Board representation: 3x3 matrix where 0 = empty, 1 = player 1 (maximizing), -1 = player 2 (minimizing)

Input & Output

Example 1 — Maximize Player Winning Move

$ Input: board = [[0,1,-1],[1,0,0],[0,0,0]], isMaximizing = true

› Output: [0,0]

💡 Note: Player 1 (maximizing) can win by playing at [0,0], creating a diagonal: [1,1,-1],[1,0,0],[0,0,0] → three 1's diagonally

Example 2 — Minimize Player Blocking Move

$ Input: board = [[1,0,0],[0,1,0],[0,0,-1]], isMaximizing = false

› Output: [2,2]

💡 Note: Player -1 (minimizing) must block the diagonal by playing at [2,2], preventing player 1 from getting three in a row

Example 3 — Late Game Optimal Move

$ Input: board = [[1,-1,1],[-1,1,-1],[0,1,0]], isMaximizing = true

› Output: [2,0]

💡 Note: With limited moves left, player 1 chooses [2,0] as the best available option to maximize their position

Constraints

Board is 3×3 matrix with values: 0 (empty), 1 (player 1), -1 (player 2)
At least one empty cell exists (game not over)
Board state is valid (no illegal configurations)
isMaximizing indicates current player: true for player 1, false for player -1

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 18 🍎 Apple 8 M Meta 10

The key insight is using minimax with alpha-beta pruning to create an unbeatable Tic-Tac-Toe AI. The algorithm recursively evaluates all possible future game states, with the maximizing player trying to achieve the highest score and the minimizing player trying to achieve the lowest. Alpha-beta pruning dramatically improves performance by eliminating branches that cannot affect the final decision. Best approach is Alpha-Beta Minimax. Time: O(b^(d/2)), Space: O(d)

Common Approaches

✓ Basic Minimax (No Pruning)

⏱️ Time: O(b^d) Space: O(d)

Pure minimax that evaluates all possible moves and counter-moves until the game ends. Maximizing player tries to get the highest score, minimizing player tries to get the lowest score.

Minimax with Alpha-Beta Pruning

⏱️ Time: O(b^(d/2)) Space: O(d)

Enhanced minimax that maintains alpha (best maximizing score) and beta (best minimizing score) bounds to eliminate branches that can't improve the current best option.

Basic Minimax (No Pruning) — Algorithm Steps

Check if game is over (win/loss/draw) and return score
Generate all possible moves for current player
For each move, recursively call minimax on resulting board state
Return best score for maximizing player or worst for minimizing player

Visualization

Tap to expand

Step-by-Step Walkthrough

Current Board

Start with given board state and player turn

Generate Moves

Find all empty cells as possible moves

Recursive Evaluation

For each move, recursively evaluate all counter-moves

Select Best

Choose move with highest score for maximizing player

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

int evaluate(int board[3][3]) {
    for (int i = 0; i < 3; i++) {
        if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][0] != 0)
            return board[i][0];
        if (board[0][i] == board[1][i] && board[1][i] == board[2][i] && board[0][i] != 0)
            return board[0][i];
    }
    if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[0][0] != 0)
        return board[0][0];
    if (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[0][2] != 0)
        return board[0][2];
    return 0;
}

int isFull(int board[3][3]) {
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            if (board[i][j] == 0) return 0;
        }
    }
    return 1;
}

int minimax(int board[3][3], int depth, int isMaximizing) {
    int score = evaluate(board);
    if (score != 0) return score;
    if (isFull(board)) return 0;
    
    if (isMaximizing) {
        int bestScore = INT_MIN;
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (board[i][j] == 0) {
                    board[i][j] = 1;
                    int currentScore = minimax(board, depth + 1, 0);
                    board[i][j] = 0;
                    if (currentScore > bestScore) bestScore = currentScore;
                }
            }
        }
        return bestScore;
    } else {
        int bestScore = INT_MAX;
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (board[i][j] == 0) {
                    board[i][j] = -1;
                    int currentScore = minimax(board, depth + 1, 1);
                    board[i][j] = 0;
                    if (currentScore < bestScore) bestScore = currentScore;
                }
            }
        }
        return bestScore;
    }
}

int* solution(int board[3][3], int isMaximizing) {
    static int bestMove[2];
    int bestScore = isMaximizing ? INT_MIN : INT_MAX;
    
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            if (board[i][j] == 0) {
                board[i][j] = isMaximizing ? 1 : -1;
                int score = minimax(board, 0, !isMaximizing);
                board[i][j] = 0;
                
                if ((isMaximizing && score > bestScore) || (!isMaximizing && score < bestScore)) {
                    bestScore = score;
                    bestMove[0] = i;
                    bestMove[1] = j;
                }
            }
        }
    }
    
    return bestMove;
}

int main() {
    char boardStr[100];
    char isMaxStr[10];
    
    fgets(boardStr, sizeof(boardStr), stdin);
    fgets(isMaxStr, sizeof(isMaxStr), stdin);
    
    int board[3][3];
    // Parse simple format [[0,1,-1],[1,0,0],[0,0,0]]
    char* ptr = boardStr;
    while (*ptr != '[') ptr++; // Find first [
    ptr++; // Skip [
    
    for (int i = 0; i < 3; i++) {
        while (*ptr != '[') ptr++; // Find row start
        ptr++; // Skip [
        for (int j = 0; j < 3; j++) {
            while (*ptr < '0' && *ptr != '-') ptr++; // Find number
            board[i][j] = atoi(ptr);
            while (*ptr != ',' && *ptr != ']') ptr++; // Skip to next
            if (*ptr == ',') ptr++;
        }
    }
    
    int isMaximizing = (strncmp(isMaxStr, "true", 4) == 0);
    
    int* result = solution(board, isMaximizing);
    printf("[%d,%d]\n", result[0], result[1]);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(b^d)

b is branching factor (avg 5 moves), d is depth (9 max), so roughly O(5^9)

✓ Linear Growth

Space Complexity

O(d)

Recursion stack depth equals maximum game tree depth (9 levels)

✓ Linear Space

23.5K Views

Medium Frequency

~45 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Minimax Game AI - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Basic Minimax (No Pruning) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler