题目

（1）有一个单线程 CPU 正在运行一个含有 n 道函数的程序。每道函数都有一个位于 0 和 n-1 之间的唯一标识符。
（2）函数调用存储在一个调用栈上：当一个函数调用开始时，它的标识符将会推入栈中。而当一个函数调用结束时，它的标识符将会从栈中弹出。标识符位于栈顶的函数是当前正在执行的函数。每当一个函数开始或者结束时，将会记录一条日志，包括函数标识符、是开始还是结束、以及相应的时间戳。
（3）给你一个由日志组成的列表 logs ，其中 logs[i] 表示第 i 条日志消息，该消息是一个按 “{function_id}:{“start” | “end”}:{timestamp}” 进行格式化的字符串。例如，“0:start:3” 意味着标识符为 0 的函数调用在时间戳 3 的起始开始执行；而 “1: end: 2” 意味着标识符为 1 的函数调用在时间戳 2 的末尾结束执行。注意，函数可以调用多次，可能存在递归调用。
（4）函数的独占时间定义是在这个函数在程序所有函数调用中执行时间的总和，调用其他函数花费的时间不算该函数的独占时间。例如，如果一个函数被调用两次，一次调用执行 2 单位时间，另一次调用执行 1 单位时间，那么该函数的独占时间为 2 + 1 = 3 。
（5）以数组形式返回每个函数的独占时间，其中第 i 个下标对应的值表示标识符 i 的函数的独占时间。
（6）示例如下所示：
在这里插入图片描述
输入：n = 2, logs = [“0:start:0”,“1:start:2”,“1: end:5”,“0: end:6”] // 注：此处为了避免markdown将 : end: 显示为图，在end前多加了一个空格。
输出：[3,4]
解释：
函数 0 在时间戳 0 的起始开始执行，执行 2 个单位时间，于时间戳 1 的末尾结束执行。
函数 1 在时间戳 2 的起始开始执行，执行 4 个单位时间，于时间戳 5 的末尾结束执行。
函数 0 在时间戳 6 的开始恢复执行，执行 1 个单位时间。
所以函数 0 总共执行 2 + 1 = 3 个单位时间，函数 1 总共执行 4 个单位时间。

解决思路

当log的状态为start时，就将函数的 id 入栈，当log的状态为end时，就弹栈。
当log的状态为start时，计算得到的时间段应该归为上一个函数的独占时间；当log的状态为end时，计算得到的时间段应归为当前函数的独占时间。

代码

C++代码

# include <stdio.h>
# include <vector>
# include <stack>
# include <string>


using namespace std;


class Solution {
public:
    vector<int> exclusiveTime(int n, vector<string>& logs) {
        stack<int> fn_id;       // 存储运行程序的编号。
        vector<int> answer(n);
        int pre = 0;            // 记录每个函数的开始时间点。

        // 遍历每个log进行解析
        for (int i = 0; i < logs.size(); i++) {
            int pos1 = logs[i].find_first_of(":");  // 找到每条log第一个冒号的位置（注意log的形式为"0:start:0"）
            int pos2 = logs[i].find_last_of(":");   // 找到每条log最后一个冒号的位置

            string id_str = logs[i].substr(0, pos1 + 1);    // 每条log第一个冒号前的字符为每个函数对应的id
            string status = logs[i].substr(pos1 + 1, pos2 - pos1 - 1);  // 每个函数的状态，是start还是end
            // 从pos2+1开始到结束为每个函数的执行时间，此处的长度logs[i].size()给的较大，目的为为了从pos2+1开始，一直取到字符串的结束。
            string time_str = logs[i].substr(pos2 + 1, logs[i].size());

            int id = atoi(id_str.c_str());          // 将函数id从字符串转换为整数
            int time_val = atoi(time_str.c_str());  // 将时间从字符串转换为整数。


            // 方法1：代码量少
            // if (!fn_id.empty()) {
            //     // 如果当前log对应的状态为end，则当前函数对应的时间段长度为time_stamp - pre + 1。
            //     // 如果当前log对应的状态为start，则上一个函数对应的时间段长度为time_stamp - pre
            //     answer[fn_id.top()] += time_val - pre + ("end" == status);
            // }

            // // 如果log的状态为start，则当前函数的开始时间为time_stamp。
            // // 如果log的状态为end，则下一个函数的开始时间为time_stamp + 1。
            // pre = time_val + ("end" == status);       // 更新函数的开始时间。
            // if ("start" == status) {
            //     fn_id.push(id);
            // } else {
            //     fn_id.pop();
            // }


            // 方法2：更直观
            if ("start" == status) {
                // 当前log的状态为start时，计算出的时间段应归为上一个函数的独占时间
                if (!fn_id.empty()) {
                    answer[fn_id.top()] += time_val - pre;
                }
                pre = time_val; // 如果log的状态为start，则当前函数的开始时间为time_stamp。
                fn_id.push(id);
            } else {            // "end" == status
                // 当log的状态为end时，计算出的时间段应归为当前函数的独占时间。
                answer[id] += time_val - pre + 1;
                pre = time_val + 1; // 如果log的状态为end，则下一个函数的开始时间为time_stamp + 1。
                fn_id.pop();
            }
        }
        return answer;
    }
};


int main() {
    int n = 2;
    vector<string> logs = {"0:start:0", "1:start:2", "1:end:5", "0:end:6"};
    Solution *solution = new Solution();
    vector<int> ret = solution->exclusiveTime(n, logs);
    for (int i = 0; i < ret.size(); i++) {
        printf("%d ", ret[i]);
    }
    printf("\n");
    return 0;
}

Python代码

# -*- coding: utf-8 -*-

from typing import List


class Solution:
    def __init__(self):
        pass

    def exclusiveTime(self, n: int, logs: List[str]) -> List[int]:
        answer: List[int] = [0] * n
        fn_id: List[int] = []  # 存储运行程序的编号。
        pre: int = 0  # 记录每个函数的开始时间点。

        # 遍历每个log进行解析
        for log in logs:
            # 用冒号对log进行分割，得到函数的id、状态、时间戳
            info = log.split(":")
            id = int(info[0])
            status = info[1]
            time = int(info[2])

            if "start" == status:
                # 当前log的状态为start时，计算出的时间段应归为上一个函数的独占时间
                if fn_id:
                    answer[fn_id[-1]] += time - pre;
                pre = time  # 如果log的状态为start，则当前函数的开始时间为time_stamp。
                fn_id.append(id)  # log的状态为start时，将函数的id压入栈中
            else:
                # 当log的状态为end时，计算出的时间段应归为当前函数的独占时间。
                answer[id] += time - pre + 1
                pre = time + 1  # 如果log的状态为end，则下一个函数的开始时间为time_stamp + 1。
                fn_id.pop()  # log的状态为end时，将函数的id从栈中弹出

        return answer


def main():
    solution = Solution()
    n: int = 2
    logs = ["0:start:0", "1:start:2", "1:end:5", "0:end:6"]
    print(solution.exclusiveTime(n, logs))


if __name__ == "__main__":
    main()