636. Exclusive Time of Functions

最新推荐文章于 2025-03-18 07:15:00 发布

BigFatSheep

最新推荐文章于 2025-03-18 07:15:00 发布

阅读量96

点赞数

CC 4.0 BY-SA版权

分类专栏： Leetcode Medium

本文链接：https://blog.youkuaiyun.com/BigFatSheep/article/details/83037741

Leetcode 同时被 2 个专栏收录

385 篇文章

订阅专栏

Medium

195 篇文章

订阅专栏

本文介绍了一种算法，用于计算一组函数在单线程CPU上运行的独占时间。通过解析运行日志并使用栈来跟踪函数调用，确保了准确计算每个函数的实际运行时间，即使在函数递归调用或被其他函数调用的情况下。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

问题描述

Given the running logs of n functions that are executed in a nonpreemptive single threaded CPU, find the exclusive time of these functions.

Each function has a unique id, start from 0 to n-1. A function may be called recursively or by another function.

A log is a string has this format : function_id:start_or_end:timestamp. For example, “0:start:0” means function 0 starts from the very beginning of time 0. “0?0” means function 0 ends to the very end of time 0.

Exclusive time of a function is defined as the time spent within this function, the time spent by calling other functions should not be considered as this function’s exclusive time. You should return the exclusive time of each function sorted by their function id.

Example 1:

Input:
n = 2
logs =
[“0:start:0”,
“1:start:2”,
“1?5”,
“0?6”]
Output:[3, 4]
Explanation:
Function 0 starts at time 0, then it executes 2 units of time and reaches the end of time 1.
Now function 0 calls function 1, function 1 starts at time 2, executes 4 units of time and end at time 5.
Function 0 is running again at time 6, and also end at the time 6, thus executes 1 unit of time.
So function 0 totally execute 2 + 1 = 3 units of time, and function 1 totally execute 4 units of time.

Note:

Input logs will be sorted by timestamp, NOT log id.
Your output should be sorted by function id, which means the 0th element of your output corresponds to the exclusive time of function 0.
Two functions won’t start or end at the same time.
Functions could be called recursively, and will always end.
1 <= n <= 100

题目链接：

思路分析

给一组functions运行的log，functions按id顺序执行，可以嵌套递归，计算每个function实际运行的时间。用栈保存递归调用的过程，注意时间都是开始时间，但是当function结束时，这个时间是要count在内的。

Using a stack to maintain function call process. Previous time starts at 0. For every log in logs, if stack is not empty, plus current time - previours time in result array. For the reason that a function may be interupted by another function it calls. PrevTime is the current time now. Then if the log is “start”, push it into stack. If not, it means “end”, pop it, and result of this function should plus one for the reason that this time should also count into this function. For the same reason, prevTime should plus one, too.

代码

class Solution {
    public int[] exclusiveTime(int n, List<String> logs) {
        int[] res = new int[n];
        Stack<Integer> stack = new Stack<>();
        int prevTime = 0;
        for (String log : logs){
            String[] decode = log.split(":");
            int curTime = Integer.parseInt(decode[2]);
            if (!stack.isEmpty()){
                res[stack.peek()] += curTime - prevTime;
            }
            prevTime = curTime;
            if (decode[1].equals("start")){
                stack.push(Integer.parseInt(decode[0]));
            }
            else{
                res[stack.pop()]++;
                prevTime++;
            }
        }
        return res;
    }
}