Maximize product of digit sum of consecutive pairs in a subsequence of length K

Difficulty Level : Hard
Last Updated : 12 Jun, 2020

Given an array of integers arr[], the task is to maximize the product of the digit sum of every consecutive pairs in a subsequence of length K.

Note: K is always even because pairs will be formed on the even length.

Examples:

Input: arr[] = {2, 100, 99, 3, 16}, K = 4
Output: 128
The optimal subsequence of length 4 is [2, 100, 99, 16]
Sum of digits = 2, 2, 18 and 7 respectively.
So Product of digit sums in pairs = 2 * 1 + 18 * 7 = 2 + 126 = 128, which is maximum.

Input: arr[] = {10, 5, 9, 101, 24, 2, 20, 14}, K = 6
Output: 69
The optimal subsequence of length 6 = [10, 5, 9, 24, 2, 14]
Sum of digits = 1, 5, 9, 6, 2 and 5 respectively.
So Product of digit sums in pairs = 1 * 5 + 9 * 6 + 2 * 5 = 5 + 54 + 10 = 69, which is maximum.

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

Approach: The idea is to use Dynamic Programming. As we need to find pairs in the array by including or excluding some of the elements from the array to form a subsequence. So let DP[i][j][k] be our dp array which stores the maximum product of the sum of digits of the elements upto index i having length j and last element as K.

Observations:

Odd Length: While choosing the even length subsequence, when current length of the choosen subsequence is odd, then the pair for the last element is to be chosen. Therefore, we have to compute the product of sum of the last and current element and we recur by keeping last as 0 in next call for even length.
$dp[i][j][k] = max(dp[i][j][k], productDigitSum(arr[k], arr[i]) + solve(i+1, j+1, 0))$
Even Length: While choosing the odd length subsequence, when current length of the choosen subsequence is even, then we have to just select the first element of the pair. Therefore, we just select the current element as last element for the next recursive call and search for second element for this pair in next recursive call.
$dp[i][j][k] = max(dp[i][j][k], solve(i+1, j+1, i))$
Exclude Element: Another option for the current element is to exclude the current element and choose the elements further.
$dp[i][j][k] = max(dp[i][j][k], solve(i+1, j, k))$

Below is the implementation of above approach:

C++

// C++ implementation to find the 
// maximum product of the digit 
// sum of the consecutive pairs of 
// the subsequence of the length K 
  
#include <bits/stdc++.h> 
using namespace std; 
  
const int MAX = 100; 
int dp[1000][MAX][MAX]; 
  
// Function to find the product 
// of two numbers digit sum 
// in the pair 
int productDigitSum(int x, int y) 
{ 
    int sumx = 0; 
  
    // Loop to find the digits of 
    // the number 
    while (x) { 
        sumx += (x % 10); 
        x /= 10; 
    } 
    int sumy = 0; 
  
    // Loop to find the digits 
    // of other number 
    while (y) { 
        sumy += (y % 10); 
        y /= 10; 
    } 
    return (sumx * sumy); 
} 
  
// Function to find the subsequence 
// of the length K 
int solve(int arr[], int i, int len, 
          int prev, int n, int k) 
{ 
    // Base Case 
    if (len == k) 
        return 0; 
  
    // Condition when we didn't reach 
    // the length K, but ran out of 
    // elements of the array 
    if (i == n) 
        return INT_MIN; 
  
    // Condition if already calculated 
    if (dp[i][len][prev]) 
        return dp[i][len][prev]; 
  
    int inc = 0, exc = 0; 
  
    // If length upto this point is odd 
    if (len & 1) { 
  
        // If length is odd, it means we need 
        // second element of this current pair, 
        // calculate the product of digit sum of 
        // current and previous element and recur 
        // by moving towards next index 
        inc = productDigitSum(arr[prev], 
                              arr[i]) 
              + solve(arr, i + 1, 
                      len + 1, 0, n, k); 
    } 
  
    // If length upto this point is even 
    else { 
        inc = solve(arr, i + 1, len + 1, i, n, k); 
    } 
  
    // Exclude this current element 
    // and recur for next elements. 
    exc = solve(arr, i + 1, len, prev, n, k); 
  
    // return by memoizing it, by selecting 
    // the maximum among two choices. 
    return dp[i][len][prev] = max(inc, exc); 
} 
  
// Driver Code 
int main() 
{ 
    int arr[] = { 10, 5, 9, 101, 24, 2, 20, 14 }; 
    int n = sizeof(arr) / sizeof(arr[0]); 
    int k = 6; 
    cout << solve(arr, 0, 0, 0, n, k); 
} 

Java

// Java implementation to find the 
// maximum product of the digit 
// sum of the consecutive pairs of 
// the subsequence of the length K 
import java.util.*; 
  
class GFG{ 
      
static int MAX = 100; 
static int dp[][][] = new int[1000][MAX][MAX]; 
  
// Function to find the product 
// of two numbers digit sum 
// in the pair 
static int productDigitSum(int x, int y) 
{ 
    int sumx = 0; 
  
    // Loop to find the digits  
    // of the number 
    while (x > 0)  
    { 
        sumx += (x % 10); 
        x /= 10; 
    } 
    int sumy = 0; 
  
    // Loop to find the digits 
    // of other number 
    while (y > 0) 
    { 
        sumy += (y % 10); 
        y /= 10; 
    } 
    return (sumx * sumy); 
} 
  
// Function to find the subsequence 
// of the length K 
static int solve(int arr[], int i, int len, 
                  int prev, int n, int k) 
{ 
      
    // Base Case 
    if (len == k) 
        return 0; 
  
    // Condition when we didn't reach 
    // the length K, but ran out of 
    // elements of the array 
    if (i == n) 
        return Integer.MIN_VALUE; 
  
    // Condition if already calculated 
    if (dp[i][len][prev] != 0) 
        return dp[i][len][prev]; 
  
    int inc = 0, exc = 0; 
  
    // If length upto this point is odd 
    if ((len & 1) != 0) 
    { 
  
        // If length is odd, it means we need 
        // second element of this current pair, 
        // calculate the product of digit sum of 
        // current and previous element and recur 
        // by moving towards next index 
        inc = (productDigitSum(arr[prev], arr[i]) +  
               solve(arr, i + 1, len + 1, 0, n, k)); 
    } 
  
    // If length upto this point is even 
    else 
    { 
        inc = solve(arr, i + 1, len + 1, i, n, k); 
    } 
  
    // Exclude this current element 
    // and recur for next elements. 
    exc = solve(arr, i + 1, len, prev, n, k); 
  
    // Return by memoizing it, by selecting 
    // the maximum among two choices. 
    return dp[i][len][prev] = Math.max(inc, exc); 
} 
  
// Driver Code 
public static void main(String []args) 
{ 
    int arr[] = { 10, 5, 9, 101, 24, 2, 20, 14 }; 
    int n = arr.length; 
    int k = 6; 
      
    System.out.print(solve(arr, 0, 0, 0, n, k)); 
} 
} 
  
// This code is contributed by chitranayal 

Python3

# Python3 implementation to find the  
# maximum product of the digit  
# sum of the consecutive pairs of  
# the subsequence of the length K  
import sys 
  
MAX = 100
dp = [] 
  
for i in range(1000): 
    temp1 = [] 
    for j in range(MAX): 
        temp2 = [] 
          
        for k in range(MAX): 
            temp2.append(0) 
        temp1.append(temp2) 
          
    dp.append(temp1) 
  
# Function to find the product  
# of two numbers digit sum  
# in the pair  
def productDigitSum(x, y): 
    sumx = 0
      
    # Loop to find the digits of  
    # the number 
    while x: 
        sumx += x % 10
        x = x // 10
          
    sumy = 0
      
    # Loop to find the digits  
    # of other number  
    while y: 
        sumy += y % 10
        y = y // 10
      
    return sumx * sumy 
  
