Lowest Common Ancestor of a Binary Tree II - Problem

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

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

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

bool find_node(TreeNode* node, int target) {
    if (!node) return false;
    if (node->val == target) return true;
    return find_node(node->left, target) || find_node(node->right, target);
}

int find_lca(TreeNode* node, int p, int q) {
    if (!node) return -1;
    
    int left_lca = find_lca(node->left, p, q);
    int right_lca = find_lca(node->right, p, q);
    
    // If LCA found in subtree, return it
    if (left_lca != -1) return left_lca;
    if (right_lca != -1) return right_lca;
    
    // Check if current node has p in one subtree and q in another
    bool left_has_p = find_node(node->left, p);
    bool left_has_q = find_node(node->left, q);
    bool right_has_p = find_node(node->right, p);
    bool right_has_q = find_node(node->right, q);
    
    bool is_p = node->val == p;
    bool is_q = node->val == q;
    
    // Current node is LCA if:
    // 1. One target is in left subtree (or current node) and other is in right subtree (or current node)
    // 2. Both conditions must be satisfied for both targets
    bool has_p = left_has_p || right_has_p || is_p;
    bool has_q = left_has_q || right_has_q || is_q;
    
    if (has_p && has_q) {
        // Check if they are in different subtrees or one is current node
        if ((left_has_p && (right_has_q || is_q)) ||
            (left_has_q && (right_has_p || is_p)) ||
            ((is_p || is_q) && (left_has_p || left_has_q || right_has_p || right_has_q))) {
            return node->val;
        }
    }
    
    return -1;
}

int solution(TreeNode* root, int p, int q) {
    if (!root) return -1;
    
    // First check if both p and q exist
    if (!find_node(root, p) || !find_node(root, q)) {
        return -1;
    }
    
    return find_lca(root, p, q);
}

TreeNode* build_tree(int* arr, int size) {
    if (size == 0 || arr[0] == -1001) return NULL;
    
    TreeNode* root = createNode(arr[0]);
    TreeNode* queue[1000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    int i = 1;
    
    while (front < rear && i < size) {
        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++;
    }
    
    return root;
}

int parse_array(char* line, int* arr) {
    int count = 0;
    char* ptr = line;
    
    // Skip initial '['
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    while (*ptr && *ptr != ']' && count < 1000) {
        // Skip whitespace and commas
        while (*ptr == ' ' || *ptr == ',') ptr++;
        
        if (*ptr == ']') break;
        
        // Check for "null"
        if (strncmp(ptr, "null", 4) == 0) {
            arr[count++] = -1001; // Use -1001 as null marker
            ptr += 4;
        } else if (*ptr == '-' || (*ptr >= '0' && *ptr <= '9')) {
            // Parse number
            char* endptr;
            arr[count++] = (int)strtol(ptr, &endptr, 10);
            ptr = endptr;
        } else {
            ptr++;
        }
    }
    
    return count;
}

int main() {
    char line[10000];
    if (!fgets(line, sizeof(line), stdin)) {
        printf("null\n");
        return 1;
    }
    
    // Remove newline
    line[strcspn(line, "\n")] = 0;
    
    int arr[1000];
    int size = parse_array(line, arr);
    
    int p, q;
    scanf("%d", &p);
    scanf("%d", &q);
    
    TreeNode* root = build_tree(arr, size);
    int result = solution(root, p, q);
    
    if (result == -1) {
        printf("null\n");
    } else {
        printf("%d\n", result);
    }
    
    return 0;
}