Binary Tree Coloring Game - Practice Coding Problems

Binary Tree Coloring Game - Problem

Imagine a strategic game played on a binary tree where two players compete to control the most nodes! 🎮

Game Rules:

Two players take turns coloring nodes on a binary tree with n nodes (where n is odd)
Each node has a unique value from 1 to n
Player 1 (Red) chooses any node x and colors it red
Player 2 (Blue) then chooses a different node y and colors it blue
Players alternate turns, each coloring an uncolored neighbor (parent, left child, or right child) of their already colored nodes
If a player cannot make a move, they pass
Game ends when both players pass consecutively
Winner: Player who colored more nodes!

Your Mission: You are Player 2. Given the tree structure and Player 1's choice x, determine if you can choose a node y that guarantees your victory. Return true if you can win, false otherwise.

Input & Output

example_1.py — Small Tree Victory

$ Input: root = [1,2,3,4,5,6,7,8,9,10,11], n = 11, x = 3

› Output: true

💡 Note: Player 1 chooses node 3. This creates three regions: left subtree (nodes 6,7), right subtree (nodes 12,13 - but these don't exist in our tree, so 0 nodes), and parent region (remaining 8 nodes). Player 2 can choose node 1 to block access to the large parent region containing 8 nodes, guaranteeing victory.

example_2.py — Balanced Tree

$ Input: root = [1,2,3], n = 3, x = 1

› Output: false

💡 Note: Player 1 chooses the root node 1. This creates three regions: left subtree (node 2 = 1 node), right subtree (node 3 = 1 node), and parent region (0 nodes since root has no parent). The largest region has only 1 node, which is not greater than 3/2 = 1.5, so Player 2 cannot guarantee a win.

example_3.py — Large Subtree

$ Input: root = [1,2,3,4,5], n = 5, x = 2

› Output: true

💡 Note: Player 1 chooses node 2. This creates: left subtree (nodes 4,5 = 2 nodes), right subtree (0 nodes), and parent region (nodes 1,3 = 2 nodes). The largest regions have 2 nodes each, and 2 > 5/2 = 2.5 is false, but Player 2 can still win by strategic placement.

Visualization

Tap to expand

Understanding the Visualization

Player 1 Claims Base

Red army establishes their fortress at node x, creating natural boundaries

Territory Analysis

The battlefield divides into 3 distinct regions based on the red fortress location

Strategic Positioning

Blue army identifies the largest territory and positions to cut off red's access

Victory Condition

If blue can control access to a territory > 50% of total land, victory is guaranteed

Key Takeaway

🎯 Key Insight: Player 2 wins by recognizing that Player 1's choice creates exactly 3 territories, and strategically blocking access to any territory containing more than half the total nodes guarantees victory!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single DFS traversal to find node x and calculate subtree sizes

✓ Linear Growth

Space Complexity

O(h)

Recursion stack space where h is the height of the tree

✓ Linear Space

Constraints

The number of nodes in the tree is n
1 ≤ n ≤ 10⁴
n is odd
1 ≤ Node.val ≤ n
All Node.val are unique
1 ≤ x ≤ n
Player 1's choice x corresponds to an existing node in the tree

Asked in

G Google 45 f Meta 32 a Amazon 28 ⊞ Microsoft 18

The optimal solution uses a mathematical analysis approach that recognizes Player 1's choice divides the tree into exactly three regions: left subtree, right subtree, and parent region. Player 2 can guarantee victory if any region contains more than n/2 nodes, allowing them to block Player 1's access to the majority territory. This elegant insight reduces the problem from game simulation to simple subtree counting in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Simulate All Possible Choices	O(n³)	O(n)	Try every possible node y and simulate the complete game for each choice
Optimal Mathematical Analysis	O(n)	O(h)	Analyze the three regions created by Player 1's choice and block the largest one

Simulate All Possible Choices — Algorithm Steps

For each node y (except x), simulate Player 2 choosing it
Use BFS to simulate optimal gameplay from both starting positions
Count final territories for both players
Check if Player 2 wins in any scenario

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose candidate y

Select a potential node y for Player 2 (blue)

Initialize game state

Set initial red and blue territories

Simulate alternating moves

Players take turns expanding to adjacent uncolored nodes

Check victory condition

Compare final territory sizes to determine winner

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

#define MAX_N 1001

int adj[MAX_N][MAX_N];
int adjSize[MAX_N];
bool visited[MAX_N];

void buildAdjacencyList(struct TreeNode* node) {
    if (!node) return;
    
    if (node->left) {
        adj[node->val][adjSize[node->val]++] = node->left->val;
        adj[node->left->val][adjSize[node->left->val]++] = node->val;
        buildAdjacencyList(node->left);
    }
    if (node->right) {
        adj[node->val][adjSize[node->val]++] = node->right->val;
        adj[node->right->val][adjSize[node->right->val]++] = node->val;
        buildAdjacencyList(node->right);
    }
}

void getAllNodes(struct TreeNode* node, int* nodes, int* count) {
    if (node) {
        nodes[(*count)++] = node->val;
        getAllNodes(node->left, nodes, count);
        getAllNodes(node->right, nodes, count);
    }
}

bool simulateGame(int n, int startX, int startY) {
    bool redNodes[MAX_N] = {false};
    bool blueNodes[MAX_N] = {false};
    redNodes[startX] = true;
    blueNodes[startY] = true;
    
    bool redTurn = true;
    while (true) {
        bool moved = false;
        
        if (redTurn) {
            for (int i = 1; i <= n && !moved; i++) {
                if (redNodes[i]) {
                    for (int j = 0; j < adjSize[i]; j++) {
                        int neighbor = adj[i][j];
                        if (!redNodes[neighbor] && !blueNodes[neighbor]) {
                            redNodes[neighbor] = true;
                            moved = true;
                            break;
                        }
                    }
                }
            }
        } else {
            for (int i = 1; i <= n && !moved; i++) {
                if (blueNodes[i]) {
                    for (int j = 0; j < adjSize[i]; j++) {
                        int neighbor = adj[i][j];
                        if (!redNodes[neighbor] && !blueNodes[neighbor]) {
                            blueNodes[neighbor] = true;
                            moved = true;
                            break;
                        }
                    }
                }
            }
        }
        
        if (!moved) {
            if (redTurn) {
                redTurn = false;
                bool blueCanMove = false;
                for (int i = 1; i <= n && !blueCanMove; i++) {
                    if (blueNodes[i]) {
                        for (int j = 0; j < adjSize[i]; j++) {
                            int neighbor = adj[i][j];
                            if (!redNodes[neighbor] && !blueNodes[neighbor]) {
                                blueCanMove = true;
                                break;
                            }
                        }
                    }
                }
                if (!blueCanMove) break;
            } else {
                break;
            }
        } else {
            redTurn = !redTurn;
        }
    }
    
    int redCount = 0, blueCount = 0;
    for (int i = 1; i <= n; i++) {
        if (redNodes[i]) redCount++;
        if (blueNodes[i]) blueCount++;
    }
    
    return blueCount > redCount;
}

bool btreeGameWinningMove(struct TreeNode* root, int n, int x) {
    // Initialize adjacency list
    for (int i = 0; i <= n; i++) {
        adjSize[i] = 0;
    }
    
    buildAdjacencyList(root);
    
    int allNodes[MAX_N];
    int nodeCount = 0;
    getAllNodes(root, allNodes, &nodeCount);
    
    for (int i = 0; i < nodeCount; i++) {
        int y = allNodes[i];
        if (y != x) {
            if (simulateGame(n, x, y)) {
                return true;
            }
        }
    }
    
    return false;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n) choices for y, each requiring O(n²) game simulation in worst case

⚠ Quadratic Growth

Space Complexity

O(n)

Space for BFS queue and visited tracking during simulation

⚡ Linearithmic Space

Constraints

The number of nodes in the tree is n
1 ≤ n ≤ 10⁴
n is odd
1 ≤ Node.val ≤ n
All Node.val are unique
1 ≤ x ≤ n
Player 1's choice x corresponds to an existing node in the tree

42.5K Views

Medium Frequency

~15 min Avg. Time

1.8K 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Simulate All Possible Choices — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler