【leetcode】周赛195--(1)1496. 判断路径是否相交 (2)1497. 检查数组对是否可以被 k 整除 (3)1498. 满足条件的子序列数目 (4)1499. 满足不等式的最大值pq

最新推荐文章于 2022-10-14 00:06:10 发布

肆一叁

最新推荐文章于 2022-10-14 00:06:10 发布

阅读量295

点赞数

分类专栏： oj 文章标签： leetcode

本文链接：https://blog.csdn.net/LanXinYue98/article/details/107242306

版权

oj 专栏收录该内容

42 篇文章 0 订阅

订阅专栏

1496、给你一个字符串 path，其中 path[i] 的值可以是 'N'、'S'、'E' 或者 'W'，分别表示向北、向南、向东、向西移动一个单位。

机器人从二维平面上的原点 (0, 0) 处开始出发，按 path 所指示的路径行走。

如果路径在任何位置上出现相交的情况，也就是走到之前已经走过的位置，请返回 True ；否则，返回 False 。

示例 1：
输入：path = "NES"
输出：false 
解释：该路径没有在任何位置相交。

原本想直接用unordered_set,但是用pair<int,int>作为class，无法自动初始化set，处理起来很麻烦，就换成vector。

后来证实使用set<pair<int,int>> st，也可以。

class Solution {
public:
    bool isPathCrossing(string path) {
        vector<pair<int,int>> vec;
        int x=0,y=0;
        vec.push_back({x,y});
        for(int i=0;i<path.size();i++){
            char c=path[i];
            if(c=='N'){
                y+=1;
            }else if(c=='S'){
                y-=1;
            }else if(c=='E'){
                x+=1;
            }else if(c=='W'){
                x-=1;
            }
            for(auto it:vec)
                if(it==pair<int,int>(x,y)) return true;
            vec.push_back({x,y});
        }
        return false;
    }
};

结果：

执行用时：4 ms, 在所有 C++ 提交中击败了96.62% 的用户

内存消耗：6.8 MB, 在所有 C++ 提交中击败了100.00% 的用户

class Solution {
public:
    bool isPathCrossing(string path) {
        set<pair<int,int>> st;
        int x=0,y=0;
        st.insert({x,y});
        for(auto c:path){
            switch(c){
                case'N':
                    y++;break;
                case'S':
                    y--;break;
                case'E':
                    x++;break;
                case'W':
                    x--;break;
            }
            if(st.count({x,y})) return true;
            st.insert({x,y});
        }
        return false;
    }
};

1497、给你一个整数数组 arr 和一个整数 k ，其中数组长度是偶数，值为 n 。

现在需要把数组恰好分成 n / 2 对，以使每对数字的和都能够被 k 整除。

如果存在这样的分法，请返回 True ；否则，返回 False 。

示例 1：

输入：arr = [1,2,3,4,5,10,6,7,8,9], k = 5
输出：true
解释：划分后的数字对为 (1,9),(2,8),(3,7),(4,6) 以及 (5,10) 。

正负数混合的取余。

// 每个元素取余入数组
// 余数为1，k-1的个数是否相同---------遇到负数怎么办？负数的取余公式！！
class Solution {
public:
    bool canArrange(vector<int>& arr, int k) {
       vector<int> mod(k);
        for(auto i:arr) mod[(i%k+k)%k]++;//attention here！
        for(int i=1;i<k;i++)
            if(mod[i]!=mod[k-i])
                return false;
        return mod[0]%2==0;    
    }
};

结果：

执行用时：284 ms, 在所有 C++ 提交中击败了53.90% 的用户

内存消耗：61.7 MB, 在所有 C++ 提交中击败了100.00% 的用户

MOD & 二分

1498、给你一个整数数组 nums 和一个整数 target 。

请你统计并返回 nums 中能满足其最小元素与最大元素的和小于或等于 target 的非空子序列的数目。

由于答案可能很大，请将结果对 10^9 + 7 取余后返回。

示例 1：

输入：nums = [3,5,6,7], target = 9
输出：4
解释：有 4 个子序列满足该条件。
[3] -> 最小元素 + 最大元素 <= target (3 + 3 <= 9)
[3,5] -> (3 + 5 <= 9)
[3,5,6] -> (3 + 6 <= 9)
[3,6] -> (3 + 6 <= 9)

