【Leetcode】267. Palindrome Permutation II

题目地址：

https://leetcode.com/problems/palindrome-permutation-ii/

给定一个字符串，问其字符重排可能得到的所有回文串。注意返回结果中不要重复。

思路是DFS。先数一下每个字符出现的次数，如果出现奇数次的字符有多于$1$个，那就不存在那样的重排方法，返回空列表；否则可以先用DFS构造回文串的左半边，最后再拼起来。拼的时候要注意原字符串是否有出现了奇数次的字符，如果有，要将其加在正中央。代码如下：

import java.util.ArrayList;
import java.util.List;

public class Solution {
    public List<String> generatePalindromes(String s) {
        List<String> res = new ArrayList<>();
        int[] count = new int[256];
        for (int i = 0; i < s.length(); i++) {
            count[s.charAt(i)]++;
        }
        
        int odd = 0;
        char oddChar = 0;
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < count.length; i++) {
        	// 如果发现出现了奇数次的字符，则记录一下
            if (count[i] % 2 == 1) {
                odd++;
                oddChar = (char) i;
            }
            
            // 把count[i] / 2这么多的字符i加入sb，以便后面DFS
            sb.append(String.valueOf((char) i).repeat(count[i] / 2));
        }
        
        // 如果出现奇数次的字符有多于1个，那说明不存在重排方案，返回空列表
        if (odd >= 2) {
            return res;
        }
        
        // 用一个变量记录一下是否存在出现了奇数次的字符
        boolean hasOdd = false;
        if (odd == 1) {
            hasOdd = true;
        }
        
        dfs(new StringBuilder(), sb.toString(), new boolean[sb.length()], hasOdd, oddChar, res);
        
        return res;
    }
    
    // 接下来就是相当于求s的所有排列
    private void dfs(StringBuilder sb, String s, boolean[] used, boolean hasOdd, char oddChar, List<String> res) {
        if (sb.length() == s.length()) {
            if (hasOdd) {
                res.add(sb.toString() + oddChar + sb.reverse().toString());
            } else {
                res.add(sb.toString() + sb.reverse().toString());
            }
            // 恢复现场
            sb.reverse();
            return;
        }
        
        for (int i = 0; i < s.length(); i++) {
        	// 避免重复枚举
            if (i > 0 && s.charAt(i) == s.charAt(i - 1) && !used[i - 1]) {
                continue;
            }
            
            if (used[i]) {
                continue;
            }
            
            sb.append(s.charAt(i));
            used[i] = true;
            dfs(sb, s, used, hasOdd, oddChar, res);
            // 恢复现场
            sb.setLength(sb.length() - 1);
            used[i] = false;
        }
    }
}

时间复杂度$O(\frac{n}{2}\lfloor \frac{n}{2}\rfloor !)$，空间$O(n)$。