我在互联网上发现了以下问题，想知道我将如何解决它：
给你一个包含 0 和 1 的数组 '。求O(n)时间和O(1)空间算法，求1和0个数相等的最大子序列。
例子：
10101010- 满足问题的最长子序列就是输入本身1101000- 满足问题的最长子序列是110100
【问题讨论】：
标签： c algorithm language-agnostic
更新。
我必须完全改写我的答案。 （如果你对早期版本投了赞成票，那你就被骗了！）
让我们再次总结一下这个简单的案例，把它排除在外：
找到最长的前缀包含的位串 相同数量的 1 和 0 数组。
这很简单：需要一个简单的计数器，计算我们拥有的 1 比 0 多多少，并在维护这一点的同时迭代位串。该计数器最后一次变为零的位置是最长搜索前缀的结尾。 O(N) 时间，O(1) 空间。 （我现在完全相信这是最初的问题所要求的。）
现在让我们切换到更困难的版本：我们不再要求子序列是前缀——它们可以从任何地方开始。
经过反复思考，我认为可能没有线性算法。例如，考虑前缀“111111111111111111...”。其中每一个 1 都可能是最长子序列的开始，没有候选子序列开始位置占主导地位（即总是给出比任何其他位置更好的解决方案），所以我们不能丢弃它们中的任何一个（O(N)空间）并且在任何步骤中，我们必须能够在 O(1) 时间内从线性众多的候选者中选择最佳开始（与当前位置具有相同数量的 1 和 0） . 事实证明这是可行的，而且也很容易实现，因为我们可以根据 1s (+1) 和 0s (-1) 的运行和来选择候选者，它的大小最多为 N，我们可以将我们达到每个总和的第一个位置存储在 2N 个单元格中 - 请参阅下面 pmod 的答案（yellowfog 的 cmets 和几何洞察力）。
没有发现这个技巧，我用一个缓慢但可靠的算法替换了一个快速但错误的算法，（因为正确的算法比错误的算法更可取！）：
A，从开始到该位置累积的 1 数，例如如果位串为“001001001”，则数组将为 [0, 0, 1, 1, 1, 2, 2, 2, 3]。使用它，我们可以在 O(1) 中测试子序列 (i,j) 是否有效：isValid(i, j) = (j - i + 1 == 2 * (A[j] - A[i - 1])，即如果它的长度是其中 1 数量的两倍，则它是有效的。例如，子序列 (3,6) 是有效的，因为 6 - 3 + 1 == 2 * A[6] - A[2] = 4。普通的旧双循环：
maxSubsLength = 0 对于 i = 1 到 N - 1 对于 j = i + 1 到 N if isValid(i, j) ... #maintain maxSubsLength 结尾 结束
这可以通过跳过比当前 maxSubsLength 短的 i/j 序列来使用一些分支定界来加快速度，但渐近地说这仍然是 O(n^2)。慢，但有一个很大的优势：正确！
【讨论】：
严格来说，答案是不存在这样的算法，因为由相等数量的 0 和 1 组成的字符串语言不规则。
当然，每个人都忽略了这样一个事实，即在空间中存储一个大小为n 的整数是O(log n)，并将其视为空间中的O(1)。 :-) 几乎所有的大 O，包括时间的，都充满（或者说没有）缺少 log n 因素，或者等效地，他们假设 n 受机器字大小的限制，这意味着你'真的在看一个有限的问题，一切都是O(1)。
【讨论】：
新解决方案： 假设我们有 n 位输入位数组 2*n 大小的数组来保持位的位置。因此，数组元素的大小必须有足够的大小来保持最大位置数。对于 256 输入位数组，需要 256x2 字节数组（字节足以保持 255 - 最大位置）。
从位数组的第一个位置移动，我们使用规则将位置从数组的中间（索引为n）开始放入数组中：
1.如果我们传递“1”位，则增加位置，当传递“0”位时减少位置
2。当遇到已经初始化的数组元素时 - 不要改变它并记住位置之间的差异（从数组元素中获取的当前减去） - 这是局部最大序列的大小。
3.每次我们遇到局部最大值时，将其与全局最大值进行比较，如果后者更小，则更新。
例如：位序列为0,0,0,1,0,1
initial array index is n
set arr[n] = 0 (position)
bit 0 -> index--
set arr[n-1] = 1
bit 0 -> index--
set arr[n-2] = 2
bit 0 -> index--
set arr[n-3] = 3
bit 1 -> index++
arr[n-2] already contains 2 -> thus, local max seq is [3,2] becomes abs. maximum
will not overwrite arr[n-2]
bit 0 -> index--
arr[n-3] already contains 3 -> thus, local max seq is [4,3] is not abs. maximum
bit 1 -> index++
arr[n-2] already contains 2 -> thus, local max seq is [5,2] is abs. max
因此，我们只通过了整个位数组一次。 这能解决任务吗？
input:
n - number of bits
a[n] - input bit-array
track_pos[2*n] = {0,};
ind = n;
/* start from position 1 since zero has
meaning track_pos[x] is not initialized */
for (i = 1; i < n+1; i++) {
if (track_pos[ind]) {
seq_size = i - track_pos[ind];
if (glob_seq_size < seq_size) {
/* store as interm. result */
glob_seq_size = seq_size;
glob_pos_from = track_pos[ind];
glob_pos_to = i;
}
} else {
track_pos[ind] = i;
}
if (a[i-1])
ind++;
else
ind--;
}
output:
glob_seq_size - length of maximum sequence
glob_pos_from - start position of max sequence
glob_pos_to - end position of max sequence
【讨论】：
在此线程 (http://discuss.techinterview.org/default.asp?interview.11.792102.31) 中，发帖人 A.F. 给出了一种算法，该算法在 O(n) 时间内运行并使用 O(sqrt(n log n)) 位。
【讨论】：
蛮力：从数组的最大长度开始计算 o 和 l。如果 o 等于 l，你就完了。否则将搜索长度减少 1 并对减少长度的所有子序列（即最大长度减去减少长度）执行算法，依此类推。当减法为 0 时停止。
【讨论】：
正如用户“R..”所指出的，严格来说，没有解决方案，除非您忽略“log n”空间复杂度。在下文中，我将考虑数组长度适合机器寄存器（例如 64 位字）并且机器寄存器的大小为 O(1)。
需要注意的重要一点是，如果 1 多于 0，那么您要查找的最大子序列必然包括所有 0 和那么多 1。所以这里的算法：
符号：数组长度n，索引从0到n-1。
请注意，可能有多种解决方案（符合标准的多个最大长度子序列）。
简单来说：假设 1 比 0 多，那么我考虑包含所有 0 的最小子序列。根据定义，该子序列被一串 1 包围。所以我只是从侧面抓住足够的 1。
编辑：正如所指出的，这不起作用......“重点”实际上是错误的。
【讨论】：
试试这样的：
/* bit(n) is a macro that returns the nth bit, 0 or 1. len is number of bits */
int c[2] = {0,0};
int d, i, a, b, p;
for(i=0; i<len; i++) c[bit(i)]++;
d = c[1] < c[0];
if (c[d] == 0) return; /* all bits identical; fail */
for(i=0; bit(i)!=d; i++);
a = b = i;
for(p=0; i<len; i++) {
p += 2*bit(i)-1;
if (!p) b = i;
}
if (a == b) { /* account for case where we need bits before the first d */
b = len - 1;
a -= abs(p);
}
printf("maximal subsequence consists of bits %d through %d\n", a, b);
完全未经测试但模数愚蠢的错误应该可以工作。根据我对 Thomas 的回答在某些情况下失败的回复。
【讨论】：
新解决方案： 空间复杂度O(1)，时间复杂度O(n^2)
int iStart = 0, iEnd = 0;
int[] arrInput = { 1, 0, 1, 1, 1,0,0,1,0,1,0,0 };
for (int i = 0; i < arrInput.Length; i++)
{
int iCurrEndIndex = i;
int iSum = 0;
for (int j = i; j < arrInput.Length; j++)
{
iSum = (arrInput[j] == 1) ? iSum+1 : iSum-1;
if (iSum == 0)
{
iCurrEndIndex = j;
}
}
if ((iEnd - iStart) < (iCurrEndIndex - i))
{
iEnd = iCurrEndIndex;
iStart = i;
}
}
【讨论】：
我不确定你所指的数组是0和1的int数组还是bitarray？？
如果是关于位数组，这是我的方法：
int isEvenBitCount(int n)
{
//n ... //Decimal equivalent of the input binary sequence
int cnt1 = 0, cnt0 = 0;
while(n){
if(n&0x01) { printf("1 "); cnt1++;}
else { printf("0 "); cnt0++; }
n = n>>1;
}
printf("\n");
return cnt0 == cnt1;
}
int main()
{
int i = 40, j = 25, k = 35;
isEvenBitCount(i)?printf("-->Yes\n"):printf("-->No\n");
isEvenBitCount(j)?printf("-->Yes\n"):printf("-->No\n");
isEvenBitCount(k)?printf("-->Yes\n"):printf("-->No\n");
}
使用按位运算，时间复杂度也几乎为 O(1)。
【讨论】：
total_bits = sizeof(n); 然后 while 循环仅计算设置位数 while(n) { cnt1++; n=n&(n-1); } 和 return ((total_bits-cnt1) == cnt1);