闲话 22.11.16

闲话

今天给我整了个好活 普通三维偏序的 \(O(n\log n)\) 解法
那就要问了，形如 \(a_i\le a_j, b_i\le b_j, d_j\le c_i\le c_j\) 的加强版三维偏序有没有什么 \(o(n\log^2n)\) 的做法
如果有人搞出来了可以在这提交（

有什么好题当社论题材吗？
最近想写ARC148F来着

啊对了今天放冠世一战了！好听！

杂题

AGC056B
给定整数 \(n\) 以及 \(m\) 对整数。第 \(i\) 对整数为 \((l_i, r_i)\) 。

请输出可以通过如下方式生成的整数序列 \(x = (x_1, x_2,\cdots,x_m)\) 的个数。答案对 \(998244353\) 取模。

生成方式：

• 取排列 \(p = (p_1, p_2,\cdots,p_n)\)，满足其为一个 \(1\) 至 \(n\) 的排列。
• 对于任意 \(1\le i \le m\) 的 \(i\)，令 \(x_i\) 为 \(p_{l_i}， p_{l_i + 1},\cdots ,p_{r_i}\) 中最大值对应的下标。即 \(p_{x_i} = \max\{p_{l_i}， p_{l_i + 1},\cdots, p_{r_i}\}\)。

\(2\le n\le 300,\ 1\le m\le \frac{n(n - 1)}2\)。

为啥这场 B 比 C 难啊
C 是个 2481 比这一段的 C 都简单 B 是个 nmd 3339 比这一段的 C 都难
A 是个 sb 构造，暂且不表

同一个 \(x\) 可能对应多个 \(p\)，因此这样计数比较困难。
考虑反过来计数。

对于给定的 \(x\)，我们将按照以下的方式构造 \(p\)：

• 令 \(p = (-1,-1,\cdots,-1)\) 。
• 我们从 \(n\) 开始依次递减地考虑每个值 \(v\)。对于每个值，我们找到 \(v\) 能放的最左侧的位置，放进去。

计数可以通过这种方式生成的 \(p\) 。

设当前最值为 \(v\)。我们首先确定下标 \(m\)，使得 \(p_m = v\)。对于所有包含 \(m\) 的区间 \(i\)，有 \(x_i = m\)。删除这些包含 \(m\) 的区间后，我们可以分别考虑位于 \(m\) 左右两侧的区间。由于 \(m\) 为最左侧的可以放 \(v\) 的位置，右侧的数均小于左侧的数，这部分是和原问题等价但规模更小的子问题。

现在考虑左侧。我们令 \(k\) 为 \(m\) 左侧最大元素对应的下标。有：必定存在一个左侧区间同时包含 \(k\) 和 \(m\)。
考虑反证。如果左侧没有区间同时包含 \(k\) 和 \(m\)，那我们可以令 \(p_k = v\)，这必定是更优且满足要求的。这与假设矛盾，因此必定存在同时包含 \(k\) 和 \(m\) 的左侧区间。
因此，左侧区间所填的数的最大值必定大于等于 \(v\)。

考虑区间 dp。我们设 \(f(l,r,v)\) 为 \([l,r]\) 区间满足最大值大于等于 \(v\) 的方案数。可以通过枚举中点以及预处理区间最大值的方式转移。转移时加入后缀和即可快速得到最终答案。

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

code

#include <bits/stdc++.h>
using namespace std; 
using pii = pair<int,int>; 
template <typename T> void get(T & x) {
	x = 0; char ch = getchar(); bool f = false; while (ch < '0' or ch > '9') f = f or ch == '-', ch = getchar();
	while ('0' <= ch and ch <= '9') x = (x << 1) + (x << 3) + ch - '0', ch = getchar(); f && (x = -x); 
} template <typename T, typename ... Args> void get(T & a, Args & ... b) { get(a); get(b...); }
template <typename T1, typename T2> T1 min(T1 a, T2 b) { T1 _b = static_cast<T1>(b); return a < b ? a : b; }
#define rep(i,s,t) for (register int i = (s), i##_ = (t) + 1; i < i##_; ++ i)
#define pre(i,s,t) for (register int i = (s), i##_ = (t) - 1; i > i##_; -- i)
const int N = 5e2 + 10;

const int mod = 998244353;
const int inv2 = (mod + 1) >> 1;
template <typename T1, typename T2> T1 add(T1 a, T2 b) { return (a += b) >= mod ? a - mod : a; }
template <typename T1, typename ...Args> T1 add(T1 a, Args ... b) { return add(a, add(b...)); }
struct FastMod { int m; ll b; void init(int _m) { m = _m; if (m == 0) m = 1; b = ((lll)1<<64) / m; } FastMod(int _m) { init(_m); } int operator() (ll a) {ll q = ((lll)a * b) >> 64; a -= q * m; if (a >= m) a -= m; return a; } } Mod(mod);
int mul(int a, int b) { return Mod(1ll * a * b); } template <typename ...Args> int mul(int a, Args ...b) { return mul(a, mul(b...)); }
template <typename T1, typename T2> T1 qp(T1 a, T2 b) { T1 ret = 1; for (; b > 0; a = mul(a, a), b >>= 1) if (b & 1) ret = mul(ret, a); return ret; }

int n, m, f[N][N][N], g[N][N][N];
pii v[N * (N - 1) >> 1];

int main() {
	get(n, m); rep(i,1,m) get(v[i].first, v[i].second);
	rep(i,0,n+1) rep(j,0,n+1) rep(k,0,n+1) g[i][j][k] = n + 1;
	rep(i,1,m) rep(k,v[i].first,v[i].second) g[v[i].first][v[i].second][k] = min(g[v[i].first][v[i].second][k], v[i].first);
	pre(l,n,1) rep(r,l+1,n) rep(k,l,r) g[l][r][k] = min( { g[l][r][k], g[l+1][r][k], g[l][r-1][k] } );
	rep(l,1,n+1) rep(k,1,n+1) f[l][l-1][k] = 1;
	pre(l,n,1) rep(r,l,n) pre(k,r,l) f[l][r][k] = add(f[l][r][k + 1], mul(f[l][k - 1][g[l][r][k]], f[k + 1][r][k + 1])); 
	cout << f[1][n][1] << '\n';
}

---

AGC056C

你需要构造一个长度为 \(n\) 、由 \(01\) 组成的字符串，同时需要满足 \(m\) 个条件。第 \(i\) 个条件由两个整数 \(l_i,\ r_i\) 给出，表示字符串位于 \([l_i,r_i]\) 区间的字符必须是相同数量的 \(0\) 和 \(1\)。

请输出满足所有条件且字典序最小的字符串。可以证明在题设条件下总存在至少一个字符串满足所有条件。

\(2\le n\le 10^6,\ 1\le m\le 2\times 10^5,\ 1\le l_i< r_i\le n, (r_i - l_i + 1) \bmod 2,\ (l_i,r_i)\neq(l_j,r_j) (i != j)\)

直接做不好做，考虑将条件转化。令 \(d_i\) 为 \(1\sim i\) 中 \(0\) 的个数减去 \(1\) 的个数。
容易发现，想要最小化原串的字典序，其实就是让 \(0\) 尽可能多，也就是让 \(d_i\) 尽可能大。这就转化为如何 \(d_i\) 的字典序最大。

我们发现，给定的条件 \((l_i,r_i)\) 可以表述为 \(d_{r_i} = d_{l_i - 1}\)，因为 \([l_i,r_i]\) 段中 \(0,1\) 个数是相等的，体现在 \(d_i\) 上就是 \([l_i,r_i]\) 段有 \(0\) 的贡献。
同时根据定义可得 \(\forall \ 1< i \le n,\ |d_i - d_{i-1}| = 1\)。这与 \(\forall \ 1< i \le n,\ |d_i - d_{i-1}| \le 1\) 等价。

列出我们已知的条件：

1. \(\forall 1\le i \le m, \ d_{l_i - 1} = d_{r_i}\)
2. \(\forall \ 1< i \le n,\ |d_i - d_{i-1}| \le 1\)

我们需要使字典序最大，这启发我们采用差分约束系统求解本题。
对 \(1.\) 条件建 \((l_i - 1, r_i)\)，边权为 \(0\) 的双向边；对 \(2.\) 条件建 \((i - 1, i)\)，边权为 \(1\) 的双向边。
由于边权的特殊性，我们可以通过 01bfs 求解所有 \(d_i\)。这给出了构造方案。

总时间复杂度 \(O(n +m)\)。

code

