Related Articles

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

• Difficulty Level : Hard
• Last Updated : 17 Jun, 2021

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

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

## Javascript

 ``

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