价值一：大数mod的使用。

（1）初始化 int mod=int(1E9+7);

（2）注意时刻%mod，尤其是求幂运算，不要用pow(x,y)，用for循环还求解值，每个值%mod后加入数组。

价值二：二分运算，大大降低了时间。

// nums升序排列
// 先确定子序列的头尾，再判断包含该头的序列长度k，总数为2^k个子序列。
// {x1,x2,x3,x4}子序列中，必定出现x1，后面有3个元素的序列，共2^3个子序列，与x1结合则为结果。
// {x1,x2},{x1,x3},{x1,x4},{x1,x2,x3},{x1,x2,x4},{x1,x3,x4},{x1,x2,x3,x4}

class Solution {
public:
    int mod=int(1E9+7);
    int numSubseq(vector<int>& nums, int target) {
        sort(nums.begin(),nums.end());
        vector<int> po(nums.size(),1);
        // 避免pow超出范围，直接存2^i
        for(int i=1;i<nums.size();i++)
            po[i]=(po[i-1]*2)%mod;
        
        // 不用二分会超时
        // for(int i=nums.size()-1;i>=0;i--){
        //     if(nums[i]>target) continue;
        //     for(int j=i;j>=0;j--){
        //         if(nums[i]+nums[j]<=target) {
        //             ans+=po[max(0,i-j-1)];
        //             ans%=mod;
        //         }
        //     }
        // }

        // 二分解法
        int l=0,r=nums.size()-1,ans=0;
        while(l<=r){
            if(nums[l]+nums[r]<=target){ // l+1至r的任意序列，加上l元素，其最小值均为l，最大值均小于r，故最值和总小于target
                ans=(ans+po[r-l])%mod;
                l++;
            }else r--;
        }
        return ans;
    }
};

结果：

执行用时：448 ms, 在所有 C++ 提交中击败了61.39% 的用户

内存消耗：50.2 MB, 在所有 C++ 提交中击败了100.00% 的用户

1499、给你一个数组 points 和一个整数 k 。数组中每个元素都表示二维平面上的点的坐标，并按照横坐标 x 的值从小到大排序。也就是说 points[i] = [xi, yi] ，并且在 1 <= i < j <= points.length 的前提下， xi < xj 总成立。

请你找出 yi + yj + |xi - xj| 的最大值，其中 |xi - xj| <= k 且 1 <= i < j <= points.length。

题目测试数据保证至少存在一对能够满足 |xi - xj| <= k 的点。

示例 1：

输入：points = [[1,3],[2,0],[5,10],[6,-10]], k = 1
输出：4
解释：前两个点满足 |xi - xj| <= 1 ，带入方程计算，则得到值 3 + 0 + |1 - 2| = 4 。第三个和第四个点也满足条件，得到值 10 + -10 + |5 - 6| = 1 。
没有其他满足条件的点，所以返回 4 和 1 中最大的那个。

用常规解法，62 / 65 个通过测试用例。问题超时：

class Solution {
public:
    int findMaxValueOfEquation(vector<vector<int>>& points, int k) {
        int ans=-int(1E9+7);
        for(int i=0;i<points.size();i++){
            for(int l=1;l<=k;l++){
                if(i+l>=points.size()) break;
                if(abs(points[i][0]-points[i+l][0])<=k){
                    int sum=points[i][1]+points[i+l][1]+abs(points[i][0]-points[i+l][0]);
                    if(sum>ans) ans=sum;
                }
            }
        }
        return ans;
    }
};

修改：题目求max(y_i+y_j+|x_i-x_j|) ---> max(y_i+y_j+x_j-x_i)--->max( (y_i-x_i)+(x_j+y_j) )

问题就变成了，找到两个点，点 points[i] 的 y(i) - x(i) 和点 points[j] 的 y(j) + x(j) 的和最大。
限制条件是，x(i) <= x(j) 且最大相差 k。
因此，我们可以扫描所有的点，对于每一个点，看前面的点中，只要横坐标相差没有超过 k，其中最大的 y(i) - x(i) 是多少。

优先队列：priority_queue<Type> pq; 最高级先出（默认最大堆）.

Besides: pair的比较，先比较第一个元素，第一个相等比较第二个.

使用优先队列求区间最大值。优先队列中存储 (y - x, x) 的数据对。
每次搜索到一个新的 point，我们可以通过优先队列，直接取出之前的点中，y - x 的最大值。
不过，每次取出元素前，我们也需要检验一下，这个元素的 x 值是否满足限制条件。

class Solution {
public:
    int findMaxValueOfEquation(vector<vector<int>>& points, int k) {
        priority_queue<pair<int,int>> pq; //{y-x,x},大根堆维护O(logn)
        pq.push({points[0][1]-points[0][0],points[0][0]});
        int ans=-int(1E9);
        //复杂度O(n*logn)
        for(int i=1;i<points.size();i++){//对每一个xj,yj,找前面x轴k距离的xi,yi，且yi-xi max
            //先判断，当前拥有最大y-x的xi,与xj距离是否<k。删除距离xj大于k距离的xi，不断更新pq，直走距离<=k，且y-x max的xi出现。
            while(!pq.empty()&&points[i][0]-pq.top().second>k) pq.pop();
            // 判断是否q为全局最大max
            if(!pq.empty())
                ans = max(ans,points[i][0]+points[i][1]+pq.top().first);
            //更新pq
            pq.push({points[i][1]-points[i][0],points[i][0]});
        }
        return ans;
    }
};

结果：

执行用时：900 ms, 在所有 C++ 提交中击败了27.00% 的用户

内存消耗：92.6 MB, 在所有 C++ 提交中击败了100.00% 的用户

单调队列：双向队列（无序）

deque<Type> dq; 双向开口的连续线性空间,可以在头尾两端分别做元素的插入和删除操作.

dq.push_front(); dq.push_back(); dq.pop_front(); dq.pop_back();

dq.front();//返回第一个数据。 dq.back();//返回最后一个数据

dq.insert(pos,elem);//在pos位置插入一个elem元素的拷贝，返回新数据的位置。

dq.erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置。

dq.erase(pos);//删除pos位置的数据，返回下一个数据的位置。

从头到尾按照 y - x 递减的deque来获得区间最大值。dp存储 {y - x, x}。
遍历数组，对每个xj，我们可以通过dq，直接取出之前的点中，y - x 的最大值。不过，每次取出xi，检验xj-xi <=k是否满足

之后，我们从队尾把这个新的{yj-xj,xj}的信息放入到队列中。

为了维护队列的单调性，我们需要把队尾 y - x <= point[i][1] - points[i][0] 的元素删除掉。

class Solution {
public:
    int findMaxValueOfEquation(vector<vector<int>>& points, int k) {
        deque<pair<int,int>> dq;
        dq.push_back({points[0][1]-points[0][0],points[0][0]});
        int ans=-int(1E9);
        // dq按照y-x降序，维护。复杂度O(n*1),
        for(int i=1;i<points.size();i++){
            //前删不符合的当前max(y-x)的xi
            while(!dq.empty()&&points[i][0]-dq.front().second>k) dq.pop_front();
            // 求全局max
            if(!dq.empty())
                ans = max(ans,points[i][0]+points[i][1]+dq.front().first);
            //更新dq，为yj-xj在dq中找合适的位置
            while(!dq.empty()&&dq.back().first<=points[i][1]-points[i][0]) dq.pop_back();
            dq.push_back({points[i][1]-points[i][0],points[i][0]});
        } 
        return ans;
    }
};

结果：

执行用时：756 ms, 在所有 C++ 提交中击败了63.20% 的用户

内存消耗：91.2 MB, 在所有 C++ 提交中击败了100.00% 的用户

肆一叁

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【leetcode】周赛195--(1)1496. 判断路径是否相交 (2)1497. 检查数组对是否可以被 k 整除 (3)1498. 满足条件的子序列数目 (4)1499. 满足不等式的最大值pq

1496、给你一个字符串 path，其中 path[i] 的值可以是 'N'、'S'、'E' 或者 'W'，分别表示向北、向南、向东、向西移动一个单位。机器人从二维平面上的原点 (0, 0) 处开始出发，按 path 所指示的路径行走。如果路径在任何位置上出现相交的情况，也就是走到之前已经走过的位置，请返回 True ；否则，返回 False 。示例 1：输入：path = "NES"输出：false 解释：该路径没有在任何位置相交。原本想直接用unordered_set..
复制链接

扫一扫