Contiguous Array

题目描述：Given a binary array, find the maximum length of a contiguous subarray with equal number of 0 and 1.

Note: The length of the given binary array will not exceed 50,000.

思路，参考官网，将数组中的 0 全都转化为 -1，然后遍历数组求和sum：如果遍历到下标a时的sum=K，继续遍历到下标b时的sum还是sum=K，(a<b)，那么可以得出(a~b] 的数组满足要求。即得出结果是 result = b - a；这是这个算法的数学依据。接下来考虑的是当得出sum之后，如何快速的判断该sum值有没有出现过，如果出现过，如何快速的找到该sum值对应的下标值？ 

//方法一，用map结构保存sum值和sum值对应的下标，实现快速判断sum值是否存在。因为map的底层实现是红黑树数据结构，每次 .find 都需要花费 log(n)的时间。在LeetCode上仅仅击败了3.66%的码友. 运行时间约 200 ms

int findMaxLength(vector<int>& nums) {
        int result = 0, sum = 0;
        for (int i = 0; i < nums.size(); i++)
            if (nums[i] == 0) nums[i] = -1;

        map<int, int> m;
        m[0] = -1;  //这个是必须的初始条件。考虑 0,1 的场景
        for (int i = 0; i < nums.size(); i++) {
            sum += nums[i];
            if (m.find(sum) != m.end()){   //注意，找到了重复的sum，只是更新result，并不对m[sum]做更新
                result = max(result, i - m[sum]);
            }else{
                m[sum] = i;  //在相同的几个sum中，m[sum]总是保存的是最开始的那个下标值
            }
        }
        return result;
}

 

//方法二，直接用数组保存值。虽然花费了更多的空间，但这个方法测试比方法一快一倍！运行时间约 100 ms

int findMaxLength(vector<int>& nums)
{
    int result = 0;
    int sum = 0;

    //初始化数组
    int size = 2*nums.size() + 1;
    vector<int> vec;
    for(int i=0; i<size; ++i)
    {
        vec.push_back(-2);
    }
    vec[0] = -1;  //注意vec[0] = -1 必须初始化为 -1
    //遍历数组，记录当前的数组和sum，查hash表，
    //如果sum对应的值不为空（-2），那么sum值出现过，用当前的下标减去sum值对应的下标方式求结果。
    //如果sum对应的值为空（-2），那么该值没有出现过，需要保存当前sum的下标值
    int sumTmp = 0;
    for(int i=0;i<nums.size();++i)
    {
        if(0==nums[i])
        {
            sum -=  1;
        }else{
            sum += 1;
        }
        //哈希转换，sum<0时取反，在加上vec的size大小（sum为负值时用vec[n+1~2n]）
        if(sum<0){
            sumTmp = (nums.size() - sum);
        }else{
            sumTmp = sum;
        }

        //assert(sumTmp<size);  //证明sumTmp不越界访问
        if(-2 != vec[sumTmp])  //有记录则更新结果
        {
            result = max(result, i - vec[sumTmp]);
        }else{  //没有记录则更新
            vec[sumTmp] = i;
        }
    }
    return result;
}

 

//第三种解法，需要熟悉C++的map实现的数据结构，map底层实现是红黑树，有没有底层实现是hash的map，实现 .find 方法的Q(1)访问？ 答案是 unordered_map，所以选对工具很重要。该方法兼顾时间和空间效率，实现简单，难以出错。在LeetCode上击败了 93.84% 的码友。

int findMaxLength(vector<int>& nums) {
        int result = 0, sum = 0;
        for (int i = 0; i < nums.size(); i++)
            if (nums[i] == 0) nums[i] = -1;

        unordered_map<int, int> m;
        m[0] = -1;  //这个是必须的初始条件。考虑 0,1 的场景
        for (int i = 0; i < nums.size(); i++) {
            sum += nums[i];
            if (m.find(sum) != m.end()){   //注意，找到了重复的sum，只是更新result，并不对m[sum]做更新
                result = max(result, i - m[sum]);
            }else{
                m[sum] = i;  //在相同的几个sum中，m[sum]总是保存的是sum第一次出现的那个下标值
            }
        }
        return result;
}