# 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[N].

## C++

 `// C++ program burst balloon problem ` `#include ` `#include ` `using` `namespace` `std; ` ` `  `int` `getMax(``int` `A[], ``int` `N) ` `{ ` `    ``// Add Bordering Balloons  ` `    ``int` `B[N + 2]; ` ` `  `    ``B = 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[N]; ` `} ` ` `  ` `  `// Driver code  ` `int` `main() ` `{ ` `    ``int` `A[] = { 1, 2, 3, 4, 5 }; ` `     `  `    ``// Size of the array ` `    ``int` `N = ``sizeof``(A) / ``sizeof``(A); ` ` `  `    ``// Calling function ` `    ``cout << getMax(A, N) << endl; ` `} ` ` `  `// This code is contributed by ashutosh450 `

## Java

 `// 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  `

## Python3

 `# 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)) `

## C#

 `// 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 = 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 `

Output:

```110
``` 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.