Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Minimize the sum after choosing elements from the given three arrays

  • Difficulty Level : Medium
  • Last Updated : 24 Apr, 2022

Given three arrays A[], B[] and C[] of same size N. The task is to minimize the sum after choosing N elements from these array such that at every index i an element from any one of the array A[i], B[i] or C[i] can be chosen and no two consecutive elements can be chosen from the same array.
Examples: 
 

Input: A[] = {1, 100, 1}, B[] = {100, 100, 100}, C[] = {100, 100, 100} 
Output: 102 
A[0] + B[1] + A[2] = 1 + 100 + 100 = 201 
A[0] + B[1] + C[2] = 1 + 100 + 100 = 201 
A[0] + C[1] + B[2] = 1 + 100 + 100 = 201 
A[0] + C[1] + A[2] = 1 + 100 + 1 = 102 
B[0] + A[1] + B[2] = 100 + 100 + 100 = 300 
B[0] + A[1] + C[2] = 100 + 100 + 100 = 300 
B[0] + C[1] + A[2] = 100 + 100 + 1 = 201 
B[0] + C[1] + B[2] = 100 + 100 + 100 = 300 
C[0] + A[1] + B[2] = 100 + 100 + 100 = 300 
C[0] + A[1] + C[2] = 100 + 100 + 100 = 300 
C[0] + B[1] + A[2] = 100 + 100 + 1 = 201 
C[0] + B[1] + C[2] = 100 + 100 + 100 = 300
Input: A[] = {1, 1, 1}, B[] = {1, 1, 1}, C[] = {1, 1, 1} 
Output: 3 
 

 

Approach: The problem is a simple variation of finding minimum cost. The extra constraint are that if we take an element from a particular array then we cannot take the next element from the same array. This could easily be solved using recursion but it would give time complexity as O(3^n) because for every element we have three arrays as choices.
To improve the time complexity we can easily store the pre-calculated values in a dp array.
Since there are three arrays to choose from at every index, three cases arise in this scenario: 
 

  • Case 1: If array A[] is selected from the ith element then we either choose the array B[] or the array C[] for the (i + 1)th element.
  • Case 2: If array B[] is selected from the ith element then we either choose the array A[] or the array C[] for the (i + 1)th element.
  • Case 3: If array C[] is selected from the ith element then we either choose the array A[] or the array B[] for the (i + 1)th element.

The above states can be solved using recursion and intermediate results can be stored in the dp array.
Below is the implementation of the above approach: 
 

C++




// C++ implementation of the above approach
 
#include <bits/stdc++.h>
using namespace std;
#define SIZE 3
const int N = 3;
 
// Function to return the minimized sum
int minSum(int A[], int B[], int C[], int i,
        int n, int curr, int dp[SIZE][N])
{
 
    // If all the indices have been used
    if (n <= 0)
        return 0;
 
    // If this value is pre-calculated
    // then return its value from dp array
    // instead of re-computing it
    if (dp[n][curr] != -1)
        return dp[n][curr];
 
    // Here curr is the array chosen
    // for the (i - 1)th element
    // 0 for A[], 1 for B[] and 2 for C[]
 
    // If A[i - 1] was chosen previously then
    // only B[i] or C[i] can chosen now
    // choose the one which leads
    // to the minimum sum
    if (curr == 0) {
        return dp[n][curr]
                = min(B[i] + minSum(A, B, C, i + 1, n - 1, 1, dp),
                      C[i] + minSum(A, B, C, i + 1, n - 1, 2, dp));
    }
 
    // If B[i - 1] was chosen previously then
    // only A[i] or C[i] can chosen now
    // choose the one which leads
    // to the minimum sum
    if (curr == 1)
        return dp[n][curr]
                = min(A[i] + minSum(A, B, C, i + 1, n - 1, 0, dp),
                      C[i] + minSum(A, B, C, i + 1, n - 1, 2, dp));
 
    // If C[i - 1] was chosen previously then
    // only A[i] or B[i] can chosen now
    // choose the one which leads
    // to the minimum sum
    return dp[n][curr]
                = min(A[i] + minSum(A, B, C, i + 1, n - 1, 0, dp),
                      B[i] + minSum(A, B, C, i + 1, n - 1, 1, dp));
}
 
