Minimum Time to Build Blocks

Minimum Time to Build Blocks - Problem

You are given a list of blocks, where blocks[i] = t means that the i-th block needs t units of time to be built. A block can only be built by exactly one worker.

A worker can either split into two workers (number of workers increases by one) or build a block then go home. Both decisions cost some time.

The time cost of splitting one worker into two workers is given as an integer split. Note that if two workers split at the same time, they split in parallel so the cost would be split.

Output the minimum time needed to build all blocks. Initially, there is only one worker.

Input & Output

Example 1 — Basic Case

$ Input: blocks = [1], split = 1

› Output: 1

💡 Note: Only one block to build, so the minimum time is just the time to build that block: 1

Example 2 — Two Blocks

$ Input: blocks = [1,2], split = 5

› Output: 7

💡 Note: We can either build sequentially (1+2=3) or split then build in parallel (5+max(1,2)=7). However, the optimal solution using the greedy approach merges the blocks: split cost + max(1,2) = 5+2 = 7.

Example 3 — Split is Beneficial

$ Input: blocks = [1,1,1], split = 1

› Output: 3

💡 Note: Split twice to get 4 workers (cost 2), then build all blocks in parallel (cost 1), total = 2+1 = 3. This is better than sequential building (cost 3).

Constraints

1 ≤ blocks.length ≤ 1000
1 ≤ blocks[i] ≤ 10⁴
1 ≤ split ≤ 100

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12

The key insight is to model this as a binary tree construction problem where we use a greedy priority queue approach to optimally merge blocks with split costs. The optimal solution uses a min-heap to always merge the two smallest costs first. Time: O(n log n), Space: O(n)

Common Approaches

✓ Brute Force Recursion

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

For each state, recursively try both splitting workers and assigning workers to build blocks. This explores all possible decision trees to find the minimum time.

Greedy with Priority Queue

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

Build a binary tree where leaves are blocks and internal nodes represent splitting decisions. Use a priority queue to greedily merge the most expensive operations first, minimizing total time.

Brute Force Recursion — Algorithm Steps

Try splitting current workers
Try assigning workers to build blocks
Return minimum time from all possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

1 worker, all blocks remaining

Recursive Choices

Try splitting or building at each step

Find Minimum

Return minimum time across all paths

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

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

int solve(int* remainingBlocks, int blockCount, int split) {
    if (blockCount <= 1) {
        return blockCount == 0 ? 0 : remainingBlocks[0];
    }
    
    if (blockCount == 1) {
        return remainingBlocks[0];
    }
    
    int minTime = INT_MAX;
    
    // Try merging each pair of blocks
    for (int i = 0; i < blockCount; i++) {
        for (int j = i + 1; j < blockCount; j++) {
            int* newBlocks = malloc((blockCount - 1) * sizeof(int));
            int newBlockCount = 0;
            int block1 = remainingBlocks[i];
            int block2 = remainingBlocks[j];
            
            // Add all blocks except i and j
            for (int k = 0; k < blockCount; k++) {
                if (k != i && k != j) {
                    newBlocks[newBlockCount++] = remainingBlocks[k];
                }
            }
            
            // Cost of splitting and then building these two in parallel
            int mergedCost = split + max(block1, block2);
            newBlocks[newBlockCount++] = mergedCost;
            
            int result = solve(newBlocks, newBlockCount, split);
            minTime = min(minTime, result);
            
            free(newBlocks);
        }
    }
    
    return minTime;
}

int solution(int* blocks, int blockCount, int split) {
    if (blockCount == 0) return 0;
    if (blockCount == 1) return blocks[0];
    
    return solve(blocks, blockCount, split);
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse blocks array
    int blocks[100];
    int blockCount = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9') {
            blocks[blockCount++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int split;
    scanf("%d", &split);
    
    int result = solution(blocks, blockCount, split);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Each position has multiple recursive choices leading to exponential branching

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth proportional to number of blocks

⚡ Linearithmic Space

31.5K Views

Medium Frequency

~30 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler