Related Articles
Find Maximum dot product of two arrays with insertion of 0’s
• Difficulty Level : Hard
• Last Updated : 09 Jan, 2019

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
```

## Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

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 product (We include A[i]).
2. We exclude A[i] from product (In other words, we insert 0 at current position in B[])

The idea is to use Dynamic programing .

```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 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);``    ``int` `n = ``sizeof``(B)/``sizeof``(B);``    ``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*/`

Output:
```107
```

Time Complexity : O(nm)

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