Skip to content
Related Articles

Related Articles

Improve Article

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 <bits/stdc++.h>
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[0] = profitA[0];
    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[0]);
 
    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[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
        Console.WriteLine(maxProfit(profitA, profitB, n));
    }
}
 
// This code is contributed by 29AjayKumar

Javascript




<script>
// Javascript implementation of the approach
// Function to calculate max profit
function maxProfit(profitA, profitB, n) {
 
    // Prefix sum array for profitA[]
    let preSum = new Array(n);
 
    preSum[0] = profitA[0];
 
    for (let i = 1; i < n; i++) {
        preSum[i] = preSum[i - 1] + profitA[i];
    }
 
    // Suffix sum array for profitB[]
    let suffSum = new Array(n);
    suffSum[n - 1] = profitB[n - 1];
 
    for (let i = n - 2; i >= 0; i--) {
        suffSum[i] = suffSum[i + 1] + profitB[i];
    }
 
    // If all the items are sold in market A
    let 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 (let 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
 
let profitA = [2, 3, 2];
let profitB = [10, 30, 40];
let n = profitA.length;
 
// Function to calculate max profit
document.write(maxProfit(profitA, profitB, n));
</script>
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
Recommended Articles
Page :