Maximum number of candies that can be bought - GeeksforGeeks

19 May, 2021
Given an array arr[] of size n where arr[i] is the number of candies of type i. You have an unlimited amount of money. The task is to buy as many candies as possible satisfying the following conditions: If you buy x(i) candies of type i (clearly, 0 ≤ x(i) ≤ arr[i]), then for all j (1 ≤ j ≤ i) at least one of the following must hold:  
x(j) < x(i) (you bought less candies of type j than of type i)x(j) = 0 (you bought 0 candies of type j)
x(j) < x(i) (you bought less candies of type j than of type i)
x(j) = 0 (you bought 0 candies of type j)
Examples:  
Input:arr[] = {1, 2, 1, 3, 6} Output: 10 x[] = {0, 0, 1, 3, 6} where x[i] is the number of candies bought of type iInput: arr[] = {3, 2, 5, 4, 10} Output: 20Input: arr[] = {1, 1, 1, 1} Output: 1  
 
Approach: We can use a greedy approach and start from the end of the array. If we have taken x candies of type i + 1 then we can only take min(arr[i], x – 1) candies of type i. If this value is negative, we cannot buy candies of the current type.Below is the implementation of the above approach:  
C++
Java
Python3
C#
PHP
Javascript
// C++ implementation of the approach#include <bits/stdc++.h>using namespace std; // Function to return the maximum candies// that can be boughtint maxCandies(int arr[], int n){     // Buy all the candies of the last type    int prevBought = arr[n - 1];    int candies = prevBought;     // Starting from second last    for (int i = n - 2; i >= 0; i--) {         // Amount of candies of the current        // type that can be bought        int x = min(prevBought - 1, arr[i]);         if (x >= 0) {             // Add candies of current type            // that can be bought            candies += x;             // Update the previous bought amount            prevBought = x;        }    }     return candies;} // Driver codeint main(){    int arr[] = { 1, 2, 1, 3, 6 };    int n = sizeof(arr) / sizeof(arr[0]);    cout << maxCandies(arr, n);     return 0;}
// Java implementation of the approachclass GFG{     // Function to return the maximum candies// that can be boughtstatic int maxCandies(int arr[], int n){     // Buy all the candies of the last type    int prevBought = arr[n - 1];    int candies = prevBought;     // Starting from second last    for (int i = n - 2; i >= 0; i--)    {         // Amount of candies of the current        // type that can be bought        int x = Math.min(prevBought - 1, arr[i]);         if (x >= 0)        {             // Add candies of current type            // that can be bought            candies += x;             // Update the previous bought amount            prevBought = x;        }    }     return candies;} // Driver codepublic static void main(String[] args){    int arr[] = { 1, 2, 1, 3, 6 };    int n = arr.length;    System.out.println(maxCandies(arr, n));}} // This code is contributed by Code_Mech.
# Python3 implementation of the approach # Function to return the maximum candies# that can be boughtdef maxCandies(arr, n) :         # Buy all the candies of the last type    prevBought = arr[n - 1];    candies = prevBought;         # Starting from second last    for i in range(n - 2, -1, -1) :                 # Amount of candies of the current        # type that can be bought        x = min(prevBought - 1, arr[i]);        if (x >= 0) :                         # Add candies of current type            # that can be bought            candies += x;                         # Update the previous bought amount            prevBought = x;                 return candies; # Driver codeif __name__ == "__main__" :         arr = [ 1, 2, 1, 3, 6 ];    n = len(arr)    print(maxCandies(arr, n)); # This code is contributed by Ryuga
// C# implementation of the approachusing System; class GFG{     // Function to return the maximum candies// that can be boughtstatic int maxCandies(int[] arr, int n){     // Buy all the candies of the last type    int prevBought = arr[n - 1];    int candies = prevBought;     // Starting from second last    for (int i = n - 2; i >= 0; i--)    {         // Amount of candies of the current        // type that can be bought        int x = Math.Min(prevBought - 1, arr[i]);         if (x >= 0)        {             // Add candies of current type            // that can be bought            candies += x;             // Update the previous bought amount            prevBought = x;        }    }     return candies;} // Driver codepublic static void Main(){    int[] arr= { 1, 2, 1, 3, 6 };    int n = arr.Length;    Console.WriteLine(maxCandies(arr, n));}} // This code is contributed by Code_Mech.
<?php// PHP implementation of the approach // Function to return the maximum candies// that can be boughtfunction maxCandies($arr, $n){     // Buy all the candies of the last type    $prevBought = $arr[$n - 1];    $candies = $prevBought;     // Starting from second last    for ($i = $n - 2; $i >= 0; $i--)    {         // Amount of candies of the current        // type that can be bought        $x = min($prevBought - 1, $arr[$i]);         if ($x >= 0)        {             // Add candies of current type            // that can be bought            $candies += $x;             // Update the previous bought amount            $prevBought = $x;        }    }     return $candies;} // Driver code$arr = array(1, 2, 1, 3, 6 );$n = sizeof($arr);echo(maxCandies($arr, $n)); // This code is contributed by Code_Mech.?>
<script> // Javascript implementation of the approach // Function to return the maximum candies// that can be boughtfunction maxCandies(arr, n){       // Buy all the candies of the last type    let prevBought = arr[n - 1];    let candies = prevBought;       // Starting from second last    for (let i = n - 2; i >= 0; i--)    {           // Amount of candies of the current        // type that can be bought        let x = Math.min(prevBought - 1, arr[i]);           if (x >= 0)        {               // Add candies of current type            // that can be bought            candies += x;               // Update the previous bought amount            prevBought = x;        }    }       return candies;}      // Driver Code       let arr = [ 1, 2, 1, 3, 6 ];    let n = arr.length;    document.write(maxCandies(arr, n));             </script>
10
 
ankthon
Code_Mech
target_2
Constructive Algorithms
Arrays
Competitive Programming
Greedy
Mathematical
Arrays
Greedy
Mathematical
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Maximum and minimum of an array using minimum number of comparisons
Top 50 Array Coding Problems for Interviews
Stack Data Structure (Introduction and Program)
Introduction to Arrays
Multidimensional Arrays in Java
Competitive Programming - A Complete Guide
Practice for cracking any coding interview
Arrow operator -> in C/C++ with Examples
Prefix Sum Array - Implementation and Applications in Competitive Programming
Top 10 Algorithms and Data Structures for Competitive Programming