JOI Open 2016

T1 JOIRIS

你在玩俄罗斯方块，游戏区域是一个宽度为 \(n\)，高度足够大的矩形网格、初始时第 \(i\) 列有 \(a_i\) 个方块。

给定参数 \(k\)，你可以做不超过 \(10^4\) 次操作，来将这个网格中的所有方块全部消除，一次操作形如：

• 在网格的最顶端落下一个 \(1 \times k\) 或者 \(k \times 1\) 的方块（也就是你可以决定方块是竖着放还是横着放），直到碰到一个方块时停止下落。
• 自下而上检查所有行，如果一行被方块填满，则消除这一行的所有方块。

需要构造方案。保证 \(1 \le n, a_i \le 50\)。

首先注意到我们可以通过若干操作使得 \(a_i \gets a_i \bmod k\)。令 \(t = \lfloor \frac{\max a_i}{k} \rfloor\)，通过对于每个位置 \(i\)，在 \(i\) 处加入若干竖块，使得 \(a_i \in [tk, (t + 1)k)\)，此时至少会消除 \(tk\) 次，于是 \(\forall i, a_i < k\)。我们称这样的操作为一次调整。

考虑 \(a\) 模 \(k\) 意义下的差分数组 \(d_{1 \sim n + 1}\)，其满足 \(d_i = a_i - a_{i - 1}\)，对于一种合法的终态，由于所有方块将被消空，所以 \(\forall i \in [2, n], d_i = 0\)。注意我们在 \(d_1\) 和 \(d_{n + 1}\) 处无限制。

现在从 \(d\) 的角度观察所有操作，现在加竖块 \(d\) 不变，消除一行 \(d_{2 \sim n}\) 不变，没有影响，唯一对 \(d\) 有影响的操作是在 \(i\) 处加一个横块，其影响为 \(d_i \gets d_i + 1, d_{i + k} \gets d_{i + k} - 1\)，那么有解的必要条件是 \(\forall r \in [0, k), 1 \bmod k \neq r, (n + 1) \bmod k \neq r, (\sum\limits_{i \bmod k = r} d_i) \equiv 0 \pmod k\)，下面我们通过构造证明其是充分的。

考虑我们一定可以通过如下操作使得 \(d_i \gets d_i + v\)，\(d_{i + k} \gets d_{i + k} - v\)（\(v \in [0, k)\)）：

• 在 \(i\) 处加入 \(v\) 个横块，在 \(\forall i \in [1, n] - [i, i + k)\) 处加入 \(2\) 个竖块，此时 \(v\) 个横块全部被消除，如果剩下部分存在高度大于 \(k\)，即 \(a_i \ge k\) 的位置，按照前面所说的方法调整即可。

那么通过上述操作，对于 \(\bmod k = r\) 分组后 \(\sum d\) 不变，但是对于 \(1\) 和 \(n + 1\) 所在的 \(r\) 我们可以全部丢到 \(1\) 和 \(n + 1\)，所以没有前面的限制。

操作次数 \(O(1) \times (n^2 + \sum a_i)\)。

Code

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

const int N = 55;

int n, k;
int a[N], d[N];
vector<int> v[N];
vector<pair<int, int>> ans;

void Adjust () {
  int mx = 0;
  for (int i = 1; i <= n; ++i) {
    mx = max(mx, a[i] / k);
  }
  for (int i = 1; i <= n; ++i) {
    while (a[i] < mx * k) {
      ans.push_back({1, i});
      a[i] += k;
    }
    a[i] -= mx * k;
  }
}

void Operate (int x, int v) {
  if (!v) return;
  d[x] = (d[x] + v) % k;
  d[x + k] = (d[x + k] - v + k) % k;
  for (int i = 1; i <= v; ++i) {
    ans.push_back({2, x});
  }
  for (int i = 1; i <= n; ++i) {
    if (i < x || i >= x + k) {
      ans.push_back({1, i});
      ans.push_back({1, i});
      a[i] += k * 2 - v;
    }
  }
  Adjust();
}

int main () {
  // freopen("tmp.in", "r", stdin);
  // freopen("tmp.out", "w", stdout);
  cin.tie(0)->sync_with_stdio(0);
  cin >> n >> k;
  for (int i = 1; i <= n; ++i) {
    cin >> a[i];
  }
  Adjust();
  for (int i = 1; i <= n + 1; ++i) {
    d[i] = (a[i] - a[i - 1] + k) % k;
    v[i % k].push_back(i);
  }
  for (int r = 0; r < k; ++r) {
    if (v[r].empty()) continue;
    int sum = 0;
    for (auto i : v[r]) {
      sum = (sum + d[i]) % k;
    }
    if (v[r][0] == 1) {
      for (int j = v[r].size() - 1; j; --j) {
        Operate(v[r][j - 1], d[v[r][j]]);
      }
    }
    else {
      if (sum && v[r].back() != n + 1) {
        cout << -1 << '\n';
        return 0;
      }
      for (int j = 0; j < v[r].size() - 1; ++j) {
        int i = v[r][j];
        Operate(i, (k - d[i]) % k);
      }
    }
  }
  int mx = *max_element(a + 1, a + n + 1);
  for (int i = 1; i <= n; ++i) {
    int cnt = (mx - a[i]) / k;
    for (int j = 1; j <= cnt; ++j) {
      ans.push_back({1, i});
    }
  }
  cout << ans.size() << '\n';
  for (auto i : ans) {
    cout << i.first << ' ' << i.second << '\n';
  }
  return 0;
}

T2 Selling RNA Strands

题意：给定 \(n\) 个字符串 \(s_{1 \sim n}\)，有 \(m\) 次询问，每次询问格式如下：

• 给出字符串 \(p\) 和 \(q\)，求 \(s_{1 \sim n}\) 中有多少个字符串同时以 \(p\) 为前缀，并以 \(q\) 为后缀。

令 \(N = \max(n, m), S = \max(\sum|s_i|, \sum|p|, \sum|q|)\)，保证 \(N \le 10^5, S \le 2 \times 10^6\)，字符集大小为 \(4\)。

首先考虑如果只有前缀为 \(p\) 的限制是好做的，我们对于 \(s\) 建 \(\text{Trie}\)，每次查询时走到 \(p\) 对应的 Trie 上的结点，做子树标记求和即可。

现在加入后缀为 \(p\) 的限制，不难想到对 \(s\) 的反串再建一棵 \(\text{Trie}\)，假设一个字符串 \(s\) 在两颗 Trie 上的对应点分别为 \(a\) 和 \(b\)，某次查询的前后缀 \(p, q\) 在两颗 \(\text{Trie}\) 上的对应点分别为 \(a_0\) 和 \(b_0\)，那么 \(s\) 对该询问有贡献，当且仅当 \(a_0\) 是 \(a\) 的祖先，\(b_0\) 是 \(b_0\) 的祖先。

对于祖先的限制考虑用 \(\text{dfs}\) 序刻画，那么原问题可转化成二维数点，扫描线 + 树状数组即可，时间复杂度 \(O(S + N \log S)\)。

Code

#include <iostream>
#include <algorithm>
#include <vector>
#include <numeric>

using namespace std;

const int N = 1e5 + 5, T = 2e6 + 5; 

int n, m;
int a[N], b[N], p[N], ans[N];

string Read () {
  string s;
  cin >> s;
  for (auto &c : s)
    c = (c == 'A' ? 0 : (c == 'G' ? 1 : (c == 'U' ? 2 : 3)));
  return s;
}

struct Trie {
  int tot;
  int ch[T][4], dfn[T], siz[T];

  int Insert (string s) {
    int k = 0;
    for (auto c : s) {
      if (!ch[k][c]) ch[k][c] = ++tot;
      k = ch[k][c];
    }
    return k;
  }

  void Dfs (int x) {
    dfn[x] = ++tot;
    siz[x] = 1;
    for (int i = 0, y; i < 4; ++i) {
      if (y = ch[x][i]) {
        Dfs(y);
        siz[x] += siz[y];
      }
    }
  }

  int Get_id (string s) {
    int k = 0;
    for (auto c : s) {
      k = ch[k][c];
      if (!k) return -1;
    }
    return k;
  }
} trie, rtrie;

struct E {
  int x, l, r, v, id;
};

struct Bit {
  int tr[T];

  void Add (int x, int y) {
    for (; x <= rtrie.tot; x += (x & -x)) {
      tr[x] += y;
    }
  }

  int Query (int l, int r) {
    int res = 0;
    for (--l; l; l -= (l & -l)) {
      res -= tr[l];
    }
    for (; r; r -= (r & -r)) {
      res += tr[r];
    }
    return res;
  }
} bit;

int main () {
  cin.tie(0)->sync_with_stdio(0);
  cin >> n >> m;
  for (int i = 1; i <= n; ++i) {
    string s = Read();
    a[i] = trie.Insert(s);
    reverse(s.begin(), s.end());
    b[i] = rtrie.Insert(s);
  }
  trie.Dfs(0), rtrie.Dfs(0);
  for (int i = 1; i <= n; ++i) {
    a[i] = trie.dfn[a[i]], b[i] = rtrie.dfn[b[i]];
  }
  vector<E> v;
  for (int i = 1; i <= m; ++i) {
    string s = Read(), t = Read();
    reverse(t.begin(), t.end());
    int p = trie.Get_id(s), q = rtrie.Get_id(t);
    if (p != -1 && q != -1) {
      int al = trie.dfn[p], ar = trie.dfn[p] + trie.siz[p] - 1, bl = rtrie.dfn[q], br = rtrie.dfn[q] + rtrie.siz[q] - 1;
      v.push_back(E({al - 1, bl, br, -1, i}));
      v.push_back(E({ar, bl, br, 1, i}));
    }
  }
  sort(v.begin(), v.end(), [&](E a, E b) -> bool {
    return a.x < b.x;
  });
  iota(p + 1, p + n + 1, 1);
  sort(p + 1, p + n + 1, [&](int i, int j) -> bool {
    return a[i] < a[j];
  });
  int t = 1;
  for (auto i : v) {
    while (t != n + 1 && a[p[t]] <= i.x) {
      bit.Add(b[p[t++]], 1);
    }
    ans[i.id] += bit.Query(i.l, i.r) * i.v;
  }
  for (int i = 1; i <= m; ++i) {
    cout << ans[i] << '\n';
  }
  return 0;
}

