Amount of Time for Binary Tree to Be Infected - Problem

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

#define MAX_NODES 10000

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

static struct TreeNode* nodes[MAX_NODES];
static int visited[MAX_NODES];
static int queue[MAX_NODES];
static int front = 0, rear = 0;

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

struct TreeNode* buildTree(char* str) {
    if (str == NULL || strlen(str) == 0) return NULL;
    
    // Remove brackets and split by comma
    int len = strlen(str);
    if (str[0] == '[') str++, len -= 2;
    if (str[len-1] == ']') str[len-1] = '\0';
    
    char* values[MAX_NODES];
    int count = 0;
    
    char* token = strtok(str, ",");
    while (token != NULL && count < MAX_NODES) {
        values[count++] = token;
        token = strtok(NULL, ",");
    }
    
    if (count == 0) return NULL;
    
    struct TreeNode* root = createNode(atoi(values[0]));
    struct TreeNode* nodeQueue[MAX_NODES];
    int qfront = 0, qrear = 0;
    nodeQueue[qrear++] = root;
    
    int i = 1;
    while (qfront < qrear && i < count) {
        struct TreeNode* current = nodeQueue[qfront++];
        
        // Left child
        if (i < count && strcmp(values[i], "null") != 0) {
            current->left = createNode(atoi(values[i]));
            nodeQueue[qrear++] = current->left;
        }
        i++;
        
        // Right child
        if (i < count && strcmp(values[i], "null") != 0) {
            current->right = createNode(atoi(values[i]));
            nodeQueue[qrear++] = current->right;
        }
        i++;
    }
    
    return root;
}

void buildGraph(struct TreeNode* root) {
    if (!root) return;
    
    // Clear adjacency lists
    for (int i = 0; i < MAX_NODES; i++) {
        nodes[i] = NULL;
    }
    
    // BFS to build undirected graph representation
    struct TreeNode* bfsQueue[MAX_NODES];
    int bfront = 0, brear = 0;
    bfsQueue[brear++] = root;
    
    while (bfront < brear) {
        struct TreeNode* current = bfsQueue[bfront++];
        
        if (current->left) {
            bfsQueue[brear++] = current->left;
        }
        if (current->right) {
            bfsQueue[brear++] = current->right;
        }
    }
}

int amountOfTime(struct TreeNode* root, int start) {
    if (!root) return 0;
    
    // Find all nodes and build parent mapping
    struct TreeNode* nodeMap[10001];
    for (int i = 0; i <= 10000; i++) nodeMap[i] = NULL;
    struct TreeNode* parent[10001];
    for (int i = 0; i <= 10000; i++) parent[i] = NULL;
    
    // BFS to map all nodes and their parents
    struct TreeNode* bfsQueue[MAX_NODES];
    int bfront = 0, brear = 0;
    bfsQueue[brear++] = root;
    nodeMap[root->val] = root;
    
    while (bfront < brear) {
        struct TreeNode* current = bfsQueue[bfront++];
        
        if (current->left) {
            bfsQueue[brear++] = current->left;
            nodeMap[current->left->val] = current->left;
            parent[current->left->val] = current;
        }
        if (current->right) {
            bfsQueue[brear++] = current->right;
            nodeMap[current->right->val] = current->right;
            parent[current->right->val] = current;
        }
    }
    
    // BFS from start node to find maximum distance
    for (int i = 0; i <= 10000; i++) visited[i] = 0;
    
    front = rear = 0;
    queue[rear++] = start;
    visited[start] = 1;
    
    int time = -1;
    
    while (front < rear) {
        int size = rear - front;
        time++;
        
        for (int i = 0; i < size; i++) {
            int currentVal = queue[front++];
            struct TreeNode* currentNode = nodeMap[currentVal];
            
            // Visit left child
            if (currentNode->left && !visited[currentNode->left->val]) {
                visited[currentNode->left->val] = 1;
                queue[rear++] = currentNode->left->val;
            }
            
            // Visit right child
            if (currentNode->right && !visited[currentNode->right->val]) {
                visited[currentNode->right->val] = 1;
                queue[rear++] = currentNode->right->val;
            }
            
            // Visit parent
            if (parent[currentVal] && !visited[parent[currentVal]->val]) {
                visited[parent[currentVal]->val] = 1;
                queue[rear++] = parent[currentVal]->val;
            }
        }
    }
    
    return time;
}

int main() {
    char line[10000];
    int start;
    
    // Read tree array
    if (fgets(line, sizeof(line), stdin) != NULL) {
        // Remove newline
        line[strcspn(line, "\n")] = 0;
        
        // Read start node
        if (fgets(line + strlen(line) + 1, sizeof(line) - strlen(line) - 1, stdin) != NULL) {
            start = atoi(line + strlen(line) + 1);
        }
        
        struct TreeNode* root = buildTree(line);
        int result = amountOfTime(root, start);
        printf("%d\n", result);
    }
    
    return 0;
}