New Problem "Burst Balloons"

Author: haoel

README.md

@@ -14,6 +14,7 @@ LeetCode
 |322|[Coin Change](https://leetcode.com/problems/coin-change/) | [C++](./algorithms/cpp/coinChange/coinChange.cpp)|Medium|
 |319|[Bulb Switcher](https://leetcode.com/problems/bulb-switcher/) | [C++](./algorithms/cpp/bulbSwitcher/bulbSwitcher.cpp)|Medium|
 |315|[Count of Smaller Numbers After Self](https://leetcode.com/problems/count-of-smaller-numbers-after-self/) | [C++](./algorithms/cpp/countOfSmallerNumbersAfterSelf/countOfSmallerNumbersAfterSelf.cpp)|Hard|
+|312|[Burst Balloons](https://leetcode.com/problems/burst-balloons/) | [C++](./algorithms/cpp/burstBalloons/BurstBalloons.cpp)|Hard|
 |307|[Range Sum Query - Mutable](https://leetcode.com/problems/range-sum-query-mutable/) | [C++](./algorithms/cpp/rangeSumQuery-Immutable/rangeSumQuery-Mutable/RangeSumQueryMutable.cpp)|Medium|
 |306|[Additive Number](https://leetcode.com/problems/additive-number/) | [C++](./algorithms/cpp/additiveNumber/AdditiveNumber.cpp)|Medium|
 |304|[Range Sum Query 2D - Immutable](https://leetcode.com/problems/range-sum-query-2d-immutable/) | [C++](./algorithms/cpp/rangeSumQuery2D-Immutable/RangeSumQuery2dImmutable.cpp)|Medium|

algorithms/cpp/burstBalloons/BurstBalloons.cpp

@@ -0,0 +1,104 @@
+// Source : https://leetcode.com/problems/burst-balloons/
+// Author : Hao Chen
+// Date   : 2016-01-17
+
+/*************************************************************************************** 
+ *
+ * Given n balloons, indexed from 0 to n-1. Each balloon is painted with a
+ *     number on it represented by array nums.
+ * 
+ *     You are asked to burst all the balloons. If the you burst
+ *     balloon i you will get nums[left] * nums[i] * nums[right] coins. Here left
+ *     and right are adjacent indices of i. After the burst, the left and right
+ *     then becomes adjacent.
+ * 
+ *     Find the maximum coins you can collect by bursting the balloons wisely.
+ * 
+ *     Note: 
+ *     (1) You may imagine nums[-1] = nums[n] = 1. They are not real therefore you can 
+ * not burst them.
+ *     (2) 0 ≤ n ≤ 500, 0 ≤ nums[i] ≤ 100
+ * 
+ *     Example:
+ * 
+ *     Given [3, 1, 5, 8]
+ * 
+ *     Return 167
+ * 
+ *     nums = [3,1,5,8] --> [3,5,8] -->   [3,8]   -->  [8]  --> []
+ *    coins =  3*1*5      +  3*5*8    +  1*3*8      + 1*8*1   = 167
+ * 
+ * Credits:Special thanks to @dietpepsi for adding this problem and creating all test 
+ * cases.
+ ***************************************************************************************/
+
+
+
+class Solution {
+public:
+    int maxCoins(vector<int>& nums) {
+        //remove all of zero item
+        nums.erase(remove_if(nums.begin(), nums.end(), [](int n){return n==0;}), nums.end());
+        
+        //add 1 for head and tail
+        nums.insert(nums.begin(),1);
+        nums.push_back(1);
+        
+        int n = nums.size();
+        vector< vector<int> > matrix(n, vector<int>(n,0));
+        
+        return maxCoins_DP(nums, matrix);
+        return maxCoins_DC(nums, matrix, 0, n-1);
+    }
+    
+    
+    //Divide and Conquer
+    //
+    //  If we seprate the array to two part, left part and right part.
+    //
+    //  Then, we will find in this problem the left and right become adjacent 
+    //  and have effects on the maxCoins in the future.
+    //
+    //  So, if we think reversely, if the balloon i is the last balloon of all to burst, 
+    //  the left and right section now has well defined boundary and do not affect each other! 
+    //  Therefore we can do either recursive method with memoization
+    //
+    int maxCoins_DC(vector<int>& nums, vector<vector<int>>& matrix, int low, int high) {
+        if (low + 1 == high) return 0;
+        if (matrix[low][high] > 0) return matrix[low][high];
+        int result = 0;
+        for (int i = low + 1; i < high; ++i){
+            result = max(result,  nums[low] * nums[i] * nums[high] 
+                                    + maxCoins_DC(nums, matrix, low, i) 
+                                    + maxCoins_DC(nums, matrix, i, high));
+        }
+        matrix[low][high] = result;
+        return result;
+    }
+    
+    //Dynamic Programming
+    // 
+    //  using the same idea of above 
+    //
+    int maxCoins_DP(vector<int>& nums, vector<vector<int>>& dp) {
+        int n = nums.size();
+        for (int k = 2; k < n; ++k) {
+            for (int low = 0; low < n - k; low++){
+                int high = low + k;
+                for (int i = low + 1; i < high; ++i)
+                    dp[low][high] = max( dp[low][high],
+                         nums[low] * nums[i] * nums[high] + dp[low][i] + dp[i][high]);
+            }
+        }
+        return dp[0][n - 1];
+    }
+    
+private:
+    void printVector(vector<int>& nums) {
+        cout << "nums: ";
+        for (auto n: nums) {
+            cout << n << ' ';
+        }
+        cout << '\n';
+    }
+};