通过翻转二进制数字的一位可以获得最大连续1或0

Question

给定一个二进制数，找出通过翻转一位（1 或 0）可以获得的最大连续 1 或 0

给出的代码是

    public int getMacCon(string[] A)
    {
        int n = A.Length;
        int result = 0;
        for (int i = 0; i < n - 1; i++)
        {
            if (A[i] == A[i + 1])
                result = result + 1;
        }
        int r = -2;

        for (int i = 0; i < n; i++)
        {
            int count = 0;
            if (i > 0)
            {
                if (A[i - 1] != A[i])
                    count = count + 1;
                else
                    count = count - 1;
            }
            if (i < n - 1)
            {
                if (A[i + 1] != A[i])
                    count = count + 1;
                else
                    count = count - 1;
            }
            r = Math.Max(r, count);
        }
        return result + r;
    }

我很难弄清楚这里的逻辑。特别是下面给出的部分

    for (int i = 0; i < n - 1; i++)
    {
        if (A[i] == A[i + 1])
            result = result + 1;
    }

如果有人可以向我解释此解决方案中的逻辑，我将不胜感激。 谢谢

Answer 1

您突出显示的位仅计算 当前 相邻相等值的数量，即一个值 (A[i]) 等于下一个值 (A[i+1])。然后它依次询问（第二个循环）每个值，翻转它是否会增加、减少而不是改变相邻相等值的数量；因此，如果当前值与之前的值 (A[i-1] != A[i]) 不同，则翻转将是增加 - 否则会减少；同样是它之后的那个。最终结果是预先存在的相邻相等值 (result) 的数量，加上在扫描中找到的最佳增量 (r)。

public int getMacCon(string[] A)
{
    int n = A.Length;
    int result = 0;
    // find how many adjacent values are currently in the string
    for (int i = 0; i < n - 1; i++)
    {
        // if same as the next value, that's a hit
        if (A[i] == A[i + 1])
            result = result + 1;
    }
    // worst case delta from flipping one value is that me make it
    // worse on both sides, so -2
    int r = -2;

    // now consider each value in turn
    for (int i = 0; i < n; i++)
    {
        int count = 0;
        if (i > 0) // test value before, if not the first value
        {
            if (A[i - 1] != A[i])
                count = count + 1; // before is different; flip is incr
            else
                count = count - 1; // before is same; flip is decr
        }
        if (i < n - 1) // test value after, if not the last value
        {
            if (A[i + 1] != A[i])
                count = count + 1; // after is different; flip is incr
            else
                count = count - 1; // after is same; flip is decr
        }
        // compare that to the tracking counter, and keep the best value
        r = Math.Max(r, count);
    }
    // final result is sum of pre-existing count plus the delta
    return result + r;
}

顺便说一句，优化可能是将第二个循环测试从 i < n 更改为 i < n && r != 2 - 即一旦找到可能的最佳增量就停止（使两边都更好，+2）

Answer 2

不是对您问题的直接回答（因为 Marc Gravell 的回答已经涵盖了它），但我只需要补充一下我将如何解决这个问题：

1. 使用 RLE（运行长度编码）对您的字符串进行编码

   所以你需要b,v,n 值的数组。其中b>=0 是起始位置，v={0,1} 是位值，n 是后续发生的计数。例如：

   const int _max=100; // max number of bits
   int b[_max],v[_max],n[_max],bvns=0;
   

   bvns 是数组中使用的b,v,n 的数量。您也可以改用任何动态列表/模板。

2. 重置您的实际解决方案

   您需要更改ix 的位位置以及翻转sz 后产生的后续位的计数。将展位设置为零。

3. 使用n=1 扫描 RLE 以查找项目

   如果发现这意味着 RLE 中的前后项目相同，则翻转将加入它们。所以计算结果大小，如果更大，则存储为实际解决方案，例如：

   for (int i=1;i<bvns-1;i++) // scann RLE except first and last item
    if (n[i]==1) // single bit found
     {
     l=n[i-1]+1+n[i+1]; // resulting size
     if (l>=sz) { sz=l; ix=b; } // update solution
     }
   

4. 测试放大单个序列是否变大

   简单地说：

   for (int i=0;i<bvns;i++) // scann RLE
    if (n[i]>=sz) // result is bigger?
     {
     sz=l; ix=b-1; // update solution
     if (ix<0) ix=b+n[i];
     }