Time to Cross a Bridge

Time to Cross a Bridge - Problem

There are k workers who want to move n boxes from the right (old) warehouse to the left (new) warehouse. You are given the two integers n and k, and a 2D integer array time of size k x 4 where time[i] = [righti, picki, lefti, puti].

The warehouses are separated by a river and connected by a bridge. Initially, all k workers are waiting on the left side of the bridge. To move the boxes, the ith worker can do the following:

Cross the bridge to the right side in righti minutes.
Pick a box from the right warehouse in picki minutes.
Cross the bridge to the left side in lefti minutes.
Put the box into the left warehouse in puti minutes.

The ith worker is less efficient than the jth worker if either condition is met:

lefti + righti > leftj + rightj
lefti + righti == leftj + rightj and i > j

The following rules regulate the movement of the workers through the bridge:

Only one worker can use the bridge at a time.
When the bridge is unused, prioritize the least efficient worker (who have picked up the box) on the right side to cross. If not, prioritize the least efficient worker on the left side to cross.
If enough workers have already been dispatched from the left side to pick up all the remaining boxes, no more workers will be sent from the left side.

Return the elapsed minutes at which the last box reaches the left side of the bridge.

Input & Output

Example 1 — Basic Bridge Crossing

$ Input: n = 1, k = 3, time = [[1,1,2,1],[1,3,3,1],[1,2,1,1]]

› Output: 6

💡 Note: Worker 2 (efficiency=2) is least efficient, so crosses first. Takes 1 min to cross right + 2 min to pick + 1 min to cross left + 1 min to put = 5 min total. But worker 2 finishes putting at time 6.

Example 2 — Multiple Workers

$ Input: n = 3, k = 2, time = [[1,9,1,8],[10,10,10,10]]

› Output: 50

