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

## 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 = 1 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 c++ implementation of above idea

```// C++ program to find maximum dot product of two array
#include<bits/stdc++.h>
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;
}
```

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.

# GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.
3.7 Average Difficulty : 3.7/5.0
Based on 43 vote(s)