Binary Tree Coloring Game

Binary Tree Coloring Game - Problem

Two players play a turn-based game on a binary tree. We are given the root of this binary tree, and the number of nodes n in the tree. n is odd, and each node has a distinct value from 1 to n.

Initially, the first player names a value x with 1 <= x <= n, and the second player names a value y with 1 <= y <= n and y != x. The first player colors the node with value x red, and the second player colors the node with value y blue.

Then, the players take turns starting with the first player. In each turn, that player chooses a node of their color and colors an uncolored neighbor (either the left child, right child, or parent). If a player cannot choose such a node, they must pass their turn. If both players pass, the game ends, and the winner is the player that colored more nodes.

You are the second player. If it is possible to choose such a y to ensure you win the game, return true. If it is not possible, return false.

Input & Output

Example 1 — Blocking Strategy Works

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

› Output: true

💡 Note: First player chooses node 3. Second player can choose node 1 to block access to the parent subtree, securing more territory.

Example 2 — No Winning Strategy

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

› Output: false

💡 Note: With only 3 nodes total, first player at node 2 can spread to both children. No position gives second player majority.

Example 3 — Perfect Balance

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

› Output: true

💡 Note: First player at root (node 1) creates two subtrees of size 2 each. Second player can block one subtree and win 3-2.

Constraints

1 ≤ n ≤ 500
n is odd
1 ≤ x ≤ n
Tree has exactly n nodes with values 1 to n

Visualization

Tap to expand

Asked in

G Google 12 f Facebook 8 A Amazon 6

The key insight is that the second player should block the first player's access to their largest potential territory. By analyzing the tree structure around the first player's chosen node and calculating the sizes of the three regions (left subtree, right subtree, and parent region), we can determine if blocking the largest region gives the second player a winning advantage. Best approach uses strategic position analysis with Time: O(n), Space: O(h).

Common Approaches

✓ Bfs

⏱️ Time: N/A Space: N/A

Brute Force Simulation

⏱️ Time: O(n × 2^n) Space: O(n)

For each possible position y that the second player can choose, simulate the complete game by alternating turns and expanding territories. Count final nodes for each player to determine the winner.

Strategic Position Analysis

⏱️ Time: O(n) Space: O(h)

Instead of simulating the entire game, analyze the tree structure around the first player's chosen node. The key insight is that the second player should block the first player's access to the largest subtree.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

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

static int result[1000][1000];
static int levelSizes[1000];
static int totalLevels = 0;

void solution(struct TreeNode* root) {
    if (!root) {
        printf("[]\n");
        return;
    }
    
    // BFS using array as queue
    struct TreeNode* queue[1000];
    int front = 0, rear = 0;
    totalLevels = 0;
    memset(levelSizes, 0, sizeof(levelSizes));
    
    queue[rear++] = root;
    
    while (front < rear) {
        int levelSize = rear - front;
        int currentLevel = totalLevels++;
        
        // Process all nodes at current level
        for (int i = 0; i < levelSize; i++) {
            struct TreeNode* node = queue[front++];
            result[currentLevel][levelSizes[currentLevel]++] = node->val;
            
            // Add children to queue for next level
            if (node->left) queue[rear++] = node->left;
            if (node->right) queue[rear++] = node->right;
        }
    }
    
    // Print in reverse order (bottom-up)
    printf("[");
    for (int i = totalLevels - 1; i >= 0; i--) {
        printf("[");
        for (int j = 0; j < levelSizes[i]; j++) {
            printf("%d", result[i][j]);
            if (j < levelSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i > 0) printf(",");
    }
    printf("]\n");
}

struct TreeNode* createNode(int val) {
    struct TreeNode* node = malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

struct TreeNode* buildTree(int* arr, int size) {
    if (size == 0) return NULL;
    
    struct TreeNode** queue = malloc(size * sizeof(struct TreeNode*));
    struct TreeNode* root = createNode(arr[0]);
    queue[0] = root;
    
    int front = 0, rear = 1;
    int i = 1;
    
    while (front < rear && i < size) {
        struct TreeNode* node = queue[front++];
        
        if (i < size && arr[i] != -1001) {
            node->left = createNode(arr[i]);
            queue[rear++] = node->left;
        }
        i++;
        
        if (i < size && arr[i] != -1001) {
            node->right = createNode(arr[i]);
            queue[rear++] = node->right;
        }
        i++;
    }
    
    free(queue);
    return root;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Remove newline
    input[strcspn(input, "\n")] = 0;
    
    // Handle empty array
    if (strcmp(input, "[]") == 0) {
        printf("[]\n");
        return 0;
    }
    
    // Parse input - remove brackets
    char* content = input + 1;
    content[strlen(content) - 1] = '\0';
    
    int arr[1000];
    int size = 0;
    
    char* token = strtok(content, ",");
    while (token != NULL) {
        // Trim whitespace
        while (isspace(*token)) token++;
        char* end = token + strlen(token) - 1;
        while (end > token && isspace(*end)) *end-- = '\0';
        
        if (strcmp(token, "null") == 0) {
            arr[size++] = -1001; // Special value for null
        } else {
            arr[size++] = atoi(token);
        }
        token = strtok(NULL, ",");
    }
    
    struct TreeNode* root = buildTree(arr, size);
    solution(root);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.5K Views

Medium Frequency

~25 min Avg. Time

892 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