Maximum Number of Potholes That Can Be Fixed

Maximum Number of Potholes That Can Be Fixed - Problem

You're a road maintenance engineer with a limited budget who needs to fix as many potholes as possible on a damaged road. The road is represented as a string where 'x' represents a pothole and '.' represents smooth pavement.

Here's the key constraint: You can only repair consecutive potholes in a single operation. To repair n consecutive potholes costs n + 1 dollars (there's a fixed setup cost plus the cost per pothole).

Goal: Determine the maximum number of potholes you can fix without exceeding your budget.

Example: Road "x.xxx..x" has pothole groups of sizes [1, 3, 1]. Fixing 1 pothole costs 2, fixing 3 consecutive potholes costs 4, etc.

Input & Output

example_1.py — Basic Case

$ Input: road = "x.xxx.x", budget = 7

› Output: 4

💡 Note: We have pothole groups of sizes [1, 3, 1]. We can repair the group of size 3 (cost 4) and one group of size 1 (cost 2), totaling 4 potholes for cost 6, which is within budget 7.

example_2.py — Limited Budget

$ Input: road = "xxx.x.x", budget = 4

› Output: 3

💡 Note: We have groups [3, 1, 1]. We can either repair the group of size 3 (cost 4) or two groups of size 1 (cost 2+2=4). Repairing the size-3 group gives us 3 potholes, which is better than 2 potholes from the two size-1 groups.

example_3.py — Edge Case

$ Input: road = ".....", budget = 10

› Output: 0

💡 Note: The road has no potholes, so we can't repair anything regardless of budget.

Constraints

1 ≤ road.length ≤ 10⁴
1 ≤ budget ≤ 10⁶
road consists only of characters '.' and 'x'
Each repair operation must fix consecutive potholes

Visualization

Tap to expand

Understanding the Visualization

Identify Segments

Parse the road to find all consecutive pothole groups

Calculate Efficiency

Smaller groups have better pothole-to-cost ratios due to fixed setup cost

Greedy Selection

Always choose the most efficient option first

Maximize Repairs

Continue until budget is exhausted

Key Takeaway

🎯 Key Insight: Due to the fixed setup cost, smaller pothole groups are more cost-efficient. The greedy approach of always choosing the most efficient option first guarantees the optimal solution.

Asked in

a Amazon 45 G Google 32 ⊞ Microsoft 28 f Meta 15

The optimal approach uses a greedy strategy after recognizing that smaller pothole groups are more cost-efficient. Since each group of size n costs n+1, smaller groups provide better potholes-per-dollar ratios. Sort groups by size and greedily select from smallest to largest until the budget is exhausted.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (All Subsets)	O(2^k × k)	O(k)	Try every possible combination of pothole groups to repair
Greedy Approach (Optimal)	O(n + k log k)	O(k)	Sort groups by efficiency ratio and greedily select the best ones

Brute Force (All Subsets) — Algorithm Steps

Parse the road string to identify all consecutive pothole groups
Generate all possible subsets of these groups (2^k combinations)
For each subset, calculate total cost and total potholes repaired
Return the maximum potholes that can be repaired within budget

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse Groups

Identify consecutive pothole segments: [1, 3, 1]

Generate Subsets

Create all 2^3 = 8 possible combinations

Evaluate Each

Calculate cost and potholes for each valid combination

Find Maximum

Return the combination with maximum potholes within budget

Code -

solution.c — C

int maxPotholes(char* road, int budget) {
    int groups[1000];
    int groupCount = 0;
    int count = 0;
    
    // Find all consecutive pothole groups
    for (int i = 0; road[i]; i++) {
        if (road[i] == 'x') {
            count++;
        } else {
            if (count > 0) {
                groups[groupCount++] = count;
                count = 0;
            }
        }
    }
    if (count > 0) groups[groupCount++] = count;
    
    int maxPotholes = 0;
    
    // Try all possible subsets (2^n combinations)
    for (int mask = 0; mask < (1 << groupCount); mask++) {
        int totalCost = 0;
        int totalPotholes = 0;
        
        for (int i = 0; i < groupCount; i++) {
            if (mask & (1 << i)) {
                int groupSize = groups[i];
                int cost = groupSize + 1;
                totalCost += cost;
                totalPotholes += groupSize;
            }
        }
        
        if (totalCost <= budget && totalPotholes > maxPotholes) {
            maxPotholes = totalPotholes;
        }
    }
    
    return maxPotholes;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^k × k)

2^k subsets to check, each taking O(k) time to evaluate, where k is number of pothole groups

✓ Linear Growth

Space Complexity

O(k)

Space to store pothole groups and current subset being evaluated

✓ Linear Space

31.5K Views

Medium Frequency

~15 min Avg. Time

1.5K 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 (All Subsets) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler