GeeksforGeeks App
Open App
Browser
Continue

# Maximum number of apples that can be eaten by a person

Given two arrays apples[] and days[] representing the count of apples an apple tree produces and the number of days these apples are edible from the ith day respectively, the task is to find the maximum number of apples a person can eat if the person can eat at most one apple in a day.

Examples

Input: apples[] = { 1, 2, 3, 5, 2 }, days[] = { 3, 2, 1, 4, 2 }
Output:
Explanation:
On 1st day, person eats the apple produced by apple tree on the 1st day.
On 2nd day, person eats the apple produced by apple tree on the 2nd day.
On 3rd day, person eats the apple produced by apple tree on the 2nd day.
On 4th to 7th day, person eats the apple produced by apple tree on the 4th day.

Input: apples[] = { 3, 0, 0, 0, 0, 2 }, days[] = { 3, 0, 0, 0, 0, 2 }
Output:

Approach: The idea is to eat the apples having the closest expiration date. Follow the steps below to solve the problem:

Below is the implementation of the above approach:

## C++

 `// C++ program of the above approach``#include ``using` `namespace` `std;` `// Function to find the maximum number of apples``// a person can eat such that the person eat``// at most one apple in a day.``int` `cntMaxApples(vector<``int``> apples, vector<``int``> days)``{` `    ``// Stores count of apples and number``    ``// of days those apples are edible``    ``typedef` `pair<``int``, ``int``> P;` `    ``// Store count of apples and number``    ``// of days those apples are edible``    ``priority_queue, greater

> pq;` `    ``// Stores indices of the array``    ``int` `i = 0;` `    ``// Stores count of days``    ``int` `n = apples.size();` `    ``// Stores maximum count of``    ``// edible apples``    ``int` `total_apples = 0;` `    ``// Traverse both the arrays``    ``while` `(i < n || !pq.empty()) {` `        ``// If top element of the apple``        ``// is not already expired``        ``if` `(i < n && apples[i] != 0) {` `            ``// Insert count of apples and``            ``// their expiration date``            ``pq.push({ i + days[i] - 1, apples[i] });``        ``}` `        ``// Remove outdated apples``        ``while` `(!pq.empty() && pq.top().first < i) {``            ``pq.pop();``        ``}` `        ``// Insert all the apples produces by``        ``// tree on current day``        ``if` `(!pq.empty()) {` `            ``// Stores top element of pq``            ``auto` `curr = pq.top();` `            ``// Remove top element of pq``            ``pq.pop();` `            ``// If count of apples in curr``            ``// is greater than 0``            ``if` `(curr.second > 1) {` `                ``// Insert count of apples and``                ``// their expiration date``                ``pq.push({ curr.first,``                          ``curr.second - 1 });``            ``}` `            ``// Update total_apples``            ``++total_apples;``        ``}` `        ``// Update index``        ``++i;``    ``}` `    ``return` `total_apples;``}` `// Driver Code``int` `main()``{``    ``vector<``int``> apples = { 1, 2, 3, 5, 2 };``    ``vector<``int``> days = { 3, 2, 1, 4, 2 };``    ``cout << cntMaxApples(apples, days);``    ``return` `0;``}`

## Java

 `// Java program of the above approach``import` `java.util.*;` `// Function to find the maximum number of apples``// a person can eat such that the person eat``// at most one apple in a day.``class` `GFG {``  ``static` `int` `cntMaxApples(``int``[] apples, ``int``[] days)``  ``{``    ` `    ``// Stores count of apples and number``    ``// of days those apples are edible``    ``class` `Pair {``      ``int` `first, second;``      ``Pair(``int` `first, ``int` `second)``      ``{``        ``this``.first = first;``        ``this``.second = second;``      ``}``    ``}``    ` `    ``// Store count of apples and number``    ``// of days those apples are edible``    ``PriorityQueue pq = ``new` `PriorityQueue<>((a, b) -> a.first - b.first);``    ` `    ``// Stores indices of the array``    ``int` `i = ``0``;``    ` `    ``// Stores count of days``    ``int` `n = apples.length;``    ` `    ``// Stores maximum count of``    ``// edible apples``    ``int` `total_apples = ``0``;``    ` `    ``// Traverse both the arrays``    ``while` `(i < n || !pq.isEmpty())``    ``{``      ` `      ``// If top element of the apple``      ``// is not already expired``      ``if` `(i < n && apples[i] != ``0``)``      ``{``        ` `        ``// Insert count of apples and``        ``// their expiration date``        ``pq.add(``new` `Pair(i + days[i] - ``1``, apples[i]));``      ``}``      ` `      ``// Remove outdated apples``      ``while` `(!pq.isEmpty() && pq.peek().first < i) {``        ``pq.remove();``      ``}``      ` `      ``// Insert all the apples produces by``      ``// tree on current day``      ``if` `(!pq.isEmpty())``      ``{``        ` `        ``// Stores top element of pq``        ``Pair curr = pq.peek();``        ` `        ``// Remove top element of pq``        ``pq.remove();``        ` `        ``// If count of apples in curr``        ``// is greater than 0``        ``if` `(curr.second > ``1``)``        ``{``          ` `          ``// Insert count of apples and``          ``// their expiration date``          ``pq.add(``new` `Pair(curr.first,``                          ``curr.second - ``1``));``        ``}``        ` `        ``// Update total_apples``        ``++total_apples;``      ``}``      ` `      ``// Update index``      ``++i;``    ``}``    ``return` `total_apples;``  ``}``  ` `  ``// Driver Code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int``[] apples = { ``1``, ``2``, ``3``, ``5``, ``2` `};``    ``int``[] days = { ``3``, ``2``, ``1``, ``4``, ``2` `};``    ``System.out.println(cntMaxApples(apples, days));``  ``}``}` `// This code is contributed by ishankhandelwals.`

