typedef struct {
    int cost, node;
} Item;

typedef struct {
    Item* items;
    int size, capacity;
} PriorityQueue;

PriorityQueue* createPQ(int capacity) {
    PriorityQueue* pq = malloc(sizeof(PriorityQueue));
    pq->items = malloc(capacity * sizeof(Item));
    pq->size = 0;
    pq->capacity = capacity;
    return pq;
}

void push(PriorityQueue* pq, int cost, int node) {
    pq->items[pq->size++] = (Item){cost, node};
    // Simple insertion - in real implementation would use proper heap
}

Item pop(PriorityQueue* pq) {
    // Find minimum
    int minIdx = 0;
    for (int i = 1; i < pq->size; i++) {
        if (pq->items[i].cost < pq->items[minIdx].cost) {
            minIdx = i;
        }
    }
    Item result = pq->items[minIdx];
    // Remove by swapping with last element
    pq->items[minIdx] = pq->items[--pq->size];
    return result;
}

int* dijkstra(int** graph, int* graphSizes, int** weights, int n, int start, int multiplier) {
    int* dist = malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        dist[i] = INT_MAX;
    }
    dist[start] = 0;
    
    PriorityQueue* pq = createPQ(n * n);
    push(pq, 0, start);
    
    while (pq->size > 0) {
        Item curr = pop(pq);
        int d = curr.cost, u = curr.node;
        
        if (d > dist[u]) continue;
        
        for (int i = 0; i < graphSizes[u]; i++) {
            int v = graph[u][i];
            int weight = weights[u][i];
            int newDist = dist[u] + weight * multiplier;
            if (newDist < dist[v]) {
                dist[v] = newDist;
                push(pq, newDist, v);
            }
        }
    }
    
    free(pq->items);
    free(pq);
    return dist;
}

int* minCost(int n, int** roads, int roadsSize, int* roadsColSize, int* appleCost, int appleCostSize, int k, int* returnSize) {
    // Build adjacency list representation
    int** graph = malloc(n * sizeof(int*));
    int** weights = malloc(n * sizeof(int*));
    int* graphSizes = calloc(n, sizeof(int));
    
    // Count edges per node
    for (int i = 0; i < roadsSize; i++) {
        graphSizes[roads[i][0]-1]++;
        graphSizes[roads[i][1]-1]++;
    }
    
    // Allocate edge arrays
    for (int i = 0; i < n; i++) {
        graph[i] = malloc(graphSizes[i] * sizeof(int));
        weights[i] = malloc(graphSizes[i] * sizeof(int));
        graphSizes[i] = 0; // Reset for filling
    }
    
    // Fill adjacency list
    for (int i = 0; i < roadsSize; i++) {
        int a = roads[i][0] - 1, b = roads[i][1] - 1, cost = roads[i][2];
        graph[a][graphSizes[a]] = b;
        weights[a][graphSizes[a]] = cost;
        graphSizes[a]++;
        graph[b][graphSizes[b]] = a;
        weights[b][graphSizes[b]] = cost;
        graphSizes[b]++;
    }
    
    // Calculate all shortest paths
    int** allDistances = malloc(n * sizeof(int*));
    for (int start = 0; start < n; start++) {
        allDistances[start] = dijkstra(graph, graphSizes, weights, n, start, 1);
    }
    
    int** returnDistances = malloc(n * sizeof(int*));
    for (int appleCity = 0; appleCity < n; appleCity++) {
        returnDistances[appleCity] = dijkstra(graph, graphSizes, weights, n, appleCity, k);
    }
    
    int* result = malloc(n * sizeof(int));
    *returnSize = n;
    
    for (int start = 0; start < n; start++) {
        int minCost = INT_MAX;
        for (int appleCity = 0; appleCity < n; appleCity++) {
            int totalCost = allDistances[start][appleCity] + appleCost[appleCity] + returnDistances[appleCity][start];
            if (totalCost < minCost) {
                minCost = totalCost;
            }
        }
        result[start] = minCost;
    }
    
    // Cleanup
    for (int i = 0; i < n; i++) {
        free(graph[i]);
        free(weights[i]);
        free(allDistances[i]);
        free(returnDistances[i]);
    }
    free(graph);
    free(weights);
    free(graphSizes);
    free(allDistances);
    free(returnDistances);
    
    return result;
}