【Leetcode Sheet】Weekly Practice 16

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];
}
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

2656 K个元素的最大和(11.15)

给你一个下标从 0 开始的整数数组 nums 和一个整数 k 。你需要执行以下操作 恰好 k 次，最大化你的得分：

1. 从 nums 中选择一个元素 m 。
2. 将选中的元素 m 从数组中删除。
3. 将新元素 m + 1 添加到数组中。
4. 你的得分增加 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;
}
1
2
3
4
5
6
7
8
9

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只增不减
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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;
    }
};
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
26
27
28
29
30
31
32
33
34
35
36
37
38

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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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和对应的位置
	仅当元素和超过最大元素和时才修改最大元素和
*/
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

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 数组中的最大值即可
1
2
3
4
5
6
7
8
9
10