标签：Exclusive Functions funs 636 int res Stack starts lastStart

这道题很明显，需要用到stack，我一开始的想法是用两个stack，一个存functions，一个存start times，算法如下：

package stack;

import java.util.List;
import java.util.Stack;

public class ExclusiveTimeofFunctions636 {
    public int[] exclusiveTime(int n, List<String> logs) {
        int[] res = new int[n];
        Stack<Integer> funs = new Stack<>();
        Stack<Integer> starts = new Stack<>();

        for (int i = 0; i < logs.size(); i++) {
            String[] logInfo = logs.get(i).split(":");
            int currFun = Integer.valueOf(logInfo[0]);
            int currTime = Integer.valueOf(logInfo[2]);
            if ("start".equals(logInfo[1])) {
                if (!funs.isEmpty()) {
                    int lastFun = funs.peek();
                    int lastStart = starts.peek();
                    res[lastFun] += currTime - lastStart;
                }
                funs.add(currFun);
                starts.add(currTime);
            } else {
                int lastStart = starts.pop();
                int lastFun = funs.pop();
                res[lastFun] += currTime + 1 - lastStart;
                if (!funs.isEmpty()) {
                    starts.pop();
                    starts.add(currTime + 1);
                }
            }
        }
        return res;
    }
}

上面的算法虽然work，但是稍显繁琐，仔细分析一下，其实start time不需要放在stack中，我们只需要上一个function的开始时间和新的function的开始时间即可，改进算法如下：

class Solution {
    public int[] exclusiveTime(int n, List<String> logs) {
        Stack<Integer> funcs = new Stack<>();
        int lastStart=0;
        int[] res = new int[n];
        
        for(String s: logs){
            String[] infos = s.split(":");
            int func = Integer.valueOf(infos[0]);
            int time = Integer.valueOf(infos[2]);
            
            if(!funcs.empty()){
                res[funcs.peek()]+=time-lastStart;
            }
            if("start".equals(infos[1])){
                funcs.add(func);
                lastStart = time;
               
            }else{
                res[funcs.pop()]++;
                lastStart = time+1;
            }
        }
        return res;
    }
}

以上两个算法的时间和空间复杂度均是O(n).

标签：Exclusive,Functions,funs,636,int,res,Stack,starts,lastStart
来源： https://www.cnblogs.com/feiflytech/p/15758983.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。