Leetcode Test
1334 阈值距离内邻居最少的城市(11.14)
有 n
个城市,按从 0
到 n-1
编号。给你一个边数组 edges
,其中 edges[i] = [fromi, toi, weighti]
代表 fromi
和 toi
两个城市之间的双向加权边,距离阈值是一个整数 distanceThreshold
。
返回能通过某些路径到达其他城市数目最少、且路径距离 最大 为 distanceThreshold
的城市。如果有多个这样的城市,则返回编号最大的城市。
注意,连接城市 i 和 j 的路径的距离等于沿该路径的所有边的权重之和。
提示:
2 <= n <= 100
1 <= edges.length <= n * (n - 1) / 2
edges[i].length == 3
0 <= fromi < toi < n
1 <= weighti, distanceThreshold <= 10^4
- 所有
(fromi, toi)
都是不同的。
【Floyd】
int findTheCity(int n, int** edges, int edgesSize, int* edgesColSize, int distanceThreshold) {
int ans[2] = {INT_MAX >> 1, -1};
//初始化mp矩阵
int mp[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
mp[i][j] = INT_MAX >> 1;
}
}
//赋值mp矩阵
for (int i = 0; i < edgesSize; i++) {
int from = edges[i][0], to = edges[i][1], weight = edges[i][2];
mp[from][to] = mp[to][from] = weight;
}
//计算Floyd
for (int k = 0; k < n; ++k) {
//对角线,k到k的距离是0
mp[k][k] = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
//更新Floyd距离
mp[i][j] = fmin(mp[i][j], mp[i][k] + mp[k][j]);
}
}
}
//统计距离阈值内的城市数目
for (int i = 0; i < n; ++i) {
int cnt = 0;
//计算以i为起点,在距离阈值内的j城市数目
for (int j = 0; j < n; ++j) {
if (mp[i][j] <= distanceThreshold) {
cnt++;
//实际上这里计算了m[k][k],但是由于每一个城市都多计算了一个,所以没有影响
}
}
//如果cnt的城市数目更少,更新ans0为计数,ans1为编号
if (cnt <= ans[0]) {
ans[0] = cnt;
ans[1] = i;
}
}
//返回城市编号
return ans[1];
}
2656 K个元素的最大和(11.15)
给你一个下标从 0 开始的整数数组 nums
和一个整数 k
。你需要执行以下操作 恰好 k
次,最大化你的得分:
- 从
nums
中选择一个元素m
。 - 将选中的元素
m
从数组中删除。 - 将新元素
m + 1
添加到数组中。 - 你的得分增加
m
。
请你返回执行以上操作恰好 k
次后的最大得分。
提示:
1 <= nums.length <= 100
1 <= nums[i] <= 100
1 <= k <= 100
【贪心】
int maximizeSum(int* nums, int numsSize, int k){
int max=0;
for(int i=0;i<numsSize;i++){
max=fmax(max,nums[i]);
//O(n)找到nums的最大值
}
//max , max+1, ...,max+k-1,高斯求和即可
return max*k+(k-1)*k/2;
}
2760 最长奇偶子数组(11.16)
给你一个下标从 0 开始的整数数组 nums
和一个整数 threshold
。
请你从 nums
的子数组中找出以下标 l
开头、下标 r
结尾 (0 <= l <= r < nums.length)
且满足以下条件的 最长子数组 :
nums[l] % 2 == 0
- 对于范围
[l, r - 1]
内的所有下标i
,nums[i] % 2 != nums[i + 1] % 2
- 对于范围
[l, r]
内的所有下标i
,nums[i] <= threshold
以整数形式返回满足题目要求的最长子数组的长度。
注意:子数组 是数组中的一个连续非空元素序列。
提示:
1 <= nums.length <= 100
1 <= nums[i] <= 100
1 <= threshold <= 100
int longestAlternatingSubarray(int* nums, int numsSize, int threshold){
int cnt=0,n=numsSize,left=0;
while(left<n){
if(nums[left]>threshold || nums[left]%2==1){
left++;
continue;
}
int start=left;
left++;
while(left<n && nums[left]<=threshold && nums[left]%2!=nums[left-1]%2){
left++;
}
cnt=fmax(cnt,left-start);
}
return cnt;
}
//时间复杂度O(n),一次遍历,left只增不减
2736 最大和查询(11.17)
给你两个长度为 n
、下标从 0 开始的整数数组 nums1
和 nums2
,另给你一个下标从 1 开始的二维数组 queries
,其中 queries[i] = [xi, yi]
。
对于第 i
个查询,在所有满足 nums1[j] >= xi
且 nums2[j] >= yi
的下标 j
(0 <= j < n)
中,找出 nums1[j] + nums2[j]
的 最大值 ,如果不存在满足条件的 j
则返回 -1 。
返回数组 answer
*,*其中 answer[i]
是第 i
个查询的答案。
提示:
nums1.length == nums2.length
n == nums1.length
1 <= n <= 105
1 <= nums1[i], nums2[i] <= 109
1 <= queries.length <= 105
queries[i].length == 2
xi == queries[i][1]
yi == queries[i][2]
1 <= xi, yi <= 109
【单调栈 + 二分】
class Solution {
public:
vector<int> maximumSumQueries(vector<int>& nums1, vector<int>& nums2, vector<vector<int>>& queries) {
vector<pair<int, int>> sortedNums;
vector<tuple<int, int, int>> sortedQueries;
for (int i = 0; i < nums1.size(); i++) {
sortedNums.emplace_back(nums1[i], nums2[i]);
}
sort(sortedNums.begin(), sortedNums.end(), greater<pair<int, int>>());
for (int i = 0; i < queries.size(); i++) {
sortedQueries.emplace_back(i, queries[i][0], queries[i][1]);
}
sort(sortedQueries.begin(), sortedQueries.end(), [](tuple<int, int, int> &a, tuple<int, int, int> &b) {
return get<1>(a) > get<1>(b);
});
vector<pair<int, int>> stk;
vector<int> answer(queries.size(), -1);
int j = 0;
for (auto &[i, x, y] : sortedQueries) {
while (j < sortedNums.size() && sortedNums[j].first >= x) {
auto [num1, num2] = sortedNums[j];
while (!stk.empty() && stk.back().second <= num1 + num2) {
stk.pop_back();
}
if (stk.empty() || stk.back().first < num2) {
stk.emplace_back(num2, num1 + num2);
}
j++;
}
int k = lower_bound(stk.begin(), stk.end(), make_pair(y, 0)) - stk.begin();
if (k < stk.size()) {
answer[i] = stk[k].second;
}
}
return answer;
}
};
2342 数位和相等数对的最大和(11.18)
给你一个下标从 0 开始的数组 nums
,数组中的元素都是 正 整数。请你选出两个下标 i
和 j
(i != j
),且 nums[i]
的数位和 与 nums[j]
的数位和相等。
请你找出所有满足条件的下标 i
和 j
,找出并返回 nums[i] + nums[j]
可以得到的 最大值 。
提示:
1 <= nums.length <= 105
1 <= nums[i] <= 109
【hash】
int maximumSum(int* nums, int numsSize) {
int hash[82];
for(int i=0;i<82;i++){
hash[i]=0;
}
int ret=-1;
for(int i=0;i<numsSize;i++){
int sum=0,temp=nums[i];
while(temp>0){
sum+=temp%10;
temp/=10;
}
if(hash[sum]>0){
ret=fmax(ret,hash[sum]+nums[i]);
}
hash[sum]=fmax(hash[sum],nums[i]);
}
return ret;
}
689 三个无重叠子数组的最大和(11.19)
给你一个整数数组 nums
和一个整数 k
,找出三个长度为 k
、互不重叠、且全部数字和(3 * k
项)最大的子数组,并返回这三个子数组。
以下标的数组形式返回结果,数组中的每一项分别指示每个子数组的起始位置(下标从 0 开始)。如果有多个结果,返回字典序最小的一个。
提示:
1 <= nums.length <= 2 * 104
1 <= nums[i] < 216
1 <= k <= floor(nums.length / 3)
【滑动窗口】
class Solution {
public:
vector<int> maxSumOfThreeSubarrays(vector<int>& nums, int k) {
vector<int> ans;
int sum1=0,maxsum1=0,maxsum1id=0;
int sum2=0,maxsum12=0,maxsum12id1=0,maxsum12id2=0;
int sum3=0,maxsum3=0;
//初始化
for(int i=k*2;i<nums.size();i++){
//以第三个窗口为基准,进行判定
sum1+=nums[i-k*2];
sum2+=nums[i-k];
sum3+=nums[i];
//求出当前三个窗口的元素和,也就是初始的划分
if(i>=k*3-1){
//如果第三个窗口已经遍历完成
if(sum1>maxsum1){
//如果新的sum1大于原来的,则更新maxsum1
maxsum1=sum1;
maxsum1id=i-k*3+1;//同时更新maxsum1的id
}
if(maxsum1+sum2>maxsum12){
//如果新的sum12大于原来的,则更新maxsum12
maxsum12=maxsum1+sum2;
maxsum12id1=maxsum1id;
maxsum12id2=i-k*2+1;
}
if(maxsum12+sum3>maxsum3){
//如果新的sum123大于原来的,则更新maxsum3
maxsum3=maxsum12+sum3;
ans={maxsum12id1,maxsum12id2,i-k+1};
}
sum1-=nums[i-k*3+1];
sum2-=nums[i-k*2+1];
sum3-=nums[i-k+1];
//已经向右滑动了,去掉首位值
}
}
return ans;
}
};
/*
使用3个大小为k的滑动窗口
sum1是第一个的元素和,【0,k-1】
sum2是第二个的元素和,【k,2k-1】
sum3是第三个的元素和,【2k,3k-1】
同时向右滑动三个窗口
维护maxsum12和对应的位置
仅当元素和超过最大元素和时才修改最大元素和
*/
53 最大子数组和(11.20)
给你一个整数数组 nums
,请你找出一个具有最大和的连续子数组(子数组最少包含一个元素),返回其最大和。
子数组 是数组中的一个连续部分。
提示:
1 <= nums.length <= 105
-104 <= nums[i] <= 104
【动态规划】
int maxSubArray(int* nums, int numsSize){
int f=0,max=nums[0];
for (int i=0;i<numsSize;i++){
f=fmax(f+nums[i],nums[i]); //最大前缀和维护,f(i)=f(i-1)+nums[i] or f(i)=nums[i]
max=fmax(max,f); //最大值维护,旧值or最大前缀和+当前nums[i]
}
return max;
}
//f(i) 代表以第 i 个数结尾的「连续子数组的最大和」
//求出每个位置的 f(i),然后返回 f 数组中的最大值即可