267. Palindrome Permutation II --back tracking 以及palindrome 的优化方法ing

产生input中 所有permutation 中符合 palindrome 的。

Input: "aabb"
Output: ["abba", "baab"]

分析： 和47. Permutations II 本质上一样的，首先字母有重复的，因此为了避免重复解，得先排序。
47题example

Input: [1,1,2]
Output:
[
  [1,1,2],
  [1,2,1],
  [2,1,1]
]

 然而写了一个类似47的解竟然TLE了，

优化策略1. 统计整个字符串中每个字母的个数，如果奇数个的个数>1 ，则所有的permutation 都不可能符合要求。 

做了这个优化后写了如下code, 但时间复杂度太高，排到了 0.0%了吧，算法复杂度为o(n!)

class Solution {
    public List<String> generatePalindromes(String s) {
        List<String> result = new ArrayList<>();
        int[] map = new int[128];
        if (!canPermutePalindrome(s, map))
            return new ArrayList < > ();
        char[] ch = s.toCharArray();
        Arrays.sort(ch);
        dfs(new StringBuilder(), result, ch,new boolean[s.length()]);
        return result;
    }
    
    private void dfs(StringBuilder curResult, List<String> result, char[] ch, boolean[] used){
        if(curResult.length() == ch.length){
            //System.out.println(curResult);
            String candid = curResult.toString();
            if(isPalindromes(candid)){
                result.add(candid);
            }
            return;
        }
        
        for(int i=0; i<ch.length; i++){
            if(used[i] || i>0 && ch[i] == ch[i-1] && !used[i-1]) continue;
           
                curResult.append(ch[i]);
                used[i] = true;
                dfs(curResult,result,ch,used);
                curResult.setLength(curResult.length()-1);
                used[i] = false;
            
        }
    }
    
    private boolean isPalindromes(String s){
        int len = s.length();
        for(int i=0; i<len/2;i++){
            if(s.charAt(i) != s.charAt(len-i-1)) return false;
        }
        return true;
    }
    
  public boolean canPermutePalindrome(String s, int[] map) {
        int count = 0;
        for (int i = 0; i < s.length(); i++) {
            map[s.charAt(i)]++;
            if (map[s.charAt(i)] % 2 == 0)
                count--;
            else
                count++;
        }
        return count <= 1;
    }
}

看了 solution 里的优化方法， 可以优化到 o(n/2!) 而不是 o(n!) 每次只要build 一半的字符串就够了。