# Function to find the subsequence  
# of the length K  
def solve(arr, i, len, prev, n, k): 
      
    # Base case 
    if len == k: 
        return 0
      
    # Condition when we didn't reach  
    # the length K, but ran out of  
    # elements of the array  
    if i == n: 
        return -sys.maxsize - 1
      
    # Condition if already calculated 
    if dp[i][len][prev]: 
        return dp[i][len][prev] 
      
    # If length upto this point is odd 
    if len & 1: 
          
        # If length is odd, it means we need  
        # second element of this current pair,  
        # calculate the product of digit sum of  
        # current and previous element and recur  
        # by moving towards next index  
        inc = (productDigitSum(arr[prev], arr[i]) + 
               solve(arr, i + 1, len + 1, i, n, k)) 
    else: 
          
        # If length upto this point is even 
        inc = solve(arr, i + 1, len + 1, i, n, k) 
      
    # Exclude this current element  
    # and recur for next elements.  
    exc = solve(arr, i + 1, len, prev, n, k) 
      
    # Return by memoizing it, by selecting  
    # the maximum among two choices. 
    dp[i][len][prev] = max(inc, exc) 
    return dp[i][len][prev] 
  
# Driver code 
arr = [ 10, 5, 9, 101, 24, 2, 20, 14 ] 
n = len(arr) 
k = 6
print(solve(arr, 0, 0, 0, n, k)) 
  
# This code is contributed by Shivam Singh 

C#

// C# implementation to find the 
// maximum product of the digit 
// sum of the consecutive pairs of 
// the subsequence of the length K 
using System; 
class GFG{ 
      
static int MAX = 100; 
static int [, ,]dp = new int[1000, MAX, MAX]; 
  
// Function to find the product 
// of two numbers digit sum 
// in the pair 
static int productDigitSum(int x, int y) 
{ 
    int sumx = 0; 
  
    // Loop to find the digits  
    // of the number 
    while (x > 0)  
    { 
        sumx += (x % 10); 
        x /= 10; 
    } 
    int sumy = 0; 
  
    // Loop to find the digits 
    // of other number 
    while (y > 0) 
    { 
        sumy += (y % 10); 
        y /= 10; 
    } 
    return (sumx * sumy); 
} 
  
// Function to find the subsequence 
// of the length K 
static int solve(int []arr, int i, int len, 
                 int prev, int n, int k) 
{ 
      
    // Base Case 
    if (len == k) 
        return 0; 
  
    // Condition when we didn't reach 
    // the length K, but ran out of 
    // elements of the array 
    if (i == n) 
        return Int32.MinValue; 
  
    // Condition if already calculated 
    if (dp[i, len, prev] != 0) 
        return dp[i, len, prev]; 
  
    int inc = 0, exc = 0; 
  
    // If length upto this point is odd 
    if ((len & 1) != 0) 
    { 
  
        // If length is odd, it means we need 
        // second element of this current pair, 
        // calculate the product of digit sum of 
        // current and previous element and recur 
        // by moving towards next index 
        inc = (productDigitSum(arr[prev], arr[i]) +  
               solve(arr, i + 1, len + 1, 0, n, k)); 
    } 
  
    // If length upto this point is even 
    else
    { 
        inc = solve(arr, i + 1, len + 1, i, n, k); 
    } 
  
    // Exclude this current element 
    // and recur for next elements. 
    exc = solve(arr, i + 1, len, prev, n, k); 
  
    // Return by memoizing it, by selecting 
    // the maximum among two choices. 
    return dp[i, len, prev] = Math.Max(inc, exc); 
} 
  
// Driver Code 
public static void Main() 
{ 
    int []arr = { 10, 5, 9, 101, 24, 2, 20, 14 }; 
    int n = arr.Length; 
    int k = 6; 
      
    Console.Write(solve(arr, 0, 0, 0, n, k)); 
} 
} 
  
// This code is contributed by Nidhi_biet 

Output:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes

Related Articles

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

C++

Java

Python3

C#