Word Pattern | & II

Word Pattern |

Given a pattern and a string str, find if str follows the same pattern.

Examples:

1. pattern = "abba", str = "dog cat cat dog" should return true.
2. pattern = "abba", str = "dog cat cat fish" should return false.
3. pattern = "aaaa", str = "dog cat cat dog" should return false.
4. pattern = "abba", str = "dog dog dog dog" should return false.

Notes:

1. patterncontains only lowercase alphabetical letters, and str contains words separated by a single space. Each word in str contains only lowercase alphabetical letters.
2. Both pattern and str do not have leading or trailing spaces.
3. Each letter in pattern must map to a word with length that is at least 1.

solution:

Split the string, and add the pair to hashmap, if the existing pattern in the hashmap doesn't match the current one, return false.

    public boolean wordPattern(String pattern, String str) {
        String[] strs = str.split(" ");
        if (pattern.length() != strs.length) return false;
        Map<Character, String> map = new HashMap<Character, String>();
        for (int i = 0; i < pattern.length(); i++) {
            if (!map.containsKey(pattern.charAt(i))) {
                if (map.containsValue(strs[i])) return false;
                map.put(pattern.charAt(i), strs[i]);
            } else {
                if (!strs[i].equals(map.get(pattern.charAt(i)))) return false;
            }
        }
        return true;
    }

Word Pattern  II

Given a pattern and a string str, find if str follows the same pattern.

Here follow means a full match, such that there is a bijection between a letter in pattern and a non-empty substring in str.

Examples:

1. 1. pattern = "abab", str = "redblueredblue" should return true.
   2. pattern = "aaaa", str = "asdasdasdasd" should return true.
   3. pattern = "aabb", str = "xyzabcxzyabc" should return false. 

Notes:
You may assume both pattern and str contains only lowercase letters.

分析：

As we don't know the breaking point in str, so we have to try one by one. Onc both the pattern string and str string are empty at the same time, it means the pattern we used is correct. 

public boolean wordPatternMatch(String pattern, String str) {
        return getMapping(pattern, str, new HashMap<Character, String>());
    }

    public boolean getMapping(String pattern, String str, HashMap<Character, String> mapping) {
        if (pattern.isEmpty() && str.isEmpty()) {
            return true;
        } else if (pattern.isEmpty() || str.isEmpty()) {
            return false;
        }

        if (mapping.containsKey(pattern.charAt(0))) {
            String map = mapping.get(pattern.charAt(0));
            if (str.length() >= map.length() && str.substring(0, map.length()).equals(map)) {
                if (getMapping(pattern.substring(1), str.substring(map.length()), mapping)) {
                    return true;
                }
            }
        } else {
            for (int i = 1; i <= str.length(); i++) {  // try each pattern
                String p = str.substring(0, i);
                if (mapping.containsValue(p)) continue;  // the upper if condition is its opposite
                mapping.put(pattern.charAt(0), p);
                if (getMapping(pattern.substring(1), str.substring(i), mapping)) {
                    return true;
                }
                mapping.remove(pattern.charAt(0));
            }
        }
        return false;
    }