GeeksforGeeks App
Open App
Browser
Continue

# Find minimum pair sum by selecting element from 2nd array at index larger than 1st array

Given two arrays A[] and B[] of size N each, the task is to minimize A[i] + B[j] such that j ≥ i.

Examples:

Input: A[] = {34, 12, 45, 10, 86, 39, 77},
B[] = {5, 42, 29, 63, 30, 33, 20}
Output: 30
Explanation: For minimizing the sum, take i = 3 and j = 6.

Input: A[] = {34, 17, 45, 10, 19},
B[] = {2, 13, 7, 11, 16}
Output: 21
Explanation: For minimizing the sum, take both i and j = 3.

Naive Approach: The naive approach to solve this problem is to use 2 for loops, one for iterating over A[] and another for iterating over B[]. Just check and compare for all the possibilities to minimize the sum.

Below is the implementation of the above naive approach.

## C++

 `// C++ program for above approach``#include ``using` `namespace` `std;` `// Function to minimize the sum``int` `minimumCost(``int` `A[], ``int` `B[], ``int` `N)``{``    ``int` `minimuPrice = INT_MAX;` `    ``// Checking and comparing for``    ``// all the possibilities``    ``for` `(``int` `i = 0; i < N; i++) {``        ``for` `(``int` `j = i; j < N; j++) {``            ``int` `currentPrice = A[i] + B[j];``            ``minimuPrice = min(minimuPrice,``                              ``currentPrice);``        ``}``    ``}` `    ``// Return the minimum price found``    ``return` `minimuPrice;``}` `// Driver Code``int` `main()``{``    ``int` `A[] = { 34, 12, 45, 10, 86, 39, 77 };``    ``int` `B[] = { 5, 42, 29, 63, 30, 33, 20 };``    ``int` `N = ``sizeof``(A) / ``sizeof``(A[0]);` `    ``// Function Call``    ``cout << minimumCost(A, B, N);``    ``return` `0;``}`

## Java

 `// Java program for above approach``import` `java.io.*;` `class` `GFG {` `    ``// Function to minimize the sum``    ``public` `static` `int` `minimumCost(``int``[] A,``                                  ``int``[] B,``                                  ``int` `N)``    ``{``        ``int` `minimuPrice = Integer.MAX_VALUE;` `        ``// Checking and comparing``        ``// for all the possibilities``        ``for` `(``int` `i = ``0``; i < N; i++) {``            ``for` `(``int` `j = i; j < N; j++) {``                ``int` `currentPrice``                    ``= A[i] + B[j];``                ``minimuPrice``                    ``= Math.min(minimuPrice,``                               ``currentPrice);``            ``}``        ``}``        ``return` `minimuPrice;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int``[] A = { ``34``, ``12``, ``45``, ``10``, ``86``, ``39``, ``77` `};``        ``int``[] B = { ``5``, ``42``, ``29``, ``63``, ``30``, ``33``, ``20` `};``        ``int` `N = A.length;``        ``System.out.println(minimumCost(A, B, N));``    ``}``}`

## Python

 `# Python program for above approach``# import the module``import` `sys` `# Function to minimize the sum``def` `minimumCost(A, B, N):` `    ``minimuPrice ``=` `sys.maxint` `    ``# Checking and comparing for``    ``# all the possibilities``    ``for` `i ``in` `range``(N):``        ``for` `j ``in` `range``(i, N):``              ``currentPrice ``=` `A[i] ``+` `B[j]``              ``minimuPrice ``=` `min``(minimuPrice,``                              ``currentPrice)``   ` `    ``# Return the minimum price found``    ``return` `minimuPrice;` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``  ` `    ``A ``=` `[ ``34``, ``12``, ``45``, ``10``, ``86``, ``39``, ``77` `]``    ``B ``=` `[ ``5``, ``42``, ``29``, ``63``, ``30``, ``33``, ``20` `]` `    ``N ``=` `len``(A)` `    ``# Function Call``    ``print``(minimumCost(A, B, N))``    ` `    ``# This code is contributed by hrithikgarg03188.`

