Minimum Spanning Tree

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

#define NUM_NODES 10
#define MAX_EDGES 20

typedef struct {
    int u; 
    int v; 
    int weight;
} Edge;

Edge edges[MAX_EDGES];
int edge_count = 0;

int parent[NUM_NODES];

void add_edge(char u, char v, int w) {
    edges[edge_count].u = u - 'A';
    edges[edge_count].v = v - 'A';
    edges[edge_count].weight = w;
    edge_count++;
}

void init_graph() {
    add_edge('A', 'B', 3);
    add_edge('A', 'D', 4);
    add_edge('A', 'E', 4);
    add_edge('B', 'C', 10);
    add_edge('B', 'E', 2);
    add_edge('B', 'F', 3);
    add_edge('C', 'F', 6);
    add_edge('C', 'G', 1);
    add_edge('D', 'E', 5);
    add_edge('D', 'H', 6);
    add_edge('E', 'F', 11);
    add_edge('E', 'H', 2);
    add_edge('E', 'I', 1);
    add_edge('F', 'G', 2);
    add_edge('F', 'I', 3);
    add_edge('F', 'J', 11);
    add_edge('G', 'J', 8);
    add_edge('H', 'I', 4);
    add_edge('I', 'J', 7);
}

int find(int i) {
    if (parent[i] == i)
        return i;
    return parent[i] = find(parent[i]);
}

void union_sets(int i, int j) {
    int root_i = find(i);
    int root_j = find(j);
    if (root_i != root_j) {
        parent[root_i] = root_j;
    }
}

int compare(const void *a, const void *b) {
    return ((Edge *)a)->weight - ((Edge *)b)->weight;
}

int main() {
    init_graph();

    char c1, c2;
    int new_weight;
    
    if (scanf("%c,%c,%d", &c1, &c2, &new_weight) != 3) {
        return 1;
    }

    int u = c1 - 'A';
    int v = c2 - 'A';

    for (int i = 0; i < edge_count; i++) {
        if ((edges[i].u == u && edges[i].v == v) || 
            (edges[i].u == v && edges[i].v == u)) {
            edges[i].weight = new_weight;
            break;
        }
    }

    qsort(edges, edge_count, sizeof(Edge), compare);

    for (int i = 0; i < NUM_NODES; i++) {
        parent[i] = i;
    }

    int mst_edges_count = 0;
    
    for (int i = 0; i < edge_count; i++) {
        int root_u = find(edges[i].u);
        int root_v = find(edges[i].v);

        if (root_u != root_v) {
            union_sets(root_u, root_v);
            printf("%d,", edges[i].weight);
            mst_edges_count++;
        }
        
        if (mst_edges_count == NUM_NODES - 1) break;
    }

    return 0;
}