// Driver code
int main()
{
    int A[] = { 1, 50, 1 };
    int B[] = { 50, 50, 50 };
    int C[] = { 50, 50, 50 };
 
    // Initialize the dp[][] array
    int dp[SIZE][N];
    for (int i = 0; i < SIZE; i++)
        for (int j = 0; j < N; j++)
            dp[i][j] = -1;
 
    // min(start with A[0], start with B[0], start with C[0])
    cout << min(A[0] + minSum(A, B, C, 1, SIZE - 1, 0, dp),
                min(B[0] + minSum(A, B, C, 1, SIZE - 1, 1, dp),
                    C[0] + minSum(A, B, C, 1, SIZE - 1, 2, dp)));
 
    return 0;
}
Java



// Java implementation of the above approach
import java.io.*;
 
class GFG
{
 
static int SIZE = 3;
static int N = 3;
 
// Function to return the minimized sum
static int minSum(int A[], int B[], int C[], int i,
                    int n, int curr, int [][]dp)
{
 
    // If all the indices have been used
    if (n <= 0)
        return 0;
 
    // If this value is pre-calculated
    // then return its value from dp array
    // instead of re-computing it
    if (dp[n][curr] != -1)
        return dp[n][curr];
 
    // Here curr is the array chosen
    // for the (i - 1)th element
    // 0 for A[], 1 for B[] and 2 for C[]
 
    // If A[i - 1] was chosen previously then
    // only B[i] or C[i] can chosen now
    // choose the one which leads
    // to the minimum sum
    if (curr == 0)
    {
        return dp[n][curr]
                = Math.min(B[i] + minSum(A, B, C, i + 1, n - 1, 1, dp),
                    C[i] + minSum(A, B, C, i + 1, n - 1, 2, dp));
    }
 
    // If B[i - 1] was chosen previously then
    // only A[i] or C[i] can chosen now
    // choose the one which leads
    // to the minimum sum
    if (curr == 1)
        return dp[n][curr]
                = Math.min(A[i] + minSum(A, B, C, i + 1, n - 1, 0, dp),
                    C[i] + minSum(A, B, C, i + 1, n - 1, 2, dp));
 
    // If C[i - 1] was chosen previously then
    // only A[i] or B[i] can chosen now
    // choose the one which leads
    // to the minimum sum
    return dp[n][curr]
                = Math.min(A[i] + minSum(A, B, C, i + 1, n - 1, 0, dp),
                    B[i] + minSum(A, B, C, i + 1, n - 1, 1, dp));
}
 
// Driver code
public static void main (String[] args)
{
    int A[] = { 1, 50, 1 };
    int B[] = { 50, 50, 50 };
    int C[] = { 50, 50, 50 };
     
    // Initialize the dp[][] array
    int dp[][] = new int[SIZE][N];
    for (int i = 0; i < SIZE; i++)
        for (int j = 0; j < N; j++)
            dp[i][j] = -1;
     
    // min(start with A[0], start with B[0], start with C[0])
    System.out.println(Math.min(A[0] + minSum(A, B, C, 1, SIZE - 1, 0, dp),
                Math.min(B[0] + minSum(A, B, C, 1, SIZE - 1, 1, dp),
                    C[0] + minSum(A, B, C, 1, SIZE - 1, 2, dp))));
}
}
 
// This code is contributed by anuj_67..
Python3



# Python3 implementation of the above approach
 
import numpy as np
 
SIZE = 3;
N = 3;
 
# Function to return the minimized sum
def minSum(A, B, C, i, n, curr, dp) :
 
    # If all the indices have been used
    if (n <= 0) :
        return 0;
 
    # If this value is pre-calculated
    # then return its value from dp array
    # instead of re-computing it
    if (dp[n][curr] != -1) :
        return dp[n][curr];
 
    # Here curr is the array chosen
    # for the (i - 1)th element
    # 0 for A[], 1 for B[] and 2 for C[]
 
    # If A[i - 1] was chosen previously then
    # only B[i] or C[i] can chosen now
    # choose the one which leads
    # to the minimum sum
    if (curr == 0) :
        dp[n][curr] = min( B[i] + minSum(A, B, C, i + 1, n - 1, 1, dp),
        C[i] + minSum(A, B, C, i + 1, n - 1, 2, dp));
        return dp[n][curr]
     
 
    # If B[i - 1] was chosen previously then
    # only A[i] or C[i] can chosen now
    # choose the one which leads
    # to the minimum sum
    if (curr == 1) :
        dp[n][curr] = min(A[i] + minSum(A, B, C, i + 1, n - 1, 0, dp),
        C[i] + minSum(A, B, C, i + 1, n - 1, 2, dp));
        return dp[n][curr]
 
    # If C[i - 1] was chosen previously then
    # only A[i] or B[i] can chosen now
    # choose the one which leads
    # to the minimum sum
    dp[n][curr] = min(A[i] + minSum(A, B, C, i + 1, n - 1, 0, dp),
    B[i] + minSum(A, B, C, i + 1, n - 1, 1, dp));
     
    return dp[n][curr]
 
 
