玩转lee290 单词规律 模式匹配 lee205 同构

给定一种规律 pattern 和一个字符串 str ，判断 str 是否遵循相同的规律。

这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应规律。

示例1:

输入: pattern = “abba”, str = “dog cat cat dog”
输出: true
示例 2:

输入:pattern = “abba”, str = “dog cat cat fish”
输出: false
示例 3:

输入: pattern = “aaaa”, str = “dog cat cat dog”
输出: false
示例 4:

输入: pattern = “abba”, str = “dog dog dog dog”
输出: false
说明:
你可以假设 pattern 只包含小写字母， str 包含了由单个空格分隔的小写字母。

如果为空串怎么办呢？

思路

先用split将字符串分割为数组
针对Pattern字符串，我们可以用indexOf来判断每个字符的位置。
针对Str字符串，可以用split函数分割为字符串数组，然后再自定义一个字符串数组的indexOf函数（Apache.Common.Lang里面倒是有，但是用不了）。
依次循环判断每个Pattern中每个字符的indexOf，以及Str数组中每个字符串的indexOf，如果值都相等，则为true，否则为false。

class Solution {
    public boolean wordPattern(String pattern, String str) {
        String[] strr=str.split(" ");
        if(pattern.length()!=strr.length)
            return false;
        for(int i=0;i<pattern.length();i++){
            if(pattern.indexOf(pattern.charAt(i))!=indexOf(strr,strr[i]))
                return false;
                 

        }
        return true;

    }

    public int indexOf(String[] arr , String str){
        for(int i=0;i<arr.length;i++){
            if(arr[i].equals(str))
                return i;
        }
        return -1;

    }
}

用HashMap

循环遍历一遍，如果都符合了最后返回true

分为几种情况 ：
1，有key 但对应的value不对
2， 没找到key，但有value
3，如果没key，没value 建立对应映射关系

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

        }
        return true;
    }
}

lee205

给定两个字符串 s 和 t，判断它们是否是同构的。

如果 s 中的字符可以被替换得到 t ，那么这两个字符串是同构的。

所有出现的字符都必须用另一个字符替换，同时保留字符的顺序。两个字符不能映射到同一个字符上，但字符可以映射自己本身。

示例 1:
输入: s = “egg”, t = “add”
输出: true
示例 2:

输入: s = “foo”, t = “bar”
输出: false
示例 3:

输入: s = “paper”, t = “title”
输出: true

思考

字符集？
可以映射到自身吗？
空串？

class Solution {
    public boolean isIsomorphic  (String s, String t) {
        if(s.length()!=t.length())
            return false;
        HashMap<Character, Character> map=new HashMap<>();
        for(int i=0;i<s.length();i++){
            if(map.containsKey(s.charAt(i))){
                if(map.get(s.charAt(i))!=t.charAt(i))
                    return false;
            }
            else if(map.containsValue(t.charAt(i))){
                return false;           
            }
            else
                map.put(s.charAt(i),t.charAt(i));
        }
        return true ;
    }
}

不能这样
先不包括：

        for(int i=0;i<s.length();i++){
            if(!map.containsKey(s.charAt(i))){
                if(map.containsValue(t.charAt(i))){
                    return false;
                }
            }
            else if(map.get(s.charAt(i))!=t.charAt(i)){
                return false;
            }
            else
                map.put(s.charAt(i),t.charAt(i));
        }
        return true;

    }
}

因为不包括的是没key有value