Minimum Time to Build Blocks - Practice Coding Problems

Minimum Time to Build Blocks - Problem

Imagine you're managing a construction project where you need to build several blocks, each requiring different amounts of time. You start with just one worker, but workers have a special ability: they can split into two workers!

Given an array blocks where blocks[i] = t means the i-th block needs t units of time to build, you need to find the minimum total time to complete all blocks.

Worker Rules:

Each worker can either split into 2 workers (costs split time) OR build one block then leave
Multiple workers can split simultaneously (parallel splitting)
Only one worker can build each block

Goal: Return the minimum time needed to build all blocks starting with one worker.

Input & Output

example_1.py — Basic case

$ Input: {"blocks": [1], "split": 1}

› Output: 1

💡 Note: Only one block to build, so one worker builds it directly in 1 unit of time.

example_2.py — Two blocks

$ Input: {"blocks": [1, 2], "split": 1}

› Output: 3

💡 Note: Worker splits (1 time) → 2 workers build blocks [1,2] in parallel → max(1,2) = 2 time. Total: 1 + 2 = 3.

example_3.py — Optimal strategy

$ Input: {"blocks": [1, 2, 3], "split": 1}

› Output: 4

💡 Note: Using Huffman approach: merge (1,2)→3, then merge (3,3)→4. This represents the optimal splitting strategy.

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

You have 1 master builder and multiple buildings to construct

Decision Point

At each step: train new workers (split cost) or assign current workers to build

Optimal Strategy

Use Huffman algorithm: always combine smallest costs first

Key Takeaway

🎯 Key Insight: This problem is Huffman Coding in disguise - build an optimal binary tree by always merging the smallest costs!

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Each of n elements is pushed/popped from heap at most once, each operation takes O(log n)

⚡ Linearithmic

Space Complexity

O(n)

Priority queue stores at most n elements at any time

⚡ Linearithmic Space

Constraints

1 ≤ blocks.length ≤ 1000
1 ≤ blocks[i] ≤ 10⁴
1 ≤ split ≤ 10⁴
All values are positive integers

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 23

The optimal solution uses the Huffman Coding algorithm with a priority queue. Always combine the two smallest costs using the formula: split + max(a, b). This builds an optimal binary tree representing the best splitting strategy in O(n log n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Priority Queue (Optimal)	O(n log n)	O(n)	Use min-heap to build optimal decision tree (Huffman Coding approach)
Brute Force (Recursive Tree)	O(2^n)	O(n^2)	Try all possible combinations of splitting and building decisions

Priority Queue (Optimal) — Algorithm Steps

Add all block times to a min-heap (priority queue)
While heap has more than 1 element:
Pop two smallest elements (a, b)
Combine them as: split + max(a, b)
Push the combined cost back to heap
Return the final element in heap

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Heap

Add all block times to min-heap: [1,2,3]

First Merge

Pop 1,2 → combine as split+max(1,2) = 1+2 = 3

Final Merge

Pop 3,3 → combine as split+max(3,3) = 1+3 = 4

Code -

solution.c — C

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

// Simple min-heap implementation
typedef struct {
    int* data;
    int size;
    int capacity;
} MinHeap;

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

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

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

void heapifyDown(MinHeap* heap, int idx) {
    int left = 2 * idx + 1;
    int right = 2 * idx + 2;
    int smallest = idx;
    
    if (left < heap->size && heap->data[left] < heap->data[smallest])
        smallest = left;
    if (right < heap->size && heap->data[right] < heap->data[smallest])
        smallest = right;
    
    if (smallest != idx) {
        swap(&heap->data[idx], &heap->data[smallest]);
        heapifyDown(heap, smallest);
    }
}

void push(MinHeap* heap, int val) {
    heap->data[heap->size] = val;
    heapifyUp(heap, heap->size);
    heap->size++;
}

int pop(MinHeap* heap) {
    int min = heap->data[0];
    heap->data[0] = heap->data[heap->size - 1];
    heap->size--;
    heapifyDown(heap, 0);
    return min;
}

int minBuildTime(int* blocks, int n, int split) {
    if (n == 0) return 0;
    if (n == 1) return blocks[0];
    
    MinHeap* heap = createHeap(n * 2);
    
    for (int i = 0; i < n; i++) {
        push(heap, blocks[i]);
    }
    
    while (heap->size > 1) {
        int first = pop(heap);
        int second = pop(heap);
        int combined = split + (first > second ? first : second);
        push(heap, combined);
    }
    
    int result = pop(heap);
    free(heap->data);
    free(heap);
    return result;
}

int main() {
    int blocks[] = {1, 2, 3};
    int split = 1;
    printf("%d\n", minBuildTime(blocks, 3, split));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Each of n elements is pushed/popped from heap at most once, each operation takes O(log n)

⚡ Linearithmic

Space Complexity

O(n)

Priority queue stores at most n elements at any time

⚡ Linearithmic Space

Constraints

1 ≤ blocks.length ≤ 1000
1 ≤ blocks[i] ≤ 10⁴
1 ≤ split ≤ 10⁴
All values are positive integers

23.0K Views

Medium Frequency

~25 min Avg. Time

892 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

Priority Queue (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler