前綴樹小試：字模式

原題地址:字模式

給定一個模式串pattern和一個字符串str，請問str和pattern是否遵循相同的模式。 這裏遵循模式指的是一個徹底匹配，即在pattern中的每一個不一樣的字母和str中每一個非空的單詞之間有一個雙向映射的模式對應。

您能夠認爲模式串pattern只包含小寫字母，而str包含由單個空間分隔的小寫單詞組成。

由於要一一對應的關係，因此要雙向映射，因此須要兩個map: 一個從pattern的字符到對應的單詞，一個從單詞到字符。

這裏我沒有使用系統的map,而是實現了一個 前綴樹 來練練手，對於一個前綴樹，一個節點能夠和一個單詞作一一對應的映射，對應的單詞就是從跟沿着路徑到這個節點的那個單詞。因此能夠在這個節點裏存入跟單詞對應的數據，就能夠實現從單詞到這個數據的映射，因此這裏存入字符，實現從單詞到pattern的字符的映射。

從字符到單詞的映射，有多個方案：

1. unordered_map<char, string>，用char作key, word作value
2. 由於都是小寫字母，因此能夠用 string[26]來標記，string[c-'a']就能夠獲得字符c的word，比較
3. 由於前綴樹裏節點跟單詞一一對應，因此能夠直接存入節點，結合2的思路就是：TrieNode[26]. 相比2的好處是，比較單詞相等不用string.compare了，直接比較兩個節點是否相等就能夠了。前綴樹是節點不會刪除，讓這一點成爲了可能。這樣作複雜度直接從O(N*L)到了O(N)，L是字符串的平均長度。

using namespace std;

namespace TFDataStruct {
    template<class T>
    class Trie{
    public:
        struct TrieNode{
            char ch;
            //對應的字符串的個數
            uint32_t mark = 0;
            T relateData;  //作額外的數據處理
            TrieNode *parent = nullptr;
            unordered_map<char, TrieNode*> childern;
        };
        struct TrieNodeVisitor{
            typedef void (*VisitFunc)(TrieNode *node, string &word, int idx);
            VisitFunc visitF;
            TrieNodeVisitor(VisitFunc visitF):visitF(visitF){};
        };
    private:
    public:
        TrieNode root;
        
        Trie(){};
        Trie(vector<string> &words){
            for (auto &w : words){
                insert(w, nullptr);
            }
        }
        
        /** 插入一個元素，同時最後的節點 */
        TrieNode *insert(string &word, TrieNodeVisitor visitor = nullptr){
            TrieNode *node = &root;
            int idx = 0;
            while (idx<word.length()) {
                auto &next = node->childern[word[idx]];
                if (next == nullptr) {
                    next = new TrieNode();
                    next->ch = word[idx];
                    next->parent = node;
                }
                node = next;
                if (visitor.visitF) visitor.visitF(node, word, idx);
                
                idx++;
            }
            node->mark++;
            
            return node;
        }
        
        int count(string &word){
            TrieNode *node = &root;
            int idx = 0;
            while (idx<word.length()) {
                auto &next = node->childern[word[idx]];
                if (next == nullptr) {
                    return 0;
                }
                node = next;
                idx++;
            }
            
            return node->mark;
        }
        
        bool exist(string &word){
            return count(word)>0;
        }
    };
}


class Solution {
public:
    /**
     * @param pattern: a string, denote pattern string
     * @param teststr: a string, denote matching string
     * @return: an boolean, denote whether the pattern string and the matching string match or not
     */
bool wordPattern(string &pattern, string &teststr) {
    teststr.push_back(' ');
    
    //1. 前綴樹記錄的是單詞到字符的對應關係，每一個節點惟一對應一個單詞(即從跟到這個節點的路徑拼起來的單詞),因此用節點存儲單詞映射的字符；
    //2. markC2W[c]表示c這個字符映射的單詞，又由於節點和單詞的一一對應關係，因此把單詞對應的節點存入
    TFDataStruct::Trie<char> trieW2C;
    TFDataStruct::Trie<char>::TrieNode* charNodes[256];
    memset(charNodes, 0, sizeof(charNodes));
    
    //3. 由於要一一對應的關係，1和2恰好是兩個方向
    
    int start=-1, i = 0;
    int wordIdx = 0;
    for (auto &c : teststr){
        
        if (start<0) {
            if (c!=' ') {
                start = i;
            }
        }else{
            if (c==' ') {
                auto str = teststr.substr(start, i-start);
                auto node = trieW2C.insert(str);
                
                auto charNode = charNodes[pattern[wordIdx]];
                if (charNode == nullptr) {
                    if (node->relateData>0) {
                        return false;
                    }
                }else if (node != charNode) {
                    return false;
                }
                
                node->relateData = pattern[wordIdx];
                charNodes[pattern[wordIdx]] = node;
                
                start = -1;
                wordIdx++;
            }
        }
        
        i++;
    }
    
    return true;
}
};
複製代碼