对立问题思考，二分法逼近最大值的最小值

按顺序给出 n 个数，将 n 个数分为 m 段，使每段的和最大值最小，求改值最小为多少。

思考当前问题的对立问题：
对于一个值 max_value，判断是否可以将序列切分成连续的 m 段，并且使得每个子段和不大于 max_value 。

    定义变量 s，作为当前扩展子段的起始点，初始 s = 0。
    从 s 出发不断向右扫描，直到 t 位置，满足 sum( a[s…t] ) > max_value， 则将 s[ s, t-1 ] 作为一个子段。  

然后采用二分逼近的方法获取最小的最大值

 注意：二分逼近 这里只适用于离散的求取最大值

import java.util.Scanner;

public class Main {
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        int sum=0;
        int[] arr=new int[10000];
        int i=0;
        int hour=0;
        String s= scanner.nextLine();
        String[] split = s.split(",");
        for (i=0;i<split.length-1;i++){
            arr[i]=Integer.parseInt(split[i]);
            sum+=arr[i];
        }
        String[] s1 = split[split.length-1].split(" ");
        arr[i]= Integer.parseInt(s1[0]);
        hour=Integer.parseInt(s1[1]);
        sum+=arr[i];

        int max_min_size = binary_search(arr, arr.length, hour, sum);

        System.out.println(max_min_size);
    }

    /**
     * 二分法极限逼近
     * @param a
     * @param n
     * @param m
     * @param sum 数总和
     * @return
     */
    public static int binary_search(int a[],int n,int m,int sum){
        int low=0,high=sum,mid;
        while (high>low){
            mid=(low+high)/2;
            if (check(a, n, m,mid)){
                high=mid;
            }else {
                low=mid+1;
            }
        }
        return high;
    }

    /**
     * 最大值 把数组n个数分成m段
     * @param arr
     * @param n n个数
     * @param m 分成m段
     * @param max_val
     * @return
     */
     public static boolean check(int[] arr,int n,int m,int max_val){
        int cnt=0,sum=0;
        for (int i=0;i<n;i++){
            if (arr[i]>max_val){
                return false;
            }
            sum+=arr[i];
            if (sum>max_val){
                cnt++;
                sum=arr[i];
            }
        }
        cnt++;
        return cnt<=m;
     }
}