1300. 转变数组后最接近目标值的数组和

给你一个整数数组 arr 和一个目标值 target ，请你返回一个整数 value ，使得将数组中所有大于 value 的值变成 value 后，数组的和最接近 target （最接近表示两者之差的绝对值最小）。

如果有多种使得和最接近 target 的方案，请你返回这些整数中的最小值。

请注意，答案不一定是 arr 中的数字。

示例 1：

输入：arr = [4,9,3], target = 10
输出：3
解释：当选择 value 为 3 时，数组会变成 [3, 3, 3]，和为 9 ，这是最接近 target 的方案。
示例 2：

输入：arr = [2,3,5], target = 10
输出：5
示例 3：

输入：arr = [60864,25176,27249,21296,20204], target = 56803
输出：11361

提示：

1 <= arr.length <= 10^4
1 <= arr[i], target <= 10^5

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/sum-of-mutated-array-closest-to-target
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路：
设S(i)=sum[i]+(len-1-i)*arr[i]，易知S(i)是单调非减函数
而要想最接近目标值，无非就是找最大的pos使得S(pos)<target和最小的pos使得S(pos)>=target
而这两个pos很明显是挨着的
那么二分查找最大的pos（以arr[pos]为value，使得sum[pos]+(len-1-pos)*arr[pos]<target）
如果能找到这样一个pos，那么value一定在[ arr[pos] , arr[pos+1] ]范围内
需要分配的值就是target-sum[pos]（设为c），要分配的份数就是len-1-pos（设为num）
设a=target/c，b=a+1，然后检验这两个数是否合法（是否大于等于arr[pos]且小于等于arr[pos+1]）
如果合法就比较谁更接近即可

class Solution {
    public int findBestValue(int[] arr, int target) {
        int len=arr.length;
        Arrays.sort(arr);//排序
        int[] sum=new int[len];
        sum[0]=arr[0];
        for(int i=1;i<len;i++){//求前缀和，方便检验
            sum[i]=sum[i-1]+arr[i];
        } 
        int ans=arr[len-1];//初值设为数组内最大的数，再大没有意义
        int mn=Math.abs(sum[len-1]-target);
        int l=0,r=len-2,mid;//二分查找最大的pos（以arr[pos]为value，使得sum[pos]+(len-1-pos)*arr[pos]<target）
        while(l<=r){
            mid=(l+r)>>1;
            if(sum[mid]+(len-1-mid)*arr[mid]<target) l=mid+1;
            else r=mid-1;
        }
        int pos=l-1;//如果pos>=0，那么value的值一定在[arr[pos],arr[pos+1]]范围内
        if(pos<0){
            int a=target/len;//向下取整
            int b=a+1;//如果不整除就是向上取整，否则就无效，会在范围判断中去掉
            if(a<=arr[0]){
                if(Math.abs(a*len-target)<mn){
                    mn=Math.abs(a*len-target);
                    ans=a;
                }
                else if(Math.abs(a*len-target)==mn&&a<ans){
                    ans=a;
                }
            }
            if(b<=arr[0]){
                if(Math.abs(b*len-target)<mn){
                    mn=Math.abs(b*len-target);
                    ans=b;
                }
                else if(Math.abs(b*len-target)==mn&&b<ans){
                    ans=b;
                }
            }
        }
        else{
            int num=len-1-pos;
            int c=target-sum[pos];//需要平均分配的值
            int a=c/num;//向下取整
            int b=a+1;//如果不整除就是向上取整，否则就无效，会在范围判断中去掉
            if(a>=arr[pos]&&a<=arr[pos+1]){
                if(Math.abs(sum[pos]+a*num-target)<mn){
                    mn=Math.abs(sum[pos]+a*num-target);
                    ans=a;
                }
                else if(Math.abs(sum[pos]+a*num-target)==mn&&a<ans){
                    ans=a;
                }
            }
            if(b>=arr[pos]&&b<=arr[pos+1]){
                if(Math.abs(sum[pos]+b*num-target)<mn){
                    mn=Math.abs(sum[pos]+b*num-target);
                    ans=b;
                }
                else if(Math.abs(sum[pos]+b*num-target)==mn&&b<ans){
                    ans=b;
                }
            }
        }
        return ans;
    }
}