Question

2456. Most Popular Video Creator

中文文档

Description

You are given two string arrays creators and ids, and an integer array views, all of length n. The ith video on a platform was created by creator[i], has an id of ids[i], and has views[i] views.

The popularity of a creator is the sum of the number of views on all of the creator's videos. Find the creator with the highest popularity and the id of their most viewed video.

• If multiple creators have the highest popularity, find all of them.
• If multiple videos have the highest view count for a creator, find the lexicographically smallest id.

Return_ a 2D array of strings _answer_ where _answer[i] = [creatori, idi]_ means that _creatori _has the highest popularity and _idi_ is the id of their most popular video._ The answer can be returned in any order.

 

Example 1:

Input: creators = ["alice","bob","alice","chris"], ids = ["one","two","three","four"], views = [5,10,5,4]
Output: [["alice","one"],["bob","two"]]
Explanation:
The popularity of alice is 5 + 5 = 10.
The popularity of bob is 10.
The popularity of chris is 4.
alice and bob are the most popular creators.
For bob, the video with the highest view count is "two".
For alice, the videos with the highest view count are "one" and "three". Since "one" is lexicographically smaller than "three", it is included in the answer.

Example 2:

Input: creators = ["alice","alice","alice"], ids = ["a","b","c"], views = [1,2,2]
Output: [["alice","b"]]
Explanation:
The videos with id "b" and "c" have the highest view count.
Since "b" is lexicographically smaller than "c", it is included in the answer.

 

Constraints:

• n == creators.length == ids.length == views.length
• 1 <= n <= 105
• 1 <= creators[i].length, ids[i].length <= 5
• creators[i] and ids[i] consist only of lowercase English letters.
• 0 <= views[i] <= 105

Solutions

Solution 1: Hash Table

We traverse the three arrays, use a hash table $cnt$ to count the total play count for each creator, and use a hash table $d$ to record the index of the video with the highest play count for each creator.

Then, we traverse the hash table $cnt$ to find the maximum play count $mx$; then we traverse the hash table $cnt$ again to find the creators with a play count of $mx$, and add them to the answer array.

The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is the number of videos.

class Solution:
  def mostPopularCreator(
    self, creators: List[str], ids: List[str], views: List[int]
  ) -> List[List[str]]:
    cnt = defaultdict(int)
    d = defaultdict(int)
    for k, (c, i, v) in enumerate(zip(creators, ids, views)):
      cnt[c] += v
      if c not in d or views[d[c]] < v or (views[d[c]] == v and ids[d[c]] > i):
        d[c] = k
    mx = max(cnt.values())
    return [[c, ids[d[c]]] for c, x in cnt.items() if x == mx]

class Solution {
  public List<List<String>> mostPopularCreator(String[] creators, String[] ids, int[] views) {
    int n = ids.length;
    Map<String, Long> cnt = new HashMap<>(n);
    Map<String, Integer> d = new HashMap<>(n);
    for (int k = 0; k < n; ++k) {
      String c = creators[k], i = ids[k];
      long v = views[k];
      cnt.merge(c, v, Long::sum);
      if (!d.containsKey(c) || views[d.get(c)] < v
        || (views[d.get(c)] == v && ids[d.get(c)].compareTo(i) > 0)) {
        d.put(c, k);
      }
    }
    long mx = 0;
    for (long x : cnt.values()) {
      mx = Math.max(mx, x);
    }
    List<List<String>> ans = new ArrayList<>();
    for (var e : cnt.entrySet()) {
      if (e.getValue() == mx) {
        String c = e.getKey();
        ans.add(List.of(c, ids[d.get(c)]));
      }
    }
    return ans;
  }
}

class Solution {
public:
  vector<vector<string>> mostPopularCreator(vector<string>& creators, vector<string>& ids, vector<int>& views) {
    unordered_map<string, long long> cnt;
    unordered_map<string, int> d;
    int n = ids.size();
    for (int k = 0; k < n; ++k) {
      auto c = creators[k], id = ids[k];
      int v = views[k];
      cnt[c] += v;
      if (!d.count(c) || views[d[c]] < v || (views[d[c]] == v && ids[d[c]] > id)) {
        d[c] = k;
      }
    }
    long long mx = 0;
    for (auto& [_, x] : cnt) {
      mx = max(mx, x);
    }
    vector<vector<string>> ans;
    for (auto& [c, x] : cnt) {
      if (x == mx) {
        ans.push_back({c, ids[d[c]]});
      }
    }
    return ans;
  }
};

func mostPopularCreator(creators []string, ids []string, views []int) (ans [][]string) {
  cnt := map[string]int{}
  d := map[string]int{}
  for k, c := range creators {
    i, v := ids[k], views[k]
    cnt[c] += v
    if j, ok := d[c]; !ok || views[j] < v || (views[j] == v && ids[j] > i) {
      d[c] = k
    }
  }
  mx := 0
  for _, x := range cnt {
    if mx < x {
      mx = x
    }
  }
  for c, x := range cnt {
    if x == mx {
      ans = append(ans, []string{c, ids[d[c]]})
    }
  }
  return
}

function mostPopularCreator(creators: string[], ids: string[], views: number[]): string[][] {
  const cnt: Map<string, number> = new Map();
  const d: Map<string, number> = new Map();
  const n = ids.length;
  for (let k = 0; k < n; ++k) {
    const [c, i, v] = [creators[k], ids[k], views[k]];
    cnt.set(c, (cnt.get(c) ?? 0) + v);
    if (!d.has(c) || views[d.get(c)!] < v || (views[d.get(c)!] === v && ids[d.get(c)!] > i)) {
      d.set(c, k);
    }
  }
  const mx = Math.max(...cnt.values());
  const ans: string[][] = [];
  for (const [c, x] of cnt) {
    if (x === mx) {
      ans.push([c, ids[d.get(c)!]]);
    }
  }
  return ans;
}