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++ program for above approach #include <bits/stdc++.h> 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 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 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# 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 |
<script> // JavaScript program for above approach
const INT_MAX = 2147483647;
// Function to minimize the sum
const minimumCost = (A, B, N) => {
let minimuPrice = INT_MAX;
// Checking and comparing for
// all the possibilities
for (let i = 0; i < N; i++) {
for (let j = i; j < N; j++) {
let currentPrice = A[i] + B[j];
minimuPrice = Math.min(minimuPrice,
currentPrice);
}
}
// Return the minimum price found
return minimuPrice;
}
// Driver Code
let A = [34, 12, 45, 10, 86, 39, 77];
let B = [5, 42, 29, 63, 30, 33, 20];
let N = A.length;
// Function Call
document.write(minimumCost(A, B, N));
// This code is contributed by rakeshsahni
</script> |
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++ program for above approach #include <bits/stdc++.h> 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 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));
}
} |
# 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# 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 |
<script> // javascript program for above approach // Function to calculate minimum sum
function minimumCost(A, B, N)
{
// For storing the minimum value
// from rear end of B
var cheapestPossible = Array.from({length: N}, (_, i) => 0);
// Only one possible value
// on last index
cheapestPossible[N - 1]
= B[N - 1];
for ( var 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
var minimumPrice = Number.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 ( var i = 0; i < N; i++) {
minimumPrice = Math.min(
minimumPrice, A[i]
+ cheapestPossible[i]);
}
return minimumPrice;
}
// Driver code
var A = [ 34, 12, 45, 10, 86, 39, 77 ];
var B = [ 5, 42, 29, 63, 30, 33, 20 ];
var N = A.length;
document.write(minimumCost(A, B, N)); // This code is contributed by shikhasingrajput </script> |
30
Time Complexity: O(N)
Auxiliary Space: O(N)