Minimum Cost to Buy Apples

Minimum Cost to Buy Apples - Problem

You're a traveling merchant looking to buy apples from various cities and return home! 🍎

Given n cities numbered from 1 to n, you have a network of bidirectional roads connecting them. Each road has a travel cost, and each city sells apples at different prices. Here's the twist: after buying an apple, all road costs get multiplied by factor k for your return journey!

Your goal: For each possible starting city, find the minimum total cost to:

Travel to any city to buy exactly one apple
Return to your starting city (with increased road costs)

Input:

n cities and roads array where roads[i] = [a, b, cost]
appleCost array where appleCost[i-1] is the cost of buying an apple from city i
Factor k that multiplies return journey costs

Output: Array where answer[i-1] is the minimum total cost starting from city i

Input & Output

example_1.py — Basic Triangle

$ Input: n = 3, roads = [[1,2,5],[2,3,2],[1,3,3]], appleCost = [1,2,3], k = 2

› Output: [1, 2, 3]

💡 Note: From city 1: Best is to buy from city 1 itself (0+1+0=1). From city 2: Best is to buy from city 2 itself (0+2+0=2). From city 3: Best is to buy from city 3 itself (0+3+0=3).

example_2.py — Linear Path

$ Input: n = 2, roads = [[1,2,10]], appleCost = [5,1], k = 3

› Output: [5, 1]

💡 Note: From city 1: Buy from city 1 (0+5+0=5) or buy from city 2 (10+1+10*3=41). Min = 5. From city 2: Buy from city 2 (0+1+0=1) or buy from city 1 (10+5+10*3=45). Min = 1.

example_3.py — Single City

$ Input: n = 1, roads = [], appleCost = [10], k = 5

› Output: [10]

💡 Note: Only one city, must buy apple there with no travel cost.

Constraints

1 ≤ n ≤ 1000
0 ≤ roads.length ≤ min(n × (n - 1) / 2, 2000)
roads[i].length == 3
1 ≤ a_i, b_i ≤ n
a_i ≠ b_i
1 ≤ cost_i ≤ 1000
appleCost.length == n
1 ≤ appleCost[i] ≤ 1000
1 ≤ k ≤ 10
There are no repeated edges

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 23 🍎 Apple 18

The optimal approach uses Dijkstra's shortest path algorithm efficiently. Key insight: run Dijkstra from each starting city for outbound costs, then from each apple city with multiplied edge weights (k) for return costs. Total cost = outbound + apple_price + return. Time complexity: O(n × (E + V) log V), much better than Floyd-Warshall's O(n³) for sparse graphs.

Common Approaches

✓ Optimized Dijkstra (Multiple Source)

⏱️ Time: O(n × (E + V) log V) Space: O(V + E)

Use Dijkstra's shortest path algorithm efficiently. Run it n times for outbound paths, then once with all apple cities as sources for return paths with multiplied costs.

Optimized Dijkstra (Multiple Source) — Algorithm Steps

Build adjacency list representation of the graph
For each starting city, run Dijkstra to find shortest paths to all other cities
Run reverse Dijkstra with multiplied edge weights from all cities
Combine results: outbound_cost + apple_cost + k × return_cost
Take minimum for each starting city

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency list representation

Outbound Paths

Run Dijkstra from each starting city

Return Paths

Run Dijkstra with multiplied weights for return journeys

Combine Results

Calculate minimum total cost for each starting city

Code -

solution.c — C

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

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};
}

Item pop(PriorityQueue* pq) {
    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];
    pq->items[minIdx] = pq->items[--pq->size];
    return result;
}

int* dijkstra(int** graph, int* graphSizes, int** weights, int n, int start) {
    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 new_dist = dist[u] + weight;
            if (new_dist < dist[v]) {
                dist[v] = new_dist;
                push(pq, new_dist, v);
            }
        }
    }
    
    free(pq->items);
    free(pq);
    return dist;
}

int* minCost(int n, int** roads, int roadsSize, int* appleCost, int k) {
    // 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]++;
    }
    
    // Precompute all shortest distances
    int** all_distances = malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        all_distances[i] = dijkstra(graph, graphSizes, weights, n, i);
    }
    
    int* result = malloc(n * sizeof(int));
    
    for (int start = 0; start < n; start++) {
        int min_cost = INT_MAX;
        
        for (int apple_city = 0; apple_city < n; apple_city++) {
            // Total cost: go to apple city + buy apple + return with multiplier k
            int go_cost = all_distances[start][apple_city];
            int apple_cost = appleCost[apple_city];
            int return_cost = (all_distances[apple_city][start] == INT_MAX) ? INT_MAX : all_distances[apple_city][start] * k;
            
            // If any part is unreachable, skip this option
            if (go_cost == INT_MAX || return_cost == INT_MAX) {
                continue;
            }
            
            int total_cost = go_cost + apple_cost + return_cost;
            if (total_cost < min_cost) {
                min_cost = total_cost;
            }
        }
        
        result[start] = min_cost;
    }
    
    // Cleanup
    for (int i = 0; i < n; i++) {
        free(graph[i]);
        free(weights[i]);
        free(all_distances[i]);
    }
    free(graph);
    free(weights);
    free(graphSizes);
    free(all_distances);
    
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    
    char roadsLine[10000];
    scanf(" %[^\n]", roadsLine);
    
    static int roads[1000][3];
    int roadsSize = 0;
    
    if (strcmp(roadsLine, "[]") != 0) {
        char* p = roadsLine + 1; // Skip initial [
        while (*p && *p != ']') {
            if (*p == '[') {
                p++;
                int a = (int)strtol(p, &p, 10);
                if (*p == ',') p++;
                int b = (int)strtol(p, &p, 10);
                if (*p == ',') p++;
                int c = (int)strtol(p, &p, 10);
                
                roads[roadsSize][0] = a;
                roads[roadsSize][1] = b;
                roads[roadsSize][2] = c;
                roadsSize++;
            }
            p++;
        }
    }
    
    char appleLine[10000];
    scanf(" %[^\n]", appleLine);
    
    int appleCost[1000];
    int appleCount = 0;
    char* p = appleLine;
    while (*p) {
        if (*p >= '0' && *p <= '9') {
            appleCost[appleCount++] = (int)strtol(p, &p, 10);
            if (*p == ',') p++;
        } else {
            p++;
        }
    }
    
    int k;
    scanf("%d", &k);
    
    int** roadsPtr = malloc(roadsSize * sizeof(int*));
    for (int i = 0; i < roadsSize; i++) {
        roadsPtr[i] = roads[i];
    }
    
    int* result = minCost(n, roadsPtr, roadsSize, appleCost, k);
    
    for (int i = 0; i < n; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("\n");
    
    free(roadsPtr);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × (E + V) log V)

Run Dijkstra n+1 times, each taking O((E+V) log V) with priority queue

⚡ Linearithmic

Space Complexity

O(V + E)

Adjacency list and priority queue storage

✓ Linear Space

28.4K Views

Medium-High Frequency

~25 min Avg. Time

1.3K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Optimized Dijkstra (Multiple Source) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler