第314场周赛

最新推荐文章于 2024-10-16 19:39:35 发布

逮到647了

最新推荐文章于 2024-10-16 19:39:35 发布

阅读量348

点赞数

分类专栏：每日一题文章标签：算法

本文链接：https://blog.csdn.net/rygy_/article/details/127331402

版权

每日一题专栏收录该内容

76 篇文章 0 订阅

订阅专栏

2432. 处理用时最长的那个任务的员工-Easy

题目描述：

共有 n 位员工，每位员工都有一个从 0 到 n - 1 的唯一 id 。

给你一个二维整数数组 logs ，其中 logs[i] = [idi, leaveTimei] ：

idi 是处理第 i 个任务的员工的 id ，且

leaveTimei 是员工完成第 i 个任务的时刻。所有 leaveTimei 的值都是唯一的。

注意，第 i 个任务在第 (i - 1) 个任务结束后立即开始，且第 0 个任务从时刻 0 开始。

返回处理用时最长的那个任务的员工的 id 。如果存在两个或多个员工同时满足，则返回几人中最小的 id 。

题目解析：

很简单，找到所有用时最长的任务，然后在这些任务中选择id号最小的进行返回即可，这里需要注意的是，每个任务所需的时间为该任务结束的时间减去上一个任务结束的时间，但第一个任务的时间为其任务结束时间，代码如下：

class Solution {
public:
    int hardestWorker(int n, vector<vector<int>>& logs) {
        int time = logs[0][1];
        for(int i = 1 ;  i<logs.size() ; i++){
            int spend = logs[i][1]-logs[i-1][1];
            if(spend>time)time = spend;    
        }
        int idx = n;
        for(int i = 1 ;  i<logs.size() ; i++){
            int spend = logs[i][1]-logs[i-1][1];
            if(spend==time){
                if(logs[i][0]<idx)idx = logs[i][0];
            }    
        }
        if(logs[0][1]==time){
            idx = logs[0][0]<idx?logs[0][0]:idx;
        }
        return idx;
    }
};

执行用时：60 ms, 在所有 C++ 提交中击败了78.11%的用户

内存消耗：34.5 MB, 在所有 C++ 提交中击败了97.53%的用户

2433. 找出前缀异或的原始数组-Medium

题目描述：

给你一个长度为 n 的整数数组 pref 。找出并返回满足下述条件且长度为 n 的数组 arr ：

pref[i] = arr[0] ^ arr[1] ^ ... ^ arr[i].

注意 ^ 表示按位异或（bitwise-xor）运算。

可以证明答案是唯一的。

题目解析：

一个简单的数学题，假设我们结果数组为res，首先res[0]=pref[0]，res[1]^res[0]=pref[1]，那么res[1] = pref[1]^res[0]，res[2] = pref[2]^res[0]^res[1]，依次类推下去即可，代码如下：

class Solution {
public:
    vector<int> findArray(vector<int>& pref) {
        int len = pref.size();
        vector<int> res(len);
        res[0] = pref[0];
        int temp = res[0];
        for(int i = 1 ; i<len ; i++){
            res[i] = pref[i]^temp;
            temp ^= res[i];
        }
        return res;
    }
};

执行用时：92 ms, 在所有 C++ 提交中击败了65.13%的用户

内存消耗：74.2 MB, 在所有 C++ 提交中击败了57.15%的用户

2434. 使用机器人打印字典序最小的字符串-Medium

题目描述：

给你一个字符串 s 和一个机器人，机器人当前有一个空字符串 t 。执行以下操作之一，直到 s 和 t 都变成空字符串：

删除字符串 s 的第一个字符，并将该字符给机器人。机器人把这个字符添加到 t 的尾部。

删除字符串 t 的最后一个字符，并将该字符给机器人。机器人将该字符写到纸上。

请你返回纸上能写出的字典序最小的字符串。

题目解析：

根据题目要求，我们将一个字符串进行入栈出栈处理，要保证这个字符串的字典序最小，贪心，当栈顶元素为所剩元素中的字典序最小元素时，我们进行栈顶元素的弹出，因为这个时候如果不弹出的话，后续操作是一定会导致字典序大于等于目前弹出的情况的，如果不是那么就继续入栈即可，最后我们将栈内所有元素依次弹出即可得到我们所要求的字典序最小字符串，代码如下：

class Solution {
public:
    bool decide(char cur , int idx , string str){
        for(int i = idx ; i<str.size() ; i++){
            if(str[i]<cur)return false;
        }
        return true;
    }
    string robotWithString(string s) {
        int len = s.size();
        stack<char> stk;
        stk.push(s[0]);
        string res = "";
        for(int i = 1 ; i < len ;){
            if(!stk.empty()&&decide(stk.top(),i,s)){
                res+=stk.top();
                stk.pop();
            }
            else{
                stk.push(s[i++]);
            }
        }
        while(!stk.empty()){
            res+=stk.top();
            stk.pop();
        }
        return res;
    }
};

使用了O（N^2）的时间复杂度造成了超时，所以先通过一个for循环做了一个预处理，找到了某个位置之后最小字典序字符的数值，然后在后续循环中直接调用即可，代码如下：

class Solution {
public:
    string robotWithString(string s) {
        int len = s.size();
        vector<int> val(len);
        val[len-1] = (int)s[len-1];
        for(int i = len - 2 ; i>=0 ; i--){
            val[i] = min(val[i+1],(int)s[i]);
        }
        stack<char> stk;
        stk.push(s[0]);
        string res = "";
        for(int i = 1 ; i < len ;){
            if(!stk.empty()&&stk.top()<=val[i]){
                res+=stk.top();
                stk.pop();
            }
            else{
                stk.push(s[i++]);
            }
        }
        while(!stk.empty()){
            res+=stk.top();
            stk.pop();
        }
        return res;
    }
};

执行用时：108 ms, 在所有 C++ 提交中击败了70.17%的用户

内存消耗：37.6 MB, 在所有 C++ 提交中击败了15.90%的用户