没参加，中午听朋友说这道题挺有趣，自己想到的一种解法

时间复杂度O(n），空间复杂度O(n)

对于这道题n=5....其实就是O(1)

突然想到，如果我最小的数也很大，一定走完的话肯定会跌落到O(n^2)，我自己想的话，最差情况也是从头到尾把第最小的数走完，所以其实是O(k)？晕了。。。

题目

给出5个数，每次挑选4个数减一，最小减到0，问能减几次？

样例

输入：8 5 4 4 3

过程：

手算假定每次都挑出来最大的4个减

7 4 3 3 3
6 3 3 2 2
5 2 2 2 1
4 1 1 1 1
3 1 0 0 0

答案是5次

思路

我的想法是，能不能有一种方法，让每次考虑“靠后”的数对于整体可减次数的影响时，能不考虑更“后面”数字的影响

有点像动态规划，第i个位置对于可减次数的影响取决于前i-1位置

最后想出：

首先排序，升序降序其实没有影响，在这里取升序
考虑每两个数之间的高低落差，如果本次挑出来的4个数中，较大的数和较小的数之间存在落差，那么需要没被选中的数来弥补这个落差。比如选中 4 4 4 5，那么如果最后想把这4个数都“用完”，需要有一个没被选中的数x来补充到 5 5 5 5。
这个过程在手算模拟中，其实就是4 4 4 5变成 3 3 3 4 后，下次挑出一个3出去，把没选中的x在下次参与运算。
更浅显的例子，3 4 4 4 5 等效于  0 5 5 5 5
那么每次选哪个数来补呢？其实是无所谓的，4 3 4 4 5中，用4做x来补3 4 4 5，其实等价于3 4 4 4 5中，用3做x补4 4 4 5。为了加速运算，用最小的补，当最小的没法补了结束

代码

    /**
     * 从后往前计算落差，最小位是用来补的所以不计
     * 比如  3 4 4 5 8  就是  4-4=0   5-4=1 8-5=3  最高位没有落差
     *
     * 目标是让最小位来将前面的落差补平，这样就相当于每次找4个时，用最小位“置换”了其中的一位
     *
     * 开始找落差
     * 从前往后找第一个不是0的落差，用最小位补给他
     * 但是要注意
     *  每次补一个落差就会让这个落差顺延到下一位，比如  4 4 5 8 ， 当试图补4到5这个落差时，实际上会生成第一个4到第二个4(现在是5)的新落差
     *
     * 模拟3 4 4 5 8
     *  首先找到了 1 ，说明 5和4差一个落差，补平以后(4 5 变成  5 5)会将落差1顺延到 4 4(原来是4 4落差0，现在成了4 5 落差1 )
     *  因此最小位3除了给4 5一个1，还需要给前面的4 4一个1，变成 5 5 5 8 ，最小位变成1
     *      即需要补的数是 1 * 2
     *
     *  再往前补 5 8落差3，最小位1不能补平了(补到 8 8 8 8要3*3 )
     *  这时取最低的那个数作为答案，即 5 5 5 8中的第一个5，
     *
     * 如果最小位全都补平了怎么办？比如 7 8 8 8 8，落差0 0 0，根本不需要补
     *  直接把7分配给后面四个数，一次分配成 3 9 9 9 9，第二次分配会产生新的落差 0 9 10 10 10，不能补平了，因此直接返回9即可
     *  即8+ (int) 7/4
     */
    static public int maxMinus(int [] ns){
        Arrays.sort(ns);
        int length = ns.length;

        int[] gap = new int[5];
        //倒着往前计算落差
        for(int i=length-2;i>=1;i--){
            gap[i] = ns[i+1]-ns[i];
        }

        //经过补充，没有考虑第一个落差都不够补的情况，比如1 2 4 4 5，1其实可以在2 4这个落差中使用一次的
        if(ns[0]<gap[1]){
            return ns[0]+ns[1];
        }

        //补落差
        for(int i=1;i<length-1;i++){
            //找到第一个不是0的落差
            if(gap[i]==0){
                continue;
            }
            //如果当前是2 3 4 5 6，第一个要补的是2-3
            //补的时候前面的数也要补
            int need = gap[i]*(i-1+1);
            //如果能补
            if(ns[0]>=need){
                //所有前面的数都补
                for(int j=1;j<=i;j++){
                    ns[j]+=gap[i];
                    ns[0]-=gap[i];
                }
            }
            else{
                //不够补了，返回当前除了need最小的数
                return ns[1];
            }

        }

        //补完以后没有返回，如果还有剩余的数
        if(ns[0]>0){
            return ns[1]+ns[0]/4;
        }
        //刚刚好补完
        return ns[1];
    }