边工作边刷题：70天一遍leetcode: day 80

Palindrome Permutation I/II

要点：

• oddCount to increase/decrease count
• II:
  • chars: 先统计，再得到一半的c，相同的在一起，所以是不用排序的（permute去重需要排序）
  • odds: odds只能在中间，所以要存起来，最后直接拼接，不参与permutation。这样就免去了用变量计数来做奇偶判定。

https://repl.it/ChGE/1 (I: java)
错误点：

• java: string foreach loop: for(char c : s.toCharArray()) else : error: for-each not applicable to expression type
• java: == higher priority than & : (umap.get(c)&1)==1

https://repl.it/ChGE/2 (I: python)

https://repl.it/Chza/2 (II: python)
错误点：

• permutation 1：注意和combination不同，recursion里的index是position（一律用start省的出错），而循环是对每个字符，进入下一层passed in是start+1
• 如果+和if else，注意括号

import java.util.*;

class Main {
  public static void main(String[] args) {
    Solution sol = new Solution();
    System.out.println(sol.canPermutePalindrome("code"));
    System.out.println(sol.canPermutePalindrome("aab"));
    System.out.println(sol.canPermutePalindrome("carerac"));
  }
}

/*
Given a string, determine if a permutation of the string could form a palindrome.
For example,
"code" -> False, "aab" -> True, "carerac" -> True.
Hint:
Consider the palindromes of odd vs even length. What difference do you notice?
Count the frequency of each character.
If each character occurs even number of times, then it must be a palindrome. How about character which occurs odd number of times?
Tags: Hash Table
Similar Problems: (M) Longest Palindromic Substring, (E) Valid Anagram, (M) Palindrome Permutation II
*/

class Solution {
    public boolean canPermutePalindrome(String s) {
		Map<Character, Integer> umap = new HashMap<>();
		int oddCount = 0;
		
		for(char c : s.toCharArray()) { // error 1: error: for-each not applicable to expression type for(char c: s)
			if(!umap.containsKey(c)) {
				umap.put(c, 0);
			}
			umap.put(c, umap.get(c)+1);
			if((umap.get(c)&1)==1){ // error 2: error: bad operand types for binary operator '&' int and boolean: == has higher priority than &
				oddCount++;
			} else {
				oddCount--;
			}
		}
		return oddCount<=1;
	}
}

import java.util.*;

class Main {
  public static void main(String[] args) {
    Solution sol = new Solution();
    System.out.println(sol.canPermutePalindrome("code"));
    System.out.println(sol.canPermutePalindrome("aab"));
    System.out.println(sol.canPermutePalindrome("carerac"));
  }
}

/*
Given a string, determine if a permutation of the string could form a palindrome.
For example,
"code" -> False, "aab" -> True, "carerac" -> True.
Hint:
Consider the palindromes of odd vs even length. What difference do you notice?
Count the frequency of each character.
If each character occurs even number of times, then it must be a palindrome. How about character which occurs odd number of times?
Tags: Hash Table
Similar Problems: (M) Longest Palindromic Substring, (E) Valid Anagram, (M) Palindrome Permutation II
*/

class Solution {
    public boolean canPermutePalindrome(String s) {
		Map<Character, Integer> umap = new HashMap<>();
		int oddChars = 0;
		
		for(char c : s.toCharArray()) { // error 1: error: for-each not applicable to expression type for(char c: s)
			if(!umap.containsKey(c)) {
				umap.put(c, 0);
			}
			umap.put(c, umap.get(c)+1);
			if((umap.get(c)&1)==1){ // error 2: error: bad operand types for binary operator '&' int and boolean: == has higher priority than &
				oddChars++;
			} else {
				oddChars--;
			}
		}
		return oddChars<=1;
	}
}
            

# Problem Description:

# 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: Permutations II or Next Permutation.

from collections import Counter

class Solution(object):
    def generatePalindromes(self, s):
        """
        :type s: str
        :rtype: List[str]
        """
        def permute(s, start, used, res, solutions):
            if start>=len(s):
                solutions.append(res)
                return
            
            for i in xrange(len(s)): # error, not from start
                if i>start and s[i]==s[i-1] and not used[i-1]: continue
                if not used[i]:
                    used[i]=True
                    permute(s, start+1, used, res+s[i], solutions) 
                    used[i]=False
        
        counts, chars = Counter(s), []
        odds, evens = [], []
        for c in counts:
            if counts[c]%2:
                odds.append(c)
                if counts[c]>1: # error: odds can also append
                    chars.append(c*(counts[c]/2))
            else:
                evens.append(c)
                chars.append(c*(counts[c]/2))
        
        if len(odds)>1:
            return []
        # print chars
        used, solutions = [False]*len(chars), []
        permute(chars, 0, used, "", solutions)
        # print solutions
        
        return [s+(odds[0] if odds else "")+s[::-1] for s in solutions] # error: priority

sol = Solution()
assert sol.generatePalindromes("aabb")==['abba', 'baab']
assert sol.generatePalindromes("abc")==[]
assert sol.generatePalindromes("aaabb")==['ababa', 'baaab']