1493. Longest Subarray of 1's After Deleting One Element

Problem

Given a binary array nums, you should delete one element from it.

Return **the size of the longest non-empty subarray containing only **1's in the resulting array. Return 0 if there is no such subarray.

  Example 1:

Input: nums = [1,1,0,1]
Output: 3
Explanation: After deleting the number in position 2, [1,1,1] contains 3 numbers with value of 1's.

Example 2:

Input: nums = [0,1,1,1,0,1,1,0,1]
Output: 5
Explanation: After deleting the number in position 4, [0,1,1,1,1,1,0,1] longest subarray with value of 1's is [1,1,1,1,1].

Example 3:

Input: nums = [1,1,1]
Output: 2
Explanation: You must delete one element.

  Constraints:

• 1 <= nums.length <= 10^5

• nums[i] is either 0 or 1.

Solution (Java)

class Solution {
    public int longestSubarray(int[] nums) {
        int s = 0;
        int e = 0;
        int max = Integer.MIN_VALUE;
        boolean extraZero = false;
        boolean allOne = true;
        while (e < nums.length) {
            if (nums[e] == 1) {
                e++;
            } else if (!extraZero) {
                allOne = false;
                extraZero = true;
                e++;
            } else {
                allOne = false;
                max = Math.max(max, e - s - 1);
                while (nums[s] != 0) {
                    s++;
                }
                s++;
                extraZero = false;
            }
        }
        if (nums[e - 1] == 1) {
            max = Math.max(max, e - s - 1);
        }
        if (allOne) {
            return nums.length - 1;
        }
        return max == Integer.MIN_VALUE ? 0 : max;
    }
}

Explain:

nope.

Complexity:

• Time complexity : O(n).
• Space complexity : O(n).