Maximum Number of Alloys

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

✓ Bit Manipulation

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

Backtracking

⏱️ 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>

int maxNumberOfAlloys(int n, int k, int budget, int** composition, int* stock, int* cost) {
    int maxAlloys = 0;
    
    // Try each machine
    for (int machine = 0; machine < k; machine++) {
        // Binary search on number of alloys
        int left = 0, right = 200000000; // Upper bound based on constraints
        
        while (left <= right) {
            int mid = left + (right - left) / 2;
            
            // Check if we can make mid alloys with this machine
            long long totalCost = 0;
            int canMake = 1;
            
            for (int metal = 0; metal < n; metal++) {
                long long needed = (long long)composition[machine][metal] * mid;
                long long available = stock[metal];
                
                if (needed > available) {
                    long long toBuy = needed - available;
                    totalCost += toBuy * cost[metal];
                    
                    if (totalCost > budget) {
                        canMake = 0;
                        break;
                    }
                }
            }
            
            if (canMake && totalCost <= budget) {
                if (mid > maxAlloys) {
                    maxAlloys = mid;
                }
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
    }
    
    return maxAlloys;
}

int* parseArray(char* input, int* size) {
    *size = 0;
    
    // Handle empty array
    if (strstr(input, "[]")) {
        return NULL;
    }
    
    // Count elements
    for (int i = 0; input[i]; i++) {
        if (isdigit(input[i]) && (i == 0 || !isdigit(input[i-1]))) {
            (*size)++;
        }
    }
    
    if (*size == 0) return NULL;
    
    int* result = (int*)malloc(*size * sizeof(int));
    int idx = 0;
    
    // Parse elements
    for (int i = 0; input[i] && idx < *size; i++) {
        if (isdigit(input[i]) || (input[i] == '-' && isdigit(input[i+1]))) {
            char* endptr;
            result[idx] = (int)strtol(&input[i], &endptr, 10);
            idx++;
            i = endptr - input - 1; // Move to end of number
        }
    }
    
    return result;
}

int** parse2DArray(char* input, int* rows, int* cols) {
    *rows = 0;
    *cols = 0;
    
    // Handle empty array
    if (strstr(input, "[]")) {
        return NULL;
    }
    
    // Count rows (inner arrays)
    for (int i = 0; input[i]; i++) {
        if (input[i] == '[' && i > 0) {
            (*rows)++;
        }
    }
    
    if (*rows == 0) return NULL;
    
    // Find columns by parsing first row
    int inFirstRow = 0;
    for (int i = 1; input[i]; i++) {
        if (input[i] == '[') {
            inFirstRow = 1;
        } else if (input[i] == ']' && inFirstRow) {
            break;
        } else if (inFirstRow && (isdigit(input[i]) || (input[i] == '-' && isdigit(input[i+1])))) {
            (*cols)++;
            // Skip rest of this number
            if (input[i] == '-') i++;
            while (input[i+1] && isdigit(input[i+1])) i++;
        }
    }
    
    // Allocate matrix
    int** matrix = (int**)malloc(*rows * sizeof(int*));
    for (int i = 0; i < *rows; i++) {
        matrix[i] = (int*)malloc(*cols * sizeof(int));
    }
    
    // Parse matrix
    int row = 0, col = 0;
    int inRow = 0;
    
    for (int i = 1; input[i] && row < *rows; i++) {
        if (input[i] == '[') {
            inRow = 1;
            col = 0;
        } else if (input[i] == ']' && inRow) {
            row++;
            inRow = 0;
        } else if (inRow && (isdigit(input[i]) || (input[i] == '-' && isdigit(input[i+1])))) {
            char* endptr;
            matrix[row][col] = (int)strtol(&input[i], &endptr, 10);
            col++;
            i = endptr - input - 1; // Move to end of number
        }
    }
    
    return matrix;
}

int main() {
    char input[10000];
    
    // Read n
    fgets(input, sizeof(input), stdin);
    int n = atoi(input);
    
    // Read k
    fgets(input, sizeof(input), stdin);
    int k = atoi(input);
    
    // Read budget
    fgets(input, sizeof(input), stdin);
    int budget = atoi(input);
    
    // Read composition
    fgets(input, sizeof(input), stdin);
    int rows, cols;
    int** composition = parse2DArray(input, &rows, &cols);
    
    // Read stock
    fgets(input, sizeof(input), stdin);
    int stockSize;
    int* stock = parseArray(input, &stockSize);
    
    // Read cost
    fgets(input, sizeof(input), stdin);
    int costSize;
    int* cost = parseArray(input, &costSize);
    
    int result = maxNumberOfAlloys(n, k, budget, composition, stock, cost);
    printf("%d\n", result);
    
    // Cleanup
    if (composition) {
        for (int i = 0; i < rows; i++) {
            free(composition[i]);
        }
        free(composition);
    }
    if (stock) free(stock);
    if (cost) free(cost);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

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