# 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 **i ^{th}** 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:7Explanation:

On 1^{st}day, person eats the apple produced by apple tree on the 1^{st}day.

On 2^{nd}day, person eats the apple produced by apple tree on the 2^{nd}day.

On 3^{rd}day, person eats the apple produced by apple tree on the 2^{nd}day.

On 4^{th}to 7^{th}day, person eats the apple produced by apple tree on the 4^{th}day.

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

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

- Initialize a priority_queue to store the count of apples produced on the
**i**day and the expiration date of those apples.^{th} - Traverse both the arrays and insert the count of apples and the expiration date of those apples produced by the apple tree on the
**i**day.^{th} - Check if expiration date of the top element of the priority_queue has expired or not. If found to be true, then pop the elements from the priority_queue.
- Otherwise, increment the maximum count and decrement the count of apples from the priority_queue.
- Finally, print the maximum count obtained.

Below is the implementation of the above approach:

## C++

`// C++ program of the above approach` `#include <bits/stdc++.h>` `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<P, vector` `<p>, greater` `<p> > 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;` `}` |

## 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<Tuple<` `int` `,` `int` `>> pq = ` `new` `List<Tuple<` `int` `,` `int` `>>(); ` ` ` `// 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.` |

**Output:**

7

**Time Complexity:** O(NlogN) **Auxiliary Space:** O(N)

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**.