牛牛分蛋糕

贪心+暴力

忽略两种不能放在一盘，那么 最小值 = ，且至多有一盘是混装 数量大于等于这个最小值
​
加个盘子,蛋糕不变，一样的方法 最小值 = , n 个盘子合法，至多有一盘是混装 数量大于等于这个最小值​

所以值的范围 , 复杂度大概在​​

主要数据范围小，好像怎么都能过

    int splitCake(int n, int a, int b) {
        int m = min(min(a,b),(a+b)/n); // 数据较弱，没有min(a,b)也能过 2,10000,1000
        while(m){
            if(a/m+b/m >= n) return m;
            m-=1;
        }
        return m;
    }

    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 处理函数，返回在所有分法中，蛋糕数量最少的盘子中分到最多的蛋糕数量
     * @param n int整型 n个盘子
     * @param a int整型 a蛋糕数量
     * @param b int整型 b蛋糕数量
     * @return int整型
     */
   public int splitCake(int n, int a, int b) {
        if (a + b == n) {
            return 1;
        }
        //标准2分框架 ， 套就完事了
        int left = 0, right = a + b;
        while (left < right) {
            int mid = left + (int)Math.ceil((right - left) / 2.0);
            if (check(mid, n, a, b)) {
                //够分的话 ， 缩小左侧区间
                left = mid;
            } else {
                //这里为什么是-1 ？  因为  mid肯定是不够分的， 所以值要减少
                right = mid - 1;
            }
        }
        //返回left , right 随便那个。
        return left;

    }

    /**
     * 是否够分？ true 够 。
     *
     * @param mid 最少值
     * @param n   盘子数
     * @param a  A 蛋糕数量
     * @param b  B 蛋糕数量
     * @return
     */
    private boolean check(int mid, int n, int a, int b) {
        int count = 0;
        while (a - mid > 0){
            a -= mid;
            count++;
        }
        while (b - mid > 0){
            b -= mid;
            count++;
        }
        //如果count数量大于 盘子数， 说明是够分的。 
        return count >= n ;
    }

class Solution:
    def solve(self , n , a , b ):
        # write code here
        ans=0
        for i in range(1,n):
            ans=max(ans,min(a//i,b//(n-i)))
        return ans