LeetCode——Weekly Contest 314_2432. 处理用时最长的那个任务的

LeetCode周赛第314场记录

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

周赛第一题，根据题意写出代码即可。首先根据logs计算出每项工作的实际用时，然后根据用时长短对员工的ID号进行排序即可。给出完整代码如下：

class Solution {
	static bool cmpFunc(pair<int, int>& A, pair<int, int>& B)
	{
		if(A.second > B.second)				// 首先根据工时进行排序
			return true;
		else if(A.second < B.second)
			return false;
		else // A.second == B.second		// 工时相同的情况下ID号小的排在前面
			return A.first <= B.first;
	}
public:
    int hardestWorker(int n, vector<vector<int>>& logs) {
        vector<pair<int, int>> LogVec;
		LogVec.push_back(make_pair(logs[0][0], logs[0][1]));
		int Size = logs.size();
		for(int i = 1 ; i < Size ; ++i)		// 计算完成每项任务的实际工时，做减法即可
			LogVec.push_back(make_pair(logs[i][0], logs[i][1] - logs[i - 1][1]));
		sort(LogVec.begin(), LogVec.end(), cmpFunc);
		return LogVec[0].first;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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

这道题也很简单，主要就是考察异或运算的性质。

1. $a\oplus 0=a$（任何数字与0异或会得到自身）
2. 设$c=a\oplus b$，那么$c\oplus a=b,c\oplus b=a$，这个性质常用来加解密。

本题考察的实际上就是性质2，我们只需要将pref的相邻两个数字两两异或就可以解密出原有数组arr，以下是完整代码:

class Solution {
public:
    vector<int> findArray(vector<int>& pref) {
        vector<int> Ans;
		Ans.push_back(pref[0]);
		int Size = pref.size();
		int TmpXor = pref[0];
		for(int i = 1 ; i < Size ; ++i)
		{
			Ans.push_back(TmpXor ^ pref[i]);
			TmpXor = pref[i];
		}
		return Ans;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2434. 使用机器人打印字典序最小的字符串(模拟栈+贪心)

这道题很容易在比赛时卡住，从题面的描述上可以很快地反应出对机器人的两种操作分别对应了入栈和出栈动作，所以应该是模拟栈。但是如何得出字典序最小的字符串，这里涉及到求解的策略问题，我在比赛时尝试使用单调栈来解决，但这样的思路是错的，朴素的贪心就可以了，所以这道题是一个模拟栈+贪心问题。

我们需要使用一个栈来模拟机器人的动作，同时维持贪心的求解策略：即把最小的字符永远排在尽可能靠前的位置，如果一个字符后面还有小字符，那么当前字符就压入栈中。

如何实现这一点，那就是首先遍历字符串统计所有字符的数目，并在后面维持一个最小字符Min，当前字符不是最小字符则入栈，是最小字符则出栈并加入最后答案。

完整的求解代码如下：

class Solution {
public:
    string robotWithString(string s) {
        int Counter[26] = {0};
		for(auto c : s)
			++Counter[c - 'a'];
		
		string Ans = "";
		stack<int> S;
		int Min = 0, Size = s.size();
		for(int i = 0 ; i < Size ; ++i)
		{
			--Counter[s[i] - 'a'];
			while(Min < 26 && !Counter[Min]) 
				++Min;
			S.push(i);
			while(!S.empty() && s[S.top()] - 'a' <= Min)
			{
				Ans += s[S.top()];
				S.pop();
			}
		}
		return Ans;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

2435. 矩阵中和能被 K 整除的路径

CopyRight:灵茶山艾府
出乎意料的是，这次周赛的第四题并不特别难，是一个比较朴素的动态规划问题。
解决这种问题的一个套路就是，将路径和模k的结果作为一个扩展维度。

设一个三维数组int DP[i][j][k]，其含义如下(有些拗口)：

int DP[i][j][v]; // 从起点[0,0]走到[i,j]路径和模k余数是v的路径数量
1

这里还有一个小trick，就是为了防止数组越界引起的讨论，可以将数组下标+1，完整代码如下：

class Solution {
	// copyright:0x3f
	// 将路径和模k的结果当成一个扩展维度
public:
    int numberOfPaths(vector<vector<int>>& grid, int k) {
        const int Mod = 1e9 + 7;
		int m = grid.size(), n = grid[0].size();
		int DP[m + 1][n + 1][k];
		memset(DP, 0, sizeof(DP));
		DP[1][0][0] = 1;
		for(int i = 0 ; i < m ; ++i)
			for(int j = 0 ; j < n ; ++j)
				for(int v = 0 ; v < k ; ++v)
					DP[i + 1][j + 1][(v + grid[i][j]) % k] = (DP[i + 1][j][v]  + DP[i][j + 1][v]) % Mod;
		return DP[m][n][0];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17