Time to Cross a Bridge - Practice Coding Problems

Time to Cross a Bridge - Problem

Imagine managing a bridge logistics operation where k workers must transport n boxes from an old warehouse on the right side to a new warehouse on the left side. The challenge? Only one worker can cross the bridge at a time, and each worker has different efficiency levels for each task.

Given:

n boxes to transport
k workers available
A 2D array time[i] = [righti, picki, lefti, puti] where:

righti: minutes to cross bridge from left to right
picki: minutes to pick up a box from right warehouse
lefti: minutes to cross bridge from right to left
puti: minutes to put box in left warehouse

Worker Efficiency Ranking: Worker i is less efficient than worker j if lefti + righti > leftj + rightj, or if they're equal and i > j.

Bridge Rules:

Only one worker uses the bridge at a time
Priority goes to the least efficient worker ready to cross
Workers carrying boxes (right→left) have priority over empty workers (left→right)
Stop sending workers once enough have been dispatched for remaining boxes

Return the total time when the last box reaches the left warehouse.

Input & Output

example_1.py — Basic Case

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

› Output: 6

💡 Note: Worker 2 (least efficient with crossing time 1+4=5) goes right (1 min), picks box (1 min), returns left (4 min) for total 6 minutes. The box is then put in 1 more minute, but the crossing completion time is what matters.

example_2.py — Multiple Workers

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

› Output: 50

💡 Note: Worker 1 is less efficient (20 vs 2 total crossing time). Both workers will need to make multiple trips. Worker 1 gets priority for bridge usage due to being less efficient.

example_3.py — Edge Case

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

› Output: 49

💡 Note: Single worker must make 5 trips: each trip takes 2+3+4+1=10 minutes, so 5*10-1=49 minutes total (last put operation happens after crossing is complete).

Time & Space Complexity

Time Complexity

⏱️

O(n log k)

Each of the n boxes requires O(log k) operations for heap management

⚡ Linearithmic

Space Complexity

O(k)

Storage for priority queues containing worker information

✓ Linear Space

Constraints

1 ≤ n, k ≤ 10⁴
time.length == k
time[i].length == 4
1 ≤ righti, picki, lefti, puti ≤ 10³
Each worker has positive time for all tasks

Asked in

Common Approaches

Approach	Time	Space	Notes
✓ Optimal: Event-Driven Simulation with Priority Queues	O(n log k)	O(k)	Use priority queues to efficiently manage workers in different states and jump between significant time points

Optimal: Event-Driven Simulation with Priority Queues — Algorithm Steps

Create priority queues for workers in different states
Process events in chronological order
When bridge becomes available, find least efficient worker with priority
Update worker states and schedule next events
Continue until all boxes are processed
Return the time when last box is delivered

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Queues

All workers start in waitingLeft queue, sorted by efficiency

Bridge Assignment

Select least efficient worker from appropriate queue

State Transitions

Move workers between queues as they complete tasks

Event Processing

Jump to next significant event time

Completion

Continue until all boxes are delivered

Code -

solution.c — C

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

typedef struct {
    int time;
    int worker;
} Event;

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

typedef struct {
    int* data;
    int size;
    int capacity;
    int (*compare)(int a, int b, int** time);
    int** time;
} WorkerHeap;

int workerCompare(int a, int b, int** time) {
    int effA = time[a][0] + time[a][2];
    int effB = time[b][0] + time[b][2];
    if (effA != effB) return effB - effA; // Less efficient first
    return b - a; // Higher index first
}

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

WorkerHeap* createWorkerHeap(int capacity, int** time) {
    WorkerHeap* heap = (WorkerHeap*)malloc(sizeof(WorkerHeap));
    heap->data = (int*)malloc(sizeof(int) * capacity);
    heap->size = 0;
    heap->capacity = capacity;
    heap->compare = workerCompare;
    heap->time = time;
    return heap;
}

void minHeapPush(MinHeap* heap, int time, int worker) {
    int i = heap->size++;
    heap->data[i].time = time;
    heap->data[i].worker = worker;
    
    while (i > 0 && heap->data[i].time < heap->data[(i-1)/2].time) {
        Event temp = heap->data[i];
        heap->data[i] = heap->data[(i-1)/2];
        heap->data[(i-1)/2] = temp;
        i = (i-1)/2;
    }
}

Event minHeapPop(MinHeap* heap) {
    Event root = heap->data[0];
    heap->data[0] = heap->data[--heap->size];
    
    int i = 0;
    while (2*i+1 < heap->size) {
        int left = 2*i+1, right = 2*i+2, smallest = left;
        if (right < heap->size && heap->data[right].time < heap->data[left].time)
            smallest = right;
        if (heap->data[i].time <= heap->data[smallest].time) break;
        
        Event temp = heap->data[i];
        heap->data[i] = heap->data[smallest];
        heap->data[smallest] = temp;
        i = smallest;
    }
    return root;
}

