CSES Solutions - Factory Machines

A factory has N machines which can be used to make products. Your goal is to make a total of T products.

For each machine, you know the number of seconds it needs to make a single product, given as array K[]. The machines can work simultaneously, and you can freely decide their schedule.

What is the shortest time needed to make T products?

Examples:

Input: N = 3, T = 7, K[] = {3, 2, 5}
Output: 8
Explanation:

• Machine 1 will make 2 products. Total time taken = 3 * 2 = 6 seconds.
• Machine 2 will make 4 products. Total time taken = 2 * 4 = 8 seconds.
• Machine 3 will make 1 product. Total time taken = 5 * 1 = 5 seconds.

Shortest time to make 7 products = 8 seconds.

Input: N = 2, T = 5, K[] = {1, 2}
Output: 4
Explanation:

• Machine 1 will make 3 products. Total time taken = 1 * 3 = 3 seconds.
• Machine 2 will make 2 products. Total time taken = 2 * 2 = 4 seconds

Shortest time to make 5 products = 4 seconds.

Approach: To solve the problem, follow the below idea:

The problem can be solved using Binary Search on Answer. We can binary search for the time needed to make the T products. If we observe carefully, the time to make T products will be at least 1 second and the maximum time to make T products will be when we have only 1 machine and it takes maximum amount of time to make one product. So, we can initialize low = 1 and high = T * min value in K[]. Now, we can find mid and find the total number of products we can making using all machines. If the total number of products is less than T, then it means we need more time so we will shift lo = mid + 1. Otherwise, we shift high = mid - 1 and update the answer. We keep on searching till low <= high and after all the iterations, we can return the final answer.

Step-by-step algorithm:

• Maintain a function check(mid, N, T, K) to check whether it is possible to make T products in time <= mid.
• Also maintain a variable ans to store the minimum time to make T products.
• Declare the range in which our answer can lie, that is low = 1, high = T * min value in K[].
• Iterate till low <= high,
  • Find the mid in range [low, high] and check if we can make T products in time <= mid.
  • If we can make T products in time <= mid, then update the answer and reduce search space by moving high to mid - 1.
  • Otherwise, move low = mid + 1.
• After all the iterations, return ans as the final answer.

Below is the implementation of the algorithm:

#include <bits/stdc++.h>
#define ll long long int
using namespace std;

// Make the check function to check if we can make T
// products in time <= mid
bool check(ll mid, ll N, ll T, ll* K)
{
    // Variable to count the number of products made
    ll sum = 0;
    for (int i = 0; i < N; i++) {
        sum += (mid / K[i]);
        if (sum >= T)
            return true;
    }
    return false;
}

// Function to find the minimum time to make T products
ll solve(ll N, ll T, ll* K)
{
    // Define the range in which our answer can lie
    ll low = 1, high = (*min_element(K, K + N)) * T ;
    ll ans;

    // Binary Search for the minimum time to make T products
    while (low <= high) {
        ll mid = (low + high) / 2;

        // Check if we can make T products in time <= mid
        if (check(mid, N, T, K)) {
            // Update the answer and reduce search space by
            // moving high to mid - 1
            ans = mid;
            high = mid - 1;
        }
        else {
            // Reduce the search space by moving low to mid
            // + 1
            low = mid + 1;
        }
    }
    return ans;
}

int main()
{
    // Sample Input
    ll N = 3, T = 7;
    ll K[] = { 3, 2, 5 };

    cout << solve(N, T, K);
}

import java.util.Arrays;

public class Main {
    // Function to check if we can make T products in time <= mid
    static boolean check(long mid, long N, long T, long[] K) {
        // Variable to count the number of products made
        long sum = 0;
        for (int i = 0; i < N; i++) {
            sum += (mid / K[i]);
            if (sum >= T)
                return true;
        }
        return false;
    }