## C#

 `// C# program for above approach``using` `System;``class` `GFG``{` `  ``// Function to minimize the sum``  ``static` `int` `minimumCost(``int``[] A, ``int``[] B, ``int` `N)``  ``{``    ``int` `minimuPrice = Int32.MaxValue;` `    ``// Checking and comparing for``    ``// all the possibilities``    ``for` `(``int` `i = 0; i < N; i++) {``      ``for` `(``int` `j = i; j < N; j++) {``        ``int` `currentPrice = A[i] + B[j];``        ``minimuPrice``          ``= Math.Min(minimuPrice, currentPrice);``      ``}``    ``}` `    ``// Return the minimum price found``    ``return` `minimuPrice;``  ``}` `  ``// Driver Code``  ``public` `static` `int` `Main()``  ``{``    ``int``[] A = { 34, 12, 45, 10, 86, 39, 77 };``    ``int``[] B = { 5, 42, 29, 63, 30, 33, 20 };``    ``int` `N = A.Length;` `    ``// Function Call``    ``Console.Write(minimumCost(A, B, N));``    ``return` `0;``  ``}``}` `// This code is contributed by Taranpreet`

## Javascript

 ``

Output

`30`

Time Complexity: O(N2)
Auxiliary Space: O(1)

Efficient Approach: An efficient way to solve this problem is to create an array that contains the minimum value till ith index from the rear end of B[]. Then traverse through A[] and for each index the minimum sum will be the sum of minimum from starting of A[] and minimum from back of B[] till that index. Follow the steps below to solve the given problem.

• Create an array for storing the minimum value from the rear end of B[] for each index.
• Since there is only one possible value on the last index, assign the last index value of array B[] to the last index of the new array.
• Now, traverse B[] from the rear side and compare the current index (say i) value in B[] with the index (i+1) in the new array and store the minimum value of these two in the ith index of the newly created array.
• Now, iterate over elements of X and look at that index in the new array. Since that index at new array is the smallest possible value present in B[] for i and above.

Below is the implementation of the above efficient approach.

## C++

 `// C++ program for above approach``#include ``using` `namespace` `std;` `// Function to calculate minimum sum``int` `minimumCost(``int` `A[], ``int` `B[], ``int` `N)``{``    ``// For storing the minimum value``    ``// from rear end of B[]``    ``int` `cheapestPossible[N];` `    ``// Only one possible value on last index``    ``cheapestPossible[N - 1] = B[N - 1];` `    ``for` `(``int` `i = (N - 2); i >= 0; i--) {` `        ``// The lowest possible sum at``        ``// index i and above``        ``cheapestPossible[i]``            ``= min(cheapestPossible[i + 1],``                  ``B[i]);``    ``}` `    ``// For storing minimum sum``    ``int` `minimumPrice = INT_MAX;` `    ``// Adding the current value of A[] and``    ``// minimum value of B[] after i and``    ``// comparing it with the last minimum sum``    ``for` `(``int` `i = 0; i < N; i++) {``        ``minimumPrice``            ``= min(minimumPrice,``                  ``A[i] + cheapestPossible[i]);``    ``}``    ``return` `minimumPrice;``}` `// Driver Code``int` `main()``{``    ``int` `A[] = { 34, 12, 45, 10, 86, 39, 77 };``    ``int` `B[] = { 5, 42, 29, 63, 30, 33, 20 };``    ``int` `N = ``sizeof``(A) / ``sizeof``(A[0]);` `    ``// Function Call``    ``cout << minimumCost(A, B, N);``    ``return` `0;``}`

