Javascript LeetCode 768：在解决方案上构造一个变体，用于最大块以进行排序

LeetCode面临的挑战是：

给定一个整数数组（不一定是不同的），我们分割 将数组分为若干个“块”（分区），并分别 对每个块进行排序。连接它们之后，结果等于 排序数组

我们能制作的最大块数是多少

例如：

Input: arr = [2, 1, 3, 4, 4]
Output: 4
Explanation:
We can split into two chunks, such as [2, 1], [3, 4, 4].
However, splitting into [2, 1], [3], [4], [4] is the highest number of chunks possible.

（算法和解决方案被一个名为@benevolent的用户作为注释发布在解决方案页面上。不幸的是，我无法链接到它的注释）：

如果从

arr[0]

到（包括）

arr[k]

的最大值小于或等于最小值 从

arr[k+1]

到最后的数字，然后我们可以分成两个有效的 块。
举例说明：

   left        right  
[......max] [min......]  

要知道从

k

到

arr.length-1

的最小元素，我们可以 从右到左预计算

解决方案：

函数maxChunksToSorted（arr）{
var minRight=数组（arr.length）.fill（Number.MAX\u SAFE\u INTEGER）；
对于（变量i=arr.length-2；i>=0；--i）{
minRight[i]=Math.min（minRight[i+1]，arr[i+1]）；
}
var maxLeft=Number.MIN\u SAFE\u整数；
var ans=0；
对于（变量i=0；i如果（maxLeft这应该可以完成工作：

function chunk(list){
    let sortedList = list.slice();
    sortedList.sort();
    
    var beginIndex = -1; var biggestFound;
    var foundFirst = false; var foundLast = false; 
    
    for(var i = 0; i < list.length; i++){
        if(beginIndex == -1) {
            if(list[i] == sortedList[i]) print(list[i]);
            else {beginIndex = i; biggestFound = list[i];}
        }
        else{
            if(list[i] == sortedList[beginIndex]) foundFirst = true;
            if(list[i] > biggestFound) biggestFound = list[i];
            if(biggestFound == sortedList[i]) foundLast = true;
            if(foundFirst && foundLast){
                print(list.slice(beginIndex, i - beginIndex + 1));                
                foundFirst = false; foundLast = false; beginIndex = -1;
            }           
        }
    }
}

chunk([2,1,3,4,4]);

功能块（列表）{
让sortedList=list.slice（）；
sortedList.sort（）；
var beginIndex=-1；var biggestFound；
var foundFirst=false；var foundLast=false；
对于（变量i=0；ibiggestFound）biggestFound=list[i]；
如果（biggestFound==sortedList[i]）foundLast=true；
if（foundFirst和&foundLast）{
打印（list.slice（beginIndex，i-beginIndex+1））；
foundFirst=false；foundLast=false；beginIndex=-1；
}           
}
}
}
语块（[2,1,3,4,4]）；

正如我所评论的，如果一个块从位置
I
开始，它必须包含与排序数组中位置
I
对应的元素，如果它在位置
j
结束，它必须包含排序数组的索引
j
中的元素

当这两个条件都满足时，关闭块并开始新的块

复杂性是
O（n lg（n））
，其中
n
是数组的大小。
这应该可以完成以下工作：

function chunk(list){
    let sortedList = list.slice();
    sortedList.sort();
    
    var beginIndex = -1; var biggestFound;
    var foundFirst = false; var foundLast = false; 
    
    for(var i = 0; i < list.length; i++){
        if(beginIndex == -1) {
            if(list[i] == sortedList[i]) print(list[i]);
            else {beginIndex = i; biggestFound = list[i];}
        }
        else{
            if(list[i] == sortedList[beginIndex]) foundFirst = true;
            if(list[i] > biggestFound) biggestFound = list[i];
            if(biggestFound == sortedList[i]) foundLast = true;
            if(foundFirst && foundLast){
                print(list.slice(beginIndex, i - beginIndex + 1));                
                foundFirst = false; foundLast = false; beginIndex = -1;
            }           
        }
    }
}

chunk([2,1,3,4,4]);

功能块（列表）{
让sortedList=list.slice（）；
sortedList.sort（）；
var beginIndex=-1；var biggestFound；
var foundFirst=false；var foundLast=false；
对于（变量i=0；ibiggestFound）biggestFound=list[i]；
如果（biggestFound==sortedList[i]）foundLast=true；
if（foundFirst和&foundLast）{
打印（list.slice（beginIndex，i-beginIndex+1））；
foundFirst=false；foundLast=false；beginIndex=-1；
}           
}
}
}
语块（[2,1,3,4,4]）；

正如我所评论的，如果一个块从位置
I
开始，它必须包含与排序数组中位置
I
对应的元素，如果它在位置
j
结束，它必须包含排序数组的索引
j
中的元素

当这两个条件都满足时，关闭块并开始新的块

复杂性是
O（nlg（n））
，其中
n
是数组的大小。
我还没有真正理解代码…但我看到了两个区别：1.原始解决方案有
minRight[I]=Math.max（minRight[I+1]，arr[I+1]）；
而您的解决方案有
maxArr=Math.max（maxArr[I-1]，arr[I]）；
。请注意缺少的
-1
。2：非常确定您的
（var i=1；i当块的开头和结尾都在块内部时，块就结束了。如果这还不足以让您找到解决方案，请告诉我，然后我写一个详细的答案。上下文中的
currentmax
是什么？它会是当前块的最大值吗？如果是，它应该最初设置为一个非常小的值，然后，设置为
currentMax=Math.max（currentMax，arr[i]）
，所以它真的存储了最大值？而且，我认为这不起作用，因为您似乎只关注块的最大值，但块中还需要有最小值。如果块的最小值还不在其中，而您找到了最大值，则无法立即结束块。您的好的，
currentMax
的命名是错误的。它应该是
minLeft
，以镜像原始的
maxLeft
，所以我将在中编辑它。
maxLeft
确实是当前块的最大值，而
minLeft
是当前块的最小值。如果它对您仍然没有意义，我鼓励您提出您的疑问，因为这可能会帮助我理解镜像的错误。我还没有真正理解代码…但我看到了两个区别：1.原始解决方案有
minRight[I]=Math.max（minRight[I+1]，arr[I+1]）；
而您的解决方案有
maxArr[I]=Math.max（maxArr[I-1]，arr[I]）；
。请注意缺少的
-1
。2：非常确定您的
for（var i=1；i）一个块的开头和结尾都在其中时就结束了。如果这对您来说还不够的话