小红的数组操作

public int minMax (ArrayList<Integer> a, int k, int x) {
        // write code here
        //创建最大优先队列（大在头）
        PriorityQueue<Integer> queue1 = new PriorityQueue<>( (o1,o2) -> o2-o1);
        //添加元素进入优先队列
        for (int i:a){
            queue1.add(i);
        }
        //k次最大值-x
        for (int j=0;j<k;j++){
            //弹出最大值-x，在插入
            int max = queue1.poll();
            queue1.add(max-x);
        }
        return queue1.poll();
    } 

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param a int整型vector 
     * @param k int整型 
     * @param x int整型 
     * @return int整型
     */
    bool check(vector<int>& a, int mid, int k, int x) {
        int cnt = 0;
        for(int i = 0; i < a.size(); ++i) {
            if(a[i] > mid) {
                cnt += (a[i] - mid)/x + ((a[i]-mid)%x > 0 ? 1:0);
                // 如果(a[i] - mid)%x大于0，则表明没有减干净，有剩余，而题目的要求是要所有的值小于mid，那么就得多来一个x，把这个剩余值干掉
            }
            if(cnt > k)    return true;
        }
        return false;
    }

    int minMax(vector<int>& a, int k, int x) {
        // write code here
        sort(a.begin(), a.end());
        int l = -k*x, r = a[a.size()-1];
        while(l < r) {
            int mid = (r - l)/2 + l;
            if(check(a, mid, k, x))    l = mid + 1;
            else r = mid;
        }
        return l;
    }
};

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param a int整型ArrayList
     * @param k int整型
     * @param x int整型
     * @return int整型
     */
    public int minMax (ArrayList<Integer> a, int k, int x) {
        // write code here
        PriorityQueue<Integer> q = new PriorityQueue<>((o1, o2) -> o2 - o1);
        for(int i = 0; i < a.size(); i++) {
            q.add(a.get(i));
        }
        while(k -- > 0) {
            int top = q.poll();
            top -= x;
            q.add(top);
        }
        return q.peek();
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
public class Main2 {
    static InputStreamReader in=new InputStreamReader(System.in);
    static BufferedReader br=new BufferedReader(in);
    static final int MAXN = 100100;
    static long n, k, x;
    static long[] a = new long[MAXN];
    public static void main(String[] args) throws IOException {
        String[] nkx=br.readLine().split(" ");
        n = Long.parseLong(nkx[0]);
        k = Long.parseLong(nkx[1]);
        x = Long.parseLong(nkx[2]);
        String[] arrStr=br.readLine().split(" ");
        for (int i = 1; i <= n; i++) {
            a[i] = Long.parseLong(arrStr[i-1]);
        }

        long l = Long.MIN_VALUE, r = Long.MAX_VALUE, ans = 0;
        // l-----r
        while (r >= l) {
            long mid = (l + r) / 2;
            if (check(mid)) {
                //缩小范围
                r = mid - 1;
                ans = mid;
            }
            else {
                //扩大范围
                l = mid + 1;
            }
        }

        System.out.println(ans);
    }

    static boolean check(long ma) {
        long z = 0;
        for (int i = 1; i <= n; i++) {
            if (a[i] > ma) {
                z += (a[i] - ma) / x;
                if ((a[i] - ma) % x > 0) {
                    z++;
                }
            }
            if (z > k) {
                return false;
            }
        }
        return k >= z;
    }
}

这题是故意考察二分的，二分的时间复杂度是N,如果用优先队列的话时间复杂度为K*lg(N),这题肯定是K设置的比N大的多，所以你要是用大顶堆会超时

class Solution:
    def check(self,mid, a, k ,x):
        count = 0
        for num in a:
            if num > mid:
                count += (num - mid + x - 1) // x
        return count <= k

    def minMax(self , a: List[int], k: int, x: int) -> int:
        left = min(a)-k*x
        right = max(a)
        while left < right:
            mid = (left + right) // 2
            if self.check(mid, a, k,x):
                right = mid
            else:
                left = mid + 1
        return left

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param a int整型vector 
     * @param k int整型 
     * @param x int整型 
     * @return int整型
     */
    int minMax(vector<int>& a, int k, int x) {
        priority_queue<int> pq(a.begin(),a.end());
        while(k --) {
            int t = pq.top();
            pq.pop();
            pq.push(t - x);
        }
        return pq.top();
    }
};

public static int minMax(ArrayList<Integer> a, int k, int x) { Integer[] array; //如果a.size 大于k， 那就从前k个数里面下手  if(a.size()>k){ PriorityQueue<Integer> minheap = new PriorityQueue<>(k); Iterator<Integer> it = a.iterator(); //首先提前把k个元素放进最小堆  for (int i = 0; i < k; i++) { it.next(); minheap.add(a.get(i));
        } while (it.hasNext()) { int num = it.next(); if (num > minheap.peek()) { minheap.add(num); minheap.poll();
            }
        } array= minheap.toArray(new Integer[0]);
    }else{ //如果a.size小于k  array = a.toArray(new Integer[0]);
    } Arrays.sort(array); while (k > 0) { array[array.length - 1] -= x; Arrays.sort(array);
        k--;
    } return array[array.length - 1]; // write code here }

import java.util.*;


public class Solution {
    public int minMax (ArrayList<Integer> a, int k, int x) {
        //创建优先级队列，并使用Collections.reverseOrder()构造一个最大优先队列
        PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());
        //调用addAll方法直接传入ArrayList集合
        pq.addAll(a);
        return minMaxHelp(pq,k,x);
    }
    public int minMaxHelp(PriorityQueue<Integer> pq , int k ,int x) {
        //偷窥当前队列中的最大优先级数值
        int peek = pq.peek();
        int peek1 = peek - x;
        k--;
        //移除最大优先级数值
        pq.remove(peek);
        //添加操作后的数值
        pq.add(peek1);
        //操作次数为0就返回队列中最大优先级数值，否则就递归调用
        if (k == 0) return pq.peek();
        return minMaxHelp(pq,k,x);
    }
}

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param a int整型vector
     * @param k int整型
     * @param x int整型
     * @return int整型
     */
    int minMax(vector<int> &a, int k, int x) {
        // write code here
        priority_queue<int> pq;
        for (int i : a) {
            pq.emplace(i);
        }
        for (int i = 0; i < k; i++) {
            int mx = pq.top() - x;
            pq.pop();
            pq.emplace(mx);
        }
        return pq.top();
    }
};

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param a int整型ArrayList 
     * @param k int整型 
     * @param x int整型 
     * @return int整型
     */
    public int minMax (ArrayList<Integer> a, int k, int x) {
        // write code here
        PriorityQueue<Integer> queue = new PriorityQueue<>(new Comparator<Integer>(){
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        for (Integer num : a) {
            queue.offer(num);
        }
        for (int i = 0; i < k; i++) {
            Integer num1 = queue.poll();
            queue.offer(num1-x);
        }
        return queue.peek();
    }
}