GeeksforGeeks App
Open App
Browser
Continue

# Minimize Cost to reduce the Array to a single element by given operations

Given an array a[] consisting of N integers and an integer K, the task is to find the minimum cost to reduce the given array to a single element by choosing any pair of consecutive array elements and replace them by (a[i] + a[i+1]) for a cost K * (a[i] + a[i+1]).

Examples:

Input: a[] = {1, 2, 3}, K = 2
Output: 18
Explanation:
Replacing {1, 2} by 3 modifies the array to {3, 3}. Cost 2 * 3 = 6
Replacing {3, 3} by 6 modifies the array to {6}. Cost 2 * 6 = 12
Therefore, the total cost is 18
Input: a[] = {4, 5, 6, 7}, K = 3
Output: 132

Naive Approach:
The simplest solution is to split the array into two halves, for every index and compute the cost of the two halves recursively and finally add their respective costs.
Below is the implementation of the above approach:

## C++

 `// C++ Program to implement``// the above approach``#include ``using` `namespace` `std;``#define inf 10000009` `// Function to combine the sum of the two halves``int` `Combine(``int` `a[], ``int` `i, ``int` `j)``{``    ``int` `sum = 0;` `    ``// Calculate the sum from i to j``    ``for` `(``int` `l = i; l <= j; l++)``        ``sum += a[l];` `    ``return` `sum;``}` `// Function to minimize the cost to``// reduce the array to a single element``int` `minCost(``int` `a[], ``int` `i, ``int` `j, ``int` `k)``{``    ``if` `(i >= j)``    ``{` `        ``// Base case``        ``// If n = 1 or n = 0``        ``return` `0;``    ``}` `    ``// Initialize cost to maximum value``    ``int` `best_cost = inf;` `    ``// Iterate through all possible indices``    ``// and find the best index``    ``// to combine the subproblems``    ``for` `(``int` `pos = i; pos < j; pos++)``    ``{` `        ``// Compute left subproblem``        ``int` `left = minCost(a, i, pos, k);` `        ``// Compute right subproblem``        ``int` `right = minCost(a, pos + 1, j, k);` `        ``// Calculate the best cost``        ``best_cost = min(best_cost, left + right +``                                   ``k * Combine(a, i, j));``    ``}` `    ``// Return the answer``    ``return` `best_cost;``}` `// Driver code``int` `main()``{``    ``int` `n = 4;``    ``int` `a[] = { 4, 5, 6, 7 };``    ``int` `k = 3;` `    ``cout << minCost(a, 0, n - 1, k) << endl;``    ``return` `0;``}` `// This code is contributed by PrinciRaj1992`

## Java

 `// Java Program to implement``// the above approach``import` `java.io.*;` `class` `GFG {` `    ``static` `int` `inf = ``10000009``;` `    ``// Function to minimize the cost to``    ``// reduce the array to a single element``    ``public` `static` `int` `minCost(``int` `a[], ``int` `i,``                              ``int` `j, ``int` `k)``    ``{``        ``if` `(i >= j) {` `            ``// Base case``            ``// If n = 1 or n = 0``            ``return` `0``;``        ``}` `        ``// Initialize cost to maximum value``        ``int` `best_cost = inf;` `        ``// Iterate through all possible indices``        ``// and find the best index``        ``// to combine the subproblems``        ``for` `(``int` `pos = i; pos < j; pos++) {` `            ``// Compute left subproblem``            ``int` `left = minCost(a, i, pos, k);` `            ``// Compute right subproblem``            ``int` `right = minCost(a, pos + ``1``, j, k);` `            ``// Calculate the best  cost``            ``best_cost = Math.min(``                ``best_cost,``                ``left + right + k * Combine(a, i, j));``        ``}` `        ``// Return the answer``        ``return` `best_cost;``    ``}` `    ``// Function to combine the sum of the two halves``    ``public` `static` `int` `Combine(``int` `a[], ``int` `i, ``int` `j)``    ``{``        ``int` `sum = ``0``;` `        ``// Calculate the sum from i to j``        ``for` `(``int` `l = i; l <= j; l++)``            ``sum += a[l];` `        ``return` `sum;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `n = ``4``;``        ``int` `a[] = { ``4``, ``5``, ``6``, ``7` `};``        ``int` `k = ``3``;` `        ``System.out.println(minCost(a, ``0``, n - ``1``, k));``    ``}``}`

## Python3

 `# Python3 Program to implement``# the above approach``inf ``=` `10000009``;` `# Function to minimize the cost to``# reduce the array to a single element``def` `minCost(a, i, j, k):``    ``if` `(i >``=` `j):``      ` `        ``# Base case``        ``# If n = 1 or n = 0``        ``return` `0``;` `    ``# Initialize cost to maximum value``    ``best_cost ``=` `inf;` `    ``# Iterate through all possible indices``    ``# and find the best index``    ``# to combine the subproblems``    ``for` `pos ``in` `range``(i, j):``      ` `        ``# Compute left subproblem``        ``left ``=` `minCost(a, i, pos, k);` `        ``# Compute right subproblem``        ``right ``=` `minCost(a, pos ``+` `1``, j, k);` `        ``# Calculate the best cost``        ``best_cost ``=` `min``(best_cost,``                        ``left ``+` `right ``+``                        ``k ``*` `Combine(a, i, j));` `    ``# Return the answer``    ``return` `best_cost;` `# Function to combine``# the sum of the two halves``def` `Combine(a, i, j):``    ``sum` `=` `0``;` `    ``# Calculate the sum from i to j``    ``for` `l ``in` `range``(i, j ``+` `1``):``        ``sum` `+``=` `a[l];` `    ``return` `sum``;` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``n ``=` `4``;``    ``a ``=` `[``4``, ``5``, ``6``, ``7``];``    ``k ``=` `3``;` `    ``print``(minCost(a, ``0``, n ``-` `1``, k));` `# This code is contributed by Amit Katiyar`

## C#

 `// C# Program to implement``// the above approach``using` `System;``class` `GFG{` `  ``static` `int` `inf = 10000009;` `  ``// Function to minimize the cost to``  ``// reduce the array to a single element``  ``public` `static` `int` `minCost(``int` `[]a, ``int` `i,``                            ``int` `j, ``int` `k)``  ``{``    ``if` `(i >= j)``    ``{` `      ``// Base case``      ``// If n = 1 or n = 0``      ``return` `0;``    ``}` `    ``// Initialize cost to maximum value``    ``int` `best_cost = inf;` `    ``// Iterate through all possible indices``    ``// and find the best index``    ``// to combine the subproblems``    ``for` `(``int` `pos = i; pos < j; pos++)``    ``{` `      ``// Compute left subproblem``      ``int` `left = minCost(a, i, pos, k);` `      ``// Compute right subproblem``      ``int` `right = minCost(a, pos + 1, j, k);` `      ``// Calculate the best  cost``      ``best_cost = Math.Min(best_cost,``                           ``left + right +``                           ``k * Combine(a, i, j));``    ``}` `    ``// Return the answer``    ``return` `best_cost;``  ``}` `  ``// Function to combine the sum of the two halves``  ``public` `static` `int` `Combine(``int` `[]a, ``int` `i, ``int` `j)``  ``{``    ``int` `sum = 0;` `    ``// Calculate the sum from i to j``    ``for` `(``int` `l = i; l <= j; l++)``      ``sum += a[l];` `    ``return` `sum;``  ``}` `  ``// Driver code``  ``public` `static` `void` `Main(String[] args)``  ``{``    ``int` `n = 4;``    ``int` `[]a = { 4, 5, 6, 7 };``    ``int` `k = 3;` `    ``Console.WriteLine(minCost(a, 0, n - 1, k));``  ``}``}` `// This code is contributed by Rohit_ranjan`

## Javascript

 ``

Output:

`132`

Time Complexity: O(2N
Auxiliary Space: O(1)

Efficient Approach: To optimize the above approach, the idea is to use the concept of Dynamic Programming. Follow the steps below to solve the problem:

• Initialize a matrix dp[][] and such that dp[i][j] stores the sum from index i to j.
• Calculate sum(i, j) using Prefix Sum technique.
• Compute the sum of the two subproblems and update the cost with the minimum value.
• Store in dp[][] and return.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `int` `inf = 10000000;` `// Function to generate the cost using``// Prefix Sum Array technique``vector<``int``> preprocess(vector<``int``> a, ``int` `n)``{``    ``vector<``int``> p(n);``    ``p[0] = a[0];``    ` `    ``for``(``int` `i = 1; i < n; i++)``    ``{``        ``p[i] = p[i - 1] + a[i];``    ``}``    ``return` `p;``}` `// Function to combine the sum of the``// two subproblems``int` `Combine(vector<``int``> p, ``int` `i, ``int` `j)``{``    ``if` `(i == 0)``        ``return` `p[j];``    ``else``        ``return` `p[j] - p[i - 1];``}` `// Function to minimize the cost to``// add the array elements to a single element``int` `minCost(vector<``int``> a, ``int` `i, ``int` `j, ``int` `k,``            ``vector<``int``> prefix, vector> dp)``{``    ``if` `(i >= j)``        ``return` `0;` `    ``// Check if the value is``    ``// already stored in the array``    ``if` `(dp[i][j] != -1)``        ``return` `dp[i][j];` `    ``int` `best_cost = inf;``    ``for``(``int` `pos = i; pos < j; pos++)``    ``{``        ` `        ``// Compute left subproblem``        ``int` `left = minCost(a, i, pos,``                           ``k, prefix, dp);` `        ``// Compute left subproblem``        ``int` `right = minCost(a, pos + 1, j,``                            ``k, prefix, dp);` `        ``// Calculate minimum cost``        ``best_cost = min(best_cost, left + right +``                       ``(k * Combine(prefix, i, j)));``    ``}``    ` `    ``// Store the answer to``    ``// avoid recalculation``    ``return` `dp[i][j] = best_cost;``}` `// Driver code   ``int` `main()``{``    ``int` `n = 4;` `    ``vector<``int``> a = { 4, 5, 6, 7 };` `    ``int` `k = 3;` `    ``// Initialise dp array``    ``vector> dp;``    ``dp.resize(n + 1, vector<``int``>(n + 1));``    ``for``(``int` `i = 0; i < n + 1; i++)``    ``{``        ``for``(``int` `j = 0; j < n + 1; j++)``        ``{``            ``dp[i][j] = -1;``        ``}``    ``}` `    ``// Preprocessing the array``    ``vector<``int``> prefix = preprocess(a, n);``    ` `    ``cout << minCost(a, 0, n - 1, k, prefix, dp)``         ``<< endl;` `    ``return` `0;``}` `// This code is contributed by divyeshrabadiya07`

## Java

 `// Java Program for the above approach``import` `java.util.*;``public` `class` `Main {` `    ``static` `int` `inf = ``10000000``;` `    ``// Function to minimize the cost to``    ``// add the array elements to a single element``    ``public` `static` `int` `minCost(``int` `a[], ``int` `i, ``int` `j, ``int` `k,``                              ``int``[] prefix, ``int``[][] dp)``    ``{``        ``if` `(i >= j)``            ``return` `0``;` `        ``// Check if the value is``        ``// already stored in the array``        ``if` `(dp[i][j] != -``1``)``            ``return` `dp[i][j];` `        ``int` `best_cost = inf;``        ``for` `(``int` `pos = i; pos < j; pos++) {` `            ``// Compute left subproblem``            ``int` `left = minCost(a, i, pos, k, prefix, dp);` `            ``// Compute left subproblem``            ``int` `right``                ``= minCost(a, pos + ``1``, j, k, prefix, dp);` `            ``// Calculate minimum cost``            ``best_cost = Math.min(``                ``best_cost,``                ``left + right + (k * Combine(prefix, i, j)));``        ``}` `        ``// Store the answer to``        ``// avoid recalculation``        ``return` `dp[i][j] = best_cost;``    ``}` `    ``// Function to generate the cost using``    ``// Prefix Sum Array technique``    ``public` `static` `int``[] preprocess(``int``[] a, ``int` `n)``    ``{``        ``int` `p[] = ``new` `int``[n];``        ``p[``0``] = a[``0``];``        ``for` `(``int` `i = ``1``; i < n; i++)``            ``p[i] = p[i - ``1``] + a[i];``        ``return` `p;``    ``}` `    ``// Function to combine the sum of the two subproblems``    ``public` `static` `int` `Combine(``int``[] p, ``int` `i, ``int` `j)``    ``{``        ``if` `(i == ``0``)``            ``return` `p[j];``        ``else``            ``return` `p[j] - p[i - ``1``];``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `n = ``4``;` `        ``int` `a[] = { ``4``, ``5``, ``6``, ``7` `};` `        ``int` `k = ``3``;` `        ``// Initialise dp array``        ``int` `dp[][] = ``new` `int``[n + ``1``][n + ``1``];``        ``for` `(``int` `i[] : dp)``            ``Arrays.fill(i, -``1``);` `        ``// Preprocessing the array``        ``int` `prefix[] = preprocess(a, n);` `        ``System.out.println(``            ``minCost(a, ``0``, n - ``1``, k, prefix, dp));``    ``}``}`

## Python3

 `# Python3 program for the above approach``inf ``=` `10000000` `# Function to minimize the cost to``# add the array elements to a single element``def` `minCost(a, i, j, k, prefix, dp):``    ` `    ``if` `(i >``=` `j):``        ``return` `0` `    ``# Check if the value is``    ``# already stored in the array``    ``if` `(dp[i][j] !``=` `-``1``):``        ``return` `dp[i][j]` `    ``best_cost ``=` `inf``    ``for` `pos ``in` `range``(i, j):` `        ``# Compute left subproblem``        ``left ``=` `minCost(a, i, pos,``                       ``k, prefix, dp)` `        ``# Compute left subproblem``        ``right ``=` `minCost(a, pos ``+` `1``, j,``                        ``k, prefix, dp)` `        ``# Calculate minimum cost``        ``best_cost ``=` `min``(best_cost,``                        ``left ``+` `right ``+``                          ``(k ``*` `Combine(prefix, i, j)))` `    ``# Store the answer to``    ``# avoid recalculation``    ``dp[i][j] ``=` `best_cost``    ` `    ``return` `dp[i][j]` `# Function to generate the cost using``# Prefix Sum Array technique``def` `preprocess(a, n):``    ` `    ``p ``=` `[``0``] ``*` `n``    ``p[``0``] ``=` `a[``0``]``    ` `    ``for` `i ``in` `range``(``1``, n):``        ``p[i] ``=` `p[i ``-` `1``] ``+` `a[i]``        ` `    ``return` `p` `# Function to combine the sum``# of the two subproblems``def` `Combine(p, i, j):``    ` `    ``if` `(i ``=``=` `0``):``        ``return` `p[j]``    ``else``:``        ``return` `p[j] ``-` `p[i ``-` `1``]` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``    ` `    ``n ``=` `4``    ``a ``=` `[ ``4``, ``5``, ``6``, ``7` `]``    ``k ``=` `3` `    ``# Initialise dp array``    ``dp ``=` `[[``-``1` `for` `x ``in` `range` `(n ``+` `1``)]``              ``for` `y ``in` `range` `(n ``+` `1``)]` `    ``# Preprocessing the array``    ``prefix ``=` `preprocess(a, n)` `    ``print``(minCost(a, ``0``, n ``-` `1``, k, prefix, dp))` `# This code is contributed by chitranayal`

## C#

 `// C# Program for the above approach``using` `System;``class` `GFG{` `  ``static` `int` `inf = 10000000;` `  ``// Function to minimize the cost to``  ``// add the array elements to a single element``  ``public` `static` `int` `minCost(``int` `[]a, ``int` `i, ``int` `j, ``int` `k,``                            ``int``[] prefix, ``int``[,] dp)``  ``{``    ``if` `(i >= j)``      ``return` `0;` `    ``// Check if the value is``    ``// already stored in the array``    ``if` `(dp[i, j] != -1)``      ``return` `dp[i, j];` `    ``int` `best_cost = inf;``    ``for` `(``int` `pos = i; pos < j; pos++)``    ``{` `      ``// Compute left subproblem``      ``int` `left = minCost(a, i, pos, k, prefix, dp);` `      ``// Compute left subproblem``      ``int` `right = minCost(a, pos + 1, j,``                          ``k, prefix, dp);` `      ``// Calculate minimum cost``      ``best_cost = Math.Min(best_cost, left + right +``                          ``(k * Combine(prefix, i, j)));``    ``}` `    ``// Store the answer to``    ``// avoid recalculation``    ``return` `dp[i, j] = best_cost;``  ``}` `  ``// Function to generate the cost using``  ``// Prefix Sum Array technique``  ``public` `static` `int``[] preprocess(``int``[] a, ``int` `n)``  ``{``    ``int` `[]p = ``new` `int``[n];``    ``p[0] = a[0];``    ``for` `(``int` `i = 1; i < n; i++)``      ``p[i] = p[i - 1] + a[i];``    ``return` `p;``  ``}` `  ``// Function to combine the sum of the two subproblems``  ``public` `static` `int` `Combine(``int``[] p, ``int` `i, ``int` `j)``  ``{``    ``if` `(i == 0)``      ``return` `p[j];``    ``else``      ``return` `p[j] - p[i - 1];``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(String []args)``  ``{``    ``int` `n = 4;` `    ``int` `[]a = { 4, 5, 6, 7 };` `    ``int` `k = 3;` `    ``// Initialise dp array``    ``int` `[,]dp = ``new` `int``[n + 1, n + 1];``    ``for``(``int` `i = 0; i < n + 1; i++)``    ``{``      ``for` `(``int` `j = 0; j < n + 1; j++)``      ``{``        ``dp[i, j] = -1;``      ``}``    ``}``    ``// Preprocessing the array``    ``int` `[]prefix = preprocess(a, n);` `    ``Console.WriteLine(minCost(a, 0, n - 1, k,``                              ``prefix, dp));``  ``}``}` `// This code is contributed by sapnasingh4991`

## Javascript

 ``

Output:

`132`

Time Complexity: O(N2
Auxiliary Space: O(N2)

Another approach : Using DP Tabulation method ( Iterative approach )

In this approach we use Dp to store computation of subproblems and get the desired output without the help of recursion.

Steps to solve this problem :

• Create a table DP to store the solution of the subproblems .
• Initialize the table with base cases
• Now Iterate over subproblems to get the value of current problem form previous computation of subproblems stored in DP
• Return the final solution stored in dp[0][n-1].

Implementation :

## C++

 `// C++ code for above approach` `#include ``using` `namespace` `std;` `int` `inf = 10000000;` `// Function to generate the cost using``// Prefix Sum Array technique``vector<``int``> preprocess(vector<``int``> a, ``int` `n)``{``    ``vector<``int``> p(n);``    ``p[0] = a[0];``    ` `    ``for``(``int` `i = 1; i < n; i++)``    ``{``        ``p[i] = p[i - 1] + a[i];``    ``}``    ``return` `p;``}` `// Function to combine the sum of the``// two subproblems``int` `Combine(vector<``int``> p, ``int` `i, ``int` `j)``{``    ``if` `(i == 0)``        ``return` `p[j];``    ``else``        ``return` `p[j] - p[i - 1];``}` `// Function to minimize the cost to``// add the array elements to a single element``int` `minCost(vector<``int``> a, ``int` `n, ``int` `k)``{``    ``// Initialise dp array``    ``vector> dp(n + 1, vector<``int``>(n + 1));``    ` `    ``// Preprocessing the array``    ``vector<``int``> prefix = preprocess(a, n);``    ` `    ``// Base case``    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ``dp[i][i] = 0;``    ``}``    ` `    ``// DP tabulation``    ``for``(``int` `len = 2; len <= n; len++)``    ``{``        ``for``(``int` `i = 0; i <= n - len; i++)``        ``{``            ``int` `j = i + len - 1;``            ``dp[i][j] = inf;``            ` `            ``for``(``int` `pos = i; pos < j; pos++)``            ``{``                ``int` `left = dp[i][pos];``                ``int` `right = dp[pos + 1][j];``                ``int` `cost = k * Combine(prefix, i, j);``                ``dp[i][j] = min(dp[i][j], left + right + cost);``            ``}``        ``}``    ``}``    ` `      ``// return answer``    ``return` `dp[0][n - 1];``}` `// Driver code``int` `main()``{``    ``int` `n = 4;` `    ``vector<``int``> a = { 4, 5, 6, 7 };` `    ``int` `k = 3;``    ` `      ``// function call``    ``cout << minCost(a, n, k) << endl;` `    ``return` `0;``}` `// this code is contributed by bhardwajji`

## Java

 `import` `java.util.*;` `public` `class` `Main {``  ``static` `int` `inf = ``10000000``;` `  ``// Function to generate the cost using``  ``// Prefix Sum Array technique``  ``static` `List preprocess(List a, ``int` `n)``  ``{``    ``List p = ``new` `ArrayList<>();``    ``p.add(a.get(``0``));` `    ``for` `(``int` `i = ``1``; i < n; i++) {``      ``p.add(p.get(i - ``1``) + a.get(i));``    ``}``    ``return` `p;``  ``}` `  ``// Function to combine the sum of the``  ``// two subproblems``  ``static` `int` `Combine(List p, ``int` `i, ``int` `j)``  ``{``    ``if` `(i == ``0``)``      ``return` `p.get(j);``    ``else``      ``return` `p.get(j) - p.get(i - ``1``);``  ``}` `  ``// Function to minimize the cost to``  ``// add the array elements to a single element``  ``static` `int` `minCost(List a, ``int` `n, ``int` `k)``  ``{``    ``// Initialise dp array``    ``int``[][] dp = ``new` `int``[n + ``1``][n + ``1``];` `    ``// Preprocessing the array``    ``List prefix = preprocess(a, n);` `    ``// Base case``    ``for` `(``int` `i = ``0``; i < n; i++) {``      ``dp[i][i] = ``0``;``    ``}` `    ``// DP tabulation``    ``for` `(``int` `len = ``2``; len <= n; len++) {``      ``for` `(``int` `i = ``0``; i <= n - len; i++) {``        ``int` `j = i + len - ``1``;``        ``dp[i][j] = inf;` `        ``for` `(``int` `pos = i; pos < j; pos++) {``          ``int` `left = dp[i][pos];``          ``int` `right = dp[pos + ``1``][j];``          ``int` `cost = k * Combine(prefix, i, j);``          ``dp[i][j] = Math.min(``            ``dp[i][j], left + right + cost);``        ``}``      ``}``    ``}` `    ``// return answer``    ``return` `dp[``0``][n - ``1``];``  ``}` `  ``// Driver code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `n = ``4``;``    ``List a``      ``= ``new` `ArrayList<>(Arrays.asList(``4``, ``5``, ``6``, ``7``));``    ``int` `k = ``3``;` `    ``// function call``    ``System.out.println(minCost(a, n, k));``  ``}``}`

## Python3

 `# code``INF ``=` `10000000` `# Function to generate the cost using``# Prefix Sum Array technique`  `def` `preprocess(a, n):``    ``p ``=` `[``0``] ``*` `n``    ``p[``0``] ``=` `a[``0``]` `    ``for` `i ``in` `range``(``1``, n):``        ``p[i] ``=` `p[i ``-` `1``] ``+` `a[i]` `    ``return` `p` `# Function to combine the sum of the``# two subproblems`  `def` `Combine(p, i, j):``    ``if` `i ``=``=` `0``:``        ``return` `p[j]``    ``else``:``        ``return` `p[j] ``-` `p[i ``-` `1``]` `# Function to minimize the cost to``# add the array elements to a single element`  `def` `minCost(a, n, k):``    ``# Initialise dp array``    ``dp ``=` `[[``0``] ``*` `(n ``+` `1``) ``for` `i ``in` `range``(n ``+` `1``)]` `    ``# Preprocessing the array``    ``prefix ``=` `preprocess(a, n)` `    ``# Base case``    ``for` `i ``in` `range``(n):``        ``dp[i][i] ``=` `0` `    ``# DP tabulation``    ``for` `length ``in` `range``(``2``, n ``+` `1``):``        ``for` `i ``in` `range``(n ``-` `length ``+` `1``):``            ``j ``=` `i ``+` `length ``-` `1``            ``dp[i][j] ``=` `INF` `            ``for` `pos ``in` `range``(i, j):``                ``left ``=` `dp[i][pos]``                ``right ``=` `dp[pos ``+` `1``][j]``                ``cost ``=` `k ``*` `Combine(prefix, i, j)``                ``dp[i][j] ``=` `min``(dp[i][j], left ``+` `right ``+` `cost)` `    ``# return answer``    ``return` `dp[``0``][n ``-` `1``]`  `if` `__name__ ``=``=` `'__main__'``:``    ``n ``=` `4``    ``a ``=` `[``4``, ``5``, ``6``, ``7``]``    ``k ``=` `3` `    ``# function call``    ``print``(minCost(a, n, k))`

## C#

 `using` `System;``using` `System.Collections.Generic;` `class` `Program``{``    ``static` `int` `inf = 10000000;` `    ``// Function to generate the cost using``    ``// Prefix Sum Array technique``    ``static` `List<``int``> preprocess(List<``int``> a, ``int` `n)``    ``{``        ``List<``int``> p = ``new` `List<``int``>();``        ``p.Add(a[0]);` `        ``for` `(``int` `i = 1; i < n; i++)``        ``{``            ``p.Add(p[i - 1] + a[i]);``        ``}``        ``return` `p;``    ``}` `    ``// Function to combine the sum of the``    ``// two subproblems``    ``static` `int` `Combine(List<``int``> p, ``int` `i, ``int` `j)``    ``{``        ``if` `(i == 0)``            ``return` `p[j];``        ``else``            ``return` `p[j] - p[i - 1];``    ``}` `    ``// Function to minimize the cost to``    ``// add the array elements to a single element``    ``static` `int` `minCost(List<``int``> a, ``int` `n, ``int` `k)``    ``{``        ``// Initialise dp array``        ``int``[,] dp = ``new` `int``[n + 1, n + 1];` `        ``// Preprocessing the array``        ``List<``int``> prefix = preprocess(a, n);` `        ``// Base case``        ``for` `(``int` `i = 0; i < n; i++)``        ``{``            ``dp[i, i] = 0;``        ``}` `        ``// DP tabulation``        ``for` `(``int` `len = 2; len <= n; len++)``        ``{``            ``for` `(``int` `i = 0; i <= n - len; i++)``            ``{``                ``int` `j = i + len - 1;``                ``dp[i, j] = inf;` `                ``for` `(``int` `pos = i; pos < j; pos++)``                ``{``                    ``int` `left = dp[i, pos];``                    ``int` `right = dp[pos + 1, j];``                    ``int` `cost = k * Combine(prefix, i, j);``                    ``dp[i, j] = Math.Min(dp[i, j], left + right + cost);``                ``}``            ``}``        ``}` `        ``// return answer``        ``return` `dp[0, n - 1];``    ``}` `    ``// Driver code``    ``static` `void` `Main(``string``[] args)``    ``{``        ``int` `n = 4;``        ``List<``int``> a = ``new` `List<``int``>() { 4, 5, 6, 7 };``        ``int` `k = 3;` `        ``// function call``        ``Console.WriteLine(minCost(a, n, k));``    ``}``}`

## Javascript

 `// JavaScript code for above approach``const inf = 10000000;` `// Function to generate the cost using``// Prefix Sum Array technique``function` `preprocess(a, n) {``    ``let p = [];``    ``p[0] = a[0];``    ``for` `(let i = 1; i < n; i++) {``        ``p[i] = p[i - 1] + a[i];``    ``}``    ``return` `p;``}` `// Function to combine the sum of the``// two subproblems``function` `Combine(p, i, j) {``    ``if` `(i == 0)``        ``return` `p[j];``    ``else``        ``return` `p[j] - p[i - 1];``}` `// Function to minimize the cost to``// add the array elements to a single element``function` `minCost(a, n, k) {``    ``// Initialise dp array``    ``let dp = ``new` `Array(n + 1).fill().map(() => ``new` `Array(n + 1).fill(0));``    ``// Preprocessing the array``    ``let prefix = preprocess(a, n);` `    ``// Base case``    ``for` `(let i = 0; i < n; i++) {``        ``dp[i][i] = 0;``    ``}` `    ``// DP tabulation``    ``for` `(let len = 2; len <= n; len++) {``        ``for` `(let i = 0; i <= n - len; i++) {``            ``let j = i + len - 1;``            ``dp[i][j] = inf;` `            ``for` `(let pos = i; pos < j; pos++) {``                ``let left = dp[i][pos];``                ``let right = dp[pos + 1][j];``                ``let cost = k * Combine(prefix, i, j);``                ``dp[i][j] = Math.min(dp[i][j], left + right + cost);``            ``}``        ``}``    ``}` `    ``// return answer``    ``return` `dp[0][n - 1];``}` `// Driver code``let n = 4;``let a = [4, 5, 6, 7];``let k = 3;` `// function call``console.log(minCost(a, n, k));` `// This code is contributed by user_dtewbxkn77n`

Output

`132`

Time Complexity: O(N^3)
Auxiliary Space: O(N^2)

My Personal Notes arrow_drop_up