LeetCode-290. Word Pattern

Problem:

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 word in str.

Examples:
pattern = "abba", str = "dog cat cat dog" should return true.
pattern = "abba", str = "dog cat cat fish" should return false.
pattern = "aaaa", str = "dog cat cat dog" should return false.
pattern = "abba", str = "dog dog dog dog" should return false.
Notes:
You may assume pattern contains only lowercase letters, and str contains lowercase letters separated by a single space.

Analysis:

基本方法都一样，利用hash表的思想
即利用map或者（set和数组）保存匹配串和模式串，然后遍历每一个值，查看是否存在key（p中字符），如果存在则验证相应的匹配串中的string是否相同，不同则返回false。如果不存在，则需要查看是否存在相应的value（String），如果存在则返回false，不存在则将key和string加入map（主要考虑情况：p:”abba”,s:”cat cat cat cat “,即s中相同p中不同）。

看到另一种方法

利用两个指针从前和后分别移动判断，该方法没有利用map。

学习到的经验：

1. 这个题可以先判断一下模式串和匹配串长度是否相同，如不同返回false。
2. 利用equals判断内容是否相同
3. 字符串切割split用法
4. set有的是contains方法，map是containsKey和containsValue方法

Answer:

set 方法

public class Solution {
    public boolean wordPattern(String pattern, String str) {
        String[] strArr = str.split(" ");
        char[] p = pattern.toCharArray();
        if(strArr.length!=p.length) return false;
        int[] hash = new int[27];
        Set<String> set = new HashSet<String>();
        //初始化hash
        for(int i=1;i<hash.length;i++){
            hash[i]= 0;
        }

        for(int i=0;i<p.length;i++){
            int index = p[i]-'a'+1;
            if(hash[index]==0){
                if(set.contains(strArr[i])){
                    return false;
                }
                else{
                    hash[index]= i+1;
                    set.add(strArr[i]);
                }
            }
            else{
                if(!strArr[hash[index]-1].equals(strArr[i])){
                    return false;
                }
                hash[index]=i+1;
            }
        }
        return true;
    }
}

MAP 方法：

public class Solution {
    public boolean wordPattern(String pattern, String str) {
        char[] patterns = pattern.toCharArray();
        Map<Character,String> maps = new HashMap<>();
        String[] strs = str.split(" ");

        if(patterns.length != strs.length)
            return false;

        for(int i = 0;i<patterns.length;i++){
            char ch = patterns[i];
            if(maps.containsKey(ch)){
                String value = maps.get(ch);
                if(!value.equals(strs[i]))
                    return false;
            }else{
                if(maps.containsValue(strs[i]))
                    return false;
                maps.put(ch,strs[i]);
            }
        }
        return true;
    }
}

双指针方法：

public class Solution {
public boolean wordPattern(String pattern, String str) {
    int p1, p2;
    boolean flag = true;
    p1 = 0;
    p2 = pattern.length()-1;
    String[] strSet = str.split(" ");

    if(pattern.length() != strSet.length) return false;

    for(int i=0; i<pattern.length(); i++){
        if(pattern.charAt(p1) == pattern.charAt(p2)){
            if(strSet[p1].equals(strSet[p2])) flag = true;
            else return false;
        }else{
            if(!strSet[p1].equals(strSet[p2])) flag = true;
            else return false;
        }
        if(i%2 == 0) p1++;
        else p2--;
    }
    return flag;
}
}