Maximum Number of Alloys - Problem

You are the owner of a company that creates alloys using various types of metals. There are n different types of metals available, and you have access to k machines that can be used to create alloys.

Each machine requires a specific amount of each metal type to create an alloy. For the i-th machine to create an alloy, it needs composition[i][j] units of metal of type j.

Initially, you have stock[i] units of metal type i, and purchasing one unit of metal type i costs cost[i] coins.

Given integers n, k, budget, a 2D array composition, and arrays stock and cost, your goal is to maximize the number of alloys the company can create while staying within the budget of budget coins.

All alloys must be created with the same machine.

Return the maximum number of alloys that the company can create.

Input & Output

Example 1 — Basic Manufacturing

$ Input: n = 3, k = 2, budget = 15, composition = [[1,1,1],[1,1,2]], stock = [0,0,0], cost = [1,2,3]

› Output: 2

💡 Note: Machine 0 needs [1,1,1] per alloy: cost = 1×1 + 1×2 + 1×3 = 6 per alloy. With budget 15, we can make 15÷6 = 2 alloys. Machine 1 needs [1,1,2] per alloy: cost = 1×1 + 1×2 + 2×3 = 9 per alloy. With budget 15, we can make 15÷9 = 1 alloy. Maximum is 2.

Example 2 — With Initial Stock

$ Input: n = 3, k = 2, budget = 15, composition = [[1,1,1],[1,1,2]], stock = [1,1,0], cost = [1,2,3]

› Output: 3

💡 Note: Machine 0: For 3 alloys need [3,3,3]. Have [1,1,0], need to buy [2,2,3]. Cost = 2×1 + 2×2 + 3×3 = 15 ≤ 15. For 4 alloys need [4,4,4], buy [3,3,4]. Cost = 3×1 + 3×2 + 4×3 = 21 > 15. Machine 1: For 2 alloys need [2,2,4], buy [1,1,4]. Cost = 1×1 + 1×2 + 4×3 = 15 ≤ 15. For 3 alloys need [3,3,6], buy [2,2,6]. Cost = 2×1 + 2×2 + 6×3 = 24 > 15. Maximum is 3.

Example 3 — Single Machine

$ Input: n = 2, k = 1, budget = 10, composition = [[2,1]], stock = [1,1], cost = [1,1]

› Output: 5

💡 Note: Only machine 0: needs [2,1] per alloy. For 5 alloys need [10,5]. Have [1,1], need to buy [9,4]. Cost = 9×1 + 4×1 = 13 > 10. For 4 alloys need [8,4], buy [7,3]. Cost = 7×1 + 3×1 = 10 ≤ 10. So maximum is 4 alloys.

Constraints

1 ≤ n, k ≤ 100
0 ≤ budget ≤ 10⁸
composition[i][j] ≥ 1
0 ≤ stock[i] ≤ 10⁸
1 ≤ cost[i] ≤ 100

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Meta 6

The key insight is that for each machine, the number of affordable alloys increases monotonically with budget, making binary search applicable. Best approach uses binary search on the answer for each machine to find maximum alloys efficiently. Time: O(k × n × log(budget)), Space: O(1)

Common Approaches

✓ Backtracking

⏱️ Time: N/A Space: N/A

Bit Manipulation

⏱️ Time: N/A Space: N/A

Binary Search on Answer

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

For each machine, use binary search to find the maximum number of alloys we can make. The key insight is that if we can make X alloys, we can also make any number less than X, making this monotonic.

Brute Force with Linear Search

⏱️ Time: O(k × budget) Space: O(1)