void workerHeapPush(WorkerHeap* heap, int worker) {
    int i = heap->size++;
    heap->data[i] = worker;
    
    while (i > 0 && heap->compare(heap->data[i], heap->data[(i-1)/2], heap->time) > 0) {
        int temp = heap->data[i];
        heap->data[i] = heap->data[(i-1)/2];
        heap->data[(i-1)/2] = temp;
        i = (i-1)/2;
    }
}

int workerHeapPop(WorkerHeap* heap) {
    int root = heap->data[0];
    heap->data[0] = heap->data[--heap->size];
    
    int i = 0;
    while (2*i+1 < heap->size) {
        int left = 2*i+1, right = 2*i+2, largest = left;
        if (right < heap->size && heap->compare(heap->data[right], heap->data[left], heap->time) > 0)
            largest = right;
        if (heap->compare(heap->data[i], heap->data[largest], heap->time) >= 0) break;
        
        int temp = heap->data[i];
        heap->data[i] = heap->data[largest];
        heap->data[largest] = temp;
        i = largest;
    }
    return root;
}

int findCrossingTime(int n, int k, int** time, int timeSize, int* timeColSize) {
    WorkerHeap* waitingLeft = createWorkerHeap(k, time);
    MinHeap* workingRight = createMinHeap(k);
    WorkerHeap* waitingRight = createWorkerHeap(k, time);
    MinHeap* workingLeft = createMinHeap(k);
    
    // Initialize all workers on left side
    for (int i = 0; i < k; i++) {
        workerHeapPush(waitingLeft, i);
    }
    
    int currentTime = 0;
    int boxesPicked = 0;
    
    while (boxesPicked < n || workingRight->size > 0 || waitingRight->size > 0 || workingLeft->size > 0) {
        // Move completed workers from right side to waiting
        while (workingRight->size > 0 && workingRight->data[0].time <= currentTime) {
            Event event = minHeapPop(workingRight);
            workerHeapPush(waitingRight, event.worker);
        }
        
        // Move completed workers from left side back to waiting
        while (workingLeft->size > 0 && workingLeft->data[0].time <= currentTime) {
            Event event = minHeapPop(workingLeft);
            workerHeapPush(waitingLeft, event.worker);
        }
        
        // Determine next bridge user
        int rightCandidate = -1;
        int leftCandidate = -1;
        
        if (waitingLeft->size > 0 && boxesPicked < n) {
            leftCandidate = waitingLeft->data[0];
        }
        
        if (waitingRight->size > 0) {
            rightCandidate = waitingRight->data[0];
        }
        
        if (rightCandidate != -1) {
            workerHeapPop(waitingRight);
            int crossTime = time[rightCandidate][2];
            currentTime += crossTime;
            int putTime = time[rightCandidate][3];
            int finishTime = currentTime + putTime;
            minHeapPush(workingLeft, finishTime, rightCandidate);
            
        } else if (leftCandidate != -1) {
            workerHeapPop(waitingLeft);
            int crossTime = time[leftCandidate][0];
            currentTime += crossTime;
            int pickTime = time[leftCandidate][1];
            int finishTime = currentTime + pickTime;
            minHeapPush(workingRight, finishTime, leftCandidate);
            boxesPicked++;
            
        } else {
            int nextEventTime = INT_MAX;
            if (workingRight->size > 0) {
                if (workingRight->data[0].time < nextEventTime)
                    nextEventTime = workingRight->data[0].time;
            }
            if (workingLeft->size > 0) {
                if (workingLeft->data[0].time < nextEventTime)
                    nextEventTime = workingLeft->data[0].time;
            }
            if (nextEventTime != INT_MAX) {
                currentTime = nextEventTime;
            }
        }
    }
    
    // Wait for remaining put operations
    while (workingLeft->size > 0) {
        Event event = minHeapPop(workingLeft);
        if (event.time > currentTime) {
            currentTime = event.time;
        }
    }
    
    // Clean up memory
    free(waitingLeft->data);
    free(waitingLeft);
    free(workingRight->data);
    free(workingRight);
    free(waitingRight->data);
    free(waitingRight);
    free(workingLeft->data);
    free(workingLeft);
    
    return currentTime;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log k)

Each of the n boxes requires O(log k) operations for heap management

⚡ Linearithmic

Space Complexity

O(k)

Storage for priority queues containing worker information

✓ Linear Space

Constraints

1 ≤ n, k ≤ 10⁴
time.length == k
time[i].length == 4
1 ≤ righti, picki, lefti, puti ≤ 10³
Each worker has positive time for all tasks

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimal: Event-Driven Simulation with Priority Queues — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler