Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Minimize the sum of product of two arrays with permutations allowed

  • Difficulty Level : Easy
  • Last Updated : 25 Mar, 2021

Given two arrays, A and B, of equal size n, the task is to find the minimum value of A[0] * B[0] + A[1] * B[1] +…+ A[n-1] * B[n-1]. Shuffling of elements of arrays A and B is allowed.

Examples : 

Input : A[] = {3, 1, 1} and B[] = {6, 5, 4}.
Output : 23
Minimum value of S = 1*6 + 1*5 + 3*4 = 23.

Input : A[] = { 6, 1, 9, 5, 4 } and B[] = { 3, 4, 8, 2, 4 }
Output : 80.
Minimum value of S = 1*8 + 4*4 + 5*4 + 6*3 + 9*2 = 80.

The idea is to multiply minimum element of one array to maximum element of another array. Algorithm to solve this problem:  

  1. Sort both the arrays A and B.
  2. Traverse the array and for each element, multiply A[i] and B[n – i – 1] and add to the total.

Note: We are adding multiplication of elements which can lead to overflow conditions.

Below image is an illustration of the above approach: 

Below is the implementation of the above approach: 

C++




// C++ program to calculate minimum sum of product
// of two arrays.
#include <bits/stdc++.h>
using namespace std;
   
// Returns minimum sum of product of two arrays
// with permutations allowed
long long int minValue(int A[], int B[], int n)
{
    // Sort A and B so that minimum and maximum
    // value can easily be fetched.
    sort(A, A + n);
    sort(B, B + n);
   
    // Multiplying minimum value of A and maximum
    // value of B
    long long int result = 0;
    for (int i = 0; i < n; i++)
        result += (A[i] * B[n - i - 1]);
   
    return result;
}
   
// Driven Code
int main()
{
    int A[] = { 3, 1, 1 };
    int B[] = { 6, 5, 4 };
    int n = sizeof(A) / sizeof(A[0]);
    cout << minValue(A, B, n) << endl;
    return 0;
}
Java



// Java program to calculate minimum
// sum of product of two arrays.
import java.io.*;
import java.util.*;
 
class GFG {
 
    // Returns minimum sum of product of two arrays
    // with permutations allowed
    static long minValue(int A[], int B[], int n)
    {
        // Sort A and B so that minimum and maximum
        // value can easily be fetched.
        Arrays.sort(A);
        Arrays.sort(B);
 
        // Multiplying minimum value of A
        // and maximum value of B
        long result = 0;
        for (int i = 0; i < n; i++)
            result += (A[i] * B[n - i - 1]);
 
        return result;
    }
 
    // Driven Code
    public static void main(String[] args)
    {
        int A[] = { 3, 1, 1 };
        int B[] = { 6, 5, 4 };
        int n = A.length;
        ;
        System.out.println(minValue(A, B, n));
    }
}
 
// This code is contributed by vt_m
Python



# Python program to calculate minimum sum of product
# of two arrays.
 
# Returns minimum sum of product of two arrays
# with permutations allowed
 
 
def minValue(A, B, n):
 
    # Sort A and B so that minimum and maximum
    # value can easily be fetched.
    A.sort()
    B.sort()
 
    # Multiplying minimum value of A and maximum
    # value of B
    result = 0
    for i in range(n):
        result += (A[i] * B[n - i - 1])
 
    return result
 
 
# Driven Program
A = [3, 1, 1]
B = [6, 5, 4]
n = len(A)
print minValue(A, B, n)
 
# Contributed by: Afzal Ansari
C#



// C# program to calculate minimum
// sum of product of two arrays.
using System;
 
class GFG {
 
    // Returns minimum sum of product
    // of two arrays with permutations
    // allowed
    static long minValue(int[] a, int[] b,
                                   int n)
    {
         
        // Sort A and B so that minimum
        // and maximum value can easily
        // be fetched.
        Array.Sort(a);
        Array.Sort(b);
 
        // Multiplying minimum value of
        // A and maximum value of B
        long result = 0;
         
        for (int i = 0; i < n; i++)
            result += (a[i] * b[n - i - 1]);
 
        return result;
    }
 
    // Driven Code
    public static void Main()
    {
         
        int[] a = { 3, 1, 1 };
        int[] b = { 6, 5, 4 };
        int n = a.Length;
         
        Console.Write(minValue(a, b, n));
    }
}
 
// This code is contributed by nitin mittal.
PHP



<?php
// PHP program to calculate minimum
// sum of product of two arrays.
 
// Returns minimum sum of
// product of two arrays
// with permutations allowed
function minValue($A, $B, $n)
{
    // Sort A and B so that minimum
    // and maximum value can easily
    // be fetched.
    sort($A); sort($A , $n);
    sort($B); sort($B , $n);
 
    // Multiplying minimum value of
    // A and maximum value of B
    $result = 0;
    for ($i = 0; $i < $n; $i++)
        $result += ($A[$i] *
                    $B[$n - $i - 1]);
 
    return $result;
}
 
// Driver Code
$A = array( 3, 1, 1 );
$B = array( 6, 5, 4 );
$n = sizeof($A) / sizeof($A[0]);
echo minValue($A, $B, $n) ;
 
// This code is contributed by nitin mittal.
?>
Javascript



<script>
 
// JavaScript program to calculate minimum
// sum of product of two arrays.
 
// Returns minimum sum of product of two arrays
// with permutations allowed
function minValue(A, B, n)
{
     
    // Sort A and B so that minimum and maximum
    // value can easily be fetched.
    A.sort();
    B.sort();
 
    // Multiplying minimum value of A
    // and maximum value of B
    let result = 0;
    for(let i = 0; i < n; i++)
        result += (A[i] * B[n - i - 1]);
 
    return result;
}
 
// Driver Code
let A = [ 3, 1, 1 ];
let B = [ 6, 5, 4 ];
let n = A.length;
 
document.write(minValue(A, B, n));
     
// This code is contributed by souravghosh0416
                          
</script>
Output : 
23
Time Complexity : O(n log n).
This article is contributed by Anuj Chauhan(anuj0503). If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
 

My Personal Notes
arrow_drop_up
Next

Huffman Decoding
Recommended Articles
Page :
Minimize sum of product of same-indexed elements of two arrays by reversing a subarray of one of the two arrays
31, May 21
Maximum sum of pairwise product in an array with negative allowed
14, Dec 17
Minimize swaps between two arrays such that sum of the first array exceeds sum of the second array
18, Jan 21
Maximum sum from three arrays such that picking elements consecutively from same is not allowed
13, Mar 19
Minimize Cost with Replacement with other allowed
12, Nov 18
Check if two arrays are permutations of each other
01, Jul 15
Check if two arrays are permutations of each other using Mathematical Operation
10, Oct 18
Count of permutations of an Array having maximum MEXs sum of prefix arrays
11, Oct 21
Count number of triplets with product equal to given number with duplicates allowed
21, Sep 18
Minimize replacements with values up to K to make sum of two given arrays equal
02, Mar 21
Minimize sum of absolute differences of same-indexed elements of two given arrays by at most one replacement
16, May 21
Queries to replace subarrays by equal length arrays with at most P replacements allowed for any array element
10, Dec 20
Find maximum path sum in a 2D matrix when exactly two left moves are allowed
28, May 19
Kth smallest number in array formed by product of any two elements from two arrays
21, Oct 21
Minimum sum of product of two arrays
08, Nov 17
De-arrangements for minimum product sum of two arrays
12, Dec 17
Maximize sum of product of same-indexed elements of equal length subarrays obtained from two given arrays
30, Apr 21
Minimize positive product of two given numbers by at most N decrements
13, Oct 20
Minimize product of two scores possible by at most M reductions
02, Aug 21
Find sub-arrays from given two arrays such that they have equal sum
02, May 19
Maximum OR sum of sub-arrays of two different arrays
26, Dec 17
Minimize cost to Swap two given Arrays
05, Aug 20
Job Scheduling with two jobs allowed at a time
24, Sep 17
Minimum cost to reach a point N from 0 with two different operations allowed
14, Nov 18
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!