GFG App
Open App
Browser
Continue

# Find Maximum dot product of two arrays with insertion of 0’s

Given two arrays of positive integers of size m and n where m > n. We need to maximize the dot product by inserting zeros in the second array but we cannot disturb the order of elements.

Examples:

Input : A[] = {2, 3 , 1, 7, 8} , B[] = {3, 6, 7}
Output : 107
Explanation : We get maximum dot product after inserting 0 at first and third positions in second array.
Maximum Dot Product : = A[i] * B[j]
2*0 + 3*3 + 1*0 + 7*6 + 8*7 = 107

Input : A[] = {1, 2, 3, 6, 1, 4}, B[] = {4, 5, 1}
Output : 46

Asked in: Directi Interview

Recommended Practice

Another way to look at this problem is, for every pair of elements element A[i] and B[j] where j >= i , we have two choices:

1. We multiply A[i] and B[j] and add to the product (We include A[i]).
2. We exclude A[i] from the product (In other words, we insert 0 at the current position in B[])

The idea is to use Dynamic programming

```1) Given Array A[] of size 'm' and B[] of size 'n'

2) Create 2D matrix 'DP[n + 1][m + 1]' initialize it
with '0'

3) Run loop outer loop for i = 1 to n
Inner loop j = i to m

// Two cases arise
// 1) Include A[j]
// 2) Exclude A[j] (insert 0 in B[])
dp[i][j]  = max(dp[i-1][j-1] + A[j-1] * B[i -1],
dp[i][j-1])

// Last return maximum dot product that is
return dp[n][m]```

Below is the implementation of the above idea.

## C++

 `// C++ program to find maximum dot product of two array` `#include` `using` `namespace` `std;`   `// Function compute Maximum Dot Product and` `// return it` `long` `long` `int` `MaxDotProduct(``int` `A[], ``int` `B[],` `                            ``int` `m, ``int` `n)` `{` `    ``// Create 2D Matrix that stores dot product` `    ``// dp[i+1][j+1] stores product considering B[0..i]` `    ``// and A[0...j]. Note that since all m > n, we fill` `    ``// values in upper diagonal of dp[][]` `    ``long` `long` `int` `dp[n+1][m+1];` `    ``memset``(dp, 0, ``sizeof``(dp));`   `    ``// Traverse through all elements of B[]` `    ``for` `(``int` `i=1; i<=n; i++)`   `        ``// Consider all values of A[] with indexes greater` `        ``// than or equal to i and compute dp[i][j]` `        ``for` `(``int` `j=i; j<=m; j++)`   `            ``// Two cases arise` `            ``// 1) Include A[j]` `            ``// 2) Exclude A[j] (insert 0 in B[]) ` `            ``dp[i][j] = max((dp[i-1][j-1] + (A[j-1]*B[i-1])) ,` `                            ``dp[i][j-1]);`   `    ``// return Maximum Dot Product` `    ``return` `dp[n][m] ;` `}`   `// Driver program to test above function` `int` `main()` `{` `    ``int` `A[] = { 2, 3 , 1, 7, 8 } ;` `    ``int` `B[] = { 3, 6, 7 } ;` `    ``int` `m = ``sizeof``(A)/``sizeof``(A[0]);` `    ``int` `n = ``sizeof``(B)/``sizeof``(B[0]);` `    ``cout << MaxDotProduct(A, B, m, n);` `    ``return` `0;` `}`

## Java

 `// Java program to find maximum ` `// dot product of two array` `import` `java.util.*;`   `class` `GFG ` `{` `// Function to compute Maximum ` `// Dot Product and return it` `static` `int` `MaxDotProduct(``int` `A[], ``int` `B[], ``int` `m, ``int` `n)` `{` `    ``// Create 2D Matrix that stores dot product` `    ``// dp[i+1][j+1] stores product considering B[0..i]` `    ``// and A[0...j]. Note that since all m > n, we fill` `    ``// values in upper diagonal of dp[][]` `    ``int` `dp[][] = ``new` `int``[n + ``1``][m + ``1``];` `    ``for` `(``int``[] row : dp)` `    ``Arrays.fill(row, ``0``);`   `    ``// Traverse through all elements of B[]` `    ``for` `(``int` `i = ``1``; i <= n; i++)`   `    ``// Consider all values of A[] with indexes greater` `    ``// than or equal to i and compute dp[i][j]` `    ``for` `(``int` `j = i; j <= m; j++)`   `        ``// Two cases arise` `        ``// 1) Include A[j]` `        ``// 2) Exclude A[j] (insert 0 in B[])` `        ``dp[i][j] =` `            ``Math.max((dp[i - ``1``][j - ``1``] + ` `                    ``(A[j - ``1``] * B[i - ``1``])), dp[i][j - ``1``]);`   `    ``// return Maximum Dot Product` `    ``return` `dp[n][m];` `}`   `// Driver code` `public` `static` `void` `main(String[] args) {` `    ``int` `A[] = {``2``, ``3``, ``1``, ``7``, ``8``};` `    ``int` `B[] = {``3``, ``6``, ``7``};` `    ``int` `m = A.length;` `    ``int` `n = B.length;` `    ``System.out.print(MaxDotProduct(A, B, m, n));` `}` `}`   `// This code is contributed by Anant Agarwal.`

## Python3

 `# Python 3 program to find maximum dot` `# product of two array`   `# Function compute Maximum Dot Product ` `# and return it` `def` `MaxDotProduct(A, B, m, n):` `    `  `    ``# Create 2D Matrix that stores dot product` `    ``# dp[i+1][j+1] stores product considering ` `    ``# B[0..i] and A[0...j]. Note that since ` `    ``# all m > n, we fill values in upper ` `    ``# diagonal of dp[][]` `    ``dp ``=` `[[``0` `for` `i ``in` `range``(m ``+` `1``)] ` `             ``for` `j ``in` `range``(n ``+` `1``)]`   `    ``# Traverse through all elements of B[]` `    ``for` `i ``in` `range``(``1``, n ``+` `1``, ``1``):` `        `  `        ``# Consider all values of A[] with indexes ` `        ``# greater than or equal to i and compute` `        ``# dp[i][j]` `        ``for` `j ``in` `range``(i, m ``+` `1``, ``1``):` `            `  `            ``# Two cases arise` `            ``# 1) Include A[j]` `            ``# 2) Exclude A[j] (insert 0 in B[]) ` `            ``dp[i][j] ``=` `max``((dp[i ``-` `1``][j ``-` `1``] ``+` `                            ``(A[j ``-` `1``] ``*` `B[i ``-` `1``])) , ` `                            ``dp[i][j ``-` `1``])`   `    ``# return Maximum Dot Product` `    ``return` `dp[n][m] `   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``A ``=` `[``2``, ``3` `, ``1``, ``7``, ``8``]` `    ``B ``=` `[``3``, ``6``, ``7``]` `    ``m ``=` `len``(A)` `    ``n ``=` `len``(B)` `    ``print``(MaxDotProduct(A, B, m, n))`   `# This code is contributed by` `# Sanjit_Prasad`

## C#

 `// C# program to find maximum ` `// dot product of two array` `using` `System; `   `public` `class` `GFG{`   `    ``// Function to compute Maximum ` `    ``// Dot Product and return it` `    ``static` `int` `MaxDotProduct(``int` `[]A, ``int` `[]B, ``int` `m, ``int` `n)` `    ``{` `        ``// Create 2D Matrix that stores dot product` `        ``// dp[i+1][j+1] stores product considering B[0..i]` `        ``// and A[0...j]. Note that since all m > n, we fill` `        ``// values in upper diagonal of dp[][]` `        ``int` `[,]dp = ``new` `int``[n + 1,m + 1];`   `        ``// Traverse through all elements of B[]` `        ``for` `(``int` `i = 1; i <= n; i++)`   `        ``// Consider all values of A[] with indexes greater` `        ``// than or equal to i and compute dp[i][j]` `        ``for` `(``int` `j = i; j <= m; j++)`   `            ``// Two cases arise` `            ``// 1) Include A[j]` `            ``// 2) Exclude A[j] (insert 0 in B[])` `            ``dp[i,j] =` `                ``Math.Max((dp[i - 1,j - 1] + ` `                        ``(A[j - 1] * B[i - 1])), dp[i,j - 1]);`   `        ``// return Maximum Dot Product` `        ``return` `dp[n,m];` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main() {` `        ``int` `[]A = {2, 3, 1, 7, 8};` `        ``int` `[]B = {3, 6, 7};` `        ``int` `m = A.Length;` `        ``int` `n = B.Length;` `        ``Console.Write(MaxDotProduct(A, B, m, n));` `    ``}` `}`   `/*This code is contributed by 29AjayKumar*/`

## Javascript

 ``

Output

`107`

Time Complexity : O(n*m)
Auxiliary Space: O(n*m)

This article is contributed by Nishant Singh. 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.

My Personal Notes arrow_drop_up