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 industry experts, please refer **Geeks Classes Live** and **Geeks Classes Live USA**