zoukankan      html  css  js  c++  java
  • 768. Max Chunks To Make Sorted II

    This question is the same as "Max Chunks to Make Sorted" except the integers of the given array are not necessarily distinct, the input array could be up to length 2000, and the elements could be up to 10**8.


    Given an array arr of integers (not necessarily distinct), we split the array into some number of "chunks" (partitions), and individually sort each chunk.  After concatenating them, the result equals the sorted array.

    What is the most number of chunks we could have made?

    Example 1:

    Input: arr = [5,4,3,2,1]
    Output: 1
    Explanation:
    Splitting into two or more chunks will not return the required result.
    For example, splitting into [5, 4], [3, 2, 1] will result in [4, 5, 1, 2, 3], which isn't sorted.
    

    Example 2:

    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.

    Note:

    • arr will have length in range [1, 2000].
    • arr[i] will be an integer in range [0, 10**8].

    Approach #1: Array. [Java]

    class Solution {
        public int maxChunksToSorted(int[] arr) {
            int n = arr.length;
            
            int[] maxOfLeft = new int[n];
            int[] minOfRight = new int[n];
            
            maxOfLeft[0] = arr[0];
            for (int i = 1; i < n; ++i)
                maxOfLeft[i] = Math.max(maxOfLeft[i-1], arr[i]);
            
            minOfRight[n-1] = arr[n-1];
            for (int i = n-2; i >= 0; --i) 
                minOfRight[i] = Math.min(minOfRight[i+1], arr[i]);
            
            int res = 0;
            for (int i = 0; i < n-1; ++i) 
                if (maxOfLeft[i] <= minOfRight[i+1])
                    res++;
            
            return res+1;
        }
    }
    

      

    Analysis:

    Iterate through the array, each time all elements to the left are smaller (or equal) to all elements to the right, there is a new chunck.

    Use two arrys to store the left max and right min to achieve O(n) time complexity. Space complexity is O(n) too.

    This algorithm can be used to solve verl too.

    Reference:

    https://leetcode.com/problems/max-chunks-to-make-sorted-ii/discuss/113462/Java-solution-left-max-and-right-min.

    永远渴望,大智若愚(stay hungry, stay foolish)
  • 相关阅读:
    tkinter 进度条
    tkinter 提示符
    python 将字符串转换为字典
    pycurl实例详解
    pyAudio介绍
    Spyer中添加一些常用包的方法
    对机器学习与数据竞赛的一些总结(转)
    教你如何在机器学习竞赛中更胜一筹
    CXF:通过WebService上传文件,包括大文件的处理
    firefox中flash经常崩溃
  • 原文地址:https://www.cnblogs.com/h-hkai/p/10661396.html
Copyright © 2011-2022 走看看