# Driver code
if __name__ == "__main__" :
 
    A = [ 1, 50, 1 ];
    B = [ 50, 50, 50 ];
    C = [ 50, 50, 50 ];
 
    # Initialize the dp[][] array
    dp = np.zeros((SIZE,N));
     
    for i in range(SIZE) :
        for j in range(N) :
            dp[i][j] = -1;
 
    # min(start with A[0], start with B[0], start with C[0])
    print(min(A[0] + minSum(A, B, C, 1, SIZE - 1, 0, dp),
                min(B[0] + minSum(A, B, C, 1, SIZE - 1, 1, dp),
                C[0] + minSum(A, B, C, 1, SIZE - 1, 2, dp))));
 
# This code is contributed by AnkitRai01
C#



// C# implementation of the above approach
using System;
 
class GFG
{
 
static int SIZE = 3;
static int N = 3;
 
// Function to return the minimized sum
static int minSum(int []A, int []B, int []C, int i,
                    int n, int curr, int [,]dp)
{
 
    // If all the indices have been used
    if (n <= 0)
        return 0;
 
    // If this value is pre-calculated
    // then return its value from dp array
    // instead of re-computing it
    if (dp[n,curr] != -1)
        return dp[n,curr];
 
    // Here curr is the array chosen
    // for the (i - 1)th element
    // 0 for A[], 1 for B[] and 2 for C[]
 
    // If A[i - 1] was chosen previously then
    // only B[i] or C[i] can chosen now
    // choose the one which leads
    // to the minimum sum
    if (curr == 0)
    {
        return dp[n,curr]
                = Math.Min(B[i] + minSum(A, B, C, i + 1, n - 1, 1, dp),
                    C[i] + minSum(A, B, C, i + 1, n - 1, 2, dp));
    }
 
    // If B[i - 1] was chosen previously then
    // only A[i] or C[i] can chosen now
    // choose the one which leads
    // to the minimum sum
    if (curr == 1)
        return dp[n,curr]
                = Math.Min(A[i] + minSum(A, B, C, i + 1, n - 1, 0, dp),
                    C[i] + minSum(A, B, C, i + 1, n - 1, 2, dp));
 
    // If C[i - 1] was chosen previously then
    // only A[i] or B[i] can chosen now
    // choose the one which leads
    // to the minimum sum
    return dp[n,curr]
                = Math.Min(A[i] + minSum(A, B, C, i + 1, n - 1, 0, dp),
                    B[i] + minSum(A, B, C, i + 1, n - 1, 1, dp));
}
 
// Driver code
public static void Main ()
{
    int []A = { 1, 50, 1 };
    int []B = { 50, 50, 50 };
    int []C = { 50, 50, 50 };
     
    // Initialize the dp[][] array
    int [,]dp = new int[SIZE,N];
    for (int i = 0; i < SIZE; i++)
        for (int j = 0; j < N; j++)
            dp[i,j] = -1;
     
    // min(start with A[0], start with B[0], start with C[0])
    Console.WriteLine(Math.Min(A[0] + minSum(A, B, C, 1, SIZE - 1, 0, dp),
                Math.Min(B[0] + minSum(A, B, C, 1, SIZE - 1, 1, dp),
                    C[0] + minSum(A, B, C, 1, SIZE - 1, 2, dp))));
}
}
 
// This code is contributed by anuj_67..
Javascript



