每日一题算法：2020年7月25日 [分割数组的最大值 ]splitArray

2020年7月25日 分割数组的最大值 splitArray

class Solution {
    public int splitArray(int[] nums, int m) {

    }
}

解题思路：

首先，这道题是指分割连续的数组，而不是取出数组中的值来组成新的数组。

如果是用元素来组成，那么这案例的答案应该就是[7,8][10,5,2] 最小和17

思路1

暴力递归：

数组nums需要切割成4组。遍历前1个字符单独切割到前len-3个字符的情况，并且每种情况将剩余的数组和3进行递归计算，返回最小值。

代码实现：意料之中的时间超限

    int[] array;
    int len;
    public int splitArray(int[] nums, int m) {
        len=nums.length;
        //先对数组进行处理，减少之后的求和计算
        for (int i=1;i<len;i++){
            nums[i]=nums[i]+nums[i-1];
        }
        array=nums;
        if (m==1)
            return nums[len-1];
        return splitArray2(0,m);
    }


    public int splitArray2(int index,int m){
        int min=Integer.MAX_VALUE;
        int start=0;
        if (index-1>=0)
            start=array[index-1];
        if (m>2){

            for (;index<=len-m;index++){
               min=Integer.min(min, Integer.max(array[index]-start,splitArray2(index+1,m-1)));
            }
        }else
            //等于2时，可以直接求最小和
        {
            int end=array[len-1];
            if (index-1>=0)
                start=array[index-1];

            for (;index<len-1;index++){
                min=Integer.min(min,Integer.max(array[index]-start ,end-array[index] ));
            }
        }
        return min;
    }

进阶优化：

对每次splitArray2的操作进行记录，使用一个二维数组，如果二维数组的值为0，则进行计算，否则直接返回数组中的值。

    int[] array;
    int[][] log;
    int len;
    public int splitArray(int[] nums, int m) {
        len=nums.length;
        //先对数组进行处理，减少之后的求和计算
        for (int i=1;i<len;i++){
            nums[i]=nums[i]+nums[i-1];
        }
        array=nums;
        log=new int[len][m];
        if (m==1)
            return nums[len-1];

        return splitArray2(0,m);
    }


    public int splitArray2(int index,int m){
        if (log[index][m-1]==0){
            int oldindex=index;
            int min=Integer.MAX_VALUE;
            int start=0;
            if (index-1>=0)
                start=array[index-1];
            if (m>2){

                for (;(array[index]-start<=min)&&index<=len-m;index++){
                    min=Integer.min(min, Integer.max(array[index]-start,splitArray2(index+1,m-1)));
                }
            }else
            //等于2时，可以直接求最小和
            {
                int end=array[len-1];
                if (index-1>=0)
                    start=array[index-1];

                for (;index<len-1;index++){
                    min=Integer.min(min,Integer.max(array[index]-start ,end-array[index] ));
                }
            }
            log[oldindex][m-1]=min;
            return min;
        }
        return log[index][m-1];

    }