## Java

 `// Java program for above approach``import` `java.io.*;` `class` `GFG {` `    ``// Function to calculate minimum sum``    ``public` `static` `int` `minimumCost(``int``[] A,``                                  ``int``[] B,``                                  ``int` `N)``    ``{``        ``// For storing the minimum value``        ``// from rear end of B[]``        ``int``[] cheapestPossible = ``new` `int``[N];` `        ``// Only one possible value``        ``// on last index``        ``cheapestPossible[N - ``1``]``            ``= B[N - ``1``];` `        ``for` `(``int` `i = (N - ``2``); i >= ``0``; i--) {` `            ``// The lowest possible sum at``            ``// index i and above``            ``cheapestPossible[i]``                ``= Math.min(cheapestPossible[i + ``1``],``                           ``B[i]);``        ``}` `        ``// For storing minimum sum``        ``int` `minimumPrice = Integer.MAX_VALUE;` `        ``// Adding the current value of A[]``        ``// and minimum value of B[] after i``        ``// and comparing it with``        ``// the last minimum sum obtained``        ``for` `(``int` `i = ``0``; i < N; i++) {``            ``minimumPrice = Math.min(``                ``minimumPrice, A[i]``                                  ``+ cheapestPossible[i]);``        ``}``        ``return` `minimumPrice;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int``[] A = { ``34``, ``12``, ``45``, ``10``, ``86``, ``39``, ``77` `};``        ``int``[] B = { ``5``, ``42``, ``29``, ``63``, ``30``, ``33``, ``20` `};``        ``int` `N = A.length;``        ``System.out.println(minimumCost(A, B, N));``    ``}``}`

## Python3

 `# Python 3 program for above approach``import` `sys` `# Function to calculate minimum sum``def` `minimumCost(A, B, N):` `    ``# For storing the minimum value``    ``# from rear end of B[]``    ``cheapestPossible ``=` `[``0``]``*``N` `    ``# Only one possible value on last index``    ``cheapestPossible[N ``-` `1``] ``=` `B[N ``-` `1``]` `    ``for` `i ``in` `range``(N ``-` `2` `,``-` `1``, ``-``1``):` `        ``# The lowest possible sum at``        ``# index i and above``        ``cheapestPossible[i] ``=` `min``(cheapestPossible[i ``+` `1``],``                                  ``B[i])` `    ``# For storing minimum sum``    ``minimumPrice ``=` `sys.maxsize` `    ``# Adding the current value of A[] and``    ``# minimum value of B[] after i and``    ``# comparing it with the last minimum sum``    ``for` `i ``in` `range``(N):``        ``minimumPrice ``=` `min``(minimumPrice,``                           ``A[i] ``+` `cheapestPossible[i])` `    ``return` `minimumPrice` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``A ``=` `[``34``, ``12``, ``45``, ``10``, ``86``, ``39``, ``77``]``    ``B ``=` `[``5``, ``42``, ``29``, ``63``, ``30``, ``33``, ``20``]``    ``N ``=` `len``(A)` `    ``# Function Call``    ``print``(minimumCost(A, B, N))` `    ``# This code is contributed by ukasp.`

## C#

 `// C# program for above approach``using` `System;``using` `System.Collections.Generic;``public` `class` `GFG {` `  ``// Function to calculate minimum sum``  ``public` `static` `int` `minimumCost(``int``[] A,``                                ``int``[] B,``                                ``int` `N)``  ``{``    ` `    ``// For storing the minimum value``    ``// from rear end of []B``    ``int``[] cheapestPossible = ``new` `int``[N];` `    ``// Only one possible value``    ``// on last index``    ``cheapestPossible[N - 1]``      ``= B[N - 1];` `    ``for` `(``int` `i = (N - 2); i >= 0; i--) {` `      ``// The lowest possible sum at``      ``// index i and above``      ``cheapestPossible[i]``        ``= Math.Min(cheapestPossible[i + 1],``                   ``B[i]);``    ``}` `    ``// For storing minimum sum``    ``int` `minimumPrice = ``int``.MaxValue;` `    ``// Adding the current value of []A``    ``// and minimum value of []B after i``    ``// and comparing it with``    ``// the last minimum sum obtained``    ``for` `(``int` `i = 0; i < N; i++) {``      ``minimumPrice = Math.Min(``        ``minimumPrice, A[i]``        ``+ cheapestPossible[i]);``    ``}``    ``return` `minimumPrice;``  ``}` `  ``// Driver code``  ``public` `static` `void` `Main(String[] args)``  ``{``    ``int``[] A = { 34, 12, 45, 10, 86, 39, 77 };``    ``int``[] B = { 5, 42, 29, 63, 30, 33, 20 };``    ``int` `N = A.Length;``    ``Console.WriteLine(minimumCost(A, B, N));``  ``}``}` `// This code is contributed by shikhasingrajput`

## Javascript

 ``

Output

`30`

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

My Personal Notes arrow_drop_up