1817-查找用户活跃分钟数

Raphael Liu Lv10
  2023-09-13 00:47:26 2023-09-13 00:47:26 Created   2023-09-13 16:06:28 2023-09-13 16:06:28 Updated    

给你用户在 LeetCode 的操作日志，和一个整数 k 。日志用一个二维整数数组 logs 表示，其中每个 logs[i] = [IDi, timei] 表示 ID 为 IDi 的用户在 timei 分钟时执行了某个操作。

多个用户 可以同时执行操作，单个用户可以在同一分钟内执行 多个操作 。

指定用户的 用户活跃分钟数（user active minutes，UAM） 定义为用户对 LeetCode 执行操作的 唯一分钟数 。
即使一分钟内执行多个操作，也只能按一分钟计数。

请你统计用户活跃分钟数的分布情况，统计结果是一个长度为 k 且 下标从 1 开始计数 的数组 answer ，对于每个 j（1 <= j <= k），answer[j] 表示 用户活跃分钟数 等于 j 的用户数。

返回上面描述的答案数组 __answer __ 。

示例 1：

**输入：** logs = [[0,5],[1,2],[0,2],[0,5],[1,3]], k = 5
**输出：** [0,2,0,0,0]
**解释：**
ID=0 的用户执行操作的分钟分别是：5 、2 和 5 。因此，该用户的用户活跃分钟数为 2（分钟 5 只计数一次）
ID=1 的用户执行操作的分钟分别是：2 和 3 。因此，该用户的用户活跃分钟数为 2
2 个用户的用户活跃分钟数都是 2 ，answer[2] 为 2 ，其余 answer[j] 的值都是 0

示例 2：

**输入：** logs = [[1,1],[2,2],[2,3]], k = 4
**输出：** [1,1,0,0]
**解释：**
ID=1 的用户仅在分钟 1 执行单个操作。因此，该用户的用户活跃分钟数为 1
ID=2 的用户执行操作的分钟分别是：2 和 3 。因此，该用户的用户活跃分钟数为 2
1 个用户的用户活跃分钟数是 1 ，1 个用户的用户活跃分钟数是 2 
因此，answer[1] = 1 ，answer[2] = 1 ，其余的值都是 0

提示：

  • 1 <= logs.length <= 104
  • 0 <= IDi <= 109
  • 1 <= timei <= 105
  • k 的取值范围是 [用户的最大用户活跃分钟数, 105]

方法一：哈希表

这道题要求对于 1 \le j \le k 的每个 j 计算用户活跃分钟数等于 j 的用户数。需要首先得到每个用户的用户活跃分钟数，然后计算用户活跃分钟数等于特定值的用户数。

由于同一个用户的每次执行操作的时间不重复计算，因此需要使用哈希表记录每个用户的执行操作的时间，哈希表的关键字是用户编号，哈希表的值是存储执行操作的分钟的哈希集合，使用哈希集合可以确保同一个用户执行操作的同一分钟只会计算一次，不会重复计算。

首先遍历操作日志数组 logs 得到每个用户对应的执行操作的时间并存入哈希表，然后遍历哈希表并更新答案数组。由于这道题只需要知道用户活跃分钟数等于特定值的用户数，不需要知道具体的用户编号，因此只需要遍历哈希表中每条记录的值即可。哈希表中的每条记录的值都是一个哈希集合，哈希集合的元素个数等于当前用户的用户活跃分钟数，将答案数组中的对应元素值加 1。遍历哈希表中每条记录的值之后，即可得到答案数组。

由于答案数组的下标从 1 开始，因此在更新答案数组时需要注意将下标做转换。

[sol1-Python3]
1
2
3
4
5
6
7
8
9
class Solution:
    def findingUsersActiveMinutes(self, logs: List[List[int]], k: int) -> List[int]:
        mp = defaultdict(set)
        for i, t in logs:
            mp[i].add(t)
        ans = [0] * k
        for s in mp.values():
            ans[len(s) - 1] += 1
        return ans
[sol1-Java]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Solution {
    public int[] findingUsersActiveMinutes(int[][] logs, int k) {
        Map<Integer, Set<Integer>> activeMinutes = new HashMap<Integer, Set<Integer>>();
        for (int[] log : logs) {
            int id = log[0], time = log[1];
            activeMinutes.putIfAbsent(id, new HashSet<Integer>());
            activeMinutes.get(id).add(time);
        }
        int[] answer = new int[k];
        for (Set<Integer> minutes : activeMinutes.values()) {
            int activeCount = minutes.size();
            answer[activeCount - 1]++;
        }
        return answer;
    }
}
[sol1-C#]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Solution {
    public int[] FindingUsersActiveMinutes(int[][] logs, int k) {
        IDictionary<int, ISet<int>> activeMinutes = new Dictionary<int, ISet<int>>();
        foreach (int[] log in logs) {
            int id = log[0], time = log[1];
            activeMinutes.TryAdd(id, new HashSet<int>());
            activeMinutes[id].Add(time);
        }
        int[] answer = new int[k];
        foreach (ISet<int> minutes in activeMinutes.Values) {
            int activeCount = minutes.Count;
            answer[activeCount - 1]++;
        }
        return answer;
    }
}
[sol1-JavaScript]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
var findingUsersActiveMinutes = function(logs, k) {
    const activeMinutes = new Map();
    for (const [id, time] of logs) {
        if (!activeMinutes.has(id)) {
            activeMinutes.set(id, new Set());
        }
        activeMinutes.get(id).add(time);
    }
    const answer = new Array(k).fill(0);
    for (const minutes of activeMinutes.values()) {
        const activeCount = minutes.size;
        answer[activeCount - 1]++;
    }
    return answer;
};
[sol1-Golang]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
func findingUsersActiveMinutes(logs [][]int, k int) []int {
    mp := map[int]map[int]bool{}
    for _, p := range logs {
        id, t := p[0], p[1]
        if mp[id] == nil {
            mp[id] = map[int]bool{}
        }
        mp[id][t] = true
    }
    ans := make([]int, k+1)
    for _, m := range mp {
        ans[len(m)]++
    }
    return ans[1:]
}
[sol1-C++]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Solution {
public:
    vector<int> findingUsersActiveMinutes(vector<vector<int>>& logs, int k) {
        unordered_map<int, unordered_set<int>> activeMinutes;
        for (auto &&log : logs) {
            int id = log[0], time = log[1];
            activeMinutes[id].emplace(time);
        }
        vector<int> answer(k);
        for (auto &&[_, minutes] : activeMinutes) {
            int activeCount = minutes.size();
            answer[activeCount - 1]++;
        }
        return answer;
    }
};
[sol1-C]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
typedef struct {
    int key;
    UT_hash_handle hh;
} HashSetItem; 

typedef struct {
    int key;
    HashSetItem *val;
    UT_hash_handle hh;
} HashMapItem; 

void hashSetFree(HashSetItem **obj) {
    HashSetItem *curr = NULL, *tmp = NULL;
    HASH_ITER(hh, *obj, curr, tmp) {
        HASH_DEL(*obj, curr);  
        free(curr);             
    }
}

void hashMapFree(HashMapItem **obj) {
    HashMapItem *curr = NULL, *tmp = NULL;
    HASH_ITER(hh, *obj, curr, tmp) {
        HASH_DEL(*obj, curr);
        hashSetFree(&curr->val);  
        free(curr);             
    }
}

int* findingUsersActiveMinutes(int** logs, int logsSize, int* logsColSize, int k, int* returnSize) {
    HashMapItem *activeMinutes = NULL;
    for (int i = 0; i < logsSize; i++) {
        int id = logs[i][0], time = logs[i][1];
        HashMapItem *pMapEntry = NULL;
        HASH_FIND_INT(activeMinutes, &id, pMapEntry);
        if (NULL == pMapEntry) {
            pMapEntry = (HashMapItem *)malloc(sizeof(HashMapItem));
            pMapEntry->key = id;
            pMapEntry->val = NULL;
            HASH_ADD_INT(activeMinutes, key, pMapEntry);
        }
        HashSetItem *pSetEntry = NULL;
        HASH_FIND_INT(pMapEntry->val, &time, pSetEntry);
        if (NULL == pSetEntry) {
            pSetEntry = (HashSetItem *)malloc(sizeof(HashSetItem));
            pSetEntry->key = time;
            HASH_ADD_INT(pMapEntry->val, key, pSetEntry);
        }
    }
    int *answer = (int *)malloc(sizeof(int) * k);
    memset(answer, 0, sizeof(int) * k);
    for (HashMapItem *pEntry = activeMinutes; pEntry != NULL; pEntry = pEntry->hh.next) {
        int activeCount = HASH_COUNT(pEntry->val);
        answer[activeCount - 1]++;
    }
    *returnSize = k;
    hashMapFree(&activeMinutes);
    return answer;
}

复杂度分析

  • 时间复杂度：O(n + k)，其中 n 是数组 logs 的长度，k 是给定的整数。遍历数组 logs 并使用哈希表记录每个用户的活跃分钟需要 O(n) 的时间，创建答案数组和遍历哈希表更新答案数组需要 O(n + k) 的时间，因此时间复杂度是 O(n + k)。

  • 空间复杂度：O(n)，其中 n 是数组 logs 的长度。哈希表需要 O(n) 的空间。注意返回值不计入空间复杂度。

 Comments
On this page
1817-查找用户活跃分钟数