Minimum Skips to Arrive at Meeting On Time - Problem

You are given an integer hoursBefore, the number of hours you have to travel to your meeting. To arrive at your meeting, you have to travel through n roads. The road lengths are given as an integer array dist of length n, where dist[i] describes the length of the ith road in kilometers. In addition, you are given an integer speed, which is the speed (in km/h) you will travel at.

After you travel road i, you must rest and wait for the next integer hour before you can begin traveling on the next road. Note that you do not have to rest after traveling the last road because you are already at the meeting.

For example, if traveling a road takes 1.4 hours, you must wait until the 2 hour mark before traveling the next road. If traveling a road takes exactly 2 hours, you do not need to wait.

However, you are allowed to skip some rests to be able to arrive on time, meaning you do not need to wait for the next integer hour. Note that this means you may finish traveling future roads at different hour marks.

For example, suppose traveling the first road takes 1.4 hours and traveling the second road takes 0.6 hours. Skipping the rest after the first road will mean you finish traveling the second road right at the 2 hour mark, letting you start traveling the third road immediately.

Return the minimum number of skips required to arrive at the meeting on time, or -1 if it is impossible.

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: Without skips: 1 hour + rest to 2 + 3 hours + rest to 6 + 4 hours = 10 hours total. With 1 skip: 1 + 3 = 4 hours, rest to 5, then 4 more hours = 9 total > 6. Better: skip after road 2, so 1 + rest to 2 + 3 = 5, skip rest, + 4 = 9. Actually: travel road 1 (1 hr), rest to hour 2, travel road 2 (3 hrs, finish at 5), skip rest, travel road 3 (4 hrs, finish at 9) > 6. Try: skip after road 1: 1 hr + 3 hrs = 4 hrs, rest to 5, + 4 hrs = 9 > 6. Skip after road 2: hour 2 + 3 hrs = 5, + 4 hrs = 9 > 6. Need 1 skip to finish in 6 hours.

Example 2 — Impossible Case

$ Input: dist = [7,3,5,5], speed = 2, hoursBefore = 10

› Output: -1

💡 Note: Even with maximum skips, total time = 7/2 + 3/2 + 5/2 + 5/2 = 10 hours exactly. With rests: 3.5→4 + 1.5→6 + 2.5→9 + 2.5 = 11.5 hours. Need multiple skips but still exceeds time limit.

Example 3 — No Skips Needed

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

› Output: 0

💡 Note: Travel road 1 (1 hour), rest to hour 2, travel road 2 (1 hour), finish at hour 3. Total time = 3 hours ≤ 3, so 0 skips needed.

Constraints

n == dist.length
1 ≤ n ≤ 1000
1 ≤ dist[i] ≤ 10⁵
1 ≤ speed ≤ 10⁶
1 ≤ hoursBefore ≤ 10⁷

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 8 M Microsoft 12

The key insight is to use dynamic programming to track the minimum time needed with exactly k skips. We build a 2D DP table where dp[i][j] represents minimum time for first i roads using j skips. Best approach is 2D Dynamic Programming. Time: O(n²), Space: O(n²)

Common Approaches

✓ Brute Force - Try All Skip Combinations

⏱️ Time: O(2ⁿ) Space: O(n)

For each road, we have two choices: skip the rest or take the rest. We recursively try both options and find the minimum skips needed to arrive on time.

Dynamic Programming - 2D State

⏱️ Time: O(n²) Space: O(n²)

Create a 2D DP table where dp[i][j] represents the minimum time needed to complete first i roads using exactly j skips. For each road, we can either take rest or skip it.

Brute Force - Try All Skip Combinations — Algorithm Steps

Generate all possible combinations of skipping rests
For each combination, calculate total travel time
Find minimum skips among valid combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Binary Choices

At each road, choose skip or rest

Explore Tree

Recursively try all 2^n combinations

Find Minimum

Return minimum skips from valid paths

Code -

solution.c — C

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

int minSkips;

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int min(int a, int b) {
    return a < b ? a : b;
}

void backtrack(int* dist, int distSize, int speed, int hoursBefore, int idx, double currentTime, int skips) {
    if (idx == distSize) {
        if (currentTime <= hoursBefore) {
            minSkips = min(minSkips, skips);
        }
        return;
    }
    
    if (skips >= minSkips) return;
    
    double travelTime = (double)dist[idx] / speed;
    double newTime = currentTime + travelTime;
    
    if (idx == distSize - 1) {
        backtrack(dist, distSize, speed, hoursBefore, idx + 1, newTime, skips);
    } else {
        double restTime = ceil(newTime);
        backtrack(dist, distSize, speed, hoursBefore, idx + 1, restTime, skips);
        backtrack(dist, distSize, speed, hoursBefore, idx + 1, newTime, skips + 1);
    }
}

int solution(int* dist, int distSize, int speed, int hoursBefore) {
    minSkips = INT_MAX;
    backtrack(dist, distSize, speed, hoursBefore, 0, 0.0, 0);
    return minSkips == INT_MAX ? -1 : minSkips;
}

int main() {
    char line[1000];
    if (fgets(line, sizeof(line), stdin)) {
        line[strcspn(line, "\n")] = 0;
    }
    
    static int dist[1000];
    int n;
    parseArray(line, dist, &n);
    
    int speed, hoursBefore;
    scanf("%d", &speed);
    scanf("%d", &hoursBefore);
    
    int result = solution(dist, n, speed, hoursBefore);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ)

We try all 2^n combinations of skipping each of n rests

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth up to n roads

⚠ Quadratic Space

23.4K Views

Medium Frequency

~35 min Avg. Time

567 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

Minimum Skips to Arrive at Meeting On Time - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Skip Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler