### Problem statement

Given a binary array nums, return the maximum length of a contiguous subarray with an equal number of 0 and 1.

Problem statement taken from: https://leetcode.com/problems/contiguous-array.

**Example 1:**

```
Input: nums = [0, 1]
Output: 2
Explanation: [0, 1] is the longest contiguous subarray with an equal number of 0 and 1.
```

**Example 2:**

```
Input: nums = [0, 1, 0]
Output: 2
Explanation: [0, 1] (or [1, 0]) is a longest contiguous subarray with equal number of 0 and 1.
```

**Constraints:**

```
- 1 <= nums.length <= 10^5
- nums[i] is either 0 or 1
```

### Explanation

#### Brute Force approach

The naive approach is to consider every subset of the array and verify if it has an equal number of 0's and 1's. Then we find out the maximum size subarray with equal no of 0's and 1's.

A C++ snippet of this approach looks as below:

```
int maxLength = 0;
for (int i = 0; i < nums.size(); i++) {
int zeroes = 0, ones = 0;
for (int j = i; j < nums.length; j++) {
if (nums[j] == 0) {
zeroes++;
} else {
ones++;
}
if (zeroes == ones) {
maxLength = Math.max(maxLength, j - i + 1);
}
}
}
return maxLength;
```

The time complexity of the above approach is **O(N^2)** which will timeout for big arrays.

#### Using additional array

In this approach, we use an additional array of size 2n + 1. We use an additional **sum** variable which will track the sum of the array elements while traversing. We will increment the sum by 1 when an element at a particular index is 1 and decrement the sum by -1 if the element is 0.

So the maximum and minimum sum we can reach is n and -n, where n is the size of the array. So we create an array of size 2n + 1 to keep track of the various sum's encountered so far. Whenever we come across the same sum value while traversing

the array, we compute the length of the subarray by subtracting the value at that index from the current index. We compare the above value with the maximum subarray we might have encountered previously.

A C++ snippet of this optimized approach looks as below:

```
int n = nums.size();
int array[2 * n + 1];
array[n] = -1;
int maxLength = 0, count = 0;
for (int i = 0; i < n; i++) {
count = count + (nums[i] == 0 ? -1 : 1);
if (array[count + n] >= -1) {
maxLength = max(maxLength, i - array[count + n]);
} else {
array[count + n] = i;
}
}
return maxLength;
```

The time complexity of the above approach is **O(N)**, and space complexity is **O(N)** for an array of size 2n + 1.

#### Using hash map

We can optimize the space to n by using a hash map instead of an array. The hash map will store the key-value pair in the form of index-sum.

We create an entry for a sum in the hash map whenever we encounter that sum for the first time and store its index as value. If we encounter the sum again, we subtract the existing index (value of hash map) from the current index.

Let's check the algorithm.

```
- set unordered_map[int, int] = {0 , -1}
set maxLength = 0, sum = 0
- loop for i = 0; i < nums.size(); i++
- sum = sum + (nums[i] == 1 ? 1 : -1)
// the sum exists in the hash map update the maxLength
// else set the current index for that sum
- if m.count(sum)
- maxLength = max(maxLength, i - m[sum])
- else
- m[sum] = i
- return maxLength
```

Let's check out our solutions in **C++**, **Golang**, and **Javascript**.

#### C++ solution

```
class Solution {
public:
int findMaxLength(vector<int>& nums) {
unordered_map<int, int> m{{0, -1}};
int maxLength = 0, sum = 0;
for(int i = 0; i < nums.size(); i++) {
sum = sum + (nums[i] == 1 ? 1 : -1);
if(m.count(sum)) {
maxLength = max(maxLength, i - m[sum]);
} else {
m[sum] = i;
}
}
return maxLength;
}
};
```

#### Golang solution

```
func max(a, b int) int {
if a > b {
return a
}
return b
}
func findMaxLength(nums []int) int {
m := make(map[int]int)
maxLength, sum := 0, 0
m[0] = -1
for i := 0; i < len(nums); i++ {
if nums[i] == 1 {
sum = sum + 1
} else {
sum = sum - 1
}
if index, ok := m[sum]; ok {
maxLength = max(maxLength, i - index)
} else {
m[sum] = i
}
}
return maxLength
}
```

