题目描述(简单难度)

290、Word Pattern

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.

Example 1:

Input: pattern = "abba", str = "dog cat cat dog"
Output: true

Example 2:

Input:pattern = "abba", str = "dog cat cat fish"
Output: false

Example 3:

Input: pattern = "aaaa", str = "dog cat cat dog"
Output: false

Example 4:

Input: pattern = "abba", str = "dog dog dog dog"
Output: false

Notes: You may assume pattern contains only lowercase letters, and str contains lowercase letters that may be separated by a single space.

判断字符串是否符合某个模式,类比于汉字,abb 型,就是喜洋洋,胖乎乎,每个汉字对应题目中的每个单词。

可以先做一下 205 题,基本上和这个题一模一样了,下边的思路也都是基于 205 题 去写了。

解法一

最简单的思路,利用 HashMappattern 的每个字母作为 keystr 的每个单词作为 value 。第一次遇到的 key 就加入到 HashMap 中,第二次遇到同一个 key,那就判断它的value 和当前单词是否一致。举个例子。

pattern = "abba", str = "dog cat cat dog"

 a   b   b   a
dog cat cat dog
 ^
 i
 第一次遇到 a, 加入到 HashMap
 HashMap = {a:dog}

 a   b   b   a
dog cat cat dog
     ^
     i
 第一次遇到 b, 加入到 HashMap
 HashMap = {a: dog, b: cat}

 a   b   b   a
dog cat cat dog
         ^
         i
 HashMap = {a: dog, b: cat}
 第二次遇到 b, 判断 HashMap 中 b 的 value 和当前的单词是否符合
 符合的话继续判断, 不符合就返回 false

 a   b   b   a
dog cat cat dog
             ^
             i
 HashMap = {a: dog, b: cat}
 第二次遇到 a, 判断 HashMap 中 a 的 value 和当前的单词是否符合
 符合的话继续判断, 不符合就返回 false    

遍历结束,返回 true

可以看一下相应的代码。

public boolean wordPattern(String pattern, String str) {
    HashMap<Character, String> map = new HashMap<>();
    String[] array = str.split(" ");
    if (pattern.length() != array.length) {
        return false;
    }
    for (int i = 0; i < pattern.length(); i++) {
        char key = pattern.charAt(i);
        //当前 key 是否存在
        if (map.containsKey(key)) {
            if (!map.get(key).equals(array[i])) {
                return false;
            }
        } else {
            map.put(key, array[i]);
        }
    }
    return true;
}

但上边的代码还是有问题的,我们只是完成了 patternstr 的映射,如果对于下边的例子是有问题的。

pattern = "abba"
str = "dog dog dog dog"

最直接的方法,在添加新的 key 的时候判断一下相应的 value 是否已经用过了。

public boolean wordPattern(String pattern, String str) {
    HashMap<Character,String> map = new HashMap<>();
    String[] array = str.split(" ");
    if(pattern.length() != array.length){
        return false;
    }
    for(int i = 0; i < pattern.length();i++){
        char key = pattern.charAt(i);
        if(map.containsKey(key)){
            if(!map.get(key).equals(array[i])){
                return false;
            }
        }else{
            //判断 value 中是否存在
            if(map.containsValue(array[i])){
                return false;
            }
            map.put(key, array[i]);
        }
    }
    return true;
}

虽然可以 AC 了,但还有一个问题,containsValue 的话,需要遍历一遍 value ,会导致时间复杂度增加。最直接的解决方法,我们可以把 HashMap 中的 value 存到 HashSet 中。

public boolean wordPattern(String pattern, String str) {
    HashMap<Character, String> map = new HashMap<>();
    HashSet<String> set = new HashSet<>();
    String[] array = str.split(" ");
    if (pattern.length() != array.length) {
        return false;
    }
    for (int i = 0; i < pattern.length(); i++) {
        char key = pattern.charAt(i);
        if (map.containsKey(key)) {
            if (!map.get(key).equals(array[i])) {
                return false;
            }
        } else {
            // 判断 value 中是否存在
            if (set.contains(array[i])) {
                return false;
            }
            map.put(key, array[i]);
            set.add(array[i]);
        }
    }
    return true;
}

