<p>You are given an array of unique strings <code>words</code> where <code>words[i]</code> is six letters long. One word of <code>words</code> was chosen as a secret word.</p>

<p>You are also given the helper object <code>Master</code>. You may call <code>Master.guess(word)</code> where <code>word</code> is a six-letter-long string, and it must be from <code>words</code>. <code>Master.guess(word)</code> returns:</p>

<ul>
	<li><code>-1</code> if <code>word</code> is not from <code>words</code>, or</li>
	<li>an integer representing the number of exact matches (value and position) of your guess to the secret word.</li>
</ul>

<p>There is a parameter <code>allowedGuesses</code> for each test case where <code>allowedGuesses</code> is the maximum number of times you can call <code>Master.guess(word)</code>.</p>

<p>For each test case, you should call <code>Master.guess</code> with the secret word without exceeding the maximum number of allowed guesses. You will get:</p>

<ul>
	<li><strong><code>&quot;Either you took too many guesses, or you did not find the secret word.&quot;</code></strong> if you called <code>Master.guess</code> more than <code>allowedGuesses</code> times or if you did not call <code>Master.guess</code> with the secret word, or</li>
	<li><strong><code>&quot;You guessed the secret word correctly.&quot;</code></strong> if you called <code>Master.guess</code> with the secret word with the number of calls to <code>Master.guess</code> less than or equal to <code>allowedGuesses</code>.</li>
</ul>

<p>The test cases are generated such that you can guess the secret word with a reasonable strategy (other than using the bruteforce method).</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> secret = &quot;acckzz&quot;, words = [&quot;acckzz&quot;,&quot;ccbazz&quot;,&quot;eiowzz&quot;,&quot;abcczz&quot;], allowedGuesses = 10
<strong>Output:</strong> You guessed the secret word correctly.
<strong>Explanation:</strong>
master.guess(&quot;aaaaaa&quot;) returns -1, because &quot;aaaaaa&quot; is not in wordlist.
master.guess(&quot;acckzz&quot;) returns 6, because &quot;acckzz&quot; is secret and has all 6 matches.
master.guess(&quot;ccbazz&quot;) returns 3, because &quot;ccbazz&quot; has 3 matches.
master.guess(&quot;eiowzz&quot;) returns 2, because &quot;eiowzz&quot; has 2 matches.
master.guess(&quot;abcczz&quot;) returns 4, because &quot;abcczz&quot; has 4 matches.
We made 5 calls to master.guess, and one of them was the secret, so we pass the test case.
</pre>

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

<pre>
<strong>Input:</strong> secret = &quot;hamada&quot;, words = [&quot;hamada&quot;,&quot;khaled&quot;], allowedGuesses = 10
<strong>Output:</strong> You guessed the secret word correctly.
<strong>Explanation:</strong> Since there are two words, you can guess both.
</pre>

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

<ul>
	<li><code>1 &lt;= words.length &lt;= 100</code></li>
	<li><code>words[i].length == 6</code></li>
	<li><code>words[i]</code> consist of lowercase English letters.</li>
	<li>All the strings of <code>wordlist</code> are <strong>unique</strong>.</li>
	<li><code>secret</code> exists in <code>words</code>.</li>
	<li><code>10 &lt;= allowedGuesses &lt;= 30</code></li>
</ul>

/**
 * // This is the Master's API interface.
 * // You should not implement it, or speculate about its implementation
 * class Master {
 *   public:
 *     int guess(string word);
 * };
 */
class Solution {
public:
    void findSecretWord(vector<string>& words, Master& master) {
        int n = words.size();
        auto toBeDeleted = unordered_set<string>();
        auto scoreTable = vector<vector<int>>(6, vector<int>(26, 0));
        for (const string word : words) {
            addScore(scoreTable, word, 1);
        }

        int guessNum = -1;
        while (guessNum != 6) {
            string word1 = getHighestScoreWord(words, toBeDeleted, scoreTable);

            guessNum = master.guess(word1);
            toBeDeleted.insert(word1);
            addScore(scoreTable, word1, -1);

            for (const string word2 : words) {
                if (getScore(scoreTable, word2) == 0) {
                    continue;
                }
                if (!hasKMatches(word1, word2, guessNum)) {
                    toBeDeleted.insert(word2);
                    addScore(scoreTable, word2, -1);
                }
            }
        }
        return;
    }
    static const string getHighestScoreWord(vector<string>& words, unordered_set<string> toBeDeleted, vector<vector<int>>& scoreTable) {
        long long maxScore = -1;
        string maxScoreWord = "";
        for (const string word : words) {
            if (toBeDeleted.contains(word)) {
                continue;
            }
            long long score = getScore(scoreTable, word);
            if (score > maxScore) {
                maxScore = score;
                maxScoreWord = word;
            }
        }
        return maxScoreWord;
    }

    void addScore(vector<vector<int>>& scoreTable, string word, int score) {
        for (int i = 0; i < 6; i++) {
            scoreTable[i][word[i] - 'a'] += score;
        }
    }

    static const long long getScore(vector<vector<int>>& scoreTable, string word) {
        long long score = 1;
        for (int i = 0; i < 6; i++) {
            score *= scoreTable[i][word[i] - 'a'];
        }
        return score;
    }

    static const bool hasKMatches(string str1, string str2, int k) {
        for (int i = 0; i < 6; i++) {
            if (str1[i] == str2[i]) {
                k--;
            }
        }
        return k == 0;
    }
};

// a a a a a
// a a c c b: 2
// a d a d b: 2
9900