2456. Most Popular Video Creator

Problem

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

Solution (Java)

class Solution {
    public class Pair implements Comparable<Pair>{
        int view;
        String id;

        Pair(int view, String id){
            this.view = view;
            this.id = id;
        }

        public int compareTo(Pair o){
            if(this.view != o.view){ //if views are different, then sort Decreasingly
                return o.view - this.view; 
            }else{
                return this.id.compareTo(o.id); //if views are same, then sort lexicographically
            }
        }
    }

    public List<List<String>> mostPopularCreator(String[] creators, String[] ids, int[] views) {
        HashMap<String, Integer> map1 = new HashMap<>(); //creators VS total views
        for(int i = 0; i < creators.length; ++i){ //O(N)
            String c = creators[i];
            map1.put(c, map1.getOrDefault(c, 0) + views[i]);
        }


        HashMap<String, ArrayList<Pair>> map2 = new HashMap<>(); //creators VS (His/Her all videos id's list with there views)
        for(int i = 0; i < creators.length; ++i){ //O(N)
            String c = creators[i];
            if(map2.containsKey(c) == false){
                map2.put(c, new ArrayList<>());
            }
            map2.get(c).add(new Pair(views[i], ids[i])); //store video with id, and with there respective views
        }

        List<List<String>> res = new ArrayList<>();

        int max = 0;
        for(String key : map1.keySet()){ //finding the maximum views of the creator
            max = Math.max(max, map1.get(key));
        }

        for(String key : map1.keySet()){
            if(map1.get(key) == max){
                List<String> p = new ArrayList<>();
                p.add(key);
                Collections.sort(map2.get(key));
                p.add(map2.get(key).get(0).id);
                res.add(p);
            }
        }

        return res;
    }
}

Explain:

nope.

Complexity:

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