With respect to a given <code>puzzle</code> string, a <code>word</code> is <em>valid</em> if both the following conditions are satisfied:
<ul>
	<li><code>word</code> contains the first letter of <code>puzzle</code>.</li>
	<li>For each letter in <code>word</code>, that letter is in <code>puzzle</code>.
	<ul>
		<li>For example, if the puzzle is <code>&quot;abcdefg&quot;</code>, then valid words are <code>&quot;faced&quot;</code>, <code>&quot;cabbage&quot;</code>, and <code>&quot;baggage&quot;</code>, while</li>
		<li>invalid words are <code>&quot;beefed&quot;</code> (does not include <code>&#39;a&#39;</code>) and <code>&quot;based&quot;</code> (includes <code>&#39;s&#39;</code> which is not in the puzzle).</li>
	</ul>
	</li>
</ul>
Return <em>an array </em><code>answer</code><em>, where </em><code>answer[i]</code><em> is the number of words in the given word list </em><code>words</code><em> that is valid with respect to the puzzle </em><code>puzzles[i]</code>.
<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> words = [&quot;aaaa&quot;,&quot;asas&quot;,&quot;able&quot;,&quot;ability&quot;,&quot;actt&quot;,&quot;actor&quot;,&quot;access&quot;], puzzles = [&quot;aboveyz&quot;,&quot;abrodyz&quot;,&quot;abslute&quot;,&quot;absoryz&quot;,&quot;actresz&quot;,&quot;gaswxyz&quot;]
<strong>Output:</strong> [1,1,3,2,4,0]
<strong>Explanation:</strong> 
1 valid word for &quot;aboveyz&quot; : &quot;aaaa&quot; 
1 valid word for &quot;abrodyz&quot; : &quot;aaaa&quot;
3 valid words for &quot;abslute&quot; : &quot;aaaa&quot;, &quot;asas&quot;, &quot;able&quot;
2 valid words for &quot;absoryz&quot; : &quot;aaaa&quot;, &quot;asas&quot;
4 valid words for &quot;actresz&quot; : &quot;aaaa&quot;, &quot;asas&quot;, &quot;actt&quot;, &quot;access&quot;
There are no valid words for &quot;gaswxyz&quot; cause none of the words in the list contains letter &#39;g&#39;.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> words = [&quot;apple&quot;,&quot;pleas&quot;,&quot;please&quot;], puzzles = [&quot;aelwxyz&quot;,&quot;aelpxyz&quot;,&quot;aelpsxy&quot;,&quot;saelpxy&quot;,&quot;xaelpsy&quot;]
<strong>Output:</strong> [0,1,3,2,0]
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= words.length &lt;= 10<sup>5</sup></code></li>
	<li><code>4 &lt;= words[i].length &lt;= 50</code></li>
	<li><code>1 &lt;= puzzles.length &lt;= 10<sup>4</sup></code></li>
	<li><code>puzzles[i].length == 7</code></li>
	<li><code>words[i]</code> and <code>puzzles[i]</code> consist of lowercase English letters.</li>
	<li>Each <code>puzzles[i] </code>does not contain repeated characters.</li>
</ul>

class TrieTree {
public:
    multiset<string> endStrSet;
    unordered_map<char, TrieTree *> treeNodes;
};

class Solution {
private:
    int traverseTrieTree(TrieTree *root, char firstLetter, bool containFirstLetter, string &puzzle, int puzzleIdx) {
        if (root == NULL) {
            return 0;
        }
        if (puzzleIdx == puzzle.size()) {
            if (containFirstLetter) {
                return root->endStrSet.size();
            }
            return 0;
        }

        char nextPuzzleLetter = puzzle[puzzleIdx];
        int tmpAns = 0;
        if (containFirstLetter) {
            tmpAns += root->endStrSet.size();
        }
        for (pair<char, TrieTree *> tmp: root->treeNodes) {
            bool copyContainFirstLetter = containFirstLetter;
            if (copyContainFirstLetter == false) {
                copyContainFirstLetter = (tmp.first == firstLetter);
            }
            int tmpPuzzleIdx = puzzleIdx;
            char tmpLetter = tmp.first;
            TrieTree *nextRoot = tmp.second;
            if (nextPuzzleLetter < tmpLetter) {
                while (tmpPuzzleIdx < puzzle.size() && puzzle[tmpPuzzleIdx] < tmpLetter) {
                    tmpPuzzleIdx++;
                }
                if (tmpPuzzleIdx < puzzle.size() && puzzle[tmpPuzzleIdx] == tmpLetter) {
                    tmpAns += this->traverseTrieTree(nextRoot, firstLetter, copyContainFirstLetter, puzzle,
                                                     tmpPuzzleIdx);
                }
            } else if (nextPuzzleLetter == tmpLetter) {
                tmpAns += this->traverseTrieTree(nextRoot, firstLetter, copyContainFirstLetter, puzzle,
                                                 tmpPuzzleIdx);
            }
        }
        return tmpAns;
    }

public:
    vector<int> findNumOfValidWords(vector<string> &words, vector<string> &puzzles) {
        TrieTree *root = new TrieTree;
        for (string word: words) {
            set<char> characterSets(word.begin(), word.end());
            TrieTree *tmpNode = root;
            for (auto tmpChar: characterSets) {
                if (tmpNode->treeNodes[tmpChar] == NULL) {
                    TrieTree *tmpNewNode = new TrieTree;
                    tmpNode->treeNodes[tmpChar] = tmpNewNode;
                    tmpNode = tmpNewNode;
                } else {
                    tmpNode = tmpNode->treeNodes[tmpChar];
                }
                auto it = characterSets.find(tmpChar);
                if (distance(it, characterSets.end()) == 1) {
                    tmpNode->endStrSet.insert(word);
                }
            }
        }
        vector<int> ans;
        for (string puzzle: puzzles) {
            int tmpAns = 0;
            char firstLetter = puzzle[0];
            std::sort(puzzle.begin(), puzzle.end());
            char sortedFirstLetter = puzzle[0];

            for (pair<char, TrieTree *> tmp: root->treeNodes) {
                char tmpLetter = tmp.first;
                TrieTree *nextRoot = tmp.second;
                int tmpPuzzleIdx = 0;

                bool firstLetterFound = firstLetter == tmpLetter;

                if (sortedFirstLetter < tmpLetter) {
                    while (tmpPuzzleIdx < puzzle.size() && puzzle[tmpPuzzleIdx] < tmpLetter) {
                        tmpPuzzleIdx++;
                    }
                    if (tmpPuzzleIdx < puzzle.size() && puzzle[tmpPuzzleIdx] == tmpLetter) {
                        tmpAns += this->traverseTrieTree(nextRoot, firstLetter, firstLetterFound, puzzle,
                                                         tmpPuzzleIdx);
                    }
                } else if (sortedFirstLetter == tmpLetter) {
                    tmpAns += this->traverseTrieTree(nextRoot, firstLetter, firstLetterFound, puzzle,
                                                     tmpPuzzleIdx);
                }
            }


            ans.push_back(tmpAns);
        }
        return ans;
    }
};

202000