769. Max Chunks To Make Sorted

package LeetCode_769

/**
 * 769. Max Chunks To Make Sorted
 * https://leetcode.com/problems/max-chunks-to-make-sorted/
 * Given an array arr that is a permutation of [0, 1, ..., arr.length - 1],
 * 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 = [4,3,2,1,0]
Output: 1
Explanation:
Splitting into two or more chunks will not return the required result.
For example, splitting into [4, 3], [2, 1, 0] will result in [3, 4, 0, 1, 2], which isn't sorted.

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

Note:
1. arr will have length in range [1, 10].
2. arr[i] will be a permutation of [0, 1, ..., arr.length - 1].
 * */
class Solution {
    /*
    * solution: use max array to keep tracking the maximum value until the current position,
    * for example:
    * original: 0, 2, 1, 4, 3, 5, 7, 6
      max:      0, 2, 2, 4, 4, 5, 7, 7
      sorted:   0, 1, 2, 3, 4, 5, 6, 7
      index:    0, 1, 2, 3, 4, 5, 6, 7
      chucks: [0],[2,1],[4,3],[5],[7,6]

      Time:O(n), Space:O(n)
    * */
    fun maxChunksToSorted(arr: IntArray): Int {
        if (arr == null || arr.isEmpty()) {
            return 0
        }
        var count = 0
        val n = arr.size
        val maxArray = IntArray(n)
        maxArray[0] = arr[0]
        for (i in 1 until n) {
            maxArray[i] = Math.max(maxArray[i - 1], arr[i])
        }
        for (i in 0 until n) {
            if (maxArray[i] == i) {
                count++
            }
        }
        return count
    }
}