如何解决codility minMaxDivision

如何解决如何解决codility minMaxDivision

我一直在努力解决有关1H30的可编码性问题，以及如何用二进制搜索解决问题。我找到了答案，但我无法理解其背后的逻辑。能得到它的人能帮我解答这个问题吗？

这是问题

任务说明

您将获得整数K，M和一个非空的零索引数组A 由N个整数组成。数组的每个元素都不大 比M。

您应该将此数组划分为K个连续元素块。 块的大小是0到N之间的任何整数。 该数组应该属于某个块。

从X到Y的块的总和等于A [X] + A [X + 1] + ... + A [Y]。 空块的总和等于0。

大和是任何块的最大和。

例如，给定整数K = 3，M = 5，数组A这样

A [0] = 2 A [1] = 1 A [2] = 5 A [3] = 1 A [4] = 2 A [5] = 2
A [6] = 2

例如，可以将数组划分为以下块：

[2，1，5，1，2，2，2]，[]，[]，总和为15； [2]，[1、5、1 2]，[2、2]，且总和为9； [2，1，5]，[]，[1,2,2]和 8的大笔钱; [2，1]，[5，1]，[2，2，2]的总和为6。

目标是最大程度地减少大笔款项。在上面的示例中，6是 最小的大笔款项。

编写函数：

函数解（K，M，A）；

，给定整数K，M和非空零索引数组A 由N个整数组成，返回最小的大和。

例如，假设K = 3，M = 5且数组A满足以下条件：

A [0] = 2 A [1] = 1 A [2] = 5 A [3] = 1 A [4] = 2 A [5] = 2
A [6] = 2

该函数应返回6，如上所述。

假设：

N和K是[1..100,000]范围内的整数； M是在[0..10,000]范围内的整数； 数组A的每个元素都是[0..M]范围内的整数。

这是我可以尝试的答案

function solution(K,M,A) {
    var begin = A.reduce((a,v) => (a + v),0)
    begin = parseInt((begin+K-1)/K,10);
    var maxA = Math.max(A);
    if (maxA > begin) begin = maxA;

    var end = begin + M + 1;
    var res = 0;

    while(begin <= end) {
        var mid = (begin + end) / 2;
        var sum = 0;
        var block = 1;
        for (var ind in A) {
            var a = A[ind];
            sum += a;
            if (sum > mid) {
                ++block;
                if (block > K) break;
                sum = a;
            }
        }
        if (block > K) {
            begin = mid + 1;
        } else {
            res = mid;
            end = mid - 1;
        }
    }
    return res;
}

解决方法

这是解决方案上的binary search。对于每个候选解决方案，我们对整个数组进行一次迭代，将数组块填充到该块超过候选值之前可以达到的最大和。如果总和不可行，那么尝试较小的总和就没有意义，因此我们搜索可能的较高候选人的空间。如果总和是可以实现的，我们将尝试使用较低的候选空间，而我们可以。

,

我对代码进行了一些更改，以便更加清楚，但这是我的解释：

/*
K = numberOfBlocks
M = maxNumber
A = array
*/

function solution(numberOfBlocks,maxNumber,array) {

    let begin = array.reduce((a,b) => (a + b),0);  // Calculate total sum of A
    begin = Math.ceil(begin / numberOfBlocks);       // Calculate the mean of each theorethical block
    begin = Math.max(begin,Math.max(...array));     // Set begin to the highest number in array if > than the mean

    // In short: begin is now the smallest possible block sum


    // Calculate largest possible block sum
    let end = begin + maxNumber + 1;
    var result = 0;

    while (begin <= end) {

        // Calculate the midpoint,which is our result guess
        const midpoint = (begin + end) / 2;

        let currentBlockSum = 0;
        let block = 1;

        for (let number of array) {
            currentBlockSum += number;

            // If currentBlockSum > midpoint means that we are
            // in a different block...
            if (currentBlockSum > midpoint) {
                ++block;

                // ...so we reset sum with the current number
                currentBlockSum = number;

                // but if we are out of blocks,our guess (midpoint) is incorrect
                // and we will have to adjust it
                if (block > numberOfBlocks)
                    break;  
            }
        }


        // If we are out of blocks
        // it means that our guess (midpoint) is bigger than we thought
        if (block > numberOfBlocks) {
            begin = midpoint + 1;
        // else,it's smaller
        } else {
            result = midpoint;
            end = midpoint - 1;
        }
    }

    return result;
}