#include <bits/stdc++.h>
using namespace std; 
template <typename T> void get(T & x) {
	x = 0; char ch = getchar(); bool f = false; while (ch < '0' or ch > '9') f = f or ch == '-', ch = getchar();
	while ('0' <= ch and ch <= '9') x = (x << 1) + (x << 3) + ch - '0', ch = getchar(); f && (x = -x); 
} template <typename T, typename ... Args> void get(T & a, Args & ... b) { get(a); get(b...); }
#define rep(i,s,t) for (register int i = (s), i##_ = (t) + 1; i < i##_; ++ i)
#define pre(i,s,t) for (register int i = (s), i##_ = (t) - 1; i > i##_; -- i)
const int N = 1e6 + 10;
int n, m, l, r; 
vector <pair<int,int> > g[N];

int dis[N];
deque<int> que;
void bfs(int st) {
	memset(dis, -1, sizeof dis);
	dis[st] = 0; que.push_back(st); 
	while (que.size()) {
		int u = que.front(); que.pop_front();
		for (auto [v, w] : g[u]) {
			if (dis[v] == -1) {
				dis[v] = dis[u] + w;
				if (w == 0) que.push_front(v);
				else que.push_back(v);
			}
		}
	}
}

int main() {
	get(n, m); 
	rep(i,1,m) get(l, r), g[r].emplace_back(l - 1, 0), g[l - 1].emplace_back(r, 0);
	rep(i,1,n) g[i - 1].emplace_back(i, 1), g[i].emplace_back(i - 1, 1);
	bfs(0);
	rep(i,1,n) cout << (dis[i] < dis[i - 1]);
}

---

CF754E

给出一个字母阵 \(A\)，再给出一个部分字母没有确定的询问阵 \(B\)，求出左上角为位置 \((i,j)\) 时能否匹配 \((A[(i+x) \text{mod } n][(i+y) \text{mod }m]=B[i][j])\)，输出 \(01\) 矩阵表示答案。

\(1\le n, m, r, c \le 400\)。

昨天 WintersRain 发了个博客 vp 390 (Div. 2)
然后我看着他们没写这题 然后水一下

首先考虑朴素的 \(O(n^4)\) 如何实现。令 \(P\) 为 \(n\times m\) 的矩阵，\(T\) 为 \(r\times c\) 的矩阵。

memset(ans, true, sizeof(ans));
for (int k = 1; k <= r; ++ k) for (int l = 1; l <= c; ++ l) if (T[k][l] != '?')
	for (int i = 1; i <= n; ++ i) for (int j = 1; j <= m; ++ j) 
		ans[(i - k + n) % n][(j - l + m) % m] &= (T[k][l] == P[i][j]);

发现最终我们需要对答案数组的整行进行有条件的与操作。这使我们想到使用 bitset 优化进程。
对 \(P\) 矩阵中每行使用 26 个 bitset ，第 \(i\) 位保存 \(\text a\sim \text z\) 是否存在于这一位。我们发现朴素实现的第 \(4\) 层循环可以使用 bitset 表示。

因此采用 bitset 优化后可以做到 \(O(\frac {nmrc} {w})\)，足以通过本题。

本题的思想类似于 CF914F，二者都是通过 bitset 进行带通配符的字符串匹配。

同时，本题还有采用多项式的解法，方式形如本题。时间复杂度为 \(O(nmc\log n)\)。由于常数过大，在实际测评中远不如 bitset 做法优秀。

以及这题 \(r,c\) 可能远大于 \(n,m\)，注意直接取模。

code

#include <bits/stdc++.h>
using namespace std;
#define rep(i,s,t) for (register int i = (s), i##_ = (t) + 1; i < i##_; ++ i)
#define pre(i,s,t) for (register int i = (s), i##_ = (t) - 1; i > i##_; -- i)
const int N = 400 + 10;
int n, m, r, c;
char str[N];
bitset<N> ans[N], mask[26][N];

int main() {
	ios::sync_with_stdio(false); cin.tie(0), cout.tie(0);
	cin >> n >> m;
	rep(i,1,n) {
		ans[i].set();
		cin >> str + 1;
		rep(j,1,m) mask[str[j]-'a'][i].set(j);
	} cin >> r >> c;
	rep(i,1,r) {
		cin >> str + 1;
		rep(j,1,c) if (str[j] != '?') rep(k,1,n) 
			ans[(k - i % n + n) % n + 1] &= (mask[str[j] - 'a'][k] >> (j - 1 + m) % m) | (mask[str[j] - 'a'][k] << m - (j - 1 + m) % m);
	} 
	rep(i,1,n) {
		rep(j,1,m) cout << ans[i][j];
		cout << '\n';
	}
}