LeeCode 第 314 场周赛

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

遍历一遍，更新最大的答案就可。注意相等的时候，要取编号更小的。

代码：

class Solution {
public:
    int hardestWorker(int n, vector<vector<int>>& logs) {
        int pre=0;
        int ans=0;
        int mx=0;
        for(auto&a:logs){
            if(a[1]-pre>mx){
                ans=a[0];
                mx=a[1]-pre;
            }else if(a[1]-pre==mx){
                ans=min(a[0],ans);
            }
            pre=a[1];
        }
        return ans;
    }
};

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

这一题只需要知道异或的一个性质，a^x=b,x=a^b

代码：

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

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

做法：栈模拟

当前栈顶的元素和右边元素的最小值有两种情况：

• top > right_min 这个时候把它入栈最优，因为要等右边最小的加入答案，才可能最优
• top <= right_min 这个时候把它加入答案最优。现在不加入，后面就会跑到后面去。

代码：

class Solution {
public:
    string robotWithString(string s) {
        int n=s.size();
        vector<char> right(n+1);
        right[n-1]=s[n-1];
        right[n]='z'+1;
        // 预处理出右边最小的值
        for(int i=n-2;i>=0;i--){
            right[i]=min(right[i+1],s[i]);
        }
        vector<int> st;
        string ans;
        for(int i=0;i<n;i++){
            st.push_back(s[i]);
            while(st.size()!=0&&st.back()<=right[i+1]){
                ans+=st.back();
                st.pop_back();
            }
        }
        return ans;
    }
};

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

这个好像是原题，反正以前做过。做法：DP

dp[i][j][r]表示到位置[i,j]对k取模等于r的方案数。

递推方程：

dp[i + 1][j][(r + grid[i + 1][j]) % k] += dp[i][j][r];
dp[i][j + 1][(r + grid[i][j + 1]) % k] += dp[i][j][r];

注意边界的问题。

代码：

class Solution {
public:
    
    const int mod=1e9+7;
    int numberOfPaths(vector<vector<int>> &grid, int k){
	int n = grid.size(), m = grid[0].size();
    vector< vector < vector<int> > > dp(n,vector< vector<int> >(m,vector<int>(k,0)));
	dp[0][0][grid[0][0] % k] = 1;
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			for (int r = 0; r < k; r++)
			{
				if (i + 1 < n)
				{
					dp[i + 1][j][(r + grid[i + 1][j]) % k] += dp[i][j][r];
					dp[i + 1][j][(r + grid[i + 1][j]) % k] %= mod;
				}
				if (j + 1 < m)
				{
					dp[i][j + 1][(r + grid[i][j + 1]) % k] += dp[i][j][r];
					dp[i][j + 1][(r + grid[i][j + 1]) % k] %= mod;
				}
			}
		}
	}
	return dp[n - 1][m - 1][0];
    }
};