一个数组中只有0和1，求0和1个数相等的最大连续子序列？

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <iostream>
#include <map>

using namespace std;

void f1(int *a, int s, int n)
{ 
    int sum[n+1];
    sum[0] = 0;
    for(int i = 1;i <= n;++i){
        sum[i] = sum[i-1] + a[i-1];
    }
    multimap<int, int> map;

    for (int i = 0; i <= n; i++)
        map.insert(make_pair(sum[i], i));

    multimap<int, int>::iterator iter;

    int maxCount = 0, maxValue;

    for (iter = map.begin(); iter != map.end(); iter++) {
        if (maxCount < map.count(iter->first)) {
            maxCount = map.count(iter->first);
            maxValue = iter->first;
        }
    }

    int max = 0, min = 0x7fffffff;
    iter = map.find(maxValue);

    for (int i = 0; i < map.count(maxValue); i++, iter++) {
        if (iter->second > max)
            max = iter->second;

        if (iter->second < min)
            min = iter->second;
    }

    cout << "start: " << min+1 << " end:" << max << " length:" << max-min << endl;
}

void f(int *a, int s, int n)
{
    int sum;
    int maxS = 0, maxE = 0, maxLength = 0;

    for (int i = 0; i < n; i++) {
        sum = a[i];

        for (int j = i+1; j < n; j++) {

            sum += a[j];

            if ((abs(sum) >= n-j) || (maxLength >= n-i))
                break;

            if (sum == 0 && (j-i+1) > maxLength) {
                maxS = i;
                maxE = j;
                maxLength = j - i + 1;
            }
        }
    }printf("start: %d, end: %d, length: %d\n", maxS, maxE, maxLength);


}




int main()
{
    //int len = strlen(argv[1]);
    char *data = "101010101100100010101010001010101001010100101010101001010101001010100010101010";
    int len = strlen(data);
    int *a = (int *)malloc((len+2) * sizeof(int));
    for (int i = 0; i < len; i++) {
        if (data[i] == '0')
            a[i] = -1;
        else
            a[i] = 1;
    }

    string str(data);
    cout<<str<<endl;
    f(a, 0, len);

    free(a);

    return 0;
}

方法f和方法f1都可以使用，f1效率要略高于f。不过空间复杂度大一些。