leetcode 1499. 满足不等式的最大值—(每日一难day20)

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 中最大的那个。

示例 2：

输入：points = [[0,0],[3,0],[9,2]], k = 3
输出：3
解释：只有前两个点满足 |xi - xj| <= 3 代入方程后得到值 0 + 0 + |0 - 3| = 3 。

提示：

1. 2 <= points.length <= 1e5
2. points[i].length == 2
3. -1e8 <=points[i][0], points[i][1] <= 1e8
4. 0 <= k <= 2 * 1e8
5. 对于所有的1 <= i <j <= points.length ，points[i][0] < points[j][0] 都成立。也就是说，xi是严格递增的。

相似题目，更容易理解

解析

1. 需要求得yi + yj + |xi - xj|的最大值，很自然的想法就是暴力枚举每个点，按照此式计算每一种可能的值。会超时，应该怎么优化呢？
2. 像这种问题我们免不了枚举每个点，但是题目中还会有其他条件没有结合，比如（1）对于下标 j > i 有 xj > xi，（2）此式yi + yj + |xi - xj|中j>i,以及（3）求最大值。这些条件我们都没有用到呢。
3. 将 yi + yj + |xi - xj|去绝对值–> yi + yj + xj - xi,现在我们要找的是横坐标距离最大 + 高度（y值）最大，因此x，y是等价的。如果枚举 j ，那么每次枚举xj + yj 是固定的，因此只需要寻找满足条件的最大的 yi-xi（看作一个整体）。
4. 寻找满足条件的最大的 yi - xi 就可以了，条件1： 对于下标 j > i 有 xj > xi。有这么一个特点，如果m > n ,那么xm > xn,也就是说m相对于n更加靠近 j，如果 ym - xm > yn - xn,我们是不是就可以舍弃n这点了，这就引入了单调队列的做法。
5. 用一个单调递减的双端队列维护yi - xi ,每次找其最大值时从队尾查找，将队尾不符合条件的pop，每次插从队头插入，将小值pop。

code

class Solution {
public:
   // 单调递减队列
   int findMaxValueOfEquation(vector<vector<int>>& points, int k) {
       int n=points.size();
       deque<pair<long long,long long>> dq;
       dq.push_front(make_pair(points[0][1]-points[0][0],points[0][0]));
       long long res=INT_MIN;
       for(int i=1;i<n;i++){
       // 不符合条件的队尾删除（对于当前i不符合，后续i也不符合）
           while(!dq.empty()&&dq.back().second+k<points[i][0]){
               dq.pop_back();
           }
           // 枚举每个i求最大值（如果和前一个元素相差>K,就为空）
           if(!dq.empty())
               res=max(res,dq.back().first+points[i][0]+points[i][1]);
           // 插入
           while(!dq.empty()&&dq.front().first<points[i][1]-points[i][0]){
               dq.pop_front();
           }
           dq.push_front(make_pair(points[i][1]-points[i][0],points[i][0]));
       }
       return res;
   }
}; 

总结：单调队列往往会有位置关系，同样也有个优先级的关系，后边的总时优于前边的。加上一定的限制就成为了双端队列，同时可以舍弃前边不符合条件的元素。