力扣1300. 转变数组后最接近目标值的数组和的题解

题目

思路

很惭愧的是最终我的解法没有用到提示里面的二分法。刚开始以为是用贪心算法，或者往回溯递归的方面去想。后面开始思考时才发现这道题比较特别。

有几种情况会让人很抓狂：当输出不为数组中任何一个元素时。如果这个元素比数组中任何一个数都要小，那么比较好解决。
但是如果这个元素夹在中间，那么就很难办了。我们需要通过遍历来找到那个满足条件的值。
如果题目固定给出一个恰好等于target的答案，那么会变得很简单。但是题目很鸡贼，说可能存在多个答案，若存在这种情况，选择更小的作为答案。这又要让我们对这种情况进行一个if-else的讨论。

总的思路如下：
如果数组中最小的值，乘上数组大小，都比target大，那么只需要直接除法便可以找到答案。
如果数组本身的和小于target，那么不用做任何操作，直接返回数组最大值即可。
如果答案存在于数组的值中间。我们需要构建一个int变量sumleft，负责计算当前数组的值的左边的下标的值的和。然后试探的通过计算判断，如果右边的值全部变成当前的值，sum会不会大于target。如果大于target了，就直接可以开始我们上文所讲的if-else的讨论了。

代码

class Solution {
public:
    int findBestValue(vector<int>& arr, int target) {
        int sum=0;
        sort(arr.begin(),arr.end());
        for(int k:arr){
            sum+=k;

        }
        if(sum<=target)return arr[arr.size()-1];//和小于等于targettarget就没有改变的必要了      
        if(arr[0]*arr.size()==target)return arr[0];//刚好等于，直接就返回最小的值
        if(arr[0]*arr.size()>target){//大于 的情况
            int tmp=target/arr.size();//注意这里往下取整 进而引出下面的tmp+1
            int ans1=tmp*arr.size();
            int ans2=tmp*arr.size()+arr.size();//实际上就是size乘上tmp+1 主要针对万一tmp+1可以让差值更小的情况 
            if(abs(ans1-target)<=abs(ans2-target))return tmp;
            else return tmp+1;
        }

        int len=arr.size();//方便记号
        int sumleft=arr[0];
        //上面讨论了arr[0] 所以这里直接从arr[1]开始
        for(int i=1;i<len;i++){
            int tmpsum=sumleft+arr[i]*(len-i);
            if(tmpsum>=target){//出现了大于等于target的情况
            	//结果出现在arr[i]附近 有可能左边也有可能右边 也有可能是他自己
            	//这里tmp=arr[i]不行的原因是，tmpsum可能比target大很多 答案不一定在arr[i]附近
                int tmp=(target-sumleft)/(len-i);
                if(target-tmp*(len-i)-sumleft<=sumleft+(tmp+1)*(len-i)-target){
                    return tmp;
                }
                //这里直接把三种情况都一次性解决了 因为是向下取整 所以小于或者等于arr[i]的值直接是tmp 大于等于arr[i]自然是tmp+1了
                else return tmp+1;
            }
            sumleft+=arr[i];
        }
        return 0;

    }
};

另外一个思路的代码（未能通过）

为了防止进入误区，贴一下另外一个代码。
这个代码跟上面不同的是，不用for循环，而是while循环，实际上就是遍历arr最小的值到最大的值中间所有的值。从而找到答案。
但是存在的一个很大的弊端是，我们需要根据当前的数字是不是等于数组中的数，来判断大于等于当前的数字的值cnt要不要+1.这里给了后面tmp与tmp+1的讨论带来了很大的不方便。
于是只能够放弃这种解法，去参考网友们的sumleft解法。

从网友们的解答中，我也学到了vector在STL的新的函数。
求和函数：sum=accumulate(arr.begin(),arr.end(),0).
以及求arr末尾元素，arr.back().而不用再打一串arr.size()了。

class Solution {
public:
    int findBestValue(vector<int>& arr, int target) {
        int sum=0;
        sort(arr.begin(),arr.end());
        for(int k:arr){
            sum+=k;

        }
        if(sum<=target)return arr[arr.size()-1];//和小于等于targettarget就没有改变的必要了      
        if(arr[0]*arr.size()>target){
            int tmp=target/arr.size();
            int ans1=tmp*arr.size();
            int ans2=tmp*arr.size()+arr.size();//tmp+1
            if(abs(ans1-target)<=abs(ans2-target))return tmp;
            else return tmp+1;
        }
        int num=arr[arr.size()-2];
        
        int cnt=1;
        sum-=(arr[arr.size()-1]-num);
        cnt=2;
        num--;
        int i=arr.size()-3;//数组元素的下标
        while(i>=0&&num>=0&&sum>target){
            sum-=cnt;
            if(num==arr[i]){
                i--;
                cnt++;
            }
            num--;
            
        }
        if(cnt==2){//没有进入循环
            int tmp1=abs(sum-target);
            int tmp2=abs(sum+arr[arr.size()-1]-arr[arr.size()-2]-target);
            if(tmp1<=tmp2){
                return num+1;
            }
            else return arr[arr.size()-1];
        }

        int tmp1=abs(sum-target);
        int tmp2=abs(sum+cnt-target);
        if(tmp1<=tmp2)return num+1;
        else return num+2;


    }
};