#### Javascript solution

```
var findMaxLength = function(nums) {
let m = {0: -1};
let maxLength = 0, sum = 0;
for(let i = 0; i < nums.length; i++) {
sum = sum + (nums[i] == 1 ? 1 : -1);
if(m[sum] === undefined) {
m[sum] = i;
} else {
maxLength = Math.max(maxLength, i - m[sum]);
}
}
return maxLength;
};
```

Let's dry-run our algorithm to see how the solution works.

```
Input: [0, 1, 1, 0, 1, 1, 1, 0]
Step 1: unordered_map<int, int> m{{0, -1}}
maxLength = 0, sum = 0
Step 2: loop for i = 0; i < nums.size()
0 < 8
true
sum = sum + (nums[i] == 1 ? 1 : -1)
= 0 + (nums[0] == 1 ? 1 : -1)
= 0 + (0 == 1 ? 1 : -1)
= 0 + -1
= -1
if m.count(sum)
m.count(-1) // no key with -1
false
else
m[sum] = i
m[-1] = 0
i++
i = 1
Step 3: i < nums.size()
1 < 8
true
sum = sum + (nums[i] == 1 ? 1 : -1)
= -1 + (num[1] == 1 ? 1 : -1)
= -1 + (1 == 1 ? 1 : -1)
= -1 + 1
= 0
if m.count(sum)
m.count(0) // has key with 0
true
maxLength = max(maxLength, i - m[sum])
= max(0, 1 - (-1))
= max(0, 2)
= 2
i++
i = 2
Step 4: i < nums.size()
2 < 8
true
sum = sum + (nums[i] == 1 ? 1 : -1)
= 0 + (num[2] == 1 ? 1 : -1)
= 0 + (1 == 1 ? 1 : -1)
= 0 + 1
= 1
if m.count(sum)
m.count(1) // no key with -1
false
else
m[sum] = i
m[1] = 2
i++
i = 3
Step 5: i < nums.size()
3 < 8
true
sum = sum + (nums[i] == 1 ? 1 : -1)
= 1 + (num[3] == 1 ? 1 : -1)
= 1 + (0 == 1 ? 1 : -1)
= 1 + -1
= 0
if m.count(sum)
m.count(0) // has key with 0
true
maxLength = max(maxLength, i - m[sum])
= max(2, 3 - (-1))
= max(2, 4)
= 4
i++
i = 4
Step 6: i < nums.size()
4 < 8
true
sum = sum + (nums[i] == 1 ? 1 : -1)
= 0 + (num[4] == 1 ? 1 : -1)
= 0 + (1 == 1 ? 1 : -1)
= 0 + 1
= 1
if m.count(sum)
m.count(1) // has key with 1
true
maxLength = max(maxLength, i - m[sum])
= max(4, 4 - 2)
= max(4, 2)
= 2
i++
i = 5
Step 7: i < nums.size()
5 < 8
true
sum = sum + (nums[i] == 1 ? 1 : -1)
= 1 + (num[5] == 1 ? 1 : -1)
= 1 + (1 == 1 ? 1 : -1)
= 1 + 1
= 2
if m.count(sum)
m.count(2) // no key with 2
false
else
m[sum] = i
m[2] = 5
i++
i = 6
Step 8: i < nums.size()
6 < 8
true
sum = sum + (nums[i] == 1 ? 1 : -1)
= 2 + (num[6] == 1 ? 1 : -1)
= 2 + (1 == 1 ? 1 : -1)
= 2 + 1
= 3
if m.count(sum)
m.count(3) // no key with 3
false
else
m[sum] = i
m[3] = 6
i++
i = 7
Step 9: i < nums.size()
7 < 8
true
sum = sum + (nums[i] == 1 ? 1 : -1)
= 3 + (num[7] == 1 ? 1 : -1)
= 3 + (0 == 1 ? 1 : -1)
= 3 + -1
= 2
if m.count(sum)
m.count(2) // has key with 0
true
maxLength = max(maxLength, i - m[sum])
= max(4, 7 - 5)
= max(4, 2)
= 4
i++
i = 8
Step 10: i < nums.size()
8 < 8
false
Step 11: return maxLength
So we return the answer as 4.
```

## Top comments (0)