## Python3

 `# Python3 program of the above approach` `# Function to find the maximum number of apples``# a person can eat such that the person eat``# at most one apple in a day.``def` `cntMaxApples(apples, days) :` `    ``# Store count of apples and number``    ``# of days those apples are edible``    ``pq ``=` `[]``    ` `    ``# Stores indices of the array``    ``i ``=` `0``    ` `    ``# Stores count of days``    ``n ``=` `len``(apples)``    ` `    ``# Stores maximum count of``    ``# edible apples``    ``total_apples ``=` `0``    ` `    ``# Traverse both the arrays``    ``while` `(i < n ``or` `len``(pq) > ``0``) :``    ` `      ``# If top element of the apple``      ``# is not already expired``      ``if` `(i < n ``and` `apples[i] !``=` `0``) :``    ` `        ``# Insert count of apples and``        ``# their expiration date``        ``pq.append([i ``+` `days[i] ``-` `1``, apples[i]])``        ``pq.sort()``    ` `      ``# Remove outdated apples``      ``while` `(``len``(pq) > ``0` `and` `pq[``0``][``0``] < i) :``        ``pq.pop(``0``)``    ` `      ``# Insert all the apples produces by``      ``# tree on current day``      ``if` `(``len``(pq) > ``0``) :``    ` `        ``# Stores top element of pq``        ``curr ``=` `pq[``0``]``    ` `        ``# Remove top element of pq``        ``pq.pop(``0``)``    ` `        ``# If count of apples in curr``        ``# is greater than 0``        ``if` `(``len``(curr) > ``1``) :``    ` `          ``# Insert count of apples and``          ``# their expiration date``          ``pq.append([curr[``0``], curr[``1``] ``-` `1``])``          ``pq.sort()``    ` `        ``# Update total_apples``        ``total_apples ``+``=` `1``    ` `      ``# Update index``      ``i ``+``=` `1``    ` `    ``return` `total_apples``    ` `apples ``=` `[ ``1``, ``2``, ``3``, ``5``, ``2` `]``days ``=` `[ ``3``, ``2``, ``1``, ``4``, ``2` `]` `print``(cntMaxApples(apples, days))` `# This code is contributed by divyesh072019`

## C#

 `// C# program of the above approach``using` `System;``using` `System.Collections.Generic;``class` `GFG {` `  ``// Function to find the maximum number of apples``  ``// a person can eat such that the person eat``  ``// at most one apple in a day.``  ``static` `int` `cntMaxApples(``int``[] apples, ``int``[] days)``  ``{` `    ``// Store count of apples and number``    ``// of days those apples are edible``    ``List> pq = ``new` `List>();` `    ``// Stores indices of the array``    ``int` `i = 0;` `    ``// Stores count of days``    ``int` `n = apples.Length;` `    ``// Stores maximum count of``    ``// edible apples``    ``int` `total_apples = 0;` `    ``// Traverse both the arrays``    ``while` `(i < n || pq.Count > 0) {` `      ``// If top element of the apple``      ``// is not already expired``      ``if` `(i < n && apples[i] != 0) {` `        ``// Insert count of apples and``        ``// their expiration date``        ``pq.Add(``new` `Tuple<``int``,``int``>(i + days[i] - 1, apples[i]));``        ``pq.Sort();``      ``}` `      ``// Remove outdated apples``      ``while` `(pq.Count > 0 && pq[0].Item1 < i) {``        ``pq.RemoveAt(0);``      ``}` `      ``// Insert all the apples produces by``      ``// tree on current day``      ``if` `(pq.Count > 0) {` `        ``// Stores top element of pq``        ``Tuple<``int``,``int``> curr = pq[0];` `        ``// Remove top element of pq``        ``pq.RemoveAt(0);` `        ``// If count of apples in curr``        ``// is greater than 0``        ``if` `(curr.Item2 > 1) {` `          ``// Insert count of apples and``          ``// their expiration date``          ``pq.Add(``new` `Tuple<``int``,``int``>(curr.Item1, curr.Item2 - 1));``          ``pq.Sort();``        ``}` `        ``// Update total_apples``        ``++total_apples;``      ``}` `      ``// Update index``      ``++i;``    ``}` `    ``return` `total_apples;``  ``}   ` `  ``// Driver code``  ``static` `void` `Main() {``    ``int``[] apples = { 1, 2, 3, 5, 2 };``    ``int``[] days = { 3, 2, 1, 4, 2 };` `    ``Console.Write(cntMaxApples(apples, days));``  ``}``}` `// This code is contributed by divyeshrabadiya07.`

## Javascript

 ``

Output

`7`

Time Complexity: O(N log N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up