Minimum Skips to Arrive at Meeting On Time

Minimum Skips to Arrive at Meeting On Time - Problem

Imagine you're rushing to an important business meeting and need to travel through n roads to get there. You have exactly hoursBefore hours to make it on time, and you'll be traveling at a constant speed (km/h).

Here's the catch: after completing each road, you must rest and wait until the next integer hour before continuing to the next road. For example, if a road takes 1.4 hours to travel, you must wait until the 2-hour mark before starting the next road. However, if a road takes exactly 2 hours, no waiting is required.

But there's a twist! You can choose to skip some rests to save time. When you skip a rest, you immediately continue to the next road without waiting for the next integer hour.

Your goal is to find the minimum number of skips needed to arrive at your meeting on time, or return -1 if it's impossible even with unlimited skips.

Example: If the first road takes 1.4 hours and the second takes 0.6 hours, skipping the rest after the first road means you'll finish the second road at exactly 2.0 hours, allowing immediate travel on the third road.

Input & Output

example_1.py — Basic Case

$ Input: dist = [1,3,2], speed = 4, hoursBefore = 2

› Output: 1

💡 Note: Without skips: 0.25 hours (road 1) → wait to 1.0 → 0.75 hours (road 2) → wait to 2.0 → 0.5 hours (road 3) → total 2.5 hours. With 1 skip after road 2: 0.25 → wait to 1.0 → 0.75 → continue immediately → 0.5 → total 2.0 hours exactly.

example_2.py — Impossible Case

$ Input: dist = [3,2,4], speed = 1, hoursBefore = 1

› Output: -1

💡 Note: Even with maximum skips, the minimum time needed is 9 hours (3+2+4), which exceeds the 1-hour limit. Therefore, it's impossible to arrive on time.

example_3.py — No Skips Needed

$ Input: dist = [1,1,1], speed = 3, hoursBefore = 3

› Output: 0

💡 Note: Each road takes 1/3 hour. Total without any skips: 1/3 + wait to 1 + 1/3 + wait to 2 + 1/3 = 2.33 hours, which is within the 3-hour limit.

Visualization

Tap to expand

Understanding the Visualization

Start Journey

Begin at station 0 with 0 time elapsed

Travel Each Road

Calculate time for current road segment

Decision Point

Choose to wait for next hour or pay to skip

Track States

Remember best time for each (road, skips) combination

Find Minimum

Return smallest skips that arrive on time

Key Takeaway

🎯 Key Insight: Use DP to track all possible (time, skips) states. At each road, we can either wait (ceiling time) or skip (exact time). The optimal solution finds the minimum skips among all valid paths.

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We try all 2^(n-1) combinations of skip/wait decisions for n-1 roads

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth or space to store current combination

⚡ Linearithmic Space

Constraints

n == dist.length
1 ≤ n ≤ 1000
1 ≤ dist[i] ≤ 10⁵
1 ≤ speed ≤ 10⁶
1 ≤ hoursBefore ≤ 10⁷
Time limit: 2 seconds
Memory limit: 256 MB

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses Dynamic Programming with careful floating-point handling. We maintain a DP table where dp[i][j] represents the minimum time to reach road i using exactly j skips. The key insight is that at each road, we have two choices: skip the rest (continue with exact time) or wait (round up to next integer hour). Time complexity: O(n²).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n)	O(n)	Try every possible combination of skipping vs waiting at each road
Dynamic Programming (Optimal)	O(n²)	O(n²)	Use DP to track minimum skips needed for each road and accumulated time

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible combinations of skip/wait decisions
For each combination, simulate the journey
Calculate total time considering waits and skips
Track the minimum skips among valid combinations
Return -1 if no valid combination exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all 2^(n-1) binary combinations representing skip/wait choices

Simulate Journey

For each combination, simulate the journey calculating total time

Check Validity

Verify if the journey completes within the time limit

Track Minimum

Keep track of the minimum skips among valid journeys

Code -

solution.c — C

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

int minSkipsToArriveOnTime(int* dist, int distSize, int speed, int hoursBefore) {
    int minSkips = INT_MAX;
    
    for (int mask = 0; mask < (1 << (distSize - 1)); mask++) {
        double time = 0;
        int skips = 0;
        
        for (int i = 0; i < distSize; i++) {
            double roadTime = (double)dist[i] / speed;
            time += roadTime;
            
            if (i == distSize - 1) break;
            
            if (mask & (1 << i)) {
                skips++;
            } else {
                time = ceil(time);
            }
        }
        
        if (time <= hoursBefore) {
            if (skips < minSkips) {
                minSkips = skips;
            }
        }
    }
    
    return minSkips == INT_MAX ? -1 : minSkips;
}

int main() {
    int dist[] = {1, 3, 2};
    int speed = 4, hoursBefore = 2;
    printf("%d\n", minSkipsToArriveOnTime(dist, 3, speed, hoursBefore));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We try all 2^(n-1) combinations of skip/wait decisions for n-1 roads

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth or space to store current combination

⚡ Linearithmic Space

Constraints

n == dist.length
1 ≤ n ≤ 1000
1 ≤ dist[i] ≤ 10⁵
1 ≤ speed ≤ 10⁶
1 ≤ hoursBefore ≤ 10⁷
Time limit: 2 seconds
Memory limit: 256 MB

31.2K Views

Medium Frequency

~25 min Avg. Time

856 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

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler