#9134.反转eehniy

blog

---

题面

yinhee 去面试 Google 总裁。

面试官给他了一个长度为 \(n\) 的 \(01\) 串。

面试官给他以下两种操作是的这个序列前 \(n-m\) 个数字与后 \(n-m\) 个数字匹配。具体地说就是让

\[a_1 = a_{m+1} \cdots a_{n - m} = a_n
\]

1. 选择其中的一个数，将其反转（即为从 \(0\) 变成 \(1\)）

2. 反转前 \(k \times m\) 个数（\(k\) 为自己设定）

所以到底最少要多少次呢？

yinhee 只需要最少的翻转次数就能满足面试官的要求了。

其中保证 \(1 \le n,m \le 300\)。

---

我们可以考虑一些简单的情况，比如 \(m = 1\)。

容易发现操作 \(1\) 和操作 \(2\) 的顺序不影响结果，所以我们可以假定所有操作 \(1\) 都在操作 \(2\) 之前。

而接在操作 \(1\) 后面的操作 \(2\) 的数量即为 \((\text{连续栓的数量} - 1)\)。

然后我们考虑 \(m > 1\) 的情况。

显然最后序列上每 \(m\) 长度分一段，则每一段都相同，最后一段例外，是和其他段的一段等长前缀相同。

那么设最后每一段的状态都为 \(S\)。

一开始每段的状态为 \(e_i\) ，则在所有操作 2 之前，都有 \(S = e_i\) 或 \(S = flip(e_i)\)。\(flip(x)\) 表示把 \(x\) 串内所有数反转。

然后定义一个序列 \(c_i\) 表示第 \(i\) 段有没有被 \(flip\)。

然后考虑 DP，但是发现行不通，怎么定义都好像会有后效性。

但是我们可以考虑每 \(m\) 个一段，那么就会有 \(\left \lceil \dfrac{n}{m} \right \rceil\) 段。

结合 \(n \le 300\)，发现 \(\sqrt n \le 20\)。所以可以根号分治！！

• \(m \le \sqrt n\)

既然这样，那么段数必然少于 \(20\)，暴力状压即可。

对于每一种状态我们考虑 \(dp_{i,0/1}\) 表示当前处理到第 \(i\) 段没有反转的最小次数。

所以就可以写出这一段的代码了。

#define popcount(x) __builtin_popcount(x)
void solve1()
{
    for(int i = 1;i <= n / m + 1;i++)
    {
        for(int j = 0;j < m;j++)
        {
            c[i] |= e[(i - 1) * m + j + 1] << j;//计算c[i]的值
        }
    }
    int k = 1 << m;
    int ans = 0x3f3f3f3f;
    for(int i = 0;i < k;i++)
    {
        memset(dp,63,sizeof(dp));
        dp[0][0] = 0;
        for(int j = 1;j <= n / m;j++)
        {
            for(int l = 0;l <= 1;l++)
            {
                dp[j][l] = min(dp[j - 1][l] + popcount(i ^ c[j] ^ (l * (k - 1))),dp[j - 1][l ^ 1] + popcount(i ^ c[j] ^ (l * (k - 1))) + 1);
            }
        }
        if(n % m == 0)
        {
            ans = min({ans,dp[n / m][1],dp[n / m][0]});
        }
        else
        {
            int tmp = (1 << (n % m)) - 1;
            int x = i & tmp;
            for(int j = 0;j <= 1;j++)
            {
                dp[n / m + 1][j] = min(dp[n / m][j] + popcount(x ^ c[n / m + 1] ^ (j * tmp)),dp[n / m][j ^ 1] + popcount(i ^ c[n / m + 1] ^ (j * tmp)) + 1);
            }
            ans = min({ans,dp[n / m + 1][1],dp[n / m + 1][0]});
        }//最后一段需要单独处理
    }
    cout << ans << '\n';
}//dp,O((2^sqrt(n))*n)

\(j \times (2^m - 1)\) 是看这一段有没有反转。

注意最后一段要单独处理。

• \(m > \sqrt n\)

那么段数是 \(\le 20\) 的。

于是我们可以状压 \(c\) 然后处理状态。

然后我们可以根据每一段相同的位的 \(0/1\) 数量，贪心的选择改的最少的方案即可。

最后需要加上 \(2\) 的操作次数。所有的情况去取个最小就是答案。

void solve2()
{
    int k = 1 << ((n - 1) / m);
    int ans = 0x3f3f3f3f;
    for(int i = 0;i < k;i++)
    {
        int sum = 0;
        memset(cnt,0,sizeof(cnt));
        for(int j = 1;j <= (n - 1) / m;j++)
        {
            sum += ((i >> j) & 1) ^ ((i >> (j - 1)) & 1);
        }
        for(int j = 1;j <= n;j++)
        {
            cnt[j % m][e[j] ^ ((i >> ((j - 1) / m)) & 1)]++;
        }
        for(int j = 0;j < m;j++)
        {
            sum += min(cnt[j][0],cnt[j][1]);
        }
        ans = min(ans,sum);
    }
    cout << ans << '\n';
}

其中 \(cnt_{j,0/1}\) 表示每一段中第 \(j\) 位为 \(0/1\) 至少要修改多少个。

---

最终的code