用了三个Hashtable…

1. 菜名 -> 菜系
2. 菜系 -> Treemap
3. 菜名 -> 所在Treemap中的迭代器

每个菜系用一个TreeSet来保存从高到低的菜色排名，查询的时候只要拿出第一个就好了。

修改的时候，拿出迭代器，删除原来的评分，再把新的评分加入（别忘了更新迭代器）

时间复杂度：构造O(nlogn)，修改O(logn)，查询O(1)

空间复杂度：O(n)

class FoodRatings {
public:
  FoodRatings(vector<string>& foods, vector<string>& cuisines, vector<int>& ratings) {
    const int n = foods.size();
    for (int i = 0; i < n; ++i) {
      n_[foods[i]] = cuisines[i];
      m_[foods[i]] = c_[cuisines[i]].emplace(-ratings[i], foods[i]).first;
    }
  }
  
  void changeRating(string food, int newRating) {
    const string& cuisine = n_[food];
    c_[cuisine].erase(m_[food]);
    m_[food] = c_[cuisine].emplace(-newRating, food).first;
  }
  
  string highestRated(string cuisine) {
    return begin(c_[cuisine])->second;
  }
private:
  unordered_map<string, set<pair<int, string>>> c_; // cuisine -> {{-rating, name}}
  unordered_map<string, string> n_; // food -> cuisine  
  unordered_map<string, set<pair<int, string>>::iterator> m_; // food -> set iterator
};

/**
 * Your FoodRatings object will be instantiated and called as such:
 * FoodRatings* obj = new FoodRatings(foods, cuisines, ratings);
 * obj->changeRating(food,newRating);
 * string param_2 = obj->highestRated(cuisine);
 */

白银 Hashtable：由于所有元素的值的唯一的，我们可以使用hashtable（或者数组）来记录value所在的格子坐标，这样每次Query都是O(1)时间。
时间复杂度：初始化O(n^2)，query O(1)。
空间复杂度：O(n^2)

class NeighborSum {
public:
  NeighborSum(vector<vector<int>>& grid): 
    n_(grid.size()), g_(&grid), xy_(n_ * n_) {
    for (int i = 0; i < n_; ++i)
      for (int j = 0; j < n_; ++j)
        xy_[grid[i][j]] = {j, i};
  }
  
  int adjacentSum(int value) {
    auto [x, y] = xy_[value];
    return val(x, y - 1) + val(x, y + 1) + val(x + 1, y) + val(x - 1, y);
  }
  
  int diagonalSum(int value) {
    auto [x, y] = xy_[value];
    return val(x - 1, y - 1) + val(x - 1, y + 1) + val(x + 1, y - 1) + val(x + 1, y + 1);
  }
private:
  inline int val(int x, int y) const {
    if (x < 0 || x >= n_ || y < 0 || y >= n_) return 0;
    return (*g_)[y][x];
  }
  int n_;
  vector<vector<int>>* g_;
  vector<pair<int, int>> xy_;
};

黄金 Precompute：在初始化的时候顺便求合，开两个数组一个存上下左右的，一个存对角线的。query的时候直接返回答案就可以了。
时间复杂度和白银是一样的，但会快一些（省去了求合的过程）。

class NeighborSum {
public:
  NeighborSum(vector<vector<int>>& grid) {
    int n = grid.size();
    adj_.resize(n * n);
    dia_.resize(n * n);
    auto v = [&](int x, int y) -> int {
      if (x < 0 || x >= n || y < 0 || y >= n) 
        return 0;
      return grid[y][x];
    };
    for (int y = 0; y < n; ++y)
      for (int x = 0; x < n; ++x) {
        adj_[grid[y][x]] = v(x, y - 1) + v(x, y + 1) + v(x + 1, y) + v(x - 1, y);
        dia_[grid[y][x]] = v(x - 1, y - 1) + v(x - 1, y + 1) + v(x + 1, y - 1) + v(x + 1, y + 1);
      }
  }
  
  int adjacentSum(int value) {
    return adj_[value];
  }
  
  int diagonalSum(int value) {
    return dia_[value];
  }
private:
  vector<int> adj_;
  vector<int> dia_;
};

Return the total frequencies of elements in nums such that those elements all have the maximum frequency.

The frequency of an element is the number of occurrences of that element in the array.

Example 1:

Input: nums = [1,2,2,3,1,4]
Output: 4
Explanation: The elements 1 and 2 have a frequency of 2 which is the maximum frequency in the array.
So the number of elements in the array with maximum frequency is 4.

Example 2:

Input: nums = [1,2,3,4,5]
Output: 5
Explanation: All elements of the array have a frequency of 1 which is the maximum.
So the number of elements in the array with maximum frequency is 5.

Constraints:

• 1 <= nums.length <= 100
• 1 <= nums[i] <= 100

Solution: Hashtable

Use a hashtable to store the frequency of each element, and compare it with a running maximum frequency. Reset answer if current frequency is greater than maximum frequency. Increment the answer if current frequency is equal to the maximum frequency.

Time complexity: O(n)
Space complexity: O(n)

class Solution {
public:
  int maxFrequencyElements(vector<int>& nums) {
    unordered_map<int, int> m;
    int freq = 0;
    int ans = 0;
    for (int x : nums) {
      if (++m[x] > freq)
        freq = m[x], ans = 0;
      if (m[x] == freq)
        ans += m[x];
    }
    return ans;
  }
};

Go through each index i in arr starting from index 0 and paint the cell in mat containing the integer arr[i].

Return the smallest index i at which either a row or a column will be completely painted in mat.

Example 1:

Input: arr = [1,3,4,2], mat = [[1,4],[2,3]]
Output: 2
Explanation: The moves are shown in order, and both the first row and second column of the matrix become fully painted at arr[2].

Example 2:

Input: arr = [2,8,7,4,1,3,5,6,9], mat = [[3,2,5],[1,4,6],[8,7,9]]
Output: 3
Explanation: The second column becomes fully painted at arr[3].

Constraints:

• m == mat.length
• n = mat[i].length
• arr.length == m * n
• 1 <= m, n <= 105
• 1 <= m * n <= 105
• 1 <= arr[i], mat[r][c] <= m * n
• All the integers of arr are unique.
• All the integers of mat are unique.

Solution: Map + Counter

Use a map to store the position of each integer.

Use row counters and column counters to track how many elements have been painted.

Time complexity: O(m*n + m + n)
Space complexity: O(m*n + m + n)

// Author: Huahua
class Solution {
public:
  int firstCompleteIndex(vector<int>& arr, vector<vector<int>>& mat) {
    const int m = mat.size();
    const int n = mat[0].size();
    vector<int> rows(m);
    vector<int> cols(n);
    vector<pair<int, int>> pos(m * n + 1);
    for (int i = 0; i < m; ++i)
      for (int j = 0; j < n; ++j)
        pos[mat[i][j]] = {i, j};
    
    for (int i = 0; i < arr.size(); ++i) {
      auto [r, c] = pos[arr[i]];
      if (++rows[r] == n) return i;
      if (++cols[c] == m) return i;
    }
    return -1;
  }
};

• Choose two different indices i and j such that 0 <= i, j < nums.length.
• Choose a non-negative integer k such that the kth bit (0-indexed) in the binary representation of nums[i] and nums[j] is 1.
• Subtract 2k from nums[i] and nums[j].

A subarray is beautiful if it is possible to make all of its elements equal to 0 after applying the above operation any number of times.

Return the number of beautiful subarrays in the array nums.

A subarray is a contiguous non-empty sequence of elements within an array.

Example 1:

Input: nums = [4,3,1,2,4]
Output: 2
Explanation: There are 2 beautiful subarrays in nums: [4,3,1,2,4] and [4,3,1,2,4].
- We can make all elements in the subarray [3,1,2] equal to 0 in the following way:
  - Choose [3, 1, 2] and k = 1. Subtract 21 from both numbers. The subarray becomes [1, 1, 0].
  - Choose [1, 1, 0] and k = 0. Subtract 20 from both numbers. The subarray becomes [0, 0, 0].
- We can make all elements in the subarray [4,3,1,2,4] equal to 0 in the following way:
  - Choose [4, 3, 1, 2, 4] and k = 2. Subtract 22 from both numbers. The subarray becomes [0, 3, 1, 2, 0].
  - Choose [0, 3, 1, 2, 0] and k = 0. Subtract 20 from both numbers. The subarray becomes [0, 2, 0, 2, 0].
  - Choose [0, 2, 0, 2, 0] and k = 1. Subtract 21 from both numbers. The subarray becomes [0, 0, 0, 0, 0].

Example 2:

Input: nums = [1,10,4]
Output: 0
Explanation: There are no beautiful subarrays in nums.

Constraints:

• 1 <= nums.length <= 105
• 0 <= nums[i] <= 106

Solution: Hashtable + Prefix XOR

The problem is asking to find # of subarrays whose element wise xor is 0. We can use a hashtable to store the frequency of each prefix xor value, which reduces this problem to # of Subarray sum equal to k.

Time complexity: O(n)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  long long beautifulSubarrays(vector<int>& nums) {
    long long ans = 0;
    unordered_map<int, int> m{{0, 1}};
    int x = 0;
    for (int i = 0; i < nums.size(); ++i) {
      x ^= nums[i];
      ans += m[x];
      m[x] += 1;
    }
    return ans;
  } 
};

You are given a binary string s, and a 2D integer array queries where queries[i] = [firsti, secondi].

For the ith query, find the shortest substring of s whose decimal value, val, yields secondi when bitwise XORed with firsti. In other words, val ^ firsti == secondi.

The answer to the ith query is the endpoints (0-indexed) of the substring [lefti, righti] or [-1, -1] if no such substring exists. If there are multiple answers, choose the one with the minimum lefti.

Return an array ans where ans[i] = [lefti, righti] is the answer to the ith query.

A substring is a contiguous non-empty sequence of characters within a string.

Example 1:

Input: s = "101101", queries = [[0,5],[1,2]]
Output: [[0,2],[2,3]]
Explanation: For the first query the substring in range [0,2] is "101" which has a decimal value of 5, and 5 ^ 0 = 5, hence the answer to the first query is [0,2]. In the second query, the substring in range [2,3] is "11", and has a decimal value of 3, and 3 ^ 1 = 2. So, [2,3] is returned for the second query. 

Example 2:

Input: s = "0101", queries = [[12,8]]
Output: [[-1,-1]]
Explanation: In this example there is no substring that answers the query, hence [-1,-1] is returned.

Example 3:

Input: s = "1", queries = [[4,5]]
Output: [[0,0]]
Explanation: For this example, the substring in range [0,0] has a decimal value of 1, and 1 ^ 4 = 5. So, the answer is [0,0].

Constraints:

• 1 <= s.length <= 104
• s[i] is either '0' or '1'.
• 1 <= queries.length <= 105
• 0 <= firsti, secondi <= 109

Solution: Pre-compute

We can pre-compute all possible substrings

Time complexity: O(n*32 + m)
Space complexity: O(n*32)

// Author: Huahua
class Solution {
public:
  vector<vector<int>> substringXorQueries(string s, vector<vector<int>>& queries) {
    unordered_map<int, vector<int>> m;
    const int l = s.length();
    for (int i = 0; i < l; ++i) {
      if (s[i] == '0') {
        if (!m.count(0)) m[0] = {i, i};
        continue;
      }
      for (int j = 0, cur = 0; j < 32 && i + j < l; ++j) {
        cur = (cur << 1) | (s[i + j] - '0');
        if (!m.count(cur))
          m[cur] = {i, i + j};
      }
    }
    vector<vector<int>> ans;    
    for (const auto& q : queries) {
      int x = q[0] ^ q[1];
      if (m.count(x)) 
        ans.push_back(m[x]);
      else
        ans.push_back({-1, -1});
    }
    return ans;
  }
};

Given an integer array nums that does not contain any zeros, find the largest positive integer k such that -k also exists in the array.

Return the positive integer k. If there is no such integer, return -1.

Example 1:

Input: nums = [-1,2,-3,3]
Output: 3
Explanation: 3 is the only valid k we can find in the array.

Example 2:

Input: nums = [-1,10,6,7,-7,1]
Output: 7
Explanation: Both 1 and 7 have their corresponding negative values in the array. 7 has a larger value.

Example 3:

Input: nums = [-10,8,6,7,-2,-3]
Output: -1
Explanation: There is no a single valid k, we return -1.

Constraints:

• 1 <= nums.length <= 1000
• -1000 <= nums[i] <= 1000
• nums[i] != 0

Solution 1: Hashtable

We can do in one pass by checking whether -x in the hashtable and update ans with abs(x) if so.

Time complexity: O(n)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int findMaxK(vector<int>& nums) {
    unordered_set<int> s;
    int ans = -1;
    for (int x : nums) {
      if (abs(x) > ans && s.count(-x))
        ans = abs(x);
      s.insert(x);
    }
    return ans;
  }
};

Solution 2: Sorting

Sort the array by abs(x) in descending order.

[-1,10,6,7,-7,1] becomes = [-1, 1, 6, -7, 7, 10]

Check whether arr[i] = -arr[i-1].

Time complexity: O(nlogn)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int findMaxK(vector<int>& nums) {
    sort(begin(nums), end(nums), [](int a, int b){
      return abs(a) == abs(b) ? a < b : abs(a) > abs(b);
    });    
    for (int i = 1; i < nums.size(); ++i)
      if (nums[i] == -nums[i - 1]) return nums[i];
    return -1;
  }
};

Solution 3: Two Pointers

Sort the array.

Let sum = nums[i] + nums[j], sum == 0, we find one pair, if sum < 0, ++i else –j.

Time complexity: O(nlogn)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int findMaxK(vector<int>& nums) {
    sort(begin(nums), end(nums));
    int ans = -1;
    for (int i = 0, j = nums.size() - 1; i < j; ) {
      const int s = nums[i] + nums[j];
      if (s == 0) {
        ans = max(ans, nums[j]);
        ++i, --j;      
      } else if (s < 0) {
        ++i;
      } else {
        --j;
      }      
    }
    return ans;
  }
};

Each letter in the alphabet is numbered from 0 to 25 (i.e. 'a' -> 0, 'b' -> 1, 'c' -> 2, … , 'z' -> 25).

In a well-spaced string, the number of letters between the two occurrences of the ith letter is distance[i]. If the ith letter does not appear in s, then distance[i] can be ignored.

Return true if s is a well-spaced string, otherwise return false.

Example 1:

Input: s = "abaccb", distance = [1,3,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
Output: true
Explanation:
- 'a' appears at indices 0 and 2 so it satisfies distance[0] = 1.
- 'b' appears at indices 1 and 5 so it satisfies distance[1] = 3.
- 'c' appears at indices 3 and 4 so it satisfies distance[2] = 0.
Note that distance[3] = 5, but since 'd' does not appear in s, it can be ignored.
Return true because s is a well-spaced string.

Example 2:

Input: s = "aa", distance = [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
Output: false
Explanation:
- 'a' appears at indices 0 and 1 so there are zero letters between them.
Because distance[0] = 1, s is not a well-spaced string.

Constraints:

• 2 <= s.length <= 52
• s consists only of lowercase English letters.
• Each letter appears in s exactly twice.
• distance.length == 26
• 0 <= distance[i] <= 50

Solution: Hashtable

Use a hastable to store the index of first occurrence of each letter.

Time complexity: O(n)
Space complexity: O(26)

// Author: Huahua
class Solution {
public:
  bool checkDistances(string s, vector<int>& distance) {
    vector<int> m(26, -1);
    for (int i = 0; i < s.length(); ++i) {
      int c = s[i] - 'a';
      if (m[c] >= 0 && i - m[c] - 1 != distance[c]) return false;
      m[c] = i;
    }
    return true;
  }
};

If there is a tie, return the smallest one. If there is no such element, return -1.

Example 1:

Input: nums = [0,1,2,2,4,4,1]
Output: 2
Explanation:
The even elements are 0, 2, and 4. Of these, 2 and 4 appear the most.
We return the smallest one, which is 2.

Example 2:

Input: nums = [4,4,4,9,2,4]
Output: 4
Explanation: 4 is the even element appears the most.

Example 3:

Input: nums = [29,47,21,41,13,37,25,7]
Output: -1
Explanation: There is no even element.

Constraints:

• 1 <= nums.length <= 2000
• 0 <= nums[i] <= 105

Solution: Hashtable

Use a hashtable to store the frequency of even numbers.

Time complexity: O(n)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int mostFrequentEven(vector<int>& nums) {
    unordered_map<int, int> m;
    int ans = -1;
    int best = 0;
    for (int x : nums) {
      if (x & 1) continue;
      int cur = ++m[x];
      if (cur > best) {
        best = cur;
        ans = x;
      } else if (cur == best && x < ans) {
        ans = x;
      }
    }
    return ans;
  }
};

Return the minimum number of consecutive cards you have to pick up to have a pair of matching cards among the picked cards. If it is impossible to have matching cards, return -1.

Example 1:

Input: cards = [3,4,2,3,4,7]
Output: 4
Explanation: We can pick up the cards [3,4,2,3] which contain a matching pair of cards with value 3. Note that picking up the cards [4,2,3,4] is also optimal.

Example 2:

Input: cards = [1,0,5,3]
Output: -1
Explanation: There is no way to pick up a set of consecutive cards that contain a pair of matching cards.

Constraints:

• 1 <= cards.length <= 105
• 0 <= cards[i] <= 106

Solution: Hashtable

Record the last position of each number,
ans = min{card_i – last[card_i]}

Time complexity: O(n)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int minimumCardPickup(vector<int>& cards) {
    const int n = cards.size();
    unordered_map<int, int> m;
    int ans = INT_MAX;
    for (int i = 0; i < n; ++i) {
      if (m.count(cards[i]))
        ans = min(ans, i - m[cards[i]] + 1);
      m[cards[i]] = i;
    }
    return ans == INT_MAX ? -1 : ans;
  }
};

Example 1:

Input: nums = [[3,1,2,4,5],[1,2,3,4],[3,4,5,6]]
Output: [3,4]
Explanation: 
The only integers present in each of nums[0] = [3,1,2,4,5], nums[1] = [1,2,3,4], and nums[2] = [3,4,5,6] are 3 and 4, so we return [3,4].

Example 2:

Input: nums = [[1,2,3],[4,5,6]]
Output: []
Explanation: 
There does not exist any integer present both in nums[0] and nums[1], so we return an empty list [].

Constraints:

• 1 <= nums.length <= 1000
• 1 <= sum(nums[i].length) <= 1000
• 1 <= nums[i][j] <= 1000
• All the values of nums[i] are unique.

Solution: Hashtable

Time complexity: O(n)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  vector<int> intersection(vector<vector<int>>& nums) {
    vector<int> m(1001);
    for (const auto& arr : nums)
      for (const int x : arr)
        ++m[x];
    vector<int> ans;
    for (int i = 0; i < m.size(); ++i)
      if (m[i] == nums.size())
        ans.push_back(i);
    return ans;
  }
};

Return a list answer of size 2 where:

• answer[0] is a list of all players that have not lost any matches.
• answer[1] is a list of all players that have lost exactly one match.

The values in the two lists should be returned in increasing order.

Note:

• You should only consider the players that have played at least one match.
• The testcases will be generated such that no two matches will have the same outcome.

Example 1:

Input: matches = [[1,3],[2,3],[3,6],[5,6],[5,7],[4,5],[4,8],[4,9],[10,4],[10,9]]
Output: [[1,2,10],[4,5,7,8]]
Explanation:
Players 1, 2, and 10 have not lost any matches.
Players 4, 5, 7, and 8 each have lost one match.
Players 3, 6, and 9 each have lost two matches.
Thus, answer[0] = [1,2,10] and answer[1] = [4,5,7,8].

Example 2:

Input: matches = [[2,3],[1,3],[5,4],[6,4]]
Output: [[1,2,5,6],[]]
Explanation:
Players 1, 2, 5, and 6 have not lost any matches.
Players 3 and 4 each have lost two matches.
Thus, answer[0] = [1,2,5,6] and answer[1] = [].

Constraints:

• 1 <= matches.length <= 105
• matches[i].length == 2
• 1 <= winneri, loseri <= 105
• winneri != loseri
• All matches[i] are unique.

Solution: Hashtable

Use a hashtable to store the number of matches each player has lost. Note, also create an entry for those winners who never lose.

Time complexity: O(m), m = # of matches
Space complexity: O(n), n = # of players

// Author: Huahua
class Solution {
public:
  vector<vector<int>> findWinners(vector<vector<int>>& matches) {
    unordered_map<int, int> m;
    for (const auto& match : matches) {
      m[match[0]]; // create an entry for the winner.
      ++m[match[1]];      
    }
    vector<vector<int>> ans(2);
    for (const auto& [player, loses] : m)
      if (loses <= 1) ans[loses].push_back(player);      
    sort(begin(ans[0]), end(ans[0]));
    sort(begin(ans[1]), end(ans[1]));
    return ans;
  }  
};

• answer[0] is a list of all distinct integers in nums1 which are not present in nums2.
• answer[1] is a list of all distinct integers in nums2 which are not present in nums1.

Note that the integers in the lists may be returned in any order.

Example 1:

Input: nums1 = [1,2,3], nums2 = [2,4,6]
Output: [[1,3],[4,6]]
Explanation:
For nums1, nums1[1] = 2 is present at index 0 of nums2, whereas nums1[0] = 1 and nums1[2] = 3 are not present in nums2. Therefore, answer[0] = [1,3].
For nums2, nums2[0] = 2 is present at index 1 of nums1, whereas nums2[1] = 4 and nums2[2] = 6 are not present in nums2. Therefore, answer[1] = [4,6].

Example 2:

Input: nums1 = [1,2,3,3], nums2 = [1,1,2,2]
Output: [[3],[]]
Explanation:
For nums1, nums1[2] and nums1[3] are not present in nums2. Since nums1[2] == nums1[3], their value is only included once and answer[0] = [3].
Every integer in nums2 is present in nums1. Therefore, answer[1] = [].

Constraints:

• 1 <= nums1.length, nums2.length <= 1000
• -1000 <= nums1[i], nums2[i] <= 1000

Solution: Hashtable

Use two hashtables to store the unique numbers of array1 and array2 respectfully.

Time complexity: O(m+n)
Space complexity: O(m+n)

// Author: Huahua
class Solution {
public:
  vector<vector<int>> findDifference(vector<int>& nums1, vector<int>& nums2) {
    vector<vector<int>> ans(2);
    unordered_set<int> s1(begin(nums1), end(nums1));
    unordered_set<int> s2(begin(nums2), end(nums2));
    for (int x : s1)
      if (!s2.count(x)) ans[0].push_back(x);
    for (int x : s2)
      if (!s1.count(x)) ans[1].push_back(x);
    return ans;
  }
};

You need to divide nums into n pairs such that:

• Each element belongs to exactly one pair.
• The elements present in a pair are equal.

Return true if nums can be divided into n pairs, otherwise return false.

Example 1:

Input: nums = [3,2,3,2,2,2]
Output: true
Explanation: 
There are 6 elements in nums, so they should be divided into 6 / 2 = 3 pairs.
If nums is divided into the pairs (2, 2), (3, 3), and (2, 2), it will satisfy all the conditions.

Example 2:

Input: nums = [1,2,3,4]
Output: false
Explanation: 
There is no way to divide nums into 4 / 2 = 2 pairs such that the pairs satisfy every condition.

Constraints:

• nums.length == 2 * n
• 1 <= n <= 500
• 1 <= nums[i] <= 500

Solution: Hashtable

Each number has to appear even numbers in order to be paired. Count the frequency of each number, return true if all of them are even numbers, return false otherwise.

Time complexity: O(n)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  bool divideArray(vector<int>& nums) {
    unordered_map<int, int> m;
    for (int num : nums)
      ++m[num];
    return all_of(begin(m), end(m), [](const auto& e) { return e.second % 2 == 0; });    
  }
};

For every unique integer target in nums, count the number of times target immediately follows an occurrence of key in nums. In other words, count the number of indices i such that:

• 0 <= i <= nums.length - 2,
• nums[i] == key and,
• nums[i + 1] == target.

Return the target with the maximum count. The test cases will be generated such that the target with maximum count is unique.

Example 1:

Input: nums = [1,100,200,1,100], key = 1
Output: 100
Explanation: For target = 100, there are 2 occurrences at indices 1 and 4 which follow an occurrence of key.
No other integers follow an occurrence of key, so we return 100.

Example 2:

Input: nums = [2,2,2,2,3], key = 2
Output: 2
Explanation: For target = 2, there are 3 occurrences at indices 1, 2, and 3 which follow an occurrence of key.
For target = 3, there is only one occurrence at index 4 which follows an occurrence of key.
target = 2 has the maximum number of occurrences following an occurrence of key, so we return 2.

Constraints:

• 2 <= nums.length <= 1000
• 1 <= nums[i] <= 1000
• The test cases will be generated such that the answer is unique.

Solution: Hashtable

Time complexity: O(n)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int mostFrequent(vector<int>& nums, int key) {
    const int n = nums.size();
    unordered_map<int, int> m;
    int count = 0;
    int ans = 0;
    for (int i = 1; i < n; ++i) {
      if (nums[i - 1] == key && ++m[nums[i]] > count) {
        count = m[nums[i]];
        ans = nums[i];
      }
    }
    return ans;
  }
};