enter image description here
You are given an array A consisting of N integers.
You want to divide the array into non-intersecting contiguous subarrays to make it good.
An array is considered good if:

1. Each element belongs to exactly one subarray.
2. If we replace each subarray with the MEX (minimum excluded) of the values of the subarray, the resulting array is sorted in non-decreasing order.
   The MEX of a set is the smallest non-negative integer that does not belong to the set.
   For example:
   • The MEX of (2, 1) is 0 because 0 does not belong to the set.
   • The MEX of (3, 1, 0) is 2 because 0 and 1 belong to the set, but 2 does not.
   • The MEX of (0, 3, 1, 2) is 4 because 0, 1, 2, and 3 belong to the set, but 4 does not

To tackle the problem of finding the maximum sum of a contiguous subarray, I initially implemented a basic brute-force approach. This involved checking the sum of all possible subarrays using nested loops. While this method worked for smaller arrays, it proved inefficient for larger inputs due to its time complexity of
𝑂(𝑛^2)
O(n^2).

Next, I attempted to use Kadane’s Algorithm, which is known to solve this problem with a time complexity of
𝑂(𝑛)
O(n). In this approach, I maintained two variables: one for the maximum sum found so far and another for the current subarray sum. As I iterated through the array, I updated these variables accordingly.