文章目录
1. 比赛结果
做出来了3道题。第三题卡了一会，第四题知道拓扑排序，后面就没有思路了。继续加油！
全国排名：890 / 2259，39.4%；全球排名： 3407 / 7933，42.9%
2. 题目
1. LeetCode 5432. 去掉最低工资和最高工资后的工资平均值 easy
给你一个整数数组 salary ，数组里每个数都是 唯一 的，其中 salary[i] 是第 i 个员工的工资。
请你返回去掉最低工资和最高工资以后，剩下员工工资的平均值。
示例 1：
输入：salary = [4000,3000,1000,2000]
输出：2500.00000
解释：最低工资和最高工资分别是 1000 和 4000 。
去掉最低工资和最高工资以后的平均工资是 (2000+3000)/2= 2500
示例 2：
输入：salary = [1000,2000,3000]
输出：2000.00000
解释：最低工资和最高工资分别是 1000 和 3000 。
去掉最低工资和最高工资以后的平均工资是 (2000)/1= 2000
示例 3：
输入：salary = [6000,5000,4000,3000,2000,1000]
输出：3500.00000
示例 4：
输入：salary = [8000,9000,2000,3000,6000,1000]
输出：4750.00000
提示：
3 <= salary.length <= 100
10^3 <= salary[i] <= 10^6
salary[i] 是唯一的。
与真实值误差在 10^-5 以内的结果都将视为正确答案。
解题：
class Solution {//C++
public:
double average(vector<int>& salary) {
int MAX = *max_element(salary.begin(), salary.end());
int MIN = *min_element(salary.begin(), salary.end());
int sum = accumulate(salary.begin(), salary.end(),0);
return (sum-MAX-MIN)/double(salary.size()-2);
}
};
class Solution:# py3
def average(self, salary: List[int]) -> float:
salary.sort()
s = sum(salary)-salary[0]-salary[-1]
return s/(len(salary)-2)
2. LeetCode 5433. n 的第 k 个因子 medium
题目链接
给你两个正整数 n 和 k 。
如果正整数 i 满足 n % i == 0 ，那么我们就说正整数 i 是整数 n 的因子。
考虑整数 n 的所有因子，将它们 升序排列 。
请你返回第 k 个因子。如果 n 的因子数少于 k ，请你返回 -1 。
示例 1：
输入：n = 12, k = 3
输出：3
解释：因子列表包括 [1, 2, 3, 4, 6, 12]，第 3 个因子是 3 。
示例 2：
输入：n = 7, k = 2
输出：7
解释：因子列表包括 [1, 7] ，第 2 个因子是 7 。
示例 3：
输入：n = 4, k = 4
输出：-1
解释：因子列表包括 [1, 2, 4] ，只有 3 个因子，所以我们应该返回 -1 。
示例 4：
输入：n = 1, k = 1
输出：1
解释：因子列表包括 [1] ，第 1 个因子为 1 。
示例 5：
输入：n = 1000, k = 3
输出：4
解释：因子列表包括 [1, 2, 4, 5, 8, 10, 20, 25, 40, 50,
100, 125, 200, 250, 500, 1000] 。
提示：
1 <= k <= n <= 1000
解题：
class Solution {//C++
public:
int kthFactor(int n, int k) {
set<int> s;
for(int i = 1; i <= n; i++) {
if(n%i==0)
s.insert(i);
}
if(s.size() < k)
return -1;
auto it = s.begin();
while(--k && it != s.end())
{
it++;
}
return *it;
}
};
or
- 因为是有序的，直接遍历到第k个返回即可
class Solution { //C++
public:
int kthFactor(int n, int k) {
for(int i = 1; i <= n; ++i)
{
if(n%i==0)
{
k--;
if(k==0)
return i;
}
}
return -1;
}
};
class Solution:# py3
def kthFactor(self, n: int, k: int) -> int:
s = set()
for i in range(1,n+1):
if n%i == 0:
s.add(i)
if len(s) < k:
return -1
l = list(s)
l.sort()
return l[k-1]
3. LeetCode 5434. 删掉一个元素以后全为 1 的最长子数组 medium
题目链接
给你一个二进制数组 nums ，你需要从中删掉一个元素。
请你在删掉元素的结果数组中，返回最长的且只包含 1 的非空子数组的长度。
如果不存在这样的子数组，请返回 0 。
示例 1：
输入：nums = [1,1,0,1]
输出：3
解释：删掉位置 2 的数后，[1,1,1] 包含 3 个 1 。
示例 2：
输入：nums = [0,1,1,1,0,1,1,0,1]
输出：5
解释：删掉位置 4 的数字后，
[0,1,1,1,1,1,0,1] 的最长全 1 子数组为 [1,1,1,1,1] 。
示例 3：
输入：nums = [1,1,1]
输出：2
解释：你必须要删除一个元素。
示例 4：
输入：nums = [1,1,0,0,1,1,1,0,1]
输出：4
示例 5：
输入：nums = [0,0,0]
输出：0
提示：
1 <= nums.length <= 10^5
nums[i] 要么是 0 要么是 1 。
解题：
类似题目：LeetCode 1004. 最大连续1的个数 III（滑动窗口）
- 比赛，没想出滑动窗口，很差的代码如下（记录所有的窗口，再检查能否合并）
class Solution {//C++
public:
int longestSubarray(vector<int>& nums) {
int maxlen = 0;
vector<vector<int>> lr;//记录所有区间
int l = -1, r = -1;
for(int i = 0; i < nums.size(); i++)
{
if(nums[i]&&l==-1)
l = i;
if(l != -1 && nums[i]==0 && r==-1)
r = i-1;
if(nums[i] && i == nums.size()-1)
r = nums.size()-1;
if(l!=-1 && r!=-1)
{
lr.push_back({l,r});
l = r = -1;
}
}
if(lr.size()==0)
return 0;
if(lr.size()==1)
{
if(lr[0][0]!=0 || lr[0][1]!=nums.size()-1)
return lr[0][1]-lr[0][0]+1;
else
return nums.size()-1;
}
maxlen = max(maxlen, lr[0][1]-lr[0][0]+1);
for(int i = 0,j; i < lr.size()-1; i++)
{
j = i+1;//判断相邻的两个区间能否合并
if(lr[i][1]+2==lr[j][0])
maxlen = max(maxlen, lr[j][1]-lr[i][0]);
else
maxlen = max(maxlen, lr[j][1]-lr[j][0]+1);
}
return maxlen;
}
};
class Solution:# py3
def longestSubarray(self, nums: List[int]) -> int:
maxlen = 0
lr = []
l, r = -1, -1
for i in range(len(nums)):
if nums[i] and l==-1:
l = i
if l != -1 and nums[i]==0 and r==-1:
r = i-1
if nums[i] and i == len(nums)-1:
r = len(nums)-1
if l != -1 and r != -1:
lr.append([l,r])
l, r = -1, -1
if len(lr)==0:
return 0
if len(lr)==1:
if lr[0][0]!=0 or lr[0][1]!=len(nums)-1:
return lr[0][1]-lr[0][0]+1
else:
return len(nums)-1
maxlen = max(maxlen, lr[0][1]-lr[0][0]+1)
for i in range(len(lr)-1):
j = i+1
if lr[i][1]+2==lr[j][0]:
maxlen = max(maxlen, lr[j][1]-lr[i][0])
else:
maxlen = max(maxlen, lr[j][1]-lr[j][0]+1)
return maxlen
- 滑动窗口，根据可以删除的0的个数k，来收放窗口
class Solution { //C++滑窗
public:
int longestSubarray(vector<int>& nums) {
int l = 0, r= 0, maxlen = 0, k=1;
while(r < nums.size())
{
if(nums[r++]==0)
k--;//可以删除的0的个数
while(k < 0)
{
if(nums[l++]==0)
k++;
}
maxlen = max(maxlen, r-l-1);
}
return maxlen;
}
};
4. LeetCode 5435. 并行课程 II hard
题目链接
给你一个整数 n 表示某所大学里课程的数目，编号为 1 到 n ，数组 dependencies 中， dependencies[i] = [xi, yi] 表示一个先修课的关系，也就是课程 xi 必须在课程 yi 之前上。同时你还有一个整数 k 。
在一个学期中，你 最多 可以同时上 k 门课，前提是这些课的先修课在之前的学期里已经上过了。
请你返回上完所有课最少需要多少个学期。题目保证一定存在一种上完所有课的方式。
示例 1：
输入：n = 4, dependencies = [[2,1],[3,1],[1,4]], k = 2
输出：3
解释：上图展示了题目输入的图。
在第一个学期中，我们可以上课程 2 和课程 3 。
然后第二个学期上课程 1 ，第三个学期上课程 4 。
示例 2：
输入：n = 5, dependencies = [[2,1],[3,1],[4,1],[1,5]], k = 2
输出：4
解释：上图展示了题目输入的图。一
个最优方案是：第一学期上课程 2 和 3，第二学期上课程 4 ，
第三学期上课程 1 ，第四学期上课程 5 。
示例 3：
输入：n = 11, dependencies = [], k = 2
输出：6
提示：
1 <= n <= 15
1 <= k <= n
0 <= dependencies.length <= n * (n-1) / 2
dependencies[i].length == 2
1 <= xi, yi <= n
xi != yi
所有先修关系都是不同的，也就是说 dependencies[i] != dependencies[j] 。
题目输入的图是个有向无环图。
解题：
待补