Burst Balloon to maximize coins

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

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 code 
int 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

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to illustrate
// Burst balloon problem
import 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 code
public static void main(String args[])
{
    int[] A = { 1, 2, 3, 4, 5 };
      
    // Size of the array 
    int N = A.length;
      
    // Calling funtion
    System.out.println(getMax(A, N)); 
}
}
  
// This code is contributed by dadi madhav 

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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 code
A = [1, 2, 3, 4, 5]
print(getMax(A))

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to illustrate 
// Burst balloon proble
using 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 code 
public 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

chevron_right


Output: 

110

 

competitive-programming-img




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.