Related Articles

# Maximum profit by selling N items at two markets

• Difficulty Level : Medium
• Last Updated : 02 Jun, 2021

Given two arrays A[] and B[] each of length N where A[i] and B[i] are the prices of the ith item when sold in market A and market B respectively. The task is to maximize the profile of selling all the N items, but there is a catch: if you went to market B then you can not return. For example, if you sell the first k items in market A you have to sell the rest of the items in market B.

Examples:

Input: A[] = {2, 3, 2}, B[] = {10, 3, 40}
Output: 53
Sell all the items in market B in order to
maximize the profit i.e. (10 + 3 + 40) = 53.

Input: A[] = {7, 5, 3, 4}, B[] = {2, 3, 1, 3}
Output: 19

Approach:

• Create a prefix sum array preA[] where preA[i] will store the profit when the items A[0…i] are sold in market A.
• Create a suffix sum array suffB[] where suffB[i] will store the profit when item B[i…n-1] is sold in market B.
• Now the problem is reduced to finding an index i such that (preA[i] + suffB[i + 1]) is the maximum.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to calculate max profit``int` `maxProfit(``int` `profitA[], ``int` `profitB[], ``int` `n)``{` `    ``// Prefix sum array for profitA[]``    ``int` `preSum[n];``    ``preSum = profitA;``    ``for` `(``int` `i = 1; i < n; i++) {``        ``preSum[i] = preSum[i - 1] + profitA[i];``    ``}` `    ``// Suffix sum array for profitB[]``    ``int` `suffSum[n];``    ``suffSum[n - 1] = profitB[n - 1];``    ``for` `(``int` `i = n - 2; i >= 0; i--) {``        ``suffSum[i] = suffSum[i + 1] + profitB[i];``    ``}` `    ``// If all the items are sold in market A``    ``int` `res = preSum[n - 1];` `    ``// Find the maximum profit when the first i``    ``// items are sold in market A and the``    ``// rest of the items are sold in market``    ``// B for all possible values of i``    ``for` `(``int` `i = 1; i < n - 1; i++) {``        ``res = max(res, preSum[i] + suffSum[i + 1]);``    ``}` `    ``// If all the items are sold in market B``    ``res = max(res, suffSum);` `    ``return` `res;``}` `// Driver code``int` `main()``{``    ``int` `profitA[] = { 2, 3, 2 };``    ``int` `profitB[] = { 10, 30, 40 };``    ``int` `n = ``sizeof``(profitA) / ``sizeof``(``int``);` `    ``// Function to calculate max profit``    ``cout << maxProfit(profitA, profitB, n);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``class` `GFG``{``    ``// Function to calculate max profit``    ``static` `int` `maxProfit(``int` `profitA[], ``int` `profitB[], ``int` `n)``    ``{``    ` `        ``// Prefix sum array for profitA[]``        ``int` `preSum[] = ``new` `int``[n];``        ``preSum[``0``] = profitA[``0``];``        ``for` `(``int` `i = ``1``; i < n; i++)``        ``{``            ``preSum[i] = preSum[i - ``1``] + profitA[i];``        ``}``    ` `        ``// Suffix sum array for profitB[]``        ``int` `suffSum[] = ``new` `int``[n];``        ``suffSum[n - ``1``] = profitB[n - ``1``];``        ``for` `(``int` `i = n - ``2``; i >= ``0``; i--)``        ``{``            ``suffSum[i] = suffSum[i + ``1``] + profitB[i];``        ``}``    ` `        ``// If all the items are sold in market A``        ``int` `res = preSum[n - ``1``];``    ` `        ``// Find the maximum profit when the first i``        ``// items are sold in market A and the``        ``// rest of the items are sold in market``        ``// B for all possible values of i``        ``for` `(``int` `i = ``1``; i < n - ``1``; i++)``        ``{``            ``res = Math.max(res, preSum[i] + suffSum[i + ``1``]);``        ``}``    ` `        ``// If all the items are sold in market B``        ``res = Math.max(res, suffSum[``0``]);``    ` `        ``return` `res;``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `main (String[] args)``    ``{``        ``int` `profitA[] = { ``2``, ``3``, ``2` `};``        ``int` `profitB[] = { ``10``, ``30``, ``40` `};``        ``int` `n = profitA.length;``    ` `        ``// Function to calculate max profit``        ``System.out.println(maxProfit(profitA, profitB, n));``    ``}``}` `// This code is contributed by AnkitRai01`

## Python3

 `# Python3 implementation of the approach` `# Function to calculate max profit``def` `maxProfit(profitA, profitB, n) :` `    ``# Prefix sum array for profitA[]``    ``preSum ``=` `[``0``] ``*` `n;``    ``preSum[``0``] ``=` `profitA[``0``];``    ` `    ``for` `i ``in` `range``(``1``, n) :``        ``preSum[i] ``=` `preSum[i ``-` `1``] ``+` `profitA[i];` `    ``# Suffix sum array for profitB[]``    ``suffSum ``=` `[``0``] ``*` `n;``    ``suffSum[n ``-` `1``] ``=` `profitB[n ``-` `1``];``    ` `    ``for` `i ``in` `range``(n ``-` `2``, ``-``1``, ``-``1``) :``        ``suffSum[i] ``=` `suffSum[i ``+` `1``] ``+` `profitB[i];` `    ``# If all the items are sold in market A``    ``res ``=` `preSum[n ``-` `1``];` `    ``# Find the maximum profit when the first i``    ``# items are sold in market A and the``    ``# rest of the items are sold in market``    ``# B for all possible values of i``    ``for` `i ``in` `range``(``1` `, n ``-` `1``) :``        ``res ``=` `max``(res, preSum[i] ``+` `suffSum[i ``+` `1``]);` `    ``# If all the items are sold in market B``    ``res ``=` `max``(res, suffSum[``0``]);` `    ``return` `res;` `# Driver code``if` `__name__ ``=``=` `"__main__"` `:` `    ``profitA ``=` `[ ``2``, ``3``, ``2` `];``    ``profitB ``=` `[ ``10``, ``30``, ``40` `];``    ``n ``=` `len``(profitA);` `    ``# Function to calculate max profit``    ``print``(maxProfit(profitA, profitB, n));` `# This code is contributed by AnkitRai01`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG``{``    ` `    ``// Function to calculate max profit``    ``static` `int` `maxProfit(``int` `[]profitA,``                        ``int` `[]profitB, ``int` `n)``    ``{``    ` `        ``// Prefix sum array for profitA[]``        ``int` `[]preSum = ``new` `int``[n];``        ``preSum = profitA;``        ``for` `(``int` `i = 1; i < n; i++)``        ``{``            ``preSum[i] = preSum[i - 1] + profitA[i];``        ``}``    ` `        ``// Suffix sum array for profitB[]``        ``int` `[]suffSum = ``new` `int``[n];``        ``suffSum[n - 1] = profitB[n - 1];``        ``for` `(``int` `i = n - 2; i >= 0; i--)``        ``{``            ``suffSum[i] = suffSum[i + 1] + profitB[i];``        ``}``    ` `        ``// If all the items are sold in market A``        ``int` `res = preSum[n - 1];``    ` `        ``// Find the maximum profit when the first i``        ``// items are sold in market A and the``        ``// rest of the items are sold in market``        ``// B for all possible values of i``        ``for` `(``int` `i = 1; i < n - 1; i++)``        ``{``            ``res = Math.Max(res, preSum[i] +``                            ``suffSum[i + 1]);``        ``}``    ` `        ``// If all the items are sold in market B``        ``res = Math.Max(res, suffSum);``    ` `        ``return` `res;``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int` `[]profitA = { 2, 3, 2 };``        ``int` `[]profitB = { 10, 30, 40 };``        ``int` `n = profitA.Length;``    ` `        ``// Function to calculate max profit``        ``Console.WriteLine(maxProfit(profitA, profitB, n));``    ``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``
Output:
`80`

Alternate Implementation in Python :

## Python3

 `# Python3 implementation of the approach``def` `maxProfit (a, b, n):` `    ``# Max profit will be saved here``    ``maxP ``=` `-``1` `    ``# loop to check all possible combinations of sales``    ``for` `i ``in` `range``(``0``, n``+``1``):` `        ``# the sum of the profit after the sale``        ``# for products 0 to i in market A``        ``sumA ``=` `sum``(a[:i])` `        ``# the sum of the profit after the sale``        ``# for products i to n in market B``        ``sumB ``=` `sum``(b[i:])` `        ``# Replace the value of Max Profit with a``        ``# bigger value among maxP and sumA+sumB``        ``maxP ``=` `max``(maxP, sumA``+``sumB)` `    ``#  Return the value of Max Profit``    ``return` `maxP`` ` `# Driver Program``if` `__name__ ``=``=` `"__main__"` `: ``    ``a ``=` `[``2``, ``3``, ``2``]``    ``b ``=` `[``10``, ``30``, ``40``]``    ``print``(maxProfit(a, b, ``4``))``     ` `# This code is contributed by aman_malhotra`
Output:
`80`

Time Complexity : O(N)

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.

My Personal Notes arrow_drop_up