<script>
    // Javascript implementation of the above approach
     
    let SIZE = 3;
    let N = 3;
 
    // Function to return the minimized sum
    function minSum(A, B, C, i, n, curr, dp)
    {
 
        // If all the indices have been used
        if (n <= 0)
            return 0;
 
        // If this value is pre-calculated
        // then return its value from dp array
        // instead of re-computing it
        if (dp[n][curr] != -1)
            return dp[n][curr];
 
        // Here curr is the array chosen
        // for the (i - 1)th element
        // 0 for A[], 1 for B[] and 2 for C[]
 
        // If A[i - 1] was chosen previously then
        // only B[i] or C[i] can chosen now
        // choose the one which leads
        // to the minimum sum
        if (curr == 0)
        {
            return dp[n][curr]
                    = Math.min(B[i] + minSum(A, B, C, i + 1, n - 1, 1, dp),
                        C[i] + minSum(A, B, C, i + 1, n - 1, 2, dp));
        }
 
        // If B[i - 1] was chosen previously then
        // only A[i] or C[i] can chosen now
        // choose the one which leads
        // to the minimum sum
        if (curr == 1)
            return dp[n][curr]
                    = Math.min(A[i] + minSum(A, B, C, i + 1, n - 1, 0, dp),
                        C[i] + minSum(A, B, C, i + 1, n - 1, 2, dp));
 
        // If C[i - 1] was chosen previously then
        // only A[i] or B[i] can chosen now
        // choose the one which leads
        // to the minimum sum
        return dp[n][curr]
                    = Math.min(A[i] + minSum(A, B, C, i + 1, n - 1, 0, dp),
                        B[i] + minSum(A, B, C, i + 1, n - 1, 1, dp));
    }
     
    let A = [ 1, 50, 1 ];
    let B = [ 50, 50, 50 ];
    let C = [ 50, 50, 50 ];
       
    // Initialize the dp[][] array
    let dp = new Array(SIZE);
    for (let i = 0; i < SIZE; i++)
    {
        dp[i] = new Array(N);
        for (let j = 0; j < N; j++)
        {
            dp[i][j] = -1;
        }
    }
       
    // min(start with A[0], start with B[0], start with C[0])
    document.write(Math.min(A[0] + minSum(A, B, C, 1, SIZE - 1, 0, dp),
                Math.min(B[0] + minSum(A, B, C, 1, SIZE - 1, 1, dp),
                    C[0] + minSum(A, B, C, 1, SIZE - 1, 2, dp))));
 
</script>
Output: 
52
 
Time Complexity: O(SIZE*N), where dp operations taking SIZE*N time
Auxiliary Space: O(SIZE*N), where dp array is made of two states SIZE*N

My Personal Notes
arrow_drop_up
Previous
Maximise array sum after taking non-overlapping sub-arrays of length K
Next

Count the maximum number of elements that can be selected from the array
Recommended Articles
Page :
Find three element from given three arrays such that their sum is X | Set 2
01, Jul 19
Maximize the product of sum and least power by choosing at most K elements from given value and power Arrays
28, Oct 21
Minimize cost of choosing and skipping array elements to reach end of the given array
25, Oct 20
Find three element from different three arrays such that a + b + c = sum
01, Feb 17
Minimize cost to reduce Array if for choosing every 2 elements, 3rd one is chosen for free
26, Jan 22
Maximise sum of product of pairs by choosing subsequence of same length from given Arrays
08, Mar 22
Maximum string length after choosing strings from given Array with given conditions
31, Jan 22
Minimize sum of product of same-indexed elements of two arrays by reversing a subarray of one of the two arrays
31, May 21
Maximum modified Array sum possible by choosing elements as per the given conditions
19, Aug 20
Minimize (max(A[i], B[j], C[k]) - min(A[i], B[j], C[k])) of three different sorted arrays
27, Dec 17
Maximize sum by selecting X different-indexed elements from three given arrays
15, Jan 21
Count of possible unique arrays after swapping elements at same index of given Arrays
27, Oct 21
Minimize the sum of differences of consecutive elements after removing exactly K elements
06, Jan 20
Minimum operations to choose Array elements with sum as K by choosing element from front, or rear or both
29, Nov 21
Maximize sum by choosing elements from different section of a matrix
03, Dec 19
Maximum sum from three arrays such that picking elements consecutively from same is not allowed
13, Mar 19
Minimize sum of absolute differences of same-indexed elements of two given arrays by at most one replacement
16, May 21
Minimize square sum of given Arrays by swapping elements at same indices
04, Mar 22
Minimum sum obtained by choosing N number from given N pairs
02, Jul 20
Check if end of given Binary string can be reached by choosing jump value in between given range
15, Oct 21
Minimize sum of count of unique elements in Array after dividing into [1, N] subsets
09, Mar 22
Minimize Subset sum difference after deleting K elements of Array
17, Mar 22
Minimum cost of choosing 3 increasing elements in an array of size N
17, Sep 19
Find common elements in three sorted arrays
18, Sep 14
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
md1844
@md1844
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!