Burst Balloon to maximize coins

09 Aug, 2021
We have been given N balloons, each with a number of coins associated with it. On bursting a balloon i, the number of coins gained is equal to A[i-1]*A[i]*A[i+1]. Also, balloons i-1 and i+1 now become adjacent. Find the maximum possible profit earned after bursting all the balloons. Assume an extra 1 at each boundary.Examples: 
Input : 5, 10
Output : 60
Explanation - First Burst 5, Coins = 1*5*10
              Then burst 10, Coins+= 1*10*1
              Total = 60

Input : 1, 2, 3, 4, 5
Output : 110
A recursive solution is discussed here. We can solve this problem using dynamic programming. First, consider a sub-array from indices Left to Right(inclusive). If we assume the balloon at index Last to be the last balloon to be burst in this sub-array, we would say the coined gained to be-A[left-1]*A[last]*A[right+1]. Also, the total Coin Gained would be this value, plus dp[left][last – 1] + dp[last + 1][right], where dp[i][j] means maximum coin gained for sub-array with indices i, j. Therefore, for each value of Left and Right, we need find and choose a value of Last with maximum coin gained, and update the dp array. Our Answer is the value at dp[1][N]. 
C++
Java
Python3
C#
Javascript
// C++ program burst balloon problem#include <bits/stdc++.h>#include <iostream>using namespace std; int getMax(int A[], int N){    // Add Bordering Balloons    int B[N + 2];     B[0] = 1;    B[N + 1] = 1;     for (int i = 1; i <= N; i++)        B[i] = A[i - 1];     // Declare DP Array    int dp[N + 2][N + 2];    memset(dp, 0, sizeof(dp));     for (int length = 1; length < N + 1; length++)    {        for (int left = 1; left < N - length + 2; left++)        {            int right = left + length - 1;            // For a sub-array from indices left, right            // This innermost loop finds the last balloon burst            for (int last = left; last < right + 1; last++)            {                dp[left][right] = max(dp[left][right],                                      dp[left][last - 1] +                                      B[left - 1] * B[last] * B[right + 1] +                                      dp[last + 1][right]);            }        }    }    return dp[1][N];}  // Driver codeint main(){    int A[] = { 1, 2, 3, 4, 5 };         // Size of the array    int N = sizeof(A) / sizeof(A[0]);     // Calling function    cout << getMax(A, N) << endl;} // This code is contributed by ashutosh450
// Java program to illustrate// Burst balloon problemimport java.util.Arrays; class GFG{ public static int getMax(int[] A, int N){         // Add Bordering Balloons    int[] B = new int[N + 2];    B[0] = B[N + 1] = 1;             for(int i = 1; i <= N; i++)        B[i] = A[i - 1];         // Declaring DP array    int[][] dp = new int[N + 2][N + 2];         for(int length = 1;            length < N + 1; length++)    {        for(int left = 1;                left < N - length + 2; left++)        {            int right = left + length -1;                         // For a sub-array from indices            // left, right. This innermost            // loop finds the last balloon burst            for(int last = left;                    last < right + 1; last++)            {                dp[left][right] = Math.max(                                  dp[left][right],                                  dp[left][last - 1] +                                   B[left - 1] * B[last] *                                   B[right + 1] +                                  dp[last + 1][right]);            }        }    }    return dp[1][N];} // Driver codepublic static void main(String args[]){    int[] A = { 1, 2, 3, 4, 5 };         // Size of the array    int N = A.length;         // Calling function    System.out.println(getMax(A, N));}} // This code is contributed by dadi madhav
# Python3 program burst balloon problem. def getMax(A):    N = len(A)    A = [1] + A + [1]# Add Bordering Balloons    dp = [[0 for x in range(N + 2)] for y in range(N + 2)]# Declare DP Array         for length in range(1, N + 1):        for left in range(1, N-length + 2):            right = left + length -1             # For a sub-array from indices left, right            # This innermost loop finds the last balloon burst            for last in range(left, right + 1):                dp[left][right] = max(dp[left][right], \                                      dp[left][last-1] + \                                      A[left-1]*A[last]*A[right + 1] + \                                      dp[last + 1][right])    return(dp[1][N]) # Driver codeA = [1, 2, 3, 4, 5]print(getMax(A))
// C# program to illustrate// Burst balloon problemusing System; class GFG{ public static int getMax(int[] A, int N){         // Add Bordering Balloons    int[] B = new int[N + 2];    B[0] = B[N + 1] = 1;             for(int i = 1; i <= N; i++)        B[i] = A[i - 1];         // Declaring DP array    int[,] dp = new int[(N + 2), (N + 2)];         for(int length = 1;            length < N + 1; length++)    {        for(int left = 1;                left < N - length + 2; left++)        {            int right = left + length -1;                         // For a sub-array from indices            // left, right. This innermost            // loop finds the last balloon burst            for(int last = left;                    last < right + 1; last++)            {                dp[left, right] = Math.Max(                                  dp[left, right],                                  dp[left, last - 1] +                                   B[left - 1] * B[last] *                                   B[right + 1] +                                  dp[last + 1, right]);            }        }    }    return dp[1, N];} // Driver codepublic static void Main(){    int[] A = new int[] { 1, 2, 3, 4, 5 };         // Size of the array    int N = A.Length;         // Calling function    Console.WriteLine(getMax(A, N));}} // This code is contributed by sanjoy_62
<script>// Javascript program burst balloon problem function getMax(A, N){    // Add Bordering Balloons    var B = new Array(N+2);     B[0] = 1;    B[N + 1] = 1;     for (var i = 1; i <= N; i++)        B[i] = A[i - 1];     // Declare DP Array        var dp = new Array(N + 2);    for (var i = 0; i < dp.length; i++) {        dp[i] = new Array(N + 2).fill(0);    }     for (var length = 1; length < N + 1; length++)    {        for (var left = 1; left < N - length + 2; left++)        {            var right = left + length - 1;            // For a sub-array from indices left, right            // This innermost loop finds the last balloon burst            for (var last = left; last < right + 1; last++)            {                dp[left][right] = Math.max(dp[left][right],                                      dp[left][last - 1] +                                      B[left - 1] * B[last] * B[right + 1] +                                      dp[last + 1][right]);            }        }    }    return dp[1][N];}  // Driver codevar A = [ 1, 2, 3, 4, 5 ]; // Size of the arrayvar N = A.length; // Calling functiondocument.write(getMax(A, N)); // This code is contributed by shubhamsingh10</script>
110
 
ashutosh450
dadimadhav
sanjoy_62
ruhelaa48
SHUBHAMSINGH10
surindertarika1234
Picked
Samsung
Competitive Programming
Dynamic Programming
Samsung
Dynamic Programming
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Modulo 10^9+7 (1000000007)
Prefix Sum Array - Implementation and Applications in Competitive Programming
Bits manipulation (Important tactics)
What is Competitive Programming and How to Prepare for It?
Algorithm Library | C++ Magicians STL Algorithm
Largest Sum Contiguous Subarray
Program for Fibonacci numbers
0-1 Knapsack Problem | DP-10
Longest Common Subsequence | DP-4
Subset Sum Problem | DP-25