Skip to content
Related Articles

Related Articles

Minimum cost to buy N kilograms of sweet for M persons

View Discussion
Improve Article
Save Article
  • Difficulty Level : Expert
  • Last Updated : 10 May, 2022

Given an array of n sizes, it includes the cost of sweets in such a way that  sweet[i] is the cost of i sweets. The task is to find the minimum cost to spend to buy exactly ‘n’ kilograms of sweets for the ‘m’ people. 
Since sweets are available in packets, you have to buy at most a ‘m’ packet of sweets for your ‘m’ relatives. You cannot buy more than a ‘m’ packet of sweets. Also, cost[i] = 0, represents that the sweet with packet size i is unavailable. Also, there is an infinite number of packets with i size of sweets. 

Examples:  

Input: m = 3, n = 6, arr[] = {2, 1, 3, 0, 4, 10} 
Output: 3 
We can choose at most 3 packets. We choose 3 packets of size 2, having cost 1 each.Thus, output is 3.

Input: m = 2, n = 7, arr[] = {1, 3, 0, 5, 0, 0, 0} 
Output : 0 
We can choose at most 2 packets. 7 can be formed by 1 2 and 4 indexes, but since you require at most 2 packets to obtain the 7 sweets packets sweet answer, which is not possible. Hence, the answer is 0 as it is formed by 3 packets, not 2. 

Approach: 

  1. Create a matrix sweet[m+1][n+1][n+1], where m is the number of relatives and n is the total kg of sweets to be bought, and the number of packages of sweets.
  2. Initialize sweet[i][0][j] element with 0 and sweet[i][j][0] with -1.
  3. Now fill the matrix according to the following rules – 
    • Buy the ‘k’ package and assign it to dp array. If i>0 and j>=Number of current packages and the price of k sweets is greater than 0. Define dp as dp [i-1][j-k][k] + sweet[k]
    • If dp is undefined, select from previous k-1 packages -> dp[i][j][k]=dp[i][j][k-1]
  4. If dp[m][n][n] is -1, the answer is 0. Otherwise, print dp[m][n][n]

Below is the implementation of the above approach: 

C++




// C++ program to minimum cost to buy
// N kilograms of sweet for M persons
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the minimum cost of sweets
int find(int m, int n, int adj[])
{
    // Defining the sweet array
    int sweet[n + 1];
 
    // DP array to store the values
    int dp[n + 1][n + 1][n + 1];
 
    sweet[0] = 0;
 
    // Since index starts from 1 we
    // reassign the array into sweet
    for (int i = 1; i <= m; ++i)
        sweet[i] = adj[i - 1];
 
    // Assigning base cases for dp array
    for (int i = 0; i <= m; ++i) {
        for (int k = 0; k <= n; ++k)
 
            // At 0 it is free
            dp[i][0][k] = 0;
 
        // Package not available for desirable amount of sweets
        for (int k = 1; k <= n; ++k)
            dp[i][k][0] = -1;
    }
 
    for (int i = 0; i <= m; ++i) {
        for (int j = 1; j <= n; ++j) {
            for (int k = 1; k <= n; ++k) {
 
                dp[i][j][k] = -1;
 
                // Buying the 'k' kg package and
                // assigning it to dp array
                if (i > 0 && j >= k && sweet[k] > 0
                    && dp[i - 1][j - k][k] != -1)
 
                    dp[i][j][k] = dp[i - 1][j - k][k] + sweet[k];
 
                // If no solution, select from previous k-1 packages
                if (dp[i][j][k] == -1 || (dp[i][j][k - 1] != -1
                                          && dp[i][j][k] > dp[i][j][k - 1]))
 
                    dp[i][j][k] = dp[i][j][k - 1];
            }
        }
    }
 
    // If solution does not exist
    if (dp[m][n][n] == -1)
        return 0;
 
    // Print the solution
    else
        return dp[m][n][n];
}
 
// Driver Function
int main()
{
    int m = 3;
    int adj[] = { 2, 1, 3, 0, 4, 10 };
    int n = sizeof(adj) / sizeof(adj[0]);
 
    // Calling the desired function
    cout << find(m, n, adj);
    return 0;
}

Java



// Java program to minimum cost to buy
// N kilograms of sweet for M persons
public class GFG {
     
    // Function to find the minimum cost of sweets
    static int find(int m, int n, int adj[])
    {
        // Defining the sweet array
        int sweet[] = new int [n + 1] ;
       
        // DP array to store the values
        int dp[][][] = new int [n + 1][n + 1][n + 1] ;
       
        sweet[0] = 0;
       
        // Since index starts from 1 we
        // reassign the array into sweet
        for (int i = 1; i <= m; ++i)
            sweet[i] = adj[i - 1];
       
        // Assigning base cases for dp array
        for (int i = 0; i <= m; ++i) {
            for (int k = 0; k <= n; ++k)
       
                // At 0 it is free
                dp[i][0][k] = 0;
       
            // Package not available for desirable amount of sweets
            for (int k = 1; k <= n; ++k)
                dp[i][k][0] = -1;
        }
       
        for (int i = 0; i <= m; ++i) {
            for (int j = 1; j <= n; ++j) {
                for (int k = 1; k <= n; ++k) {
       
                    dp[i][j][k] = -1;
       
                    // Buying the 'k' kg package and
                    // assigning it to dp array
                    if (i > 0 && j >= k && sweet[k] > 0
                        && dp[i - 1][j - k][k] != -1)
       
                        dp[i][j][k] = dp[i - 1][j - k][k] + sweet[k];
       
                    // If no solution, select from previous k-1 packages
                    if (dp[i][j][k] == -1 || (dp[i][j][k - 1] != -1
                                              && dp[i][j][k] > dp[i][j][k - 1]))
       
                        dp[i][j][k] = dp[i][j][k - 1];
                }
            }
        }
       
        // If solution does not exist
        if (dp[m][n][n] == -1)
            return 0;
       
        // Print the solution
        else
            return dp[m][n][n];
    }
 
    // Driver code
    public static void main(String args[])
    {
        int m = 3;
        int adj[] = { 2, 1, 3, 0, 4, 10 };
        int n = adj.length ;
        System.out.println( find(m, n, adj));
    }
    // This Code is contributed by ANKITRAI1
}
  
Python



# Python3 program to minimum cost to buy
# N kilograms of sweet for M persons
 
# Function to find the minimum cost of sweets
def find(m, n, adj):
     
    # Defining the sweet array
    sweet = [0] * (n + 1)
 
    # DP array to store the values
    dp = [[[ 0 for i in range(n + 1)] for i in range(n + 1)] for i in range(n + 1)]
 
    sweet[0] = 0
 
    # Since index starts from 1 we
    # reassign the array into sweet
    for i in range(1, m + 1):
        sweet[i] = adj[i - 1]
 
    # Assigning base cases for dp array
    for i in range(m + 1):
        for k in range(n + 1):
 
            # At 0 it is free
            dp[i][0][k] = 0
 
        # Package not available for desirable amount of sweets
        for k in range(1, n + 1):
            dp[i][k][0] = -1
 
 
    for i in range(m + 1):
        for j in range(1, n + 1):
            for k in range(1, n + 1):
 
                dp[i][j][k] = -1
 
                # Buying the 'k' kg package and
                # assigning it to dp array
                if (i > 0 and j >= k and sweet[k] > 0 and dp[i - 1][j - k][k] != -1):
 
                    dp[i][j][k] = dp[i - 1][j - k][k] + sweet[k]
 
                # If no solution, select from previous k-1 packages
                if (dp[i][j][k] == -1 or (dp[i][j][k - 1] != -1 and dp[i][j][k] > dp[i][j][k - 1])):
 
                    dp[i][j][k] = dp[i][j][k - 1]
 
    # If solution does not exist
    if (dp[m][n][n] == -1):
        return 0
 
    # Print the solution
    else:
        return dp[m][n][n]
 
# Driver Function
 
m = 3
adj = [2, 1, 3, 0, 4, 10]
n = len(adj)
 
# Calling the desired function
print(find(m, n, adj))
 
# This code is contributed by mohit kumar 29
C#



// C# program to minimum cost to buy
// N kilograms of sweet for M persons
using System;
 
class GFG
{
 
// Function to find the minimum
// cost of sweets
static int find(int m, int n,
                int[] adj)
{
    // Defining the sweet array
    int[] sweet = new int [n + 1] ;
     
    // DP array to store the values
    int[,,] dp = new int [n + 1, n + 1,
                                 n + 1];
     
    sweet[0] = 0;
     
    // Since index starts from 1 we
    // reassign the array into sweet
    for (int i = 1; i <= m; ++i)
        sweet[i] = adj[i - 1];
     
    // Assigning base cases
    // for dp array
    for (int i = 0; i <= m; ++i)
    {
        for (int k = 0; k <= n; ++k)
     
            // At 0 it is free
            dp[i, 0, k] = 0;
     
        // Package not available for
        // desirable amount of sweets
        for (int k = 1; k <= n; ++k)
            dp[i, k, 0] = -1;
    }
     
    for (int i = 0; i <= m; ++i)
    {
        for (int j = 1; j <= n; ++j)
        {
            for (int k = 1; k <= n; ++k)
            {
     
                dp[i, j, k] = -1;
     
                // Buying the 'k' kg package and
                // assigning it to dp array
                if (i > 0 && j >= k && sweet[k] > 0 &&
                    dp[i - 1, j - k, k] != -1)
     
                    dp[i, j, k] = dp[i - 1, j - k, k] +
                                             sweet[k];
     
                // If no solution, select from
                // previous k-1 packages
                if (dp[i, j, k] == -1 ||
                   (dp[i, j, k - 1] != -1 &&
                    dp[i, j, k] > dp[i, j, k - 1]))
     
                    dp[i, j, k] = dp[i, j, k - 1];
            }
        }
    }
     
    // If solution does not exist
    if (dp[m, n, n] == -1)
        return 0;
     
    // Print the solution
    else
        return dp[m, n, n];
}
 
// Driver code
public static void Main()
{
    int m = 3;
    int[] adj = { 2, 1, 3, 0, 4, 10 };
    int n = adj.Length ;
    Console.Write(find(m, n, adj));
}
}
 
// This code is contributed
// by ChitraNayal
// C# program to minimum cost to buy
// N kilograms of sweet for M persons
using System;
 
class GFG
{
 
// Function to find the minimum
// cost of sweets
static int find(int m, int n,
                int[] adj)
{
    // Defining the sweet array
    int[] sweet = new int [n + 1] ;
     
    // DP array to store the values
    int[,,] dp = new int [n + 1, n + 1,
                                 n + 1];
     
    sweet[0] = 0;
     
    // Since index starts from 1 we
    // reassign the array into sweet
    for (int i = 1; i <= m; ++i)
        sweet[i] = adj[i - 1];
     
    // Assigning base cases
    // for dp array
    for (int i = 0; i <= m; ++i)
    {
        for (int k = 0; k <= n; ++k)
     
            // At 0 it is free
            dp[i, 0, k] = 0;
     
        // Package not available for
        // desirable amount of sweets
        for (int k = 1; k <= n; ++k)
            dp[i, k, 0] = -1;
    }
     
    for (int i = 0; i <= m; ++i)
    {
        for (int j = 1; j <= n; ++j)
        {
            for (int k = 1; k <= n; ++k)
            {
     
                dp[i, j, k] = -1;
     
                // Buying the 'k' kg package and
                // assigning it to dp array
                if (i > 0 && j >= k && sweet[k] > 0 &&
                    dp[i - 1, j - k, k] != -1)
     
                    dp[i, j, k] = dp[i - 1, j - k, k] +
                                             sweet[k];
     
                // If no solution, select from
                // previous k-1 packages
                if (dp[i, j, k] == -1 ||
                   (dp[i, j, k - 1] != -1 &&
                    dp[i, j, k] > dp[i, j, k - 1]))
     
                    dp[i, j, k] = dp[i, j, k - 1];
            }
        }
    }
     
    // If solution does not exist
    if (dp[m, n, n] == -1)
        return 0;
     
    // Print the solution
    else
        return dp[m, n, n];
}
 
// Driver code
public static void Main()
{
    int m = 3;
    int[] adj = { 2, 1, 3, 0, 4, 10 };
    int n = adj.Length ;
    Console.Write(find(m, n, adj));
}
}
 
// This code is contributed
// by ChitraNayal
Javascript



<script>
// Javascript program to minimum cost to buy
// N kilograms of sweet for M persons
     
    // Function to find the minimum cost of sweets
    function find(m,n,adj)
    {
        // Defining the sweet array
        let sweet = new Array(n + 1) ;
         
        // DP array to store the values
        let dp = new Array(n + 1) ;
        for (let i = 0; i <n+1; ++i) {
            dp[i]=new Array(n+1);
            for (let j = 0; j <= n; ++j) {
                dp[i][j]=new Array(n+1);
                    for (let k = 0; k <= n; ++k) {
         
                        dp[i][j][k] = -1;
                      }
            }
        }
        sweet[0] = 0;
         
        // Since index starts from 1 we
        // reassign the array into sweet
        for (let i = 1; i <= m; ++i)
            sweet[i] = adj[i - 1];
         
        // Assigning base cases for dp array
        for (let i = 0; i <= m; ++i) {
            for (let k = 0; k <= n; ++k)
         
                // At 0 it is free
                dp[i][0][k] = 0;
         
            // Package not available for desirable amount of sweets
            for (let k = 1; k <= n; ++k)
                dp[i][k][0] = -1;
        }
         
        for (let i = 0; i <= m; ++i) {
             
            for (let j = 1; j <= n; ++j) {
                for (let k = 1; k <= n; ++k) {
         
                    dp[i][j][k] = -1;
         
                    // Buying the 'k' kg package and
                    // assigning it to dp array
                    if (i > 0 && j >= k && sweet[k] > 0
                        && dp[i - 1][j - k][k] != -1)
         
                        dp[i][j][k] = dp[i - 1][j - k][k] + sweet[k];
         
                    // If no solution, select from previous k-1 packages
                    if (dp[i][j][k] == -1 || (dp[i][j][k - 1] != -1
                                              && dp[i][j][k] > dp[i][j][k - 1]))
         
                        dp[i][j][k] = dp[i][j][k - 1];
                }
            }
        }
         
        // If solution does not exist
        if (dp[m][n][n] == -1)
            return 0;
         
        // Print the solution
        else
            return dp[m][n][n];
    }
     
    // Driver code
    let m = 3;
    let adj=[2, 1, 3, 0, 4, 10];
    let n = adj.length ;
    document.write( find(m, n, adj));
 
// This code is contributed by avanitrachhadiya2155
</script>
Output: 
3
 
The time complexity of the above algorithm is O(m*n*n).
 

My Personal Notes
arrow_drop_up
Previous
Minimum odd cost path in a matrix
Next

Length of largest sub-array having primes strictly greater than non-primes
Recommended Articles
Page :
Buy minimum items without change and given coins
30, Dec 18
Minimum days required to cure N persons
27, Jan 21
Minimum cost to empty Array where cost of removing an element is 2^(removed_count) * arr[i]
20, Jul 20
Minimum cost to complete given tasks if cost of 1, 7 and 30 days are given
09, Jul 21
Best Time to Buy and Sell Stock
02, Dec 21
Maximize the total profit of all the persons
06, Sep 18
Maximum points by traversing from top left of Matrix to bottom right by two persons
09, Aug 21
Maximum number of teams that can be formed with given persons
31, Jan 19
Maximum points collected by two persons allowed to meet once
09, Feb 17
Minimize cost to empty given array where cost of removing an element is its absolute difference with Time instant
08, Dec 20
Minimize cost to convert all 0s to 1s with cost of converting 0s group be X and that of 1 be X/3
09, Nov 21
Minimize cost to travel from source to destination in a Matrix based on given row change and column change cost
27, Dec 21
Minimize cost to reach bottom right from top left corner of Matrix with given separate cost for each move
11, Jan 22
Minimize cost to sort the Array by moving elements with cost as the value itself
29, Sep 21
Minimum cost to make Longest Common Subsequence of length k
05, Dec 17
Minimum Cost to make two Numeric Strings Identical
04, Oct 18
Minimum cost path from source node to destination node via an intermediate node
22, Aug 18
Minimum odd cost path in a matrix
12, Oct 18
Minimum cost to reach a point N from 0 with two different operations allowed
14, Nov 18
Minimum cost to make a string free of a subsequence
28, Feb 19
Minimum cost to reach end of array array when a maximum jump of K index is allowed
15, Mar 19
Find the minimum cost to cross the River
09, Jan 20
Minimum cost to select K strictly increasing elements
08, May 19
Minimum cost to build N blocks from one block
09, Jan 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
atulim
@atulim
Vote for difficulty
Current difficulty :
Expert





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

Start Your Coding Journey Now!