LeetCode 290 Word Pattern（单词模式）（istringstream、vector、map）（*）

翻译

给定一个模式，和一个字符串str。返回str是否符合同样的模式。

这里的符合意味着全然的匹配，所以这是一个一对多的映射，在pattern中是一个字母。在str中是一个为空的单词。

比如：
pattern = “abba”。 str = “dog cat cat dog” 应该返回真。
pattern = “abba”， str = “dog cat cat fish” 应该返回假。
pattern = “aaaa”， str = “dog cat cat dog” 应该返回假。
pattern = “abba”， str = “dog dog dog dog” 应该返回假。

批注：
你可以假定pattern中仅仅包括小写字母，在str中仅仅包括被单个空格隔开的小写字母。

原文

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.

分析

我发现我真是越来越爱LeetCode了 ……

今天刚做了一道相似的题目：

LeetCode 205 Isomorphic Strings（同构的字符串）（string、vector、map）（*）

仅仅只是本题是升级版的，之前是字母匹配字母。如今是字母匹配单词了。

之前的题目示比例如以下：

For example,
Given "egg", "add", return true.

Given "foo", "bar", return false.

Given "paper", "title", return true.

当时我们实现了这么一个函数：

vector<int> getVecOrder(string str) {
    map<char, int> strM;
    int index = 0;
    vector<int> strVec;
    for (int i = 0; i < str.size(); ++i) {
        auto iter = strM.find(str[i]);
        if (iter == strM.end()) {
            strM.insert(pair<char, int>(str[i], index));
            strVec.push_back(index);
            index += 1;
        }
        else {
            strVec.push_back(strM[str[i]]);
        }
    }
    return strVec;
}

它可以依据字符串生成序列：

For example,

Given "paper", return "01023".

Given "foo", return "011".

Given "isomorphic", return "0123245607".

如今的需求也是相似的，仅仅只是更加升级了一点而已：

For example,

Given "dog cat cat dog", return "0110".
Given "dog cat cat fish", return "0112".
Given "Word Pattern", return "01".

所以就封装了例如以下函数：

vector<int> getVecOrderPro(string str) {
    istringstream sstream(str);
    string tempStr;
    vector<string> strVec;
    while (!sstream.eof()) {
        getline(sstream, tempStr, ' ');
        strVec.push_back(tempStr);
    }

    map<string, int> strNumMap;
    int strNumIndex = 0;
    vector<int> orderNumVec;
    for (int i = 0; i < strVec.size(); ++i) {
        auto iter = strNumMap.find(strVec[i]);
        if (iter == strNumMap.end()) {
            strNumMap.insert(pair<string, int>(strVec[i], strNumIndex));
            orderNumVec.push_back(strNumIndex);
            strNumIndex += 1;
        }
        else {
            orderNumVec.push_back(strNumMap[strVec[i]]);
        }
    }
    return orderNumVec;             
}

首先须要对整个长长的字符串进行依据空格进行分割，分割成的单个的字符串并加入到vector数组中。使用了流的相关函数。

后面的部分就和之前的一样了，由于是个封装好的函数了，对变量名也进行了一定的改动，前面的那个函数由此改动例如以下：

vector<int> getVecOrder(string str) {
    map<char, int> charNumMap;
    int charNumIndex = 0;
    vector<int> orderNumVec;
    for (int i = 0; i < str.size(); ++i) {
        auto iter = charNumMap.find(str[i]);
        if (iter == charNumMap.end()) {
            charNumMap.insert(pair<char, int>(str[i], charNumIndex));
            orderNumVec.push_back(charNumIndex);
            charNumIndex += 1;
        }
        else {
            orderNumVec.push_back(charNumMap[str[i]]);
        }
    }
    return orderNumVec;
}

最后的比較例如以下，由于题目没有说pattern和str的长度一致，也就是说假设最后的索引长度不匹配了那肯定就是false了。

所以多加一行：

bool wordPattern(string pattern, string str) {
    vector<int> pattern_v = getVecOrder(pattern), str_v = getVecOrderPro(str);
    if (pattern_v.size() != str_v.size()) return false;
    for (int i = 0; i < pattern_v.size(); ++i) {
        if (pattern_v[i] != str_v[i]) return false;
    }                                                               
    return true;
}

updated at 2016/09/17

一点半了，大半夜的不睡觉~

没看之前写的这篇博客。只是思想应该是几乎相同的~ pattern方面还是一样，str的话就先构造出一个String数组。然后在HashMap中存储和推断String。而不是Char了。

    public boolean wordPattern(String pattern, String str) {
        ArrayList s0 = getArrayOrder(pattern);
        ArrayList s1 = getArrayOrder2(getArrayFromString(str));
        if (s0.size() != s1.size())
            return false;
        for (int i = 0; i < s0.size(); i++) {
            if (s0.get(i) != s1.get(i)) {
                return false;
            }
        }
        return true;
    }


    private ArrayList getArrayOrder(String str) {
        HashMap<Character, Integer> strM = new HashMap<>();
        int index = 0;
        ArrayList order = new ArrayList(str.length());
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if (strM.containsKey(c)) {
                order.add(strM.get(c));
            } else {
                strM.put(c, index);
                order.add(index);
                index += 1;
            }
        }
        return order;
    }

    private ArrayList<String> getArrayFromString(String str) {
        ArrayList<String> arrayList = new ArrayList<>();
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            if (str.charAt(i) == ' ' && !builder.toString().equals("")) {
                arrayList.add(builder.toString());
                builder = new StringBuilder();
            } else if (i == str.length() -1) {
                builder.append(str.charAt(i));
                arrayList.add(builder.toString());
                builder = null;
            } else {
                builder.append(str.charAt(i));
            }
        }
        return arrayList;
    }

    private ArrayList getArrayOrder2(ArrayList<String> arrayList) {
        HashMap<String, Integer> strM = new HashMap<>();
        int index = 0;
        ArrayList order = new ArrayList(arrayList.size());
        for (int i = 0; i < arrayList.size(); i++) {
            String s = arrayList.get(i);
            if (strM.containsKey(s)) {
                order.add(strM.get(s));
            } else {
                strM.put(s, index);
                order.add(index);
                index += 1;
            }
        }
        return order;
    }

代码

class Solution {
public:      
    vector<int> getVecOrder(string str) {
        map<char, int> charNumMap;
        int charNumIndex = 0;
        vector<int> orderNumVec;
        for (int i = 0; i < str.size(); ++i) {
            auto iter = charNumMap.find(str[i]);
            if (iter == charNumMap.end()) {
                charNumMap.insert(pair<char, int>(str[i], charNumIndex));
                orderNumVec.push_back(charNumIndex);
                charNumIndex += 1;
            }
            else {
                orderNumVec.push_back(charNumMap[str[i]]);
            }
        }
        return orderNumVec;
    }

    vector<int> getVecOrderPro(string str) {
        istringstream sstream(str);
        string tempStr;
        vector<string> strVec;
        while (!sstream.eof()) {
            getline(sstream, tempStr, ' ');
            strVec.push_back(tempStr);
        }

        map<string, int> strNumMap;
        int strNumIndex = 0;
        vector<int> orderNumVec;
        for (int i = 0; i < strVec.size(); ++i) {
            auto iter = strNumMap.find(strVec[i]);
            if (iter == strNumMap.end()) {
                strNumMap.insert(pair<string, int>(strVec[i], strNumIndex));
                orderNumVec.push_back(strNumIndex);
                strNumIndex += 1;
            }
            else {
                orderNumVec.push_back(strNumMap[strVec[i]]);
            }
        }
        return orderNumVec;
    }

    bool wordPattern(string pattern, string str) {
        vector<int> pattern_v = getVecOrder(pattern), str_v = getVecOrderPro(str);
        if (pattern_v.size() != str_v.size()) return false;
        for (int i = 0; i < pattern_v.size(); ++i) {
            if (pattern_v[i] != str_v[i]) return false;
        }
        return true;
    }       
};