LC-1499. 满足不等式的最大值（单调队列、优先队列 + 同向双指针）

1499. 满足不等式的最大值

难度困难80

给你一个数组 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 。

提示：

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

优先队列 + 滑动窗口

1. 由于|xi - xj| <= k和 xi < xj，可以使用同向双指针，枚举右端点寻找最大值。

2. 等式变形：=>yi - xi + yj + xj，发现右端点不会改变，改变值只有yi - xi，可以使用优先队列维护窗口内yi - xi最大值

class Solution {
    //  yi + yj + |xi - xj| =>  yi + yj + xj - xi =>  yi - xi + yj + xj
    public int findMaxValueOfEquation(int[][] points, int k) {
        int n = points.length;
        // 优先队列，维护区间 [left, right] 内 yi - xi 的最大值
        PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> (b[1] - b[0]) - (a[1] - a[0]));
        pq.add(points[0]);
        int ans = Integer.MIN_VALUE, left = 0; 
        for(int right = 1; right < n; right++){
            while(points[right][0] - points[left][0] > k){
                pq.remove(points[left]);
                left += 1;
            }
            if(left != right){
                int[] mx = pq.peek();
                ans = Math.max(ans, - mx[0] + mx[1] + points[right][1] + points[right][0]);
            }    
            pq.add(points[right]);
        }
        return ans;
    }
}

单调队列

class Solution {
    //  yi + yj + |xi - xj| =>  yi + yj + xj - xi =>  yi - xi + yj + xj
    // 枚举j，问题变成计算 yi - xi 的最大值（老员工的能力必须比新来的强。否则就淘汰）
    public int findMaxValueOfEquation(int[][] points, int k) {
        int ans = Integer.MIN_VALUE;
        // 单调队列存储二元组(xi, yi - xi)
        Deque<int[]> q = new ArrayDeque<>();
        for(int[] p : points){
            int x = p[0], y = p[1];
            while(!q.isEmpty() && q.peekFirst()[0] < x - k) // 队首超出范围
                q.pollFirst();
            if(!q.isEmpty())
                ans = Math.max(ans, x + y + q.peekFirst()[1]);
            while(!q.isEmpty() && q.peekLast()[1] <= y - x) 
                q.pollLast();
            q.addLast(new int[]{x, y-x});
        }
        return ans;
    }
}