[LeetCode 267] Palindrome Permua

Solution

Hint:

1. If a palindromic permutation exists, we just need to generate the first half of the string.
2. To generate all distinct permutations of a (half of) string, use a similar approach from: Permutations II or Next Permutation.

思路

1. 根据提示：如果回文全排列存在，只需要生成前半段字符串即可，后面的直接根据前半段得到。
2. 由于回文字符串有奇偶两种情况，
   • 偶数回文串例如abba，可以平均分成前后半段，
   • 奇数回文串例如abcba，需要分成前中后三段，需要注意的是中间部分只能是一个字符

3.分析得出，如果一个字符串的回文字符串要存在，那么奇数个的字符只能有0个或1个，其余的必须是偶数个：

• 所以我们可以用哈希表来记录所有字符的出现个数，然后我们找出出现奇数次数的字符加入middle中，如果有两个或两个以上的奇数个数的字符，那么返回空集。

4. 对于每个字符，不管其奇偶，都将其个数除以2的个数的字符加入t中，这样做的原因是如果是偶数个，那么将其一般加入t中，如果是奇数，如果有1个，那么除以2是0，不会有字符加入t，如果是3个，那么除以2是1，取一个加入list。
5. 等我们获得了list之后，list是就是前半段字符，对其做全排列，每得到一个全排列，我们加上middle和该全排列的逆序列就是一种所求的回文字符串，这样我们就可以得到所有的回文全排列了。

class Solution {
    public List<String> generatePalindromes(String s) {
        List<String> result = new ArrayList<> ();
        if (s == null || s.length () == 0) {
            return result;
        }
        
        //1. string pre process
        Map<Character, Integer> tracker = new HashMap<> ();
        int oddStringCount = 0;
        
        for (char ch : s.toCharArray()) {
            int count = tracker.getOrDefault (ch, 0) + 1;
            tracker.put (ch, count);
            oddStringCount += count % 2 == 0 ? -1 : 1; // 累计所以 == 0 时为-1， 这样 aaaa，遍历完之后，oddStringCount == 0，而aaa的oddStringcount == 1
        }
        
        // 要组成palindrome，字符串中奇数个的字符只能出现 0 或者 1 个。所以 大于1时，直接返回空
        if (oddStringCount > 1)
            return result; 
        
        //2. 由于回文的原理，前后都是一样的，所以只需要求出前半段的permutation，然后 + 中间的那个奇数个字符 （0或者1个） + 这个permutation的逆序即可
        // 所以先处理String成  前半段 和 中间那个字符
        
        String middle = "";
        List<Character> chars = new ArrayList<> ();
        
        for (Map.Entry<Character, Integer> entry : tracker.entrySet ()) {
            char ch = entry.getKey ();
            int count = entry.getValue ();
            
            System.out.println (ch + ": " + count);
            
            if (count % 2 != 0) {
                middle += ch;
            }
            
            for (int i = 0; i < count / 2; i++) {
                chars.add (ch);
            }
        }
        
        System.out.println ("middle: " + middle);
        System.out.println ("chars: " + chars.toString ());
        
        boolean[] visited = new boolean[chars.size ()];
        
        // sort the string
        Collections.sort (chars);
        
        generatePalindromesHelper (chars, middle, visited, new ArrayList<Character> (), result); // current index
        
        return result;
    }
    
    private void generatePalindromesHelper (List<Character> chars, String middle, boolean[] visited, List<Character> combinationEntry, List<String> result) {
        if (combinationEntry.size () == chars.size ()) {
            String firstHalf = convert (combinationEntry);
            String laterHalf = new StringBuilder(firstHalf).reverse ().toString ();
            
            result.add (firstHalf + middle + laterHalf);
            return;
        }
        
        for (int i = 0; i < chars.size (); i++) {
            
            
            if (i > 0 && !visited [i - 1] && chars.get(i - 1) == chars.get(i))
                continue;
            
            if (visited [i])
                continue;
            
            combinationEntry.add (chars.get (i));
            visited [i] = true;
            
            generatePalindromesHelper (chars, middle, visited, combinationEntry, result);
            
            combinationEntry.remove (combinationEntry.size () - 1);
            visited [i] = false;
        }
    }
    
    private String convert (List<Character> combinationEntry) {
        String result = "";
        for (char ch : combinationEntry) {
            result += ch;
        }
        
        return result;
    }
    
}