    // Function to find the minimum time to make T products
    static long solve(long N, long T, long[] K) {
        // Define the range in which our answer can lie
        long low = 1, high = Arrays.stream(K).min().getAsLong() * T; // Updated high value
        long ans = 0;

        // Binary Search for the minimum time to make T products
        while (low <= high) {
            long mid = (low + high) / 2;

            // Check if we can make T products in time <= mid
            if (check(mid, N, T, K)) {
                // Update the answer and reduce search space by
                // moving high to mid - 1
                ans = mid;
                high = mid - 1;
            } else {
                // Reduce the search space by moving low to mid + 1
                low = mid + 1;
            }
        }
        return ans;
    }

    public static void main(String[] args) {
        // Sample Input
        long N = 3, T = 7;
        long[] K = { 3, 2, 5 };

        System.out.println(solve(N, T, K));
    }
}

// This code is contributed by shivamgupta0987654321

def check(mid, N, T, K):
    # Variable to count the number of products made
    sum_val = 0
    for i in range(N):
        sum_val += (mid // K[i])
        if sum_val >= T:
            return True
    return False

def solve(N, T, K):
    # Define the range in which our answer can lie
    low, high = 1, min(K) * T
    ans = 0

    # Binary Search for the minimum time to make T products
    while low <= high:
        mid = (low + high) // 2

        # Check if we can make T products in time <= mid
        if check(mid, N, T, K):
            # Update the answer and reduce search space by moving high to mid - 1
            ans = mid
            high = mid - 1
        else:
            # Reduce the search space by moving low to mid + 1
            low = mid + 1

    return ans

if __name__ == "__main__":
    # Sample Input
    N = 3
    T = 7
    K = [3, 2, 5]

    # Output the result
    print(solve(N, T, K))

using System;
using System.Linq;

class Program
{
    // Function to check if we can make T products in time <= mid
    static bool Check(long mid, long N, long T, long[] K)
    {
        // Variable to count the number of products made
        long sum = 0;
        for (int i = 0; i < N; i++)
        {
            sum += (mid / K[i]);
            if (sum >= T)
                return true;
        }
        return false;
    }

    // Function to find the minimum time to make T products
    static long Solve(long N, long T, long[] K)
    {
        // Define the range in which our answer can lie
        long low = 1, high = K.Min() * T;
        long ans = 0;

        // Binary Search for the minimum time to make T products
        while (low <= high)
        {
            long mid = (low + high) / 2;

            // Check if we can make T products in time <= mid
            if (Check(mid, N, T, K))
            {
                // Update the answer and reduce search space by
                // moving high to mid - 1
                ans = mid;
                high = mid - 1;
            }
            else
            {
                // Reduce the search space by moving low to mid + 1
                low = mid + 1;
            }
        }
        return ans;
    }

    static void Main(string[] args)
    {
        // Sample Input
        long N = 3, T = 7;
        long[] K = { 3, 2, 5 };

        Console.WriteLine(Solve(N, T, K));
    }
}

// Make the check function to check if we can make T
// products in time <= mid
function check(mid, N, T, K) {
    // Variable to count the number of products made
    let sum = 0;
    for (let i = 0; i < N; i++) {
        sum += Math.floor(mid / K[i]);
        if (sum >= T)
            return true;
    }
    return false;
}

// Function to find the minimum time to make T products
function solve(N, T, K) {
    // Define the range in which our answer can lie
    let low = 1, high = Math.min(...K) * T;
    let ans;

    // Binary Search for the minimum time to make T products
    while (low <= high) {
        let mid = Math.floor((low + high) / 2);

        // Check if we can make T products in time <= mid
        if (check(mid, N, T, K)) {
            // Update the answer and reduce search space by
            // moving high to mid - 1
            ans = mid;
            high = mid - 1;
        } else {
            // Reduce the search space by moving low to mid
            // + 1
            low = mid + 1;
        }
    }
    return ans;
}

// Sample Input
let N = 3, T = 7;
let K = [3, 2, 5];

console.log(solve(N, T, K));

// This code is contributed by Ayush Mishra

8

Time Complexity: O(N * log(T * max(K[]))), N is the number of machines, T is the number of products and K[] is the array of time which each machine takes to make 1 product.
Auxiliary Space: O(1)