For each machine, incrementally try making 1, 2, 3... alloys until the budget is exceeded. Calculate the cost needed for each attempt and track the maximum achievable.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static int** parseMatrix(char* input, int* rows) {
    // Remove all spaces first
    char cleaned[10000];
    int cleanIdx = 0;
    for (int i = 0; input[i]; i++) {
        if (input[i] != ' ') {
            cleaned[cleanIdx++] = input[i];
        }
    }
    cleaned[cleanIdx] = '\0';
    
    // Remove outer []
    char inner[10000];
    strcpy(inner, cleaned + 1);
    inner[strlen(inner) - 1] = '\0';
    
    // Count rows and parse
    int** matrix = (int**)malloc(100 * sizeof(int*));
    for (int i = 0; i < 100; i++) {
        matrix[i] = (int*)malloc(100 * sizeof(int));
    }
    
    *rows = 0;
    int depth = 0;
    char current[1000];
    int currentIdx = 0;
    
    for (int i = 0; i <= strlen(inner); i++) {
        char c = (i < strlen(inner)) ? inner[i] : '\0';
        
        if (c == '[') {
            depth++;
            if (depth == 1) {
                currentIdx = 0;
            }
        } else if (c == ']' || c == '\0') {
            if (depth == 1 || c == '\0') {
                current[currentIdx] = '\0';
                
                // Parse current row
                int col = 0;
                char tempCurrent[1000];
                strcpy(tempCurrent, current);
                char* token = strtok(tempCurrent, ",");
                while (token != NULL) {
                    matrix[*rows][col++] = atoi(token);
                    token = strtok(NULL, ",");
                }
                
                (*rows)++;
                currentIdx = 0;
            }
            if (c == ']') depth--;
        } else if (c == ',' && depth == 0) {
            // Skip comma between rows
        } else if (depth == 1) {
            current[currentIdx++] = c;
        }
        
        if (c == '\0') break;
    }
    
    return matrix;
}

static int* parseArray(char* input, int* size) {
    int* result = (int*)malloc(100 * sizeof(int));
    *size = 0;
    
    // Remove all spaces
    char cleaned[1000];
    int cleanIdx = 0;
    for (int i = 0; input[i]; i++) {
        if (input[i] != ' ') {
            cleaned[cleanIdx++] = input[i];
        }
    }
    cleaned[cleanIdx] = '\0';
    
    // Remove outer []
    char inner[1000];
    strcpy(inner, cleaned + 1);
    inner[strlen(inner) - 1] = '\0';
    
    if (strlen(inner) == 0) return result;
    
    char tempInner[1000];
    strcpy(tempInner, inner);
    char* token = strtok(tempInner, ",");
    while (token != NULL) {
        if (strlen(token) > 0) {
            result[(*size)++] = atoi(token);
        }
        token = strtok(NULL, ",");
    }
    
    return result;
}

static int canMake(int alloys, int* composition, int* stock, int* cost, int n, long long budget) {
    long long totalCost = 0;
    
    for (int i = 0; i < n; i++) {
        long long needed = (long long)alloys * composition[i];
        long long available = stock[i];
        
        if (needed > available) {
            long long toBuy = needed - available;
            totalCost += toBuy * cost[i];
            
            if (totalCost > budget) {
                return 0;
            }
        }
    }
    
    return totalCost <= budget;
}

static int maxAlloysForMachine(int* composition, int* stock, int* cost, int n, long long budget) {
    int left = 0, right = 2000000;
    int result = 0;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        
        if (canMake(mid, composition, stock, cost, n, budget)) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return result;
}

int main() {
    char line[10000];
    
    // Read n
    fgets(line, sizeof(line), stdin);
    int n = atoi(line);
    
    // Read k
    fgets(line, sizeof(line), stdin);
    int k = atoi(line);
    
    // Read budget
    fgets(line, sizeof(line), stdin);
    long long budget = atoll(line);
    
    // Read composition
    fgets(line, sizeof(line), stdin);
    int rows;
    int** composition = parseMatrix(line, &rows);
    
    // Read stock
    fgets(line, sizeof(line), stdin);
    int stockSize;
    int* stock = parseArray(line, &stockSize);
    
    // Read cost
    fgets(line, sizeof(line), stdin);
    int costSize;
    int* cost = parseArray(line, &costSize);
    
    int maxAlloys = 0;
    
    // Try each machine
    for (int i = 0; i < k; i++) {
        int alloys = maxAlloysForMachine(composition[i], stock, cost, n, budget);
        if (alloys > maxAlloys) {
            maxAlloys = alloys;
        }
    }
    
    printf("%d\n", maxAlloys);
    
    // Cleanup
    for (int i = 0; i < 100; i++) {
        free(composition[i]);
    }
    free(composition);
    free(stock);
    free(cost);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

✓ Linear Space

18.5K Views

Medium Frequency

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