Minimum Cost to Buy Apples - Practice Coding Problems

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: [8, 8, 10]

💡 Note: From city 1: Best is to buy from city 1 (cost 0 + 1 + 0*2 = 1) but we need to consider the return journey cost structure. Actually going to city 2 costs 5+2+5*2 = 17, going to city 3 costs 3+3+3*2 = 12. So minimum is buying from city 1 itself: 0+1+0 = 1. Wait, let me recalculate properly...

example_2.py — Linear Path

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

› Output: [35, 31]

💡 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.

Visualization

Tap to expand

Understanding the Visualization

Map the Network

Build a graph of cities connected by roads with travel costs

Calculate Outbound Costs

From each starting city, find shortest paths to all apple markets

Calculate Return Costs

From each apple market, find shortest paths back with traffic multiplier k

Find Optimal Strategy

For each starting city, choose the apple market that minimizes total journey cost

Key Takeaway

🎯 Key Insight: The problem combines shortest path finding with economic optimization. Use Dijkstra's algorithm twice: once for normal costs and once with multiplied return costs.

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

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

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

Approach	Time	Space	Notes
✓ Optimized Dijkstra (Multiple Source)	O(n × (E + V) log V)	O(V + E)	Run Dijkstra from each city and from all cities combined for return paths

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

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

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

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized Dijkstra (Multiple Source) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler