edit 248

fishercoder1534 · fishercoder1534 · commit 1168932212a1 · 2017-06-07T22:50:47.000-07:00
diff --git a/README.md b/README.md
@@ -289,7 +289,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |251|[Flatten 2D Vector](https://leetcode.com/problems/flatten-2d-vector/)|[Solution](../master/src/main/java/com/fishercoder/solutions/Flatten2DVector.java)| O(1)|O(m*n) | Medium| 
 |250|[Count Univalue Subtrees](https://leetcode.com/problems/count-univalue-subtrees/)|[Solution](../master/src/main/java/com/fishercoder/solutions/CountUnivalueSubtrees.java)| O(n)|O(h) | Medium| DFS
 |249|[Group Shifted Strings](https://leetcode.com/problems/group-shifted-strings/)|[Solution](../master/src/main/java/com/fishercoder/solutions/GroupShiftedStrings.java) | O(nlogn) | O(n) | 
-|248|[Strobogrammatic Number III](https://leetcode.com/problems/strobogrammatic-number-iii/)|[Solution](../master/src/main/java/com/fishercoder/solutions/StrobogrammaticNumberIII.java) | O(?) | O(?) | Hard | 
+|248|[Strobogrammatic Number III](https://leetcode.com/problems/strobogrammatic-number-iii/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_248.java) | O(?) | O(?) | Hard | Recursion, DFS 
 |247|[Strobogrammatic Number II](https://leetcode.com/problems/strobogrammatic-number-ii/)|[Solution](../master/src/main/java/com/fishercoder/solutions/StrobogrammaticNumberII.java) | O(n^2) | O(n) | Medium | Recursion
 |246|[Strobogrammatic Number](https://leetcode.com/problems/strobogrammatic-number/)|[Solution](../master/src/main/java/com/fishercoder/solutions/StrobogrammaticNumber.java) | O(n) | O(1) | Easy 
 |245|[Shortest Word Distance III](https://leetcode.com/problems/shortest-word-distance-iii/)|[Solution](../master/src/main/java/com/fishercoder/solutions/ShortestWordDistanceIII.java) | O(n) | O(1) | Medium | 
diff --git a/src/main/java/com/fishercoder/solutions/StrobogrammaticNumberIII.java b/src/main/java/com/fishercoder/solutions/StrobogrammaticNumberIII.java
diff --git a/src/main/java/com/fishercoder/solutions/_248.java b/src/main/java/com/fishercoder/solutions/_248.java
@@ -0,0 +1,113 @@
+package com.fishercoder.solutions;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * A strobogrammatic number is a number that looks the same when rotated 180 degrees (looked at upside down).
+
+Write a function to count the total strobogrammatic numbers that exist in the range of low <= num <= high.
+
+For example,
+Given low = "50", high = "100", return 3. Because 69, 88, and 96 are three strobogrammatic numbers.
+
+Note:
+Because the range might be a large number, the low and high numbers are represented as string.
+
+*/
+public class _248 {
+
+    static class Solution2 {
+        /**Credit: https://discuss.leetcode.com/topic/31386/concise-java-solution
+         *
+         Construct char arrays from low.length() to high.length()
+         Add stro pairs from outside
+         When left > right, add eligible count
+         */
+
+        private static final char[][] pairs = {{'0', '0'}, {'1', '1'}, {'6', '9'}, {'8', '8'}, {'9', '6'}};
+
+        public int strobogrammaticInRange(String low, String high) {
+            int[] count = {0};
+            for (int len = low.length(); len <= high.length(); len++) {
+                char[] c = new char[len];
+                dfs(low, high, c, 0, len - 1, count);
+            }
+            return count[0];
+        }
+
+        public void dfs(String low, String high , char[] c, int left, int right, int[] count) {
+            if (left > right) {
+                String s = new String(c);
+                if ((s.length() == low.length() && s.compareTo(low) < 0) ||
+                        (s.length() == high.length() && s.compareTo(high) > 0)) {
+                    return;
+                }
+                count[0]++;
+                return;
+            }
+            for (char[] p : pairs) {
+                c[left] = p[0];
+                c[right] = p[1];
+                if (c.length != 1 && c[0] == '0') {
+                    continue;
+                }
+                if (left == right && p[0] != p[1]) {
+                    continue;
+                }
+                dfs(low, high, c, left + 1, right - 1, count);
+            }
+        }
+    }
+
+    class Solution1 {
+        Map<Character, Character> map = new HashMap<>();
+
+        {
+            map.put('1', '1');
+            map.put('8', '8');
+            map.put('6', '9');
+            map.put('9', '6');
+            map.put('0', '0');
+        }
+
+        String low = "", high = "";
+
+        public int strobogrammaticInRange(String low, String high) {
+            this.low = low;
+            this.high = high;
+            int result = 0;
+            for (int n = low.length(); n <= high.length(); n++) {
+                int[] count = new int[1];
+                strobogrammaticInRange(new char[n], count, 0, n - 1);
+                result += count[0];
+            }
+            return result;
+        }
+
+        private void strobogrammaticInRange(char[] arr, int[] count, int lo, int hi) {
+            if (lo > hi) {
+                String s = new String(arr);
+                if ((arr[0] != '0' || arr.length == 1) && compare(low, s) && compare(s, high)) {
+                    count[0]++;
+                }
+                return;
+            }
+            for (Character c : map.keySet()) {
+                arr[lo] = c;
+                arr[hi] = map.get(c);
+                if ((lo == hi && c == map.get(c)) || lo < hi)
+                    strobogrammaticInRange(arr, count, lo + 1, hi - 1);
+            }
+        }
+
+        private boolean compare(String a, String b) {
+            if (a.length() != b.length())
+                return a.length() < b.length();
+            int i = 0;
+            while (i < a.length() && a.charAt(i) == b.charAt(i))
+                i++;
+            return i == a.length() ? true : a.charAt(i) <= b.charAt(i);
+        }
+    }
+}
