LOJ565. 「LibreOJ Round #10」mathematican 的二进制（NTT）

题目链接

https://loj.ac/problem/565

题解

首先，若进行所有操作之后成功执行的操作数为 \(m\)，最终得到的数为 \(w\)，那么发生改变的二进制位的数量之和（即代价之和）为 \(2m - {\rm bit}(w)\)。其中，\({\rm bit}(x)\) 表示 \(x\) 在二进制下 \(1\) 的个数。

证明：不难发现，一次操作会改变的二进制位的总数为进位次数\(+1\)，因此执行 \(m\) 次操作后改变的二进制位的数量总和为总进位次数\(+m\)。由于一次进位会导致整个二进制数中 \(1\) 的个数减少 \(1\)，因此若最终得到的数为 \(w\)，那么 \(m - {\rm bit}(w)\) 即为总进位次数。故总代价为 \(2m - {\rm bit}(w)\)。不仅如此，该结论也同时告诉我们操作顺序与最终答案是无关的。

这样，本题转化为求 \(2m - {\rm bit}(w)\) 的期望值。考虑将其拆开计算，\(2m\) 的期望值显然为所有操作执行成功的概率和乘以 \(2\)，\({\rm bit}(w)\) 的期望值可以根据期望的线性性质转化为所有操作后每一个二进制位上的数字最终为 \(1\) 的概率之和。这样，我们就只需要求出最终每一个二进制位上的数字为 \(1\) 的概率即可。

设 \(f_{i, j}\) 表示进行所有操作之后从小到大第 \(i\) 个二进制位（以下简称第 \(i\) 位）的值被改变了 \(j\) 次的概率。由于第 \(i\) 位最终的结果可能被在第 \(i\) 位本身的操作以及所有第 \(j(j < i)\) 位上的操作所影响，我们将两部分分开考虑，再设 \(g_{i, j}\) 表示进行完所有在第 \(i\) 位上的操作之后第 \(i\) 位的值被改变了 \(j\) 次的概率，这样，我们就能够用 \(g_i\) 与 \(f_{i - 1}\) 算出 \(f_i\)。

首先考虑如何计算 \(g_i\)。对于在第 \(i\) 位上的某个操作，若该操作成功执行的概率为 \(p\)，那么有 \(g_{i, j} \leftarrow g_{i, j - 1} \times p + g_{i, j} \times (1 - p)\)，显然该转移可视为两个多项式相乘，那么最终的结果多项式即为若干个一次多项式的乘积，可用堆优化 NTT 合并。这样，我们就能在 \(O(m \log^2 m)\) 的时间内求出整个 \(g\) 数组。

接下来考虑算 \(f\)，由于在第 \(i - 1\) 位上的每两次改变才会导致第 \(i\) 位的一次改变，故转移为 \(f_{i, j} = \sum_\limits{\lfloor\frac{a}{2}\rfloor + b = j} f_{i - 1, a} + g_{i, b}\)。显然该转移也可视为两个多项式相乘，可用 NTT 优化。对于每个 \(i\)，计算 \(f\) 数组时我们只需要暴力做 NTT 即可。以下是来自 yww 的时间复杂度证明：

记 \(c_i\) 表示所有操作中在第 \(i\) 位上的操作数量（那么有 \(\sum c_i = m\)）。

算 \(f\) 的时间复杂度是

\[\begin{aligned}& O(\log m \times \sum_{i = 0}^n \sum_{j = 0}^i \frac{c_j}{2^{i - j}}) \\ =& O(\log m \times \sum_{i = 0}^{n} c_i \sum_{j = 0}^{i} 2^{-j}) \\ =& O(m \log m)\end{aligned}
\]

上面的时间复杂度分析基于以下两点：

• 在第 \(j\) 位上的每 \(2^{i - j}\) 次改变才会导致第 \(i\) 位的一次改变（\(j < i\)）。
• \(\sum_\limits{i = 0}^{+\infty} 2^{-i} = 2\)。

这样，暴力用 NTT 求 \(f\) 的时间复杂度是可接受的，因此解决整个问题的时间复杂度为 \(O(m \log^2 m)\)。

代码

#include<bits/stdc++.h>

using namespace std;

const int N = 524288, mod = 998244353, G = 3;

void add(int& x, int y) {
  x += y;
  if (x > mod) {
    x -= mod;
  }
}

void sub(int& x, int y) {
  x -= y;
  if (x < 0) {
    x += mod;
  }
}

int mul(int x, int y) {
  return (long long) x * y % mod;
}

int qpow(int v, int p) {
  int result = 1;
  for (; p; p >>= 1, v = mul(v, v)) {
    if (p & 1) {
      result = mul(result, v);
    }
  }
  return result;
}

int n, m, a[N], b[N], c[N], rev[N], len, poly_a[N], poly_b[N];
vector<int> event[N], arr[N], f[N];

void ntt(int* c, int n, int type) {
  for (int i = 0; i < n; ++i) {
    if (i < rev[i]) {
      swap(c[i], c[rev[i]]);
    }
  }
  for (int i = 1; i < n; i <<= 1) {
    int x = qpow(G, type == 1 ? (mod - 1) / (i << 1) : mod - 1 - (mod - 1) / (i << 1));
    for (int j = 0; j < n; j += i << 1) {
      int y = 1;
      for (int k = 0; k < i; ++k, y = mul(y, x)) {
        int p = c[j + k], q = mul(y, c[i + j + k]);
        c[j + k] = (p + q) % mod;
        c[i + j + k] = (p - q + mod) % mod;
      }
    }
  }
  if (type == -1) {
    int inv = qpow(n, mod - 2);
    for (int i = 0; i < n; ++i) {
      c[i] = mul(c[i], inv);
    }
  }
}

void mul(int len_a, int len_b, int* a, int* b, int* c) {
  for (len = 0; (1 << len) <= len_a + len_b; ++len);
  int m = 1 << len;
  for (int i = 0; i < m; ++i) {
    rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << len - 1);
  }
  for (int i = 0; i < m; ++i) {
    poly_a[i] = poly_b[i] = 0;
    if (i <= len_a) {
      poly_a[i] = a[i];
    }
    if (i <= len_b) {
      poly_b[i] = b[i];
    }
  }
  ntt(poly_a, m, 1);
  ntt(poly_b, m, 1);
  for (int i = 0; i < m; ++i) {
    poly_a[i] = mul(poly_a[i], poly_b[i]);
  }
  ntt(poly_a, m, -1);
  for (int i = 0; i < m; ++i) {
    c[i] = poly_a[i];
  }
}

struct poly {
  vector<int> poly_s;

  poly () {
    poly_s.clear();
  }

  bool operator < (const poly& a) const {
    return poly_s.size() > a.poly_s.size();
  }
};

int main() {
  scanf("%d%d", &n, &m);
  n += 19;
  int ans = 0;
  for (int i = 1; i <= m; ++i) {
    int a, x, y;
    scanf("%d%d%d", &a, &x, &y);
    int p = mul(x, qpow(y, mod - 2));
    event[a].push_back(p);
    add(ans, p);
  }
  ans = (ans << 1) % mod;

  auto get_array = [&] (vector<int>& all) {
    priority_queue<poly> s;
    for (auto v : all) {
      poly new_poly;
      new_poly.poly_s.push_back((1 - v + mod) % mod);
      new_poly.poly_s.push_back(v);
      s.push(new_poly);
    }
    while (s.size() > 1) {
      poly l = s.top();
      s.pop();
      poly r = s.top();
      s.pop();
      int len_a = l.poly_s.size() - 1, len_b = r.poly_s.size() - 1;
      for (int i = 0; i <= len_a; ++i) {
        a[i] = l.poly_s[i];
      }
      for (int i = 0; i <= len_b; ++i) {
        b[i] = r.poly_s[i];
      }
      mul(len_a, len_b, a, b, c);
      poly new_poly;
      for (int i = 0; i <= len_a + len_b; ++i) {
        new_poly.poly_s.push_back(c[i]);
      }
      s.push(new_poly);
    }
    return s.top().poly_s;
  };

  for (int i = 0; i <= n; ++i) {
    if (event[i].size()) {
      arr[i] = get_array(event[i]);
    } else {
      arr[i].push_back(1);
    }
  }
  f[0] = arr[0];
  int total_len = event[0].size();
  for (int i = 1; i <= n; ++i) {
    int old = total_len >> 1;
    fill(a, a + old + 1, 0);
    for (int j = 0; j <= total_len; ++j) {
      add(a[j >> 1], f[i - 1][j]);
    }
    for (int j = 0; j <= event[i].size(); ++j) {
      b[j] = arr[i][j];
    }
    mul(old, event[i].size(), a, b, c);
    total_len = old + event[i].size();
    for (int j = 0; j <= total_len; ++j) {
      f[i].push_back(c[j]);
    }
  }
  for (int i = 0; i <= n; ++i) {
    for (int j = 1; j < f[i].size(); j += 2) {
      sub(ans, f[i][j]);
    }
  }
  printf("%d\n", ans);
  return 0;
}