add 488

fishercoder1534 · fishercoder1534 · commit fc5771ea2d0d · 2017-06-06T23:12:55.000-07:00
diff --git a/README.md b/README.md
@@ -96,6 +96,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |492|[Construct the Rectangle](https://leetcode.com/problems/construct-the-rectangle/)|[Solution](../master/src/main/java/com/fishercoder/solutions/ConstructTheRectangle.java) | O(n) |O(1) | Easy| Array
 |491|[Increasing Subsequences](https://leetcode.com/problems/increasing-subsequences/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_491.java) | O(n!) |O(n) | Medium| Backtracking, DFS
 |490|[The Maze](https://leetcode.com/problems/the-maze/)|[Solution](../master/src/main/java/com/fishercoder/solutions/TheMaze.java) | O(m*n) |O(m*n) | Medium| BFS
+|488|[Zuma Game](https://leetcode.com/problems/zuma-game/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_488.java) | O(?) |O(?) | Hard | DFS, Backtracking
 |487|[Max Consecutive Ones II](https://leetcode.com/problems/max-consecutive-ones-ii/)|[Solution](../master/src/main/java/com/fishercoder/solutions/MaxConsecutiveOnesII.java) | O(n) |O(n) | Medium| Array
 |486|[Predict the Winner](https://leetcode.com/problems/predict-the-winner/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_486.java) | O(2^n) |O(n^2) | Medium | DP
 |485|[Max Consecutive Ones](https://leetcode.com/problems/max-consecutive-ones/)|[Solution](../master/src/main/java/com/fishercoder/solutions/MaxConsecutiveOnes.java) | O(n) |O(1) | Easy| Array
diff --git a/src/main/java/com/fishercoder/solutions/_488.java b/src/main/java/com/fishercoder/solutions/_488.java
@@ -0,0 +1,81 @@
+package com.fishercoder.solutions;
+
+/**
+ * 488. Zuma Game
+ *
+ * Think about Zuma Game. You have a row of balls on the table, colored red(R), yellow(Y), blue(B), green(G), and white(W).
+ * You also have several balls in your hand.
+
+ Each time, you may choose a ball in your hand, and insert it into the row (including the leftmost place and rightmost place).
+ Then, if there is a group of 3 or more balls in the same color touching, remove these balls. Keep doing this until no more balls can be removed.
+
+ Find the minimal balls you have to insert to remove all the balls on the table. If you cannot remove all the balls, output -1.
+
+ Examples:
+
+ Input: "WRRBBW", "RB"
+ Output: -1
+ Explanation: WRRBBW -> WRR[R]BBW -> WBBW -> WBB[B]W -> WW
+
+ Input: "WWRRBBWW", "WRBRW"
+ Output: 2
+ Explanation: WWRRBBWW -> WWRR[R]BBWW -> WWBBWW -> WWBB[B]WW -> WWWW -> empty
+
+ Input:"G", "GGGGG"
+ Output: 2
+ Explanation: G -> G[G] -> GG[G] -> empty
+
+ Input: "RBYYBBRRB", "YRBGB"
+ Output: 3
+ Explanation: RBYYBBRRB -> RBYY[Y]BBRRB -> RBBBRRB -> RRRB -> B -> B[B] -> BB[B] -> empty
+
+ Note:
+
+ You may assume that the initial row of balls on the table won’t have any 3 or more consecutive balls with the same color.
+ The number of balls on the table won't exceed 20, and the string represents these balls is called "board" in the input.
+ The number of balls in your hand won't exceed 5, and the string represents these balls is called "hand" in the input.
+ Both input strings will be non-empty and only contain characters 'R','Y','B','G','W'.
+ */
+public class _488 {
+
+    /**credit: https://discuss.leetcode.com/topic/79820/short-java-solution-beats-98
+     * Two layer of recursion, pretty cool!*/
+
+    int MAXCOUNT = 6;   // the max balls you need will not exceed 6 since "The number of balls in your hand won't exceed 5"
+
+    public int findMinStep(String board, String hand) {
+        int[] handCount = new int[26];
+        for (int i = 0; i < hand.length(); ++i) {
+            ++handCount[hand.charAt(i) - 'A'];
+        }
+        int result = dfs(board + "#", handCount);  // append a "#" to avoid special process while j==board.length, make the code shorter.
+        return result == MAXCOUNT ? -1 : result;
+    }
+    private int dfs(String s, int[] handCount) {
+        s = removeConsecutive(s);
+        if (s.equals("#")) return 0;
+        int result = MAXCOUNT;
+        int need = 0;
+        for (int i = 0, j = 0 ; j < s.length(); ++j) {
+            if (s.charAt(j) == s.charAt(i)) continue;
+            need = 3 - (j - i);     //balls need to remove current consecutive balls.
+            if (handCount[s.charAt(i) - 'A'] >= need) {
+                handCount[s.charAt(i) - 'A'] -= need;
+                result = Math.min(result, need + dfs(s.substring(0, i) + s.substring(j), handCount));
+                handCount[s.charAt(i) - 'A'] += need;
+            }
+            i = j;
+        }
+        return result;
+    }
+
+    //remove consecutive balls longer than 3
+    private String removeConsecutive(String board) {
+        for (int i = 0, j = 0; j < board.length(); ++j) {
+            if (board.charAt(j) == board.charAt(i)) continue;
+            if (j - i >= 3) return removeConsecutive(board.substring(0, i) + board.substring(j));
+            else i = j;
+        }
+        return board;
+    }
+}