T3 Skyscraper

题意：给定一个长度为 \(n\) 的序列 \(a_i\)，满足 \(a\) 中元素两两不相同。

给定 \(L\)，计数有多少个 \(a\) 的排列 \(p\)，满足 \(\sum\limits_{i = 1}^{n - 1} |p_i - p_{i + 1}| \le L\)。

\(1 \le n \le 10^2, 1 \le a_i, L \le 10^3\)。

考虑 \(\sum\limits_{i = 1}^{n - 1} |p_i - p_{i + 1}| \le L\) 的限制，显然正着是不好做的。套路的可以想到从上往下扫描线，维护连续段的数量。那么我们的要求就是线段长度总和 \(\le L\)。

假设我们从大往小加数，假设扫描线的上一个位置为 \(lst\)，当前这个数所在位置为 \(cur\)，那么可能会有若干未闭合的插头，每个会对线段长度总和造成 \(lst - cur\) 的贡献。我们发现这样的插头数量至于当前的连续段数有关，于是我们并不关心当前加入的所有数的形态，而只需记录有多少个连续段。

考虑一个问题，如果一个数在边界，那么它会少贡献一个插头，如右上图所示。但是这个是好处理的，我们只需再记录位于左右边界上的数是否已经确定即可。

默认滚动数组消去当且加的是第几个数的维度。状态就是 \(f_{i, j, p, q}\)，表示当前有 \(i\) 个连续段，线段总长为 \(j\)，\(p, q\) 表示是否钦定了最左和最右的数的方案数。

转移有三种情况：新创建一个段、延续一个段、合并相邻的两个段，分类讨论一下即可。

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

Code

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 105, M = 1e3 + 5;
const int Mod = 1e9 + 7; 

int n, lim;
int a[N], f[N][M][2][2], g[N][M][2][2];

void Add (int &x, int y) {
  x = ((x += y) >= Mod ? x - Mod : x);
}

int main () {
  cin.tie(0)->sync_with_stdio(0);
  cin >> n >> lim;
  for (int i = 1; i <= n; ++i) {
    cin >> a[i];
  }
  sort(a + 1, a + n + 1, greater<int>());
  for (int i = 0; i < 2; ++i)
    for (int j = 0; j < 2; ++j)
      f[1][0][i][j] = 1;
  for (int i = 1; i < n; ++i) {
    for (int j = 1; j <= i; ++j) {
      for (int k = 0; k <= lim; ++k) {
        for (int p = 0; p < 2; ++p) {
          for (int q = 0; q < 2; ++q) {
            g[j][k][p][q] = f[j][k][p][q], f[j][k][p][q] = 0;
          }
        }
      }
    }
    for (int j = 1; j <= i; ++j) {
      for (int k = 0; k <= lim; ++k) {
        for (int p = 0; p < 2; ++p) {
          for (int q = 0; q < 2; ++q) {
            int v = g[j][k][p][q];
            if (!v)
              continue;
            int _k = k + (j * 2 - p - q) * (a[i] - a[i + 1]);
            if (_k > lim) continue;
            Add(f[j + 1][_k][p][q], 1ll * (j - 1) * v % Mod);
            if (!p) {
              Add(f[j + 1][_k][0][q], v);
              Add(f[j + 1][_k][1][q], v);
            }
            if (!q) {
              Add(f[j + 1][_k][p][0], v);
              Add(f[j + 1][_k][p][1], v);
            }
            Add(f[j][_k][p][q], 2ll * (j - 1) * v % Mod);
            if (!p) {
              Add(f[j][_k][0][q], v);
              Add(f[j][_k][1][q], v);
            }
            if (!q) {
              Add(f[j][_k][p][0], v);
              Add(f[j][_k][p][1], v);
            }
            if (j > 1) {
              Add(f[j - 1][_k][p][q], 1ll * (j - 1) * v % Mod);
            }
          }
        }
      }
    }
  }
  int ans = 0;
  for (int i = 0; i <= lim; ++i) {
    ans = (ans + f[1][i][1][1]) % Mod;
  }
  cout << ans << '\n';
  return 0;
}