「这是我参与11月更文挑战的第17天，活动详情查看：2021最后一次更文挑战」
有一个 单线程 CPU 正在运行一个含有 n 道函数的程序。每道函数都有一个位于 0 和 n-1 之间的唯一标识符。
函数调用 存储在一个 调用栈 上 ：当一个函数调用开始时，它的标识符将会推入栈中。而当一个函数调用结束时，它的标识符将会从栈中弹出。标识符位于栈顶的函数是 当前正在执行的函数 。每当一个函数开始或者结束时，将会记录一条日志，包括函数标识符、是开始还是结束、以及相应的时间戳。
给你一个由日志组成的列表 logs ，其中 logs[i] 表示第 i 条日志消息，该消息是一个按 "{function_id}:{"start" | "end"}:{timestamp}" 进行格式化的字符串。例如，"0:start:3" 意味着标识符为 0 的函数调用在时间戳 3 的 起始开始执行 ；而 "1:end:2" 意味着标识符为 1 的函数调用在时间戳 2 的 末尾结束执行。注意，函数可以 调用多次，可能存在递归调用 。
函数的 独占时间 定义是在这个函数在程序所有函数调用中执行时间的总和，调用其他函数花费的时间不算该函数的独占时间。例如，如果一个函数被调用两次，一次调用执行 2 单位时间，另一次调用执行 1 单位时间，那么该函数的 独占时间 为 2 + 1 = 3 。
以数组形式返回每个函数的 独占时间 ，其中第 i 个下标对应的值表示标识符 i 的函数的独占时间。
示例 1：
输入：n = 2, logs = ["0:start:0","1:start:2","1:end:5","0:end:6"] 输出：[3,4] 解释： 函数 0 在时间戳 0 的起始开始执行，执行 2 个单位时间，于时间戳 1 的末尾结束执行。 函数 1 在时间戳 2 的起始开始执行，执行 4 个单位时间，于时间戳 5 的末尾结束执行。 函数 0 在时间戳 6 的开始恢复执行，执行 1 个单位时间。 所以函数 0 总共执行 2 + 1 = 3 个单位时间，函数 1 总共执行 4 个单位时间。
示例 2：
输入：n = 1, logs = ["0:start:0","0:start:2","0:end:5","0:start:6","0:end:6","0:end:7"] 输出：[8] 解释： 函数 0 在时间戳 0 的起始开始执行，执行 2 个单位时间，并递归调用它自身。 函数 0（递归调用）在时间戳 2 的起始开始执行，执行 4 个单位时间。 函数 0（初始调用）恢复执行，并立刻再次调用它自身。 函数 0（第二次递归调用）在时间戳 6 的起始开始执行，执行 1 个单位时间。 函数 0（初始调用）在时间戳 7 的起始恢复执行，执行 1 个单位时间。 所以函数 0 总共执行 2 + 4 + 1 + 1 = 8 个单位时间。
示例 3：
输入：n = 2, logs = ["0:start:0","0:start:2","0:end:5","1:start:6","1:end:6","0:end:7"] 输出：[7,1] 解释： 函数 0 在时间戳 0 的起始开始执行，执行 2 个单位时间，并递归调用它自身。 函数 0（递归调用）在时间戳 2 的起始开始执行，执行 4 个单位时间。 函数 0（初始调用）恢复执行，并立刻调用函数 1 。 函数 1在时间戳 6 的起始开始执行，执行 1 个单位时间，于时间戳 6 的末尾结束执行。 函数 0（初始调用）在时间戳 7 的起始恢复执行，执行 1 个单位时间，于时间戳 7 的末尾结束执行。 所以函数 0 总共执行 2 + 4 + 1 = 7 个单位时间，函数 1 总共执行 1 个单位时间。
示例 4：
输入：n = 2, logs = ["0:start:0","0:start:2","0:end:5","1:start:7","1:end:7","0:end:8"] 输出：[8,1]
示例 5：
输入：n = 1, logs = ["0:start:0","0:end:0"] 输出：[1]
由题意，我的第一感觉是这道题和有效的括号类似，同样需要利用栈，start入栈，end出栈。只不过有效的括号只需要判断最后栈是否为空，这道题需要判断每一个种类的start→end在栈中停留了多久。
我们要在没遇到一条start时，入栈，并将对应的ID入栈。当遇到一条end时，我们将对应的ID出栈。只有栈顶的函数，会被记为正在执行的函数。
直到栈顶的函数执行完毕出栈后，上一个函数才会继续执行。
我们遍历所有的日志。对于第 i 条日志，如果它包含 start，那么栈顶函数从其时间戳 time[i] 开始运行，即 prev = time[i]；如果它包含 end，那么栈顶函数从其时间戳 time[i] 的下一个时间开始运行，即 prev = time[i] + 1。对于第 i + 1 条日志，如果它包含 start，那么在时间戳 time[i + 1] 时，有新的函数被调用，因此原来的栈顶函数的独占时间为 time[i + 1] - prev；如果它包含 end，那么在时间戳 time[i + 1] 时，原来的栈顶函数执行结束，独占时间为 time[i + 1] - prev + 1。在这之后，我们更新 prev 并遍历第 i + 2 条日志。在遍历结束后，我们就可以得到所有函数的独占时间。
var exclusiveTime = function (n, logs) {
// 记录时间的数组
let res = new Array(n).fill(0);
// 记录出入栈
let stack = [];
// 记录上一个时间
let prev = 0;
// 遍历日志
for (const item of logs) {
// 拆分日志内容
let temp = item.split(":")
// 日志ID
let id = temp[0];
// 日志状态
let status = temp[1];
// 开始/结束时间
let time = temp[2];
// 如果标记为开始
if (status == "start") {
// 栈中存在函数
if (stack.length) {
// 取出栈顶函数的时间，加上当前时间，再去掉上次执行的终止时间，为此次更新的初始时间
res[stack[stack.length - 1]] += time - prev
}
// 记录此时的时间
prev = time;
// id入栈
stack.push(id)
} else {
// 此时status为end,代表函数执行结束
res[id] += time - prev + 1;
prev = parseInt(time) + 1;
stack.pop()
}
}
console.log(res);
}
复杂度分析
- 时间复杂度：O(N)。我们需要遍历所有的日志，因为有 N 个函数，因此日志的数量为 2N。
- 空间复杂度：O(N)，为栈占用的空间。
