CF2061F2 Kevin and Binary String (Hard Version) 题解

Description

Kevin 有一个长度为 $ n $ 的二进制字符串 $ s $。Kevin 可以执行以下操作：

• 选择 $ s $ 中两个相邻的块并交换它们。

块是指由相同字符组成的最大子串。形式化定义：设 $ s[l,r] $ 为子串 \(s_l s_{l+1} \ldots s_r\)。当满足以下条件时，$ s[l,r] $ 构成一个块：

1. $ l=1 $ 或 $ s_l \neq s_{l-1} $；
2. $ s_l = s_{l+1} = \ldots = s_r $；
3. $ r=n $ 或 $ s_r \neq s_{r+1} $。

相邻块是指两个块 $ s[l_1,r_1] $ 和 $ s[l_2,r_2] $ 满足 $ r_1 + 1 = l_2 $。

例如，若 $ s = \mathtt{000},\mathbf{11},\mathbf{00},\mathtt{111} $，Kevin 可以选择块 $ s[4,5] $ 和 $ s[6,7] $ 进行交换，将 $ s $ 变为 $ \mathtt{000},\mathbf{00},\mathbf{11},\mathtt{111} $。

给定一个由 '0'、'1' 和 '?' 组成且长度为 $ n $ 的字符串 $ t $，Kevin 希望确定使对于所有索引 \(i\)（$ 1 \le i \le n $），若 $ t_i \neq $ '?' 则 $ s_i = t_i $ 所需的最小操作次数。若无法实现，输出 $ -1 $。

\(n\leq 4\times 10^5\)。

Solution

首先考虑没有问号的时候怎么做。

先把 \(s\) 中的极长连续段缩起来，那么 \(t\) 里面的每个段都是由 \(s\) 中的一些位置连续的颜色相同的段拼起来。

假设 \(s=\texttt{0101010},t=\texttt{1110000}\)，那么容易知道 \(t\) 第一段 \(\texttt{1}\) 是由初始哪些段构成的，贪心地将这些段移到最前面一定不劣。此时 \(s\) 变为 \(\texttt{111000}\,\texttt{0}\)。

经过一些拟合会发现这个东西等价于每次从前往后，如果开头的段颜色一样，就贪心往后跳，否则一定是找到一段形如 \(\texttt{010101}\) 的前缀，设段数为 \(k\)。用 \(\lfloor\frac{k}{2}\rfloor\) 的代价将其变为 \(\texttt{000111}\) 或者 \(\texttt{111000}\)。

然后就可以 dp 了。

设 \(f_{i,c}\) 表示将前 \(i\) 个段做完操作，让 \(s\) 在这前 \(i\) 个段构成的前缀和 \(t\) 的同长度前缀相同，且目前最后一个字符是 \(c\) 的最小操作次数。\(c\) 存在的意义是如果第 \(i+1\) 段的颜色和当前末尾相同，则说明第 \(i+1\) 段强制不能动了，这种情况需要单独转移。当 \(c\) 和 \(i+1\) 颜色不同时才能进行长度大于等于 \(2\) 的转移。

设 \(p_{i,c}\) 表示使 \([i,j]\) 排序后前面的 \(c\) 不出现矛盾的最大 \(j\)，\(q_{i,c}\) 表示使 \([j,i]\) 排序后后面的 \(1-c\) 不出现矛盾的最小 \(j\)。

那么转移方程为

\[f_{i,1-c_1}\leftarrow\min_{1\leq j\leq i,c_2\neq col_j,j\geq q_{i,c_1},i\leq p_{j,c_1}}{\left\{f_{j-1,c_2}+\left\lfloor\frac{i-j+1}{2}\right\rfloor\right\}} \]

用 cdq 分治维护即可。

时间复杂度：\(O(n\log^2n)\)。

Code

#include <bits/stdc++.h>

// #define int int64_t

const int kMaxN = 4e5 + 5;

int n, m;
int op[kMaxN], len[kMaxN], pre[kMaxN], cnt[2][kMaxN], sum[2][kMaxN], f[kMaxN][2];
int L[kMaxN][2], R[kMaxN][2];
std::string s, t;

inline void chkmax(int &x, int y) { x = (x > y ? x : y); }
inline void chkmin(int &x, int y) { x = (x < y ? x : y); }

struct BIT {
  int c[kMaxN];
  void clear() { std::fill_n(c + 1, n, 1e9); }
  void upd(int x, int v) {
    for (x = n - x + 1; x <= n; x += x & -x) chkmin(c[x], v);
  }
  int qry(int x) {
    int ret = 1e9;
    for (x = n - x + 1; x; x -= x & -x) chkmin(ret, c[x]);
    return ret;
  }
  void clear(int x) {
    for (x = n - x + 1; x <= n; x += x & -x) c[x] = 1e9;
  }
} bit[2];

int getsum(int *s, int l, int r) { return l <= r ? s[r] - s[l - 1] : 0; }

bool check(int i, int j, int o) {
  return !getsum(cnt[o ^ 1], pre[i - 1] + 1, pre[i - 1] + getsum(sum[o], i, j)) && !getsum(cnt[o], pre[j] - getsum(sum[o ^ 1], i, j) + 1, pre[j]);
}

void solve(int l, int r) {
  if (l == r) {
    if (check(l, l, op[l])) chkmin(f[l][op[l]], std::min(f[l - 1][0], f[l - 1][1]));
    return;
  }
  int mid = (l + r) >> 1;
  solve(l, mid);
  for (int o1 = 0; o1 < 2; ++o1) {
    for (int o2 = 0; o2 < 2; ++o2) {
      static std::vector<int> vec[kMaxN];
      for (int i = mid + 1; i <= r; ++i) std::vector<int>().swap(vec[i]);
      for (int i = l; i <= mid; ++i) {
        if (R[i][o2] >= mid + 1) vec[std::min(R[i][o2], r)].emplace_back(i);
      }
      for (int i = r; i >= mid + 1; --i) {
        for (auto j : vec[i]) {
          if (op[j] == o1 && o1 != o2) continue;
          bit[(j - 1) & 1].upd(j, f[j - 1][o1] - (j - 1) / 2);
        }
        if (i % 2 == 0) {
          chkmin(f[i][o2 ^ 1], bit[0].qry(L[i][o2]) + i / 2);
          chkmin(f[i][o2 ^ 1], bit[1].qry(L[i][o2]) + i / 2 - 1);
        } else {
          chkmin(f[i][o2 ^ 1], bit[0].qry(L[i][o2]) + i / 2);
          chkmin(f[i][o2 ^ 1], bit[1].qry(L[i][o2]) + i / 2);
        }
      }
      for (int i = l; i <= mid; ++i) bit[(i - 1) & 1].clear(i);
    }
  }
  solve(mid + 1, r);
}

void dickdreamer() {
  std::cin >> s >> t; m = 0;
  n = s.size(), s = " " + s, t = " " + t;
  for (int i = 1, lst = 0; i <= n; ++i) {
    if (i == n || s[i] != s[i + 1]) {
      op[++m] = s[i] - '0', len[m] = i - lst, pre[m] = pre[m - 1] + len[m];
      for (int o = 0; o < 2; ++o)
        sum[o][m] = sum[o][m - 1] + (op[m] == o) * len[m];
      lst = i;
    }
  }
  for (int i = 1; i <= n; ++i) {
    for (int o = 0; o < 2; ++o)
      cnt[o][i] = cnt[o][i - 1] + (t[i] == '0' + o);
  }
  f[0][0] = f[0][1] = 0;
  for (int i = 1; i <= m; ++i) {
    for (int o = 0; o < 2; ++o) {
      {
        int L = i - 1, R = m + 1, res = i - 1;
        while (L + 1 < R) {
          int mid = (L + R) >> 1;
          if (!getsum(cnt[o ^ 1], pre[i - 1] + 1, pre[i - 1] + getsum(sum[o], i, mid))) L = res = mid;
          else R = mid;
        }
        ::R[i][o] = res;
      }
      {
        int L = 0, R = i + 1, res = i + 1;
        while (L + 1 < R) {
          int mid = (L + R) >> 1;
          if (!getsum(cnt[o], pre[i] - getsum(sum[o ^ 1], mid, i) + 1, pre[i])) R = res = mid;
          else L = mid;
        }
        ::L[i][o] = res;
      }
    }
  }
  for (int i = 1; i <= m; ++i) f[i][0] = f[i][1] = 1e9;
  // for (int i = 1; i <= m; ++i) {
  //   f[i][0] = f[i][1] = 1e9;
  //   if (check(i, i, op[i])) chkmin(f[i][op[i]], std::min(f[i - 1][0], f[i - 1][1]));
  //   for (int j = 1; j <= i; ++j) {
  //     for (int o = 0; o < 2; ++o) {
  //       if (o == op[j]) {
  //         // if (check(j + 1, i, o)) chkmin(f[i][o ^ 1], f[j][o] + (i - j) / 2);
  //         if (R[j][o] >= i && L[i][o] <= j) chkmin(f[i][o ^ 1], f[j - 1][o] + (i - j + 1) / 2);
  //       } else {
  //         // if (check(j + 1, i, 0)) chkmin(f[i][1], f[j][o] + (i - j) / 2);
  //         // if (check(j + 1, i, 1)) chkmin(f[i][0], f[j][o] + (i - j) / 2);
  //         if (R[j][0] >= i && L[i][0] <= j) chkmin(f[i][1], f[j - 1][o] + (i - j + 1) / 2);
  //         if (R[j][1] >= i && L[i][1] <= j) chkmin(f[i][0], f[j - 1][o] + (i - j + 1) / 2);
  //       }
  //     }
  //   }
  // }
  bit[0].clear(), bit[1].clear();
  solve(1, m);
  int res = std::min(f[m][0], f[m][1]);
  std::cout << (res <= n ? res : -1) << '\n';
}

int32_t main() {
#ifdef ORZXKR
  freopen("in.txt", "r", stdin);
  freopen("out.txt", "w", stdout);
#endif
  std::ios::sync_with_stdio(0), std::cin.tie(0), std::cout.tie(0);
  int T = 1;
  std::cin >> T;
  while (T--) dickdreamer();
  // std::cerr << 1.0 * clock() / CLOCKS_PER_SEC << "s\n";
  return 0;
}