Minimum Cost to Reach City With Discounts

Minimum Cost to Reach City With Discounts - Problem

Imagine you're planning a road trip across a network of cities connected by toll highways! 🛣️

You have n cities numbered from 0 to n-1, connected by a series of highways. Each highway is represented as [city1, city2, toll], meaning you can travel between these cities in either direction for the given toll cost.

Here's the twist: You have a limited number of discount coupons that can cut any highway's toll in half! Each coupon can only be used once, and you can use at most one coupon per highway.

Goal: Find the minimum cost to travel from city 0 to city n-1, using your discounts strategically. If it's impossible to reach the destination, return -1.

Example: With highways [[0,1,4], [1,2,3], [0,2,10]] and 1 discount, you could go 0→1 (cost 4) then 1→2 with discount (cost 1), totaling 5 instead of the direct route's cost of 10.

Input & Output

example_1.py — Simple Path with Discount

$ Input: n = 5, highways = [[0,1,4],[2,1,3],[1,4,11],[3,2,3],[3,4,2]], discounts = 1

› Output: 9

💡 Note: The optimal path is 0→1→2→3→4. Costs are 4+3+3+2=12 normally. Using the discount on the highway 1→4 (cost 11→5) gives us path 0→1→4 with cost 4+5=9, which is optimal.

example_2.py — Multiple Discounts

$ Input: n = 4, highways = [[0,1,3],[2,3,2]], discounts = 0

› Output: -1

💡 Note: There's no path from city 0 to city 3 since the highways don't connect these cities. The graph has disconnected components: {0,1} and {2,3}.

example_3.py — Strategic Discount Usage

$ Input: n = 4, highways = [[0,1,10],[1,2,10],[2,3,10],[0,3,20]], discounts = 1

› Output: 25

💡 Note: Without discounts: path 0→1→2→3 costs 30, direct path 0→3 costs 20. With 1 discount optimally used on 0→3, we get cost 10. But the optimal is actually 0→1→2→3 using discount on any 10-cost edge: 5+10+10=25. Wait, that's wrong. Actually 0→3 with discount = 10 is optimal.

Constraints

1 ≤ n ≤ 1000
0 ≤ highways.length ≤ 1000
highways[i].length == 3
0 ≤ city1_i, city2_i ≤ n - 1
city1_i ≠ city2_i
0 ≤ toll_i ≤ 10⁵
0 ≤ discounts ≤ 500
No duplicate highways between the same pair of cities

Visualization

Tap to expand

Understanding the Visualization

Build the Highway Network

Create a graph where cities are nodes and highways are bidirectional edges with toll costs

Track State as (City, Discounts Used)

Each state represents your current location and how many discount coupons you've used so far

Use Priority Queue for Minimum Cost

Always explore the cheapest unvisited state first, similar to Dijkstra's algorithm

For Each Highway, Consider Both Options

When moving to a neighboring city, try both using and not using a discount coupon

Return Cost When Destination Reached

The first time we reach the destination city, we've found the optimal cost

Key Takeaway

🎯 Key Insight: This problem transforms the classic shortest path problem into a 3D state space where we track (city, discounts_used, cost). By using Dijkstra's algorithm on this expanded state space, we can efficiently find the optimal way to use our limited discount coupons!

Asked in

G Google 23 a Amazon 19 f Meta 15 ⊞ Microsoft 12

The optimal solution uses a modified Dijkstra's algorithm that tracks states as (city, discounts_used) tuples. Instead of just finding the shortest path between cities, we maintain a priority queue of states where each state represents being at a specific city with a specific number of discounts already used. This allows us to explore all possible ways to use discounts optimally while guaranteeing we find the minimum cost path in O((V + E) × D × log(V × D)) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (DFS with All Combinations)	O(2^(ED) P)	O(V + E)	Try every possible path and every possible way to use discounts
Modified Dijkstra's Algorithm (Optimal)	O((V + E) * D * log(V * D))	O(V * D)	Use Dijkstra with state (city, discounts_used) to find optimal path

Brute Force (DFS with All Combinations) — Algorithm Steps

Build adjacency list representation of the graph
Use DFS to explore all paths from city 0 to city n-1
For each path found, try all possible combinations of discount usage
Track the minimum cost across all valid combinations
Return the minimum cost found, or -1 if no path exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from city 0

Begin DFS exploration from the source city

Explore all neighbors

For each neighbor, try both with and without discount

Recursive exploration

Continue DFS to all reachable cities, tracking costs

Backtrack and try alternatives

Backtrack to explore all possible combinations

Return minimum cost

Return the minimum cost found across all valid paths

Code -

solution.c — C

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

#define MAX_CITIES 1000

struct Edge {
    int city;
    int toll;
    struct Edge* next;
};

struct Edge* graph[MAX_CITIES];
bool visited[MAX_CITIES];
int minCost = INT_MAX;

void addEdge(int city1, int city2, int toll) {
    struct Edge* edge1 = malloc(sizeof(struct Edge));
    edge1->city = city2;
    edge1->toll = toll;
    edge1->next = graph[city1];
    graph[city1] = edge1;
    
    struct Edge* edge2 = malloc(sizeof(struct Edge));
    edge2->city = city1;
    edge2->toll = toll;
    edge2->next = graph[city2];
    graph[city2] = edge2;
}

void dfs(int city, int target, int currentCost, int discountsLeft) {
    if (city == target) {
        if (currentCost < minCost) {
            minCost = currentCost;
        }
        return;
    }
    
    if (currentCost >= minCost) return;
    
    struct Edge* edge = graph[city];
    while (edge != NULL) {
        if (!visited[edge->city]) {
            visited[edge->city] = true;
            
            // Try without discount
            dfs(edge->city, target, currentCost + edge->toll, discountsLeft);
            
            // Try with discount if available
            if (discountsLeft > 0) {
                dfs(edge->city, target, currentCost + edge->toll / 2, discountsLeft - 1);
            }
            
            visited[edge->city] = false;
        }
        edge = edge->next;
    }
}

int minimumCost(int n, int** highways, int highwaysSize, int* highwaysColSize, int discounts) {
    if (n == 1) return 0;
    
    // Initialize graph
    for (int i = 0; i < n; i++) {
        graph[i] = NULL;
        visited[i] = false;
    }
    minCost = INT_MAX;
    
    // Build adjacency list
    for (int i = 0; i < highwaysSize; i++) {
        addEdge(highways[i][0], highways[i][1], highways[i][2]);
    }
    
    visited[0] = true;
    dfs(0, n - 1, 0, discounts);
    
    return minCost == INT_MAX ? -1 : minCost;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(E*D) * P)

Where E is edges, D is discounts, P is number of paths - exponential due to trying all discount combinations on all paths

✓ Linear Growth

Space Complexity

O(V + E)

Space for adjacency list and recursion stack depth

✓ Linear Space

28.5K Views

Medium Frequency

~25 min Avg. Time

847 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

Brute Force (DFS with All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler