2025-08-04：统计用户被提及情况。用go语言，你有一个整数 numberOfUsers，表示用户总数量，还有一个大小为

2025-08-04：统计用户被提及情况。用go语言，你有一个整数 numberOfUsers，表示用户总数量，还有一个大小为 n x 3 的二维数组 events。

每个 events[i] 代表两种事件之一：

1. 1.消息事件（MESSAGE）：格式为 ["MESSAGE", "timestamp", "mentions_string"]

• • 表示在 timestamp 时间点，有一条消息提到了若干用户。

• • mentions_string 可能是以下形式之一：

• • • 多个用户 ID，用空格分隔，如 id ，其中 是 0 到 numberOfUsers - 1 的整数，且可能有重复，也可以包含离线用户。

  • • "ALL"：代表提及所有用户。

  • • "HERE"：代表提及所有当前在线的用户。

2.离线事件（OFFLINE）：格式为 ["OFFLINE", "timestamp", "id"]

• • 表示用户 id 在 timestamp 时间点进入离线状态，持续 60 单位时间，之后（timestamp + 60）会自动恢复在线。

初始状态下所有用户都是在线的。如果多个事件时间相同，状态变化（离线或恢复）会先于消息事件处理并生效。

最终你需要返回一个长度为 numberOfUsers 的数组 mentions，其中 mentions[i] 是用户 i 在所有消息事件中被提及的总次数。

特别注意，单条消息中同一个用户被多次提及，需要累计每次提及的次数。

1 <= numberOfUsers <= 100。

1 <= events.length <= 100。

events[i].length == 3。

events[i][0] 的值为 MESSAGE 或 OFFLINE 。

1 <= int(events[i][1]) <= 100000。

在任意 "MESSAGE" 事件中，以 id 形式提及的用户数目介于 1 和 100 之间。

0 <= <= numberOfUsers - 1。

题目保证 OFFLINE 引用的用户 id 在事件发生时处于 在线 状态。

输入：numberOfUsers = 2, events = [["MESSAGE","10","id1 id0"],["OFFLINE","11","0"],["MESSAGE","71","HERE"]]。

输出：[2,2]。

解释：

最初，所有用户都在线。

时间戳 10 ，id1 和 id0 被提及，mentions = [1,1]。

时间戳 11 ，id0 离线 。

时间戳 71 ，id0 再次 上线 并且 "HERE" 被提及，mentions = [2,2]。

题目来自力扣3433。

分步骤描述过程

1. 1.事件排序：

• • 首先，对所有事件按照时间戳（events[i][1]）进行升序排序（从小到大）。

• • 如果两个事件的时间戳相同，则优先处理离线事件（OFFLINE），再处理消息事件（MESSAGE）。这是因为题目要求状态变化（如离线）先于消息事件生效。排序规则确保在相同时间戳下，OFFLINE事件排在MESSAGE事件之前。

2.初始化数据结构：

• • 创建一个长度numberOfUsers的结果数组ans，初始化为全 0，用于存储每个用户被提及的总次数。

• • 创建一个长度numberOfUsers的数组onlineT，初始化为全 0。onlineT[i]表示用户i下一次恢复在线的时间戳。初始值为 0 表示所有用户在线（因为时间戳从 1 开始，任何时间点t ≥ 1 > 0都满足在线条件）。

3.遍历处理事件：

• • 按排序后的事件顺序依次处理每个事件。

• • 提取当前事件的时间戳curT（将events[i][1]转换为整数）。

• • 根据事件类型执行不同操作：

• • •OFFLINE 事件：

  • • • 格式：["OFFLINE", timestamp, id]，其中id是直接的数字字符串（如"0"）。

    • • 将id转换为整数i（表示用户索引）。

    • • 设置onlineT[i] = curT + 60，表示用户i将在curT + 60时间点恢复在线。

  • •MESSAGE 事件：

  • • • 格式：["MESSAGE", timestamp, mentions_string]。

    • • 根据mentions_string的内容处理提及：

    • • •"ALL"：表示提及所有用户。

      • • • 遍历所有用户索引i（0 到numberOfUsers - 1），将ans[i]加 1。

      • •"HERE"：表示提及所有当前在线用户。

      • • • 遍历所有用户索引i，检查onlineT[i] <= curT（如果为真，表示用户在线）。

        • • 对在线的用户，将ans[i]加 1。

      • •用户 ID 列表：格式为空格分隔的"id " 字符串（如"id1 id0"）。

      • • • 使用空格分割mentions_string得到多个子串（如["id1", "id0"]）。

        • • 对每个子串：

        • • • 提取数字部分（去除前缀"id"，即取子串s[2:]）。

          • • 将数字字符串转换为整数i（表示用户索引）。

          • • 将ans[i]加 1。

        • • 注意：同一用户可能在单条消息中被多次提及（如"id0 id0"），每次提及都会独立计数。

4.在线状态管理：

• • 通过onlineT数组隐式管理用户在线状态：

• • • 用户i在时间t在线当且仅当onlineT[i] <= t。

  • • 离线事件（OFFLINE）设置onlineT[i] = curT + 60，表示从curT到curT + 60 - 1用户离线，在curT + 60及之后自动恢复在线。

• • 在消息事件中（尤其是"HERE"）直接使用curT与onlineT[i]比较判断在线状态，无需显式处理恢复事件。

5.处理重复提及和边界：

• • 单条消息中同一用户多次提及会被多次计数（如"id0 id0"会使ans[0]增加 2）。

• • 题目保证OFFLINE事件发生时用户在线，因此设置onlineT[i]是安全的。

• • 时间戳相同时，排序确保OFFLINE先执行，状态更新后MESSAGE才使用新状态。

• •时间复杂度：

• • • 排序事件：使用快速排序（slices.SortFunc），时间复杂度为O(n log n)，其中n是事件数量（events.length ≤ 100）。

  • • 处理事件：遍历n个事件。

  • • •OFFLINE事件：处理时间为 O(1)。

    • •MESSAGE事件：

    • • •"ALL"或"HERE"：遍历m个用户（m = numberOfUsers ≤ 100），时间为 O(m)。

      • • 用户 ID 列表：处理时间 O(k)，其中k是提及的用户数量（k ≤ 100）。

    • • 最坏情况下，所有事件都是"ALL"或"HERE"，总时间为O(n * m)。

  • • 整体时间复杂度：O(n log n + n * m)。由于n ≤ 100，m ≤ 100，实际可视为常数时间（约 100 × log₂100 + 100 × 100 ≈ 700 + 10000 = 10700 操作）。

• •空间复杂度：

• • • 存储结果数组ans和在线时间数组onlineT：各占用 O(m) 空间。

  • • 排序使用原地排序，栈空间 O(log n)。

  • • 处理用户 ID 列表时临时分割字符串：占用 O(k) 临时空间（k ≤ 100）。

  • • 总体额外空间复杂度：O(m)（m = numberOfUsers ≤ 100），即线性于用户数量。

package main import (     "fmt"     "strconv"     "strings"     "cmp"     "slices" ) func countMentions(numberOfUsers int, events [][]string) []int {     // 按照时间戳从小到大排序，时间戳相同的，离线事件排在前面     slices.SortFunc(events, func(a, b []string)int {         ta, _ := strconv.Atoi(a[1])         tb, _ := strconv.Atoi(b[1])         return cmp.Or(ta-tb, int(b[0][0])-int(a[0][0]))     })     ans := make([]int, numberOfUsers)     onlineT := make([]int, numberOfUsers)     for _, e := range events {         curT, _ := strconv.Atoi(e[1])         if e[0][0] == 'O' {             i, _ := strconv.Atoi(e[2])             onlineT[i] = curT + 60         } elseif e[2][0] == 'A' {             for i := range ans {                 ans[i]++             }         } elseif e[2][0] == 'H' {             for i, t := range onlineT {                 if t <= curT { // 在线                     ans[i]++                 }             }         } else {             for _, s := range strings.Split(e[2], " ") {                 i, _ := strconv.Atoi(s[2:])                 ans[i]++             }         }     }     return ans } func main() {     numberOfUsers := 2     events := [][]string{{"MESSAGE","10","id1 id0"},{"OFFLINE","11","0"},{"MESSAGE","71","HERE"}}     result := countMentions(numberOfUsers,events)     fmt.Println(result) }

Python完整代码如下：

# -*-coding:utf-8-*- def count_mentions(numberOfUsers, events):     # 排序事件：首先按时间戳升序，时间戳相同时，按事件类型首字母的ASCII值降序（即离线事件在前）     events.sort(key=lambda e: (int(e[1]), -ord(e[0][0])))          ans = [0] * numberOfUsers     onlineT = [0] * numberOfUsers  # 记录每个用户被视为在线的截止时间戳          for e in events:         curT = int(e[1])         if e[0] == "OFFLINE":             user_id = int(e[2])             onlineT[user_id] = curT + 60         elif e[0] == "MESSAGE":             content = e[2]             if content.startswith('A'):  # 全体消息                 for i in range(numberOfUsers):                     ans[i] += 1             elif content.startswith('H'):  # 在线消息                 for i in range(numberOfUsers):                     # 注意：这里条件与Go代码一致（onlineT[i] <= curT 表示用户在线）                     if onlineT[i] <= curT:                         ans[i] += 1             else:  # 定向消息                 parts = content.split()                 for part in parts:                     # 提取"idX"中的X并转换为整数                     user_id = int(part[2:])                     ans[user_id] += 1     return ans def main():     numberOfUsers = 2     events = [["MESSAGE","10","id1 id0"],["OFFLINE","11","0"],["MESSAGE","71","HERE"]]     result = count_mentions(numberOfUsers, events)     print(result) if __name__ == "__main__":     main()

我们相信Go语言和算法为普通开发者提供了困境的“面试利器”，并致力于分享全面的编程知识。在这里，您可以找到最新的Go语言教程、算法解析、提升面试竞争力的秘籍以及行业动态。 欢迎关注“福大规模架构师每日一题”，让 Go 语言和算法助力您的职业发展