当然还有另外一种思路,我们只判断了 patternstr 的映射,我们只需要再判断一次 strpattern 的映射就可以了,这样就保证了一一对应。

两次判断映射的逻辑是一样的,所以我们可以抽象出一个函数,但由于 pattern 只能看成 char 数组,这样的话会使得两次的 HashMap 不一样,一次是 HashMap<Character, String> ,一次是 HashMap<String, Character>。所以我们提前将 pattern 转成 String 数组。

public boolean wordPattern(String pattern, String str) {
    String[] array1 = str.split(" ");
    if (array1.length != pattern.length()) {
        return false;
    }
    String[] array2 = pattern.split("");
    //两个方向的映射
    return wordPatternHelper(array1, array2) && wordPatternHelper(array2, array1);
}

//array1 到 array2 的映射
private boolean wordPatternHelper(String[] array1, String[] array2) {
    HashMap<String, String> map = new HashMap<>(); 
    for (int i = 0; i < array1.length; i++) {
        String key = array1[i];
        if (map.containsKey(key)) {
            if (!map.get(key).equals(array2[i])) {
                return false;
            }
        } else {
            map.put(key, array2[i]);
        }
    }
    return true;
}

解法二

205 题 还介绍了另一种思路。

解法一中,我们通过对两个方向分别考虑来解决的。

这里的话,我们找一个第三方来解决。即,按照单词出现的顺序,把两个字符串都映射到另一个集合中。

第一次出现的单词(字母)映射到 1 ,第二次出现的单词(字母)映射到 2... 依次类推,这样就会得到一个新的字符串了。两个字符串都通过这样方法去映射,然后判断新得到的字符串是否相等 。

举个现实生活中的例子,一个人说中文,一个人说法语,怎么判断他们说的是一个意思呢?把中文翻译成英语,把法语也翻译成英语,然后看最后的英语是否相同即可。举个例子。

pattern = "abba", str = "dog cat cat dog"

对于 abba
a -> 1
b -> 2
最终的得到的字符串就是 1221

对于 dog cat cat dog
dog -> 1
cat -> 2
最终的得到的字符串就是 1221    

最终两个字符串都映射到了 1221, 所以 str 符合 pattern

代码的话,我们同样封装一个函数,返回映射后的结果。

public boolean wordPattern(String pattern, String str) {
    String[] array = str.split(" ");
    if(array.length!=pattern.length()){
        return false;
    }
    //判断映射后的结果是否相等
    return wordPatternHelper(pattern.split("")).equals(wordPatternHelper(array));
}

private String wordPatternHelper(String[] array) {
    HashMap<String, Integer> map = new HashMap<>();
    int count = 1;
    //保存映射后的结果
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < array.length; i++) {
        //是否已经映射过
        if (map.containsKey(array[i])) {
            sb.append(map.get(array[i]));
        } else {
            sb.append(count);
            map.put(array[i], count);
            count++;
        }
    }
    return sb.toString();
}

为了方便,我们也可以将当前单词(字母)直接映射为当前单词(字母)的下标,省去 count 变量。

public boolean wordPattern(String pattern, String str) {
    String[] array = str.split(" ");
    if(array.length!=pattern.length()){
        return false;
    }
    //判断映射后的结果是否相等
    return wordPatternHelper(pattern.split("")).equals(wordPatternHelper(array));
}

private String wordPatternHelper(String[] array) {
    HashMap<String, Integer> map = new HashMap<>(); 
    //保存映射后的结果
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < array.length; i++) {
        //是否已经映射过
        if (map.containsKey(array[i])) {
            sb.append(map.get(array[i]));
        } else {
            sb.append(i);
            map.put(array[i], i); 
        }
    }
    return sb.toString();
}

上边我们是调用了两次函数,将字符串整体转换后来判断。我们其实可以一个单词(字母)一个单词(字母)的判断。第一次遇到的单词(字母)就给它一个 value ,也就是把下标给它。如果第二次遇到,就判断它们的 value 是否一致。

怎么判断是否是第一次遇到,我们可以通过判断 key 是否存在,但这样判断起来会比较麻烦。为了统一,我们可以给还不存在的 key 一个默认的 value,这样代码写起来比较统一。

