[栈] 636. 函数的独占时间

Devil
200 阅读6分钟

携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第9天，点击查看活动详情

每日刷题 2022.08.07

题目

  • 有一个 单线程 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 image.png
输入：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]

提示

  • 1 <= n <= 100
  • 1 <= logs.length <= 500
  • 0 <= function_id < n
  • 0 <= timestamp <= 10^9
  • 两个开始事件不会在同一时间戳发生
  • 两个结束事件不会在同一时间戳发生
  • 每道函数都有一个对应 "start" 日志的 "end" 日志

解题思路

  • 根据题意可知：目前有很多个函数正在执行，并且有些函数还会自己调用自己，类似于递归。本题要求计算出每一个函数的独占时间，也就是只能包含自己，不能包含别人的运行时间。
  • 验证样例的过程中，栈这种数据结构比较适合解决这道题，有点类似于左右括号的那道题，每个不同的函数都会有自己的开始和结束时间，那么就可以使用栈数据结构来将一对的放在一起处理。
  • 那么现在已经解决了如何查找到相同的函数的开始和结束，就需要接着考虑下：如何计算每个函数的独立时间呢？
  • 不重复调用的函数的时间比较好计算 = 结束时间 - 开始时间 + 1；但是对于会重复调用的函数的时间如何计算呢？
  • 可以将整个最外层的函数开始的时候，将其内部的各个小的函数的独立时间叠加记录下来，最终使用最外层的函数的结束时间 - 开始时间 - 内部的各个函数的独立时间叠加值 + 1，就是最外层的函数的独立时间。
  • 那么如何利用栈stack来实现呢？每次处理内部的函数inner的时候，外部的函数outer一定在栈顶，此时可以通过不断的修改outer的内部独立时间值，最终记录下总的内部独立时间值。

新的书写方式

  • 会直接将数组中的三个元素，分别赋值给三个变量存储。
let [id, status, time] = one.split(':');

AC代码

/**
 * @param {number} n
 * @param {string[]} logs
 * @return {number[]}
 */
var exclusiveTime = function(n, logs) {
  // 栈：先进后出
  let stack = [], ans = new Array(n).fill(0);
  for(let one of logs) {
    let [id, status, time] = one.split(':');
    if(status === 'start') {
      // 需要判断栈中是否存在元素，如果存在那么就需要记录当前的差值
      stack.push([id, time, 0]);
    }else {
      let [eId, eTime, eTotal] = stack.pop();
      if(stack.length != 0) {
        stack[stack.length - 1][2] += (time - eTime + 1);
      }
      ans[eId] += (time - eTime - eTotal + 1);
    }
  }
  return ans;
}
avatar
文章
阅读
粉丝