Exclusive Time of Functions

On a single threaded CPU, we execute some functions.  Each function has a unique id between 0 and N-1.

We store logs in timestamp order that describe when a function is entered or exited.

Each log is a string with this format: "{function_id}:{"start" | "end"}:{timestamp}".  For example, "0:start:3" means the function with id 0 started at the beginning of timestamp 3.  "1:end:2" means the function with id 1 ended at the end of timestamp 2.

A function's exclusive time is the number of units of time spent in this function.  Note that this does not include any recursive calls to child functions.

The CPU is single threaded which means that only one function is being executed at a given time unit.

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:end:5","0:end:6"]
Output: [3, 4]
Explanation:
Function 0 starts at the beginning of time 0, then it executes 2 units of time and reaches the end of time 1.
Now function 1 starts at the beginning of time 2, executes 4 units of time and ends at time 5.
Function 0 is running again at the beginning of time 6, and also ends at the end of time 6, thus executing for 1 unit of time. 
So function 0 spends 2 + 1 = 3 units of total time executing, and function 1 spends 4 units of total time executing.

Note:

1. 1 <= n <= 100
2. Two functions won't start or end at the same time.
3. Functions will always log when they exit.

思路：因为线程会有stack调用，所以这题想到用stack，stack里面存的是thread的id；

这个思路巧妙的是，运用的都是绝对时间来算差值，len = end - start + 1; 但是stack.peek().id ，遇见不是自己的，一定要减去，后面遇见自己的了，会算绝对长度，所以会加上一个很大的length，但是中间有不是自己的，所以已经减去了，最后的结果就是属于自己的length；

class Solution {
    public class Log {
        public int id;
        public boolean isStart;
        public int time;
        public Log(String content) {
            String[] splits = content.split(":");
            this.id = Integer.parseInt(splits[0]);
            this.isStart = splits[1].equals("start");
            this.time = Integer.parseInt(splits[2]);
        }
    }
    
    public int[] exclusiveTime(int n, List<String> logs) {
        int[] res = new int[n];
        Stack<Log> stack = new Stack<>();
        for(String content: logs) {
            Log log = new Log(content);
            if(log.isStart) {
                stack.push(log);
            } else {
                Log top = stack.pop();
                res[top.id] += log.time - top.time + 1;
                if(!stack.isEmpty()) {
                    res[stack.peek().id] -= log.time - top.time + 1;
                }
            }
        }
        return res;
    }
}