public boolean wordPattern(String pattern, String str) {
    String[] array1 = str.split(" ");
    if (array1.length != pattern.length()) {
        return false;
    }
    char[] array2 = pattern.toCharArray();
    HashMap<String, Integer> map1 = new HashMap<>();
    HashMap<Character, Integer> map2 = new HashMap<>();
    for (int i = 0; i < array1.length; i++) {
        String c1 = array1[i];
        char c2 = array2[i];
        // 当前的映射值是否相同
        int a = map1.getOrDefault(c1, -1);
        int b = map2.getOrDefault(c2, -1);
        if (a != b) {
            return false;
        } else { 
            map1.put(c1, i);
            map2.put(c2, i); 
        }
    }
    return true;
}

同样的思路,然后看一下 StefanPochmann 大神的 代码

public boolean wordPattern(String pattern, String str) {
    String[] words = str.split(" ");
    if (words.length != pattern.length())
        return false;
    Map index = new HashMap();
    for (Integer i = 0; i < words.length; ++i)
        if (index.put(pattern.charAt(i), i) != index.put(words[i], i))
            return false;
    return true;
}

他利用了 put 的返回值,如果 putkey 不存在,那么就插入成功,返回 null

如果 putkey 已经存在了,返回 key 是之前对应的 value

所以第一次遇到的单词(字母)两者都会返回 null,不会进入 return false

第二次遇到的单词(字母)就判断之前插入的 value 是否相等。也有可能其中一个之前还没插入值,那就是 null ,另一个之前已经插入了,会得到一个 value,两者一定不相等,就会返回 false

还有一点需要注意,for 循环中我们使用的是 Integer i,而不是 int i。是因为 map 中的 value 只能是 Integer

如果我们用 int i 的话,java 会自动装箱,转成 Integer。这样就会带来一个问题,put 返回的是一个 Integer ,判断对象相等的话,相当于判断的是引用的地址,那么即使 Integer 包含的值相等,那么它俩也不会相等。我们可以改成 int i 后试一试。

public boolean wordPattern(String pattern, String str) {
    String[] words = str.split(" ");
    if (words.length != pattern.length())
        return false;
    Map index = new HashMap();
    for (int i = 0; i < words.length; ++i)
        if (index.put(pattern.charAt(i), i) != index.put(words[i], i))
            return false;
    return true;
}

改成 int i 以后,就不能 AC 了。但你会发现当 pattern 的长度比较小时,代码是没有问题的,这又是为什么呢?

是因为当数字在 [-128,127] 的范围内时,对于同一个值,Integer 对象是共享的,举个例子。

Integer a = 66;
Integer b = 66;
System.out.println(a == b); // ?

Integer c = 166;
Integer d = 166;
System.out.println(c == d); // ?

大家觉得上边会返回什么?

是的,是 truefalse。当不在 [-128,127] 的范围内时,即使 Integer 包含的值相等,但由于是对象之间比较,依旧会返回 false

回到之前的问题,如果你非常想用 int ,比较两个值的时候,你可以拆箱去比较。但返回的有可能是 null,所以需要多加几个判断条件。

public boolean wordPattern(String pattern, String str) {
    String[] words = str.split(" ");
    if (words.length != pattern.length())
        return false;
    Map index = new HashMap();
    for (int i = 0; i < words.length; ++i) {
        Object a = index.put(pattern.charAt(i), i);
        Object b = index.put(words[i], i);
        if (a == null && b == null)
            continue;
        if (a == null || b == null)
            return false;
        if ((int) a != (int) b) {
            return false;
        }
    }
    return true;
}

也可以通过 Object.equals 来判断两个 Integer 是否相等。

public boolean wordPattern(String pattern, String str) {
    String[] words = str.split(" ");
    if (words.length != pattern.length())
        return false;
    Map index = new HashMap();
    for (int i=0; i<words.length; ++i)
        if (!Objects.equals(index.put(pattern.charAt(i), i),
                            index.put(words[i], i)))
            return false;
    return true;
}

其实和 205 题 用到的方法是一模一样的。此外,就是对 java 的装箱拆箱有了更多的了解。

results matching ""

    No results matching ""