💡 Note: Worker 1 has efficiency 20 (less efficient than worker 0's efficiency 2), so worker 1 goes first for each box. Each round takes about 41 minutes for worker 1.

Example 3 — Single Worker

$ Input: n = 2, k = 1, time = [[5,2,3,1]]

› Output: 21

💡 Note: Only one worker available. First box: 5+2+3+1=11 min. Second box: starts at time 11, finishes at 11+5+2+3+1=22. But since putting starts at time 21, answer is 21.

Constraints

1 ≤ n, k ≤ 10⁴
time.length == k
time[i].length == 4
1 ≤ righti, picki, lefti, puti ≤ 1000

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to always prioritize the least efficient worker to minimize bottlenecks at the bridge. Best approach uses priority queues for efficient worker scheduling with event-driven simulation. Time: O((n+k) × log k), Space: O(k)

Common Approaches

✓ Brute Force Simulation

⏱️ Time: O(T × k) Space: O(k)

Track all workers manually and process events in chronological order. For each time step, check which workers are available and pick one to cross the bridge.

Priority Queue Optimization

⏱️ Time: O((n + k) × log k) Space: O(k)

Maintain separate priority queues for workers on left and right sides, ordered by efficiency. This eliminates the need to check all workers at each time step.

Brute Force Simulation — Algorithm Steps

Step 1: Track worker states manually
Step 2: Process each time unit sequentially
Step 3: Make crossing decisions at each step

Visualization

Tap to expand

Step-by-Step Walkthrough

Track States

Monitor each worker's current state and location

Process Time

Advance time unit by unit, updating worker states

Make Decisions

At each step, decide which worker crosses bridge

Code -

solution.c — C

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

typedef struct {
    int rightTime, pickTime, leftTime, putTime, efficiency, idx;
} Worker;

typedef struct {
    int time;
    char type[10];
    int workerIdx;
} Event;

typedef struct {
    int eff, idx, workerIdx;
} HeapItem;

typedef struct {
    HeapItem* data;
    int size;
    int capacity;
} MinHeap;

MinHeap* createHeap(int capacity) {
    MinHeap* heap = malloc(sizeof(MinHeap));
    heap->data = malloc(capacity * sizeof(HeapItem));
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

void swap(HeapItem* a, HeapItem* b) {
    HeapItem temp = *a;
    *a = *b;
    *b = temp;
}

void heapifyUp(MinHeap* heap, int idx) {
    while (idx > 0) {
        int parent = (idx - 1) / 2;
        if (heap->data[idx].eff > heap->data[parent].eff || 
            (heap->data[idx].eff == heap->data[parent].eff && heap->data[idx].idx > heap->data[parent].idx)) {
            break;
        }
        swap(&heap->data[idx], &heap->data[parent]);
        idx = parent;
    }
}

void heapifyDown(MinHeap* heap, int idx) {
    while (1) {
        int minIdx = idx;
        int left = 2 * idx + 1;
        int right = 2 * idx + 2;
        
        if (left < heap->size && 
            (heap->data[left].eff < heap->data[minIdx].eff || 
             (heap->data[left].eff == heap->data[minIdx].eff && heap->data[left].idx < heap->data[minIdx].idx))) {
            minIdx = left;
        }
        
        if (right < heap->size && 
            (heap->data[right].eff < heap->data[minIdx].eff || 
             (heap->data[right].eff == heap->data[minIdx].eff && heap->data[right].idx < heap->data[minIdx].idx))) {
            minIdx = right;
        }
        
        if (minIdx == idx) break;
        
        swap(&heap->data[idx], &heap->data[minIdx]);
        idx = minIdx;
    }
}

void heapPush(MinHeap* heap, HeapItem item) {
    heap->data[heap->size] = item;
    heapifyUp(heap, heap->size);
    heap->size++;
}

HeapItem heapPop(MinHeap* heap) {
    HeapItem result = heap->data[0];
    heap->data[0] = heap->data[heap->size - 1];
    heap->size--;
    heapifyDown(heap, 0);
    return result;
}

int solution(int n, int k, int time[][4]) {
    Worker* workers = malloc(k * sizeof(Worker));
    for (int i = 0; i < k; i++) {
        workers[i].rightTime = time[i][0];
        workers[i].pickTime = time[i][1];
        workers[i].leftTime = time[i][2];
        workers[i].putTime = time[i][3];
        workers[i].efficiency = time[i][2] + time[i][0];
        workers[i].idx = i;
    }
    
    int currentTime = 0;
    int bridgeFreeTime = 0;
    int boxesReachedLeft = 0;
    int workersDispatched = 0;
    
    MinHeap* leftWaiting = createHeap(k);
    MinHeap* rightWithBox = createHeap(k);
    
    Event* events = malloc(n * k * 10 * sizeof(Event));
    int eventCount = 0;
    
    for (int i = 0; i < k; i++) {
        HeapItem item = {-workers[i].efficiency, -workers[i].idx, i};
        heapPush(leftWaiting, item);
    }
    
    int lastBoxArrivalTime = 0;
    
    while (boxesReachedLeft < n) {
        int newEventCount = 0;
        for (int i = 0; i < eventCount; i++) {
            if (events[i].time == currentTime) {
                if (strcmp(events[i].type, "pick_done") == 0) {
                    Worker w = workers[events[i].workerIdx];
                    HeapItem item = {-w.efficiency, -w.idx, events[i].workerIdx};
                    heapPush(rightWithBox, item);
                } else if (strcmp(events[i].type, "put_done") == 0) {
                    Worker w = workers[events[i].workerIdx];
                    if (workersDispatched < n) {
                        HeapItem item = {-w.efficiency, -w.idx, events[i].workerIdx};
                        heapPush(leftWaiting, item);
                    }
                }
            } else {
                events[newEventCount++] = events[i];
            }
        }
        eventCount = newEventCount;
        
        if (currentTime >= bridgeFreeTime) {
            if (rightWithBox->size > 0) {
                HeapItem item = heapPop(rightWithBox);
                Worker w = workers[item.workerIdx];
                
                bridgeFreeTime = currentTime + w.leftTime;
                int arriveLeftTime = bridgeFreeTime;
                
                boxesReachedLeft += 1;
                lastBoxArrivalTime = arriveLeftTime;
                
                int putFinishTime = arriveLeftTime + w.putTime;
                events[eventCount].time = putFinishTime;
                strcpy(events[eventCount].type, "put_done");
                events[eventCount].workerIdx = item.workerIdx;
                eventCount++;
                
            } else if (leftWaiting->size > 0 && workersDispatched < n) {
                HeapItem item = heapPop(leftWaiting);
                Worker w = workers[item.workerIdx];
                
                bridgeFreeTime = currentTime + w.rightTime;
                int arriveRightTime = bridgeFreeTime;
                workersDispatched += 1;
                
                int pickFinishTime = arriveRightTime + w.pickTime;
                events[eventCount].time = pickFinishTime;
                strcpy(events[eventCount].type, "pick_done");
                events[eventCount].workerIdx = item.workerIdx;
                eventCount++;
            }
        }
        
        if (boxesReachedLeft >= n) {
            break;
        }
        
        int nextTime = INT_MAX;
        
        for (int i = 0; i < eventCount; i++) {
            if (events[i].time < nextTime) {
                nextTime = events[i].time;
            }
        }
        
        if (rightWithBox->size > 0 || (leftWaiting->size > 0 && workersDispatched < n)) {
            if (bridgeFreeTime < nextTime) {
                nextTime = bridgeFreeTime;
            }
        }
        
        if (nextTime == INT_MAX) {
            break;
        }
        
        currentTime = nextTime;
    }
    
    free(workers);
    free(leftWaiting->data);
    free(leftWaiting);
    free(rightWithBox->data);
    free(rightWithBox);
    free(events);
    
    return lastBoxArrivalTime;
}

int main() {
    int n, k;
    scanf("%d\n%d\n", &n, &k);
    
    int time[k][4];
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    char* ptr = strchr(line, '[') + 1;
    for (int i = 0; i < k; i++) {
        ptr = strchr(ptr, '[') + 1;
        for (int j = 0; j < 4; j++) {
            time[i][j] = strtol(ptr, &ptr, 10);
            if (j < 3) ptr = strchr(ptr, ',') + 1;
        }
        ptr = strchr(ptr, ']') + 1;
    }
    
    printf("%d\n", solution(n, k, time));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(T × k)

T is total time needed, k workers checked each time unit

⚡ Linearithmic

Space Complexity

O(k)

Arrays to track worker states and positions

✓ Linear Space

12.8K Views

Medium Frequency

~45 min Avg. Time

487 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler