# Minimum sum of product of two arrays

Find the minimum sum of Products of two arrays of the same size, given that k modifications are allowed on the first array. In each modification, one array element of the first array can either be increased or decreased by 2.

Examples:

```Input : ar[] = {1, 2, -3}
b[]  = {-2, 3, -5}
k = 5
Output : -31
Explanation:
Here n = 3 and k = 5.
So, we modified a, which is -3 and
increased it by 10 (as 5 modifications
are allowed).
Final sum will be :
(1 * -2) + (2 * 3) + (7 * -5)
-2    +    6    -    35
-31
(which is the minimum sum of the array
with given conditions)

Input : a[] = {2, 3, 4, 5, 4}
b[] = {3, 4, 2, 3, 2}
Output : 25
Explanation:
Here, total numbers are 5 and total
modifications allowed are 3. So, modify
a, which is 3 and decreased it by 6
(as 3 modifications are allowed).
Final sum will be :
(2 * 3) + (-3 * 4) + (4 * 2) + (5 * 3) + (4 * 2)
6    –    12    +    8    +    15   +    8
25
(which is the minimum sum of the array with
given conditions)
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Since we need to minimize the product sum, we find the maximum product and reduce it. By taking some examples, we observe that making 2*k changes to only one element is enough to get the minimum sum. Based on this observation, we consider every element as the element on which we apply all k operations and keep track of the element that reduces result to minimum.

## C++

 `// CPP program to find minimum sum of product  ` `// of two arrays with k operations allowed on ` `// first array. ` `#include ` `using` `namespace` `std; ` ` `  `// Function to find the minimum product ` `int` `minproduct(``int` `a[], ``int` `b[], ``int` `n, ``int` `k) ` `{ ` `    ``int` `diff = 0, res = 0; ` `    ``int` `temp; ` `    ``for` `(``int` `i = 0; i < n; i++) { ` ` `  `        ``// Find product of current elements and update ` `        ``// result. ` `        ``int` `pro = a[i] * b[i]; ` `        ``res = res + pro; ` ` `  `        ``// If both product and b[i] are negative, ` `        ``// we must increase value of a[i] to minimize ` `        ``// result. ` `        ``if` `(pro < 0 && b[i] < 0) ` `            ``temp = (a[i] + 2 * k) * b[i]; ` ` `  `        ``// If both product and a[i] are negative, ` `        ``// we must decrease value of a[i] to minimize ` `        ``// result. ` `        ``else` `if` `(pro < 0 && a[i] < 0) ` `            ``temp = (a[i] - 2 * k) * b[i]; ` ` `  `        ``// Similar to above two cases for positive ` `        ``// product. ` `        ``else` `if` `(pro > 0 && a[i] < 0) ` `            ``temp = (a[i] + 2 * k) * b[i]; ` `        ``else` `if` `(pro > 0 && a[i] > 0) ` `            ``temp = (a[i] - 2 * k) * b[i]; ` ` `  `        ``// Check if current difference becomes higher ` `        ``// than the maximum difference so far. ` `        ``int` `d = ``abs``(pro - temp); ` `        ``if` `(d > diff) ` `            ``diff = d;         ` `    ``} ` ` `  `    ``return` `res - diff; ` `} ` ` `  `// Driver function ` `int` `main() ` `{ ` `    ``int` `a[] = { 2, 3, 4, 5, 4 }; ` `    ``int` `b[] = { 3, 4, 2, 3, 2 }; ` `    ``int` `n = 5, k = 3; ` `    ``cout << minproduct(a, b, n, k)  ` `         ``<< endl; ` `    ``return` `0; ` `} `

## Java

 `// Java program to find minimum sum  ` `// of product of two arrays with k  ` `// operations allowed on first array. ` `import` `java.math.*; ` ` `  `class` `GFG { ` ` `  `// Function to find the minimum product ` `static` `int` `minproduct(``int` `a[], ``int` `b[], ``int` `n,  ` `                                       ``int` `k) ` `{ ` `    ``int` `diff = ``0``, res = ``0``; ` `    ``int` `temp = ``0``; ` `    ``for` `(``int` `i = ``0``; i < n; i++) { ` ` `  `        ``// Find product of current elements  ` `        ``// and update result. ` `        ``int` `pro = a[i] * b[i]; ` `        ``res = res + pro; ` ` `  `        ``// If both product and b[i] are  ` `        ``// negative, we must increase value  ` `        ``// of a[i] to minimize result. ` `        ``if` `(pro < ``0` `&& b[i] < ``0``) ` `            ``temp = (a[i] + ``2` `* k) * b[i]; ` ` `  `        ``// If both product and a[i] are  ` `        ``// negative, we must decrease value  ` `        ``// of a[i] to minimize result. ` `        ``else` `if` `(pro < ``0` `&& a[i] < ``0``) ` `            ``temp = (a[i] - ``2` `* k) * b[i]; ` ` `  `        ``// Similar to above two cases  ` `        ``// for positive product. ` `        ``else` `if` `(pro > ``0` `&& a[i] < ``0``) ` `            ``temp = (a[i] + ``2` `* k) * b[i]; ` `        ``else` `if` `(pro > ``0` `&& a[i] > ``0``) ` `            ``temp = (a[i] - ``2` `* k) * b[i]; ` ` `  `        ``// Check if current difference  ` `        ``// becomes higher than the maximum  ` `        ``// difference so far. ` `        ``int` `d = Math.abs(pro - temp); ` `        ``if` `(d > diff) ` `            ``diff = d;      ` `    ``} ` ` `  `    ``return` `res - diff; ` `} ` ` `  `// Driver function ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `a[] = { ``2``, ``3``, ``4``, ``5``, ``4` `}; ` `    ``int` `b[] = { ``3``, ``4``, ``2``, ``3``, ``2` `}; ` `    ``int` `n = ``5``, k = ``3``; ` `    ``System.out.println(minproduct(a, b, n, k)); ` `} ` `} ` ` `  `// This code is contributed by Prerna Saini `

## Python3

 `# Python program to find ` `# minimum sum of product  ` `# of two arrays with k ` `# operations allowed on ` `# first array. ` ` `  `# Function to find the minimum product ` `def` `minproduct(a,b,n,k): ` ` `  `    ``diff ``=` `0` `    ``res ``=` `0` `    ``for` `i ``in` `range``(n):  ` ` `  `        ``# Find product of current ` `        ``# elements and update result. ` `        ``pro ``=` `a[i] ``*` `b[i] ` `        ``res ``=` `res ``+` `pro ` ` `  `        ``# If both product and ` `        ``# b[i] are negative, ` `        ``# we must increase value ` `        ``# of a[i] to minimize result. ` `        ``if` `(pro < ``0` `and` `b[i] < ``0``): ` `            ``temp ``=` `(a[i] ``+` `2` `*` `k) ``*` `b[i] ` ` `  `        ``# If both product and ` `        ``# a[i] are negative, ` `        ``# we must decrease value ` `        ``# of a[i] to minimize result. ` `        ``elif` `(pro < ``0` `and` `a[i] < ``0``): ` `            ``temp ``=` `(a[i] ``-` `2` `*` `k) ``*` `b[i] ` ` `  `        ``# Similar to above two cases ` `        ``# for positive product. ` `        ``elif` `(pro > ``0` `and` `a[i] < ``0``): ` `            ``temp ``=` `(a[i] ``+` `2` `*` `k) ``*` `b[i] ` `        ``elif` `(pro > ``0` `and` `a[i] > ``0``): ` `            ``temp ``=` `(a[i] ``-` `2` `*` `k) ``*` `b[i] ` ` `  `        ``# Check if current difference ` `        ``# becomes higher ` `        ``# than the maximum difference so far. ` `        ``d ``=` `abs``(pro ``-` `temp) ` ` `  `        ``if` `(d > diff): ` `            ``diff ``=` `d        ` `    ``return` `res ``-` `diff ` ` `  `# Driver function ` `a ``=` `[ ``2``, ``3``, ``4``, ``5``, ``4` `] ` `b ``=` `[ ``3``, ``4``, ``2``, ``3``, ``2` `] ` `n ``=` `5` `k ``=` `3` ` `  `print``(minproduct(a, b, n, k)) ` ` `  `# This code is contributed ` `# by Azkia Anam. `

## C#

 `// C# program to find minimum sum  ` `// of product of two arrays with k  ` `// operations allowed on first array. ` `using` `System; ` ` `  `class` `GFG { ` ` `  `    ``// Function to find the minimum product ` `    ``static` `int` `minproduct(``int` `[]a, ``int` `[]b, ` `                                ``int` `n, ``int` `k) ` `    ``{ ` `        ``int` `diff = 0, res = 0; ` `        ``int` `temp = 0; ` `        ``for` `(``int` `i = 0; i < n; i++) ` `        ``{ ` `     `  `            ``// Find product of current elements  ` `            ``// and update result. ` `            ``int` `pro = a[i] * b[i]; ` `            ``res = res + pro; ` `     `  `            ``// If both product and b[i] are  ` `            ``// negative, we must increase value  ` `            ``// of a[i] to minimize result. ` `            ``if` `(pro < 0 && b[i] < 0) ` `                ``temp = (a[i] + 2 * k) * b[i]; ` `     `  `            ``// If both product and a[i] are  ` `            ``// negative, we must decrease value  ` `            ``// of a[i] to minimize result. ` `            ``else` `if` `(pro < 0 && a[i] < 0) ` `                ``temp = (a[i] - 2 * k) * b[i]; ` `     `  `            ``// Similar to above two cases  ` `            ``// for positive product. ` `            ``else` `if` `(pro > 0 && a[i] < 0) ` `                ``temp = (a[i] + 2 * k) * b[i]; ` `            ``else` `if` `(pro > 0 && a[i] > 0) ` `                ``temp = (a[i] - 2 * k) * b[i]; ` `     `  `            ``// Check if current difference  ` `            ``// becomes higher than the maximum  ` `            ``// difference so far. ` `            ``int` `d = Math.Abs(pro - temp); ` `            ``if` `(d > diff) ` `                ``diff = d;  ` `        ``} ` `     `  `        ``return` `res - diff; ` `    ``} ` `     `  `    ``// Driver function ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int` `[]a = { 2, 3, 4, 5, 4 }; ` `        ``int` `[]b = { 3, 4, 2, 3, 2 }; ` `        ``int` `n = 5, k = 3; ` `         `  `        ``Console.WriteLine(minproduct(a, b, n, k)); ` `    ``} ` `} ` ` `  `// This code is contributed by vt_m. `

## PHP

 ` 0 ``and` `\$a``[``\$i``] < 0) ` `            ``\$temp` `= (``\$a``[``\$i``] + 2 * ``\$k``) * ``\$b``[``\$i``]; ` `        ``else` `if` `(``\$pro` `> 0 ``and` `\$a``[``\$i``] > 0) ` `            ``\$temp` `= (``\$a``[``\$i``] - 2 * ``\$k``) * ``\$b``[``\$i``]; ` ` `  `        ``// Check if current difference becomes higher ` `        ``// than the maximum difference so far. ` `        ``\$d` `= ``abs``(``\$pro` `- ``\$temp``); ` `        ``if` `(``\$d` `> ``\$diff``) ` `            ``\$diff` `= ``\$d``;  ` `    ``} ` ` `  `    ``return` `\$res` `- ``\$diff``; ` `} ` ` `  `    ``// Driver Code ` `    ``\$a` `= ``array``(2, 3, 4, 5, 4 ,0); ` `    ``\$b` `=``array``(3, 4, 2, 3, 2); ` `    ``\$n` `= 5;  ` `    ``\$k` `= 3; ` `    ``echo` `minproduct(``\$a``, ``\$b``, ``\$n``, ``\$k``); ` `     `  `// This code is contributed by anuj_67. ` `?> `

Output :

```25
```

This article is contributed by Abhishek Sharma. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up

Improved By : vt_m

Article Tags :
Practice Tags :

5

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.