Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Capacity To Ship Packages Within D Days

  • Difficulty Level : Hard
  • Last Updated : 06 Jul, 2021

Given an array arr[] consisting of N positive integers representing the weights of N items and a positive integer D, the task is to find the minimum weight capacity of a boat(say K) to ship all weights within D days such that the order of weights loaded on the ship is in the order of the array elements in arr[] and the total amount of weight loaded by ship each day is K.

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[] = {1, 2, 1}, D = 2
Output: 3
Explanation:
Consider the minimum weight required by the boat as 3, then below is the order of weights such all the weight can be shipped within D(= 2) days:
Day 1: Ship the weights of values 1 and 2 on the first day as the sum of weights 1 + 2 = 3(<= 3).
Day 2: Ship the weights of value 1 on the second day as the sum of weights 1(<= 3).
Considering the minimum weight amount as 3, ships all the weight within D(= 2) days. Therefore, print 3.



Input: arr[] = {9, 8, 10}, D = 3
Output: 10

Approach: The given problem can be solved by using the Greedy Technique and Binary Search. The monotonicity of the problem can be observed that if all packages can be successfully shipped within D days with capacity K, then definitely they can be shipped with any capacity larger than K. Follow the steps below to solve the problem:

  • Initialize a variable, say ans as -1 to store the resultant minimum capacity of the boat required.
  • Initialize two variables, say s and e with the maximum element in the given array and the total sum of the array respectively which denotes the lower and upper bounds of the search space.
  • Iterate until the value of s is less than or equals to e, and perform the following steps:
    • Initialize a variable, say mid as (s + e)/2.
    • Check if it is possible to ship all the packages within D days when the maximum capacity allowed is mid. If found to be true, then update the value of ans to mid and the value of e to (mid – 1).
    • Otherwise, update the value of s to (mid + 1).
  • After completing the above steps, print the value of ans as the result.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if the weights
// can be delivered in D days or not
bool isValid(int weight[], int n,
             int D, int mx)
{
    // Stores the count of days required
    // to ship all the weights if the
    // maximum capacity is mx
    int st = 1;
    int sum = 0;
 
    // Traverse all the weights
    for (int i = 0; i < n; i++) {
        sum += weight[i];
 
        // If total weight is more than
        // the maximum capacity
        if (sum > mx) {
            st++;
            sum = weight[i];
        }
 
        // If days are more than D,
        // then return false
        if (st > D)
            return false;
    }
 
    // Return true for the days < D
    return true;
}
 
// Function to find the least weight
// capacity of a boat to ship all the
// weights within D days
void shipWithinDays(int weight[], int D,
                    int n)
{
    // Stores the total weights to
    // be shipped
    int sum = 0;
 
    // Find the sum of weights
    for (int i = 0; i < n; i++)
        sum += weight[i];
 
    // Stores the maximum weight in the
    // array that has to be shipped
    int s = weight[0];
    for (int i = 1; i < n; i++) {
        s = max(s, weight[i]);
    }
 
    // Store the ending value for
    // the search space
    int e = sum;
 
    // Store the required result
    int res = -1;
 
    // Perform binary search
    while (s <= e) {
 
        // Store the middle value
        int mid = s + (e - s) / 2;
 
        // If mid can be shipped, then
        // update the result and end
        // value of the search space
        if (isValid(weight, n, D, mid)) {
            res = mid;
            e = mid - 1;
        }
 
        // Search for minimum value
        // in the right part
        else
            s = mid + 1;
    }
 
    // Print the result
    cout << res;
}
 
// Driver Code
int main()
{
    int weight[] = { 9, 8, 10 };
    int D = 3;
    int N = sizeof(weight) / sizeof(weight[0]);
    shipWithinDays(weight, D, N);
 
    return 0;
}
Java



// Java program for the above approach
import java.io.*;
 
class GFG{
   
// Function to check if the weights
// can be delivered in D days or not
static boolean isValid(int[] weight, int n,
                       int D, int mx)
{
     
    // Stores the count of days required
    // to ship all the weights if the
    // maximum capacity is mx
    int st = 1;
    int sum = 0;
 
    // Traverse all the weights
    for(int i = 0; i < n; i++)
    {
        sum += weight[i];
 
        // If total weight is more than
        // the maximum capacity
        if (sum > mx)
        {
            st++;
            sum = weight[i];
        }
 
        // If days are more than D,
        // then return false
        if (st > D)
            return false;
    }
 
    // Return true for the days < D
    return true;
}
 
// Function to find the least weight
// capacity of a boat to ship all the
// weights within D days
static void shipWithinDays(int[] weight, int D, int n)
{
     
    // Stores the total weights to
    // be shipped
    int sum = 0;
 
    // Find the sum of weights
    for(int i = 0; i < n; i++)
        sum += weight[i];
 
    // Stores the maximum weight in the
    // array that has to be shipped
    int s = weight[0];
    for(int i = 1; i < n; i++)
    {
        s = Math.max(s, weight[i]);
    }
 
    // Store the ending value for
    // the search space
    int e = sum;
 
    // Store the required result
    int res = -1;
 
    // Perform binary search
    while (s <= e)
    {
         
        // Store the middle value
        int mid = s + (e - s) / 2;
 
        // If mid can be shipped, then
        // update the result and end
        // value of the search space
        if (isValid(weight, n, D, mid))
        {
            res = mid;
            e = mid - 1;
        }
 
        // Search for minimum value
        // in the right part
        else
            s = mid + 1;
    }
 
    // Print the result
    System.out.println(res);
}
 
// Driver Code
public static void main(String[] args)
{
     
    int[] weight = { 9, 8, 10 };
    int D = 3;
    int N = weight.length;
     
    shipWithinDays(weight, D, N);
}
}
 
// This code is contributed by Dharanendra L V.
Python3



# Python3 program for the above approach
 
# Function to check if the weights
# can be delivered in D days or not
def isValid(weight, n, D, mx):
     
    # Stores the count of days required
    # to ship all the weights if the
    # maximum capacity is mx
    st = 1
    sum = 0
 
    # Traverse all the weights
    for i in range(n):
        sum += weight[i]
 
        # If total weight is more than
        # the maximum capacity
        if (sum > mx):
            st += 1
            sum = weight[i]
 
        # If days are more than D,
        # then return false
        if (st > D):
            return False
 
    # Return true for the days < D
    return True
 
# Function to find the least weight
# capacity of a boat to ship all the
# weights within D days
def shipWithinDays(weight, D, n):
     
    # Stores the total weights to
    # be shipped
    sum = 0
 
    # Find the sum of weights
    for i in range(n):
        sum += weight[i]
 
    # Stores the maximum weight in the
    # array that has to be shipped
    s = weight[0]
    for i in range(1, n):
        s = max(s, weight[i])
 
    # Store the ending value for
    # the search space
    e = sum
 
    # Store the required result
    res = -1
 
    # Perform binary search
    while (s <= e):
         
        # Store the middle value
        mid = s + (e - s) // 2
 
        # If mid can be shipped, then
        # update the result and end
        # value of the search space
        if (isValid(weight, n, D, mid)):
            res = mid
            e = mid - 1
 
        # Search for minimum value
        # in the right part
        else:
            s = mid + 1
 
    # Print the result
    print(res)
 
# Driver Code
if __name__ == '__main__':
     
    weight = [ 9, 8, 10 ]
    D = 3
    N = len(weight)
     
    shipWithinDays(weight, D, N)
 
# This code is contributed by ipg2016107
C#



// C# program for the above approach
using System;
 
class GFG{
 
// Function to check if the weights
// can be delivered in D days or not
static bool isValid(int[] weight, int n,
                    int D, int mx)
{
     
    // Stores the count of days required
    // to ship all the weights if the
    // maximum capacity is mx
    int st = 1;
    int sum = 0;
 
    // Traverse all the weights
    for(int i = 0; i < n; i++)
    {
        sum += weight[i];
 
        // If total weight is more than
        // the maximum capacity
        if (sum > mx)
        {
            st++;
            sum = weight[i];
        }
 
        // If days are more than D,
        // then return false
        if (st > D)
            return false;
    }
 
    // Return true for the days < D
    return true;
}
 
// Function to find the least weight
// capacity of a boat to ship all the
// weights within D days
static void shipWithinDays(int[] weight, int D, int n)
{
     
    // Stores the total weights to
    // be shipped
    int sum = 0;
 
    // Find the sum of weights
    for(int i = 0; i < n; i++)
        sum += weight[i];
 
    // Stores the maximum weight in the
    // array that has to be shipped
    int s = weight[0];
    for(int i = 1; i < n; i++)
    {
        s = Math.Max(s, weight[i]);
    }
 
    // Store the ending value for
    // the search space
    int e = sum;
 
    // Store the required result
    int res = -1;
 
    // Perform binary search
    while (s <= e)
    {
         
        // Store the middle value
        int mid = s + (e - s) / 2;
 
        // If mid can be shipped, then
        // update the result and end
        // value of the search space
        if (isValid(weight, n, D, mid))
        {
            res = mid;
            e = mid - 1;
        }
 
        // Search for minimum value
        // in the right part
        else
            s = mid + 1;
    }
 
    // Print the result
    Console.WriteLine(res);
}
 
// Driver Code
public static void Main()
{
    int[] weight = { 9, 8, 10 };
    int D = 3;
    int N = weight.Length;
     
    shipWithinDays(weight, D, N);
}
}
 
// This code is contributed by ukasp
Javascript



<script>
 
// JavaScript program for the above approach
 
// Function to check if the weights
// can be delivered in D days or not
function isValid(weight, n,
                       D, mx)
{
      
    // Stores the count of days required
    // to ship all the weights if the
    // maximum capacity is mx
    let st = 1;
    let sum = 0;
  
    // Traverse all the weights
    for(let i = 0; i < n; i++)
    {
        sum += weight[i];
  
        // If total weight is more than
        // the maximum capacity
        if (sum > mx)
        {
            st++;
            sum = weight[i];
        }
  
        // If days are more than D,
        // then return false
        if (st > D)
            return false;
    }
  
    // Return true for the days < D
    return true;
}
  
// Function to find the least weight
// capacity of a boat to ship all the
// weights within D days
function shipWithinDays(weight, D, n)
{
      
    // Stores the total weights to
    // be shipped
    let sum = 0;
  
    // Find the sum of weights
    for(let i = 0; i < n; i++)
        sum += weight[i];
  
    // Stores the maximum weight in the
    // array that has to be shipped
    let s = weight[0];
    for(let i = 1; i < n; i++)
    {
        s = Math.max(s, weight[i]);
    }
  
    // Store the ending value for
    // the search space
    let e = sum;
  
    // Store the required result
    let res = -1;
  
    // Perform binary search
    while (s <= e)
    {
          
        // Store the middle value
        let mid = s + Math.floor((e - s) / 2);
  
        // If mid can be shipped, then
        // update the result and end
        // value of the search space
        if (isValid(weight, n, D, mid))
        {
            res = mid;
            e = mid - 1;
        }
  
        // Search for minimum value
        // in the right part
        else
            s = mid + 1;
    }
  
    // Print the result
    document.write(res);
}
 
// Driver Code
 
    let weight = [ 9, 8, 10 ];
    let D = 3;
    let N = weight.length;
      
    shipWithinDays(weight, D, N);
 
</script>
Output: 
10
 
Time Complexity: O(N*log(S – M)), where S is the sum of the array elements and M is the maximum element of the array.
Auxiliary Space: O(1)



My Personal Notes
arrow_drop_up
Previous
Minimize maximum array element by splitting array elements into powers of two at most K times
Next

Maximum number of intersections possible for any of the N given segments
Recommended Articles
Page :
Total number of days taken to complete the task if after certain days one person leaves
27, May 19
Largest square that can be inscribed within a hexagon which is inscribed within an equilateral triangle
10, Jan 19
Biggest Reuleaux Triangle within a Square which is inscribed within a Circle
11, Jan 19
Biggest Reuleaux Triangle within a Square which is inscribed within a Right angle Triangle
11, Jan 19
Largest right circular cylinder that can be inscribed within a cone which is in turn inscribed within a cube
11, Jan 19
Biggest Reuleaux Triangle inscribed within a square which is inscribed within an ellipse
21, Jan 19
Largest right circular cone that can be inscribed within a sphere which is inscribed within a cube
21, Jan 19
Biggest Reuleaux Triangle inscribed within a square which is inscribed within a hexagon
21, Jan 19
Largest sphere that can be inscribed within a cube which is in turn inscribed within a right circular cone
19, Mar 19
Largest ellipse that can be inscribed within a rectangle which in turn is inscribed within a semicircle
10, Apr 19
Find the minimum capacity of the train required to hold the passengers
19, Sep 19
Maximum possible value of array elements that can be made based on given capacity conditions
27, Sep 21
Minimum capacity of small arrays needed to contain all element of the given array
10, May 20
Find number of days between two given dates
10, Mar 15
Active and Inactive cells after k Days
07, Sep 16
Date after adding given number of days to the given date
17, May 17
Program to calculate the number of odd days in given number of years
10, Apr 19
Finding number of days between two dates using StringStream
10, Apr 20
Number of days after which tank will become empty
20, Aug 17
Minimum number of days required to complete the work
26, Sep 18
C program to print number of days in a month
28, Jul 20
Find the day of the week after K days from the given day
04, Jun 20
Total number of cells covered in a matrix after D days
20, Jun 20
Find temperature of missing days using given sum and average
28, Jul 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
parthagarwal1962000
@parthagarwal1962000
Vote for difficulty
Current difficulty :
Hard





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox