refactor 267

fishercoder1534 · fishercoder1534 · commit 5efa888f6d8c · 2018-11-11T07:16:40.000-08:00
diff --git a/src/main/java/com/fishercoder/solutions/_267.java b/src/main/java/com/fishercoder/solutions/_267.java
@@ -5,87 +5,74 @@
 import java.util.List;
 import java.util.Map;
 
-/**
- * Given a string s, return all the palindromic permutations (without duplicates) of it. Return an empty list if no palindromic permutation could be form.
-
- For example:
-
- Given s = "aabb", return ["abba", "baab"].
-
- Given s = "abc", return [].
-
- Hint:
-
- If a palindromic permutation exists, we just need to generate the first half of the string.
- To generate all distinct permutations of a (half of) string, use a similar approach from: _46 II or Next Permutation.
- */
 public class _267 {
 
-    public List<String> generatePalindromes(String s) {
-        int odd = 0;
-        String mid = "";
-        List<String> res = new ArrayList();
-        List<Character> list = new ArrayList();
-        Map<Character, Integer> map = new HashMap();
-
-        // step 1. build character count map and count odds
-        for (int i = 0; i < s.length(); i++) {
-            char c = s.charAt(i);
-            map.put(c, map.containsKey(c) ? map.get(c) + 1 : 1);
-            odd += map.get(c) % 2 != 0 ? 1 : -1;
-        }
+    public static class Solution1 {
+        public List<String> generatePalindromes(String s) {
+            int odd = 0;
+            String mid = "";
+            List<String> res = new ArrayList();
+            List<Character> list = new ArrayList();
+            Map<Character, Integer> map = new HashMap();
+
+            // step 1. build character count map and count odds
+            for (int i = 0; i < s.length(); i++) {
+                char c = s.charAt(i);
+                map.put(c, map.containsKey(c) ? map.get(c) + 1 : 1);
+                odd += map.get(c) % 2 != 0 ? 1 : -1;
+            }
 
-        // cannot form any palindromic string
-        if (odd > 1) {
-            return res;
-        }
+            // cannot form any palindromic string
+            if (odd > 1) {
+                return res;
+            }
 
-        // step 2. add half count of each character to list
-        for (Map.Entry<Character, Integer> entry : map.entrySet()) {
-            char key = entry.getKey();
-            int val = entry.getValue();
+            // step 2. add half count of each character to list
+            for (Map.Entry<Character, Integer> entry : map.entrySet()) {
+                char key = entry.getKey();
+                int val = entry.getValue();
 
-            if (val % 2 != 0) {
-                mid += key;
-            }
+                if (val % 2 != 0) {
+                    mid += key;
+                }
 
-            for (int i = 0; i < val / 2; i++) {
-                list.add(key);
+                for (int i = 0; i < val / 2; i++) {
+                    list.add(key);
+                }
             }
-        }
 
-        // step 3. generate all the permutations
-        getPerm(list, mid, new boolean[list.size()], new StringBuilder(), res);
+            // step 3. generate all the permutations
+            getPerm(list, mid, new boolean[list.size()], new StringBuilder(), res);
 
-        return res;
-    }
-
-    // generate all unique permutation from list
-    void getPerm(List<Character> list, String mid, boolean[] used, StringBuilder sb,
-                 List<String> res) {
-        if (sb.length() == list.size()) {
-            // form the palindromic string
-            res.add(sb.toString() + mid + sb.reverse().toString());
-            sb.reverse();
-            return;
+            return res;
         }
 
-        for (int i = 0; i < list.size(); i++) {
-            // avoid duplication
-            if (i > 0 && list.get(i) == list.get(i - 1) && !used[i - 1]) {
-                continue;
+        // generate all unique permutation from list
+        void getPerm(List<Character> list, String mid, boolean[] used, StringBuilder sb,
+                     List<String> res) {
+            if (sb.length() == list.size()) {
+                // form the palindromic string
+                res.add(sb.toString() + mid + sb.reverse().toString());
+                sb.reverse();
+                return;
             }
 
-            if (!used[i]) {
-                used[i] = true;
-                sb.append(list.get(i));
-                // recursion
-                getPerm(list, mid, used, sb, res);
-                // backtracking
-                used[i] = false;
-                sb.deleteCharAt(sb.length() - 1);
+            for (int i = 0; i < list.size(); i++) {
+                // avoid duplication
+                if (i > 0 && list.get(i) == list.get(i - 1) && !used[i - 1]) {
+                    continue;
+                }
+
+                if (!used[i]) {
+                    used[i] = true;
+                    sb.append(list.get(i));
+                    // recursion
+                    getPerm(list, mid, used, sb, res);
+                    // backtracking
+                    used[i] = false;
+                    sb.deleteCharAt(sb.length() - 1);
+                }
             }
         }
     }
-
 }
