Accounts Merge - Problem

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

#define MAX_ACCOUNTS 1000
#define MAX_EMAILS 10
#define MAX_EMAIL_LEN 31
#define MAX_NAME_LEN 31
#define MAX_INPUT 10000

typedef struct {
    char emails[MAX_EMAILS * MAX_ACCOUNTS][MAX_EMAIL_LEN];
    int emailCount;
} EmailSet;

typedef struct {
    int connections[MAX_ACCOUNTS];
    int count;
} AdjList;

static int visited[MAX_ACCOUNTS];
static AdjList graph[MAX_ACCOUNTS];
static EmailSet componentEmails;

void dfs(int accountIdx, char*** accounts, int* accountsColSize) {
    visited[accountIdx] = 1;
    
    for (int i = 1; i < accountsColSize[accountIdx]; i++) {
        strcpy(componentEmails.emails[componentEmails.emailCount], accounts[accountIdx][i]);
        componentEmails.emailCount++;
    }
    
    for (int i = 0; i < graph[accountIdx].count; i++) {
        int neighbor = graph[accountIdx].connections[i];
        if (!visited[neighbor]) {
            dfs(neighbor, accounts, accountsColSize);
        }
    }
}

void removeDuplicates(EmailSet* set) {
    int newCount = 0;
    for (int i = 0; i < set->emailCount; i++) {
        int isDuplicate = 0;
        for (int j = 0; j < newCount; j++) {
            if (strcmp(set->emails[i], set->emails[j]) == 0) {
                isDuplicate = 1;
                break;
            }
        }
        if (!isDuplicate) {
            if (i != newCount) {
                strcpy(set->emails[newCount], set->emails[i]);
            }
            newCount++;
        }
    }
    set->emailCount = newCount;
}

int compareEmails(const void* a, const void* b) {
    return strcmp((const char*)a, (const char*)b);
}

char*** parseInput(char* input, int* accountsSize, int** accountsColSize) {
    char*** accounts = (char***)malloc(MAX_ACCOUNTS * sizeof(char**));
    *accountsColSize = (int*)malloc(MAX_ACCOUNTS * sizeof(int));
    *accountsSize = 0;
    
    char* ptr = input + 2; // Skip initial [[
    
    while (*ptr && *ptr != '\n') {
        if (*accountsSize >= MAX_ACCOUNTS) break;
        
        accounts[*accountsSize] = (char**)malloc(MAX_EMAILS * sizeof(char*));
        (*accountsColSize)[*accountsSize] = 0;
        
        while (*ptr && *ptr != ']') {
            if (*ptr == '"') {
                ptr++; // Skip opening quote
                char* start = ptr;
                while (*ptr && *ptr != '"') ptr++;
                
                int len = ptr - start;
                accounts[*accountsSize][(*accountsColSize)[*accountsSize]] = (char*)malloc((len + 1) * sizeof(char));
                strncpy(accounts[*accountsSize][(*accountsColSize)[*accountsSize]], start, len);
                accounts[*accountsSize][(*accountsColSize)[*accountsSize]][len] = '\0';
                (*accountsColSize)[*accountsSize]++;
                
                if (*ptr == '"') ptr++; // Skip closing quote
            } else {
                ptr++;
            }
        }
        
        if (*ptr == ']') ptr++; // Skip ]
        while (*ptr && (*ptr == ',' || *ptr == '[' || *ptr == ' ')) ptr++; // Skip separators
        
        (*accountsSize)++;
        
        if (*ptr == ']') break; // End of input
    }
    
    return accounts;
}

int main() {
    static char input[MAX_INPUT];
    fgets(input, MAX_INPUT, stdin);
    
    int accountsSize;
    int* accountsColSize;
    char*** accounts = parseInput(input, &accountsSize, &accountsColSize);
    
    // Initialize graph
    for (int i = 0; i < accountsSize; i++) {
        graph[i].count = 0;
        visited[i] = 0;
    }
    
    // Build graph - connect accounts that share emails and have same name
    for (int i = 0; i < accountsSize; i++) {
        for (int j = i + 1; j < accountsSize; j++) {
            if (strcmp(accounts[i][0], accounts[j][0]) == 0) {
                int hasCommon = 0;
                for (int ei = 1; ei < accountsColSize[i] && !hasCommon; ei++) {
                    for (int ej = 1; ej < accountsColSize[j]; ej++) {
                        if (strcmp(accounts[i][ei], accounts[j][ej]) == 0) {
                            hasCommon = 1;
                            break;
                        }
                    }
                }
                
                if (hasCommon) {
                    graph[i].connections[graph[i].count++] = j;
                    graph[j].connections[graph[j].count++] = i;
                }
            }
        }
    }
    
    printf("[");
    int resultCount = 0;
    
    for (int i = 0; i < accountsSize; i++) {
        if (!visited[i]) {
            componentEmails.emailCount = 0;
            dfs(i, accounts, accountsColSize);
            
            removeDuplicates(&componentEmails);
            qsort(componentEmails.emails, componentEmails.emailCount, MAX_EMAIL_LEN, compareEmails);
            
            if (resultCount > 0) printf(",");
            printf("[\"%s\"", accounts[i][0]);
            
            for (int j = 0; j < componentEmails.emailCount; j++) {
                printf(",\"%s\"", componentEmails.emails[j]);
            }
            
            printf("]");
            resultCount++;
        }
    }
    
    printf("]\n");
    
    return 0;
}