g2401_2500.s2456_most_popular_video_creator.Solution Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of leetcode-in-java21 Show documentation
Java-based LeetCode algorithm problem solutions, regularly updated
There is a newer version: 1.38
package g2401_2500.s2456_most_popular_video_creator;

// #Medium #Array #String #Hash_Table #Sorting #Heap_Priority_Queue
// #2022_12_16_Time_57_ms_(97.10%)_Space_85.2_MB_(99.42%)

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 2456 - Most Popular Video Creator\.
 *
 * Medium
 *
 * You are given two string arrays `creators` and `ids`, and an integer array `views`, all of length `n`. The i^th 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] = [creator_i, id_i] _means that_ creator_i _has the **highest** popularity and_ id_i _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 <= 10⁵
 * *   `1 <= creators[i].length, ids[i].length <= 5`
 * *   `creators[i]` and `ids[i]` consist only of lowercase English letters.
 * *   0 <= views[i] <= 10⁵
**/
public class Solution {
    public List> mostPopularCreator(String[] creators, String[] ids, int[] views) {
        HashMap totalViews = new HashMap<>();
        HashMap maxView = new HashMap<>();
        long globalMaxView = 0;
        for (int i = 0; i < creators.length; i++) {
            long currentView = totalViews.getOrDefault(creators[i], 0L) + views[i];
            globalMaxView = Math.max(currentView, globalMaxView);
            totalViews.put(creators[i], currentView);
            int lastIndex = maxView.getOrDefault(creators[i], -1);
            if (!maxView.containsKey(creators[i])
                    || views[lastIndex] < views[i]
                    || (views[lastIndex] == views[i] && ids[lastIndex].compareTo(ids[i]) > 0)) {
                maxView.put(creators[i], i);
            }
        }
        List> res = new ArrayList<>();
        for (Map.Entry entry : totalViews.entrySet()) {
            if (entry.getValue() == globalMaxView) {
                res.add(Arrays.asList(entry.getKey(), ids[maxView.get(entry.getKey())]));
            }
        }
        return res;
    }
}