[题解]数学学科竞赛
\[\color{red}{\text{校长者，真神人也，左马桶，右永神，会执利笔破邪炁，何人当之？}} \\
\begin{array}{|}
\hline
\color{pink}{\text{The principal is really a god}} \\
\color{pink}{\text{with a closestool on the left and Yongshen on the right}} \\
\color{pink}{\text{holding a sharp pen to pierce the truth}} \\
\color{pink}{\text{Who can resist him? }} \\
\hline
\end{array} \\
\begin{array}{|}
\hline
\color{green}{\text{校長は本当に神であり、左側にトイレ、右側にヨンシェンがあり}} \\
\color{green}{\text{鋭いペンを持って真実を突き刺している。誰が彼に抵抗できるだろうか？ }} \\
\hline
\end{array} \\
\begin{array}{|}
\hline
\color{lightblue}{\text{Le principal est vraiment un dieu}} \\
\color{lightblue}{\text{avec des toilettes à gauche et Yongshen à droite}} \\
\color{lightblue}{\text{tenant un stylo pointu pour percer la vérité}} \\
\color{lightblue}{\text{Qui peut lui résister ? }} \\
\hline
\end{array} \\
\begin{array}{|}
\hline
\color{purple}{\text{Der Direktor ist wirklich ein Gott}} \\
\color{purple}{\text{mit einer Toilette links und Yongshen rechts}} \\
\color{purple}{\text{der einen spitzen Stift hält}} \\
\color{purple}{\text{um die Wahrheit zu durchdringen.}} \\
\color{purple}{\text{Wer kann ihm widerstehen? }} \\
\hline
\end{array} \\
\begin{array}{|}
\hline
\color{cyan}{\text{Principalis deus est, Yongshen a dextris cum latrina}} \\
\color{cyan}{\text{acuto stylo ad perforandum veritatem: quis resistet ei? }} \\
\hline
\end{array} \\
\color{red}{\text{对曰：“无人，狗欲当之，还请赐教！”}} \\
\newcommand\brak[1]{\left({#1}\right)}
\newcommand\Brak[1]{\left\{{#1}\right\}}
\newcommand\d[0]{\text{d}}
\newcommand\string[2]{\genfrac{\{}{\}}{0pt}{}{#1}{#2}}
\newcommand\down[2]{{#1}^{\underline{#2}}}
\newcommand\ddiv[2]{\left\lfloor\frac{#1}{#2}\right\rfloor}
\newcommand\udiv[2]{\left\lceil\frac{#1}{#2}\right\rceil}
\newcommand\lcm[0]{\operatorname{lcm}}
\newcommand\set[1]{\left\{{#1}\right\}}
\newcommand\ceil[1]{\left\lceil{#1}\right\rceil}
\newcommand\floor[1]{\left\lfloor{#1}\right\rfloor}
\newcommand\rhs[1]{\;\text{Rhs}\;#1}
\newcommand\lhs[1]{\;\text{Lhs}\;#1}
\newcommand\Vec[1]{\vec{\mathbf{#1}}}
\newcommand\rank[0]{\text{rank}}
\]
\(\mathcal{Back\;To\;The\;Menu}\).
2022-03-05 数学学科竞赛
令人振奋的是，T1 正确地感觉出了结论ヾ(≧▽≦*)o
小 G 的约数 / Divisor
第一个和第二个条件都很显然，对于第三个条件变个形
\[\begin{aligned}
d_i\lcm(d_i,d_j)+d_j\gcd(d_i,d_j)&>2d_id_j \\
\Leftrightarrow \frac{d_i^2d_j}{g}+d_jg&>2d_id_j&\gcd(d_i,d_j)\overset\Delta=g \\
\Leftrightarrow d_jg&>\brak{2-\frac{d_i}{g}}d_id_j \\
\Leftrightarrow \frac{g}{d_i}&>2-\frac{d_i}{g} \\
\Leftrightarrow \frac{d_i}{g}&>1 \\
\Rightarrow d_i&\neq g
\end{aligned}
\]
也就是说，\(\forall i<j,d_i\nmid d_j\).
因此，我们需要构造的数列满足：
- 所有 \(d_i\) 都是 \(n\) 的因数；
- \(\forall i<j,d_i\nmid d_j\)；
- 数列 \(\set{D_i}\) 单调不降；
单调不降可以不管他，只要我们选出了 \(\set{d_i}\)，排序之后就可以得到 \(\set{D_i}\). 事实上，现在我们要在 \(n\) 的因数中选择最长反链，答案就是最长反链长度，一个比较直观的结论是选择 “按照质因数指数之和分层之后” 的最大的一层。这个结论用调整法稍微想一下感觉差不多是对的。
小 G 的连通图 / Graph
这个我还不会🤕.
这个思路是怎么想到的🤕.
两个数 \(x,y\) 可以连边当且仅当存在 \(p\) 使得 \(x\equiv y\equiv 0\pmod p\)，那么，我们可以耍赖地取一个 \(\displaystyle L=\prod_{p\in \Bbb P}^{p\le n}p\)，这样，\(L\) 和 \(L+2,L+3,\cdots,L+n-1\) 都可以有连边，因为 \(\forall 1<t\le n,L\equiv L+t\pmod{t}\)，唯一一个钉子户就是 \(L+1\)，这个时候，我们想个办法，从 \([1,n]\) 的质数集中随意取出一个 \(a\)，使得 \(x\equiv -1\pmod a\)（对于其他质数仍然存在 \(p\mid x\)），这样 \(x+1\equiv 0\equiv x+a+1\pmod a\)，并且 \(x+a+1\equiv x\equiv 0\pmod{a+1}\)，于是 \(x+1\) 就和 \(x\) 联通了，这个 \(x\) 不难找，令 \(\displaystyle q=\frac{L}{a}\)，于是 \(x\) 满足 \(q\mid x\land a\mid(x+1)\) 即可。
但是又有一个问题，就是 \(x\equiv x+a^k\equiv -1\not\equiv 0\pmod a\)（不是 \(x+ka\) 的原因是 \(k\) 中如果含有其他质数，那么可以通过该质数与 \(x\) 间接相连），也就是 \(x+a^k\) 和 \(x\) 又不连通了，这个时候，我们又会想取出另外一个质数 \(b\)，使得 \(x\equiv -a\pmod b\)，用类似填上 \(x+1\) 的坑，但是有一个问题，那就是 \(x\equiv -a\pmod b\) 不意味着 \(x\) 能和 \(x+a^2\) 联通，于是我们规定前面取出的 \(a>\sqrt n\)，这样在区间 \([x,x+n-1]\) 中就不存在 \(x+a^2\) 这个点，于是不用考虑它了，然后我们用 \(b\) 填上了 \(x+a\) 的这个坑。
然而，理想是十分美好的，用这个 \(b\) 填上 \(a\) 的坑之后，又发现 \(x+b\) 也出现了坑（不是 \(x+b^k\) 是因为 \(b>a>\sqrt n\)，因此也不存在 \(x+b^2\) 这样的点了），如果再用类似方法，我们将无限递归下去，直到重新回到 \(a\)，打破这个无尽递归的方法是，我们让 \(a\) 和 \(b\) 互成嵌套，即 \(a\) 可以填 \(x+b\) 的坑，而 \(b\) 可以填 \(x+a\) 的坑，即需要满足几个取模方程
\[\begin{cases}
x\equiv -a\pmod{b}&(1) \\[2ex]
x\equiv -b\pmod a&(2) \\[2ex]
x\equiv -1\pmod a&(3)
\end{cases}
\]
通过 \((2)(3)\) 发现他们的必要条件是 \(b=ka+1(k\ge 2)\)（因为我们要使 \(x\) 和 \(x+a+1\) 联通，进而和 \(x+1\) 联通，因此 \(k\) 不能取 \(1\)），于是我们只需要取 \(k=2\)，即令 \(b=2a+1\)，然后满足 \((1)(3)\) 两个方程即可。
总结一下，我们需要干的事情：算出 \(\displaystyle L=\prod_{p\in \Bbb P}^{p\le n}p\)，找到一个 \(a>\sqrt n\) 使得 \(a,2a+1\) 均为质数，然后找到一个 \(x\) 使得 \(\displaystyle \brak{\prod_{p\in \Bbb P}^{p\neq a\land p\neq b\land p\le n}p}\mid x\land a\mid (x+1)\land (2a+1)\mid (x+a)\)，这个 \(x\) 就是我们想要求的答案，至于怎么找到 \(x\)，稍微变个形：
\[a\mid(x+1)\land(2a+1)\mid(x+1)\Leftrightarrow a(2a+1)\mid (x+3a+1)
\]
暴力找即可。
另外，不难证明打表发现在 \(n>35\) 时，总能找到一个 \(a>\sqrt n\) 使得 \(a,2a+1\) 均为质数且有一个合法的 \(x\). 所以较小范围还得写个暴力判断一下。
至于题解做法，见鬼去吧。
/** @author __Elaina__ */
#pragma GCC optimize(2)
#include <bits/stdc++.h>
using namespace std;
#define USING_FREAD
// #define NDEBUG
#include <cassert>
namespace Elaina {
/** その可憐な少女は魔女であり、旅人でした。 ―― そう、私です! */
#define rep(i, l, r) for(int i = (l), i##_end_ = (r); i <= i##_end_; ++i)
#define drep(i, l, r) for(int i = (l), i##_end_ = (r); i >= i##_end_; --i)
#define fi first
#define se second
#define mp(a, b) make_pair(a, b)
#define Endl putchar('\n')
#define whole(v) ((v).begin()), ((v).end())
#define bitcnt(s) (__builtin_popcount(s))
/** @warning no forced type conversion */
#define rqr(x) ((x) * (x))
#define y0 FUCK_UP
#define y1 MOTHER_FUCKER
#define console(...) fprintf(stderr, __VA_ARGS__)
typedef long long ll;
typedef unsigned long long ull;
typedef std::pair<int, int> pii;
template<class T> inline T fab(T x) { return x < 0 ? -x : x; }
template<class T> inline void chkmin(T& x, const T rhs) { x = std::min(x, rhs); }
template<class T> inline void chkmax(T& x, const T rhs) { x = std::max(x, rhs); }
template<class T> inline void myswap(T& x, T& y) { x ^= y ^= x ^= y; }
#ifdef USING_FREAD
inline char qkgetc() {
# define BUFFERSIZE 1 << 20
static char BUF[BUFFERSIZE], *p1 = BUF, *p2 = BUF;
return p1 == p2 && (p2 = (p1 = BUF) + fread(BUF, 1, BUFFERSIZE, stdin), p1 == p2) ? EOF : *p1++;
# undef BUFFERSIZE
}
# define CHARRECEI qkgetc()
#else
# define CHARRECEI getchar()
#endif
template<class T> inline T readret(T x) {
x = 0; int f = 0; char c;
while (!isdigit(c = CHARRECEI)) if(c == '-') f = 1;
for (x = (c ^ 48); isdigit(c = CHARRECEI); x = (x << 1) + (x << 3) + (c ^ 48));
return f ? -x : x;
}
template<class T> inline void readin(T& x) {
x = 0; int f = 0; char c;
while (!isdigit(c = CHARRECEI)) if (c == '-') f = 1;
for (x = (c ^ 48); isdigit(c = CHARRECEI); x = (x << 1) + (x << 3) + (c ^ 48));
if (f) x = -x;
}
template<class T, class... Args> inline void readin(T& x, Args&... args) {
readin(x), readin(args...);
}
template<class T> inline void writln(T x, char c = '\n') {
if (x < 0) putchar('-'), x = -x;
static int __stk[55], __bit = 0;
do __stk[++__bit] = x % 10, x /= 10; while (x);
while (__bit) putchar(__stk[__bit--] ^ 48);
putchar(c);
}
} // namespace Elaina
using namespace Elaina;
int n;
namespace Brute {
const int Maxn = 2e7;
int prime[Maxn + 5], minp[Maxn + 5];
bool vis[Maxn + 5];
inline void sieve() {
vis[1] = true;
rep (i, 2, Maxn) {
if (!vis[i]) prime[++*prime] = minp[i] = i;
for (int j = 1; j <= *prime && i * prime[j] <= Maxn; ++j) {
vis[i * prime[j]] = true;
minp[i * prime[j]] = prime[j];
if (i % prime[j] == 0) break;
}
}
}
inline bool check(int l) {
for (int i = l, j = 1; j <= n; ++i, ++j)
if (i % 2 == 1 && j - minp[i] < 1 && j + minp[i] > n)
return false;
return true;
}
inline void launch() {
sieve();
for (int l = 2; l <= Maxn - n + 1; ++l) if (check(l))
return void(printf("%d\n", l));
puts("No solution");
}
} // namespace Brute;
const int Maxn = 1e5;
const int Bit = 1e8;
int prime[Maxn + 5];
bool vis[Maxn + 5];
inline void sieve() {
vis[1] = true;
rep (i, 2, Maxn) {
if (!vis[i]) prime[++*prime] = i;
for (int j = 1; j <= *prime && i * prime[j] <= Maxn; ++j) {
vis[i * prime[j]] = true;
if (i % prime[j] == 0) break;
}
}
}
struct Bigint {
int len;
ll a[Maxn + 5];
inline Bigint operator =(const int rhs) {
assert(rhs < Bit);
memset(a, 0, sizeof a);
len = 1, a[0] = rhs;
return (*this);
}
inline Bigint(const int rhs) { (*this) = rhs; }
// inline Bigint operator *(const int rhs) const {
// Bigint ret = (*this);
// for (int i = 0; i < len; ++i) ret.a[i] *= rhs;
// for (int i = 0; i < len; ++i)
// ret.a[i + 1] += ret.a[i] / Bit, ret.a[i] %= Bit;
// if (ret.a[len]) ++ret.len;
// return ret;
// }
inline void operator *=(const int& rhs) {
for (int i = 0; i < len; ++i) a[i] *= rhs;
for (int i = 0; i < len; ++i)
a[i + 1] += a[i] / Bit, a[i] %= Bit;
if (a[len]) ++len;
}
inline void print() {
printf("%lld", a[len - 1]);
for (int i = len - 2; i >= 0; --i) printf("%08lld", a[i]);
Endl;
}
};
signed main() {
freopen("graph.in", "r", stdin);
freopen("graph.out", "w", stdout);
readin(n);
if (n == 1) return puts("1") & 0;
if (n <= 40) return Brute::launch(), 0;
sieve();
int a;
for (a = 1; a <= n; ++a) {
if ((a << 1) + 1 > n) break;
if (1ll * a * a <= n) continue;
if (!vis[a] && !vis[(a << 1) + 1]) break;
}
Bigint ans = 1; ll M = 1ll * a * ((a << 1) + 1), prod = 1;
for (int i = 1; i <= n; ++i) if (!vis[i] && i != a && i != (a << 1) + 1)
prod = prod * i % M, ans *= i;
int times; ll now;
for (now = prod, times = 1; now != M - 3 * a - 1; now = (now + prod) % M, ++times);
ans *= times;
ans.print();
return 0;
}
小 G 的 DAG / Dag
把带 \(\log\) 的算法几乎全部遍历了一遍，然后不会，分块几乎都是往大小点想，完全没想到对操作序列进行分块......不过确实应当往这个方面想一下的，对于一个点，操作 1 显然只有最后一次才真正有效，就凭这一点，也应当想一想操作分块。
对于操作 \(1\)，可以设置一个阈值 \(\sqrt n\)，当这种操作堆到 \(\sqrt n\) 大小的时候再全部同时操作，对于剩下的，可以在询问的时候直接暴力扫，这个部分的复杂度是 \(\mathcal O(n\sqrt n)\).
对于操作 2，实际上对于一个点 \(x\)，真正有用的操作 2 是介于最后一个覆盖它的 1 操作和询问它的 3 操作之间，也就是说，我们需要处理出一个操作区间内，能够到达 \(x\) 的最小值。因此，我们需要处理出 \(minv(id,u)\)，即第 \(id\) 个块对于 \(u\) 的最小值是多少（如果没有，就设为 \(+\infty\)），处理询问的时候，边角料就暴力问了。
现在唯一的问题就是处理出 \(u\) 能否到 \(v\) 这个问题了，直接开 \(10^{10}\) 的 bitset 怕是有点困难，于是乎，把点集每 \(10^4\) 分成一组，处理出每个点到这 \(10^4\) 个点的可达情况，这样空间大概就只需要 \(\mathcal O\brak{\frac{10^9}{\omega}}\approx 120\rm MB\) 了。
最后的复杂度大概是 \(\mathcal O(10n\sqrt n)\) 吧，效率还行。
/** @author __Elaina__ */
#include <bits/stdc++.h>
using namespace std;
#define USING_FREAD
// #define NDEBUG
#include <cassert>
namespace Elaina {
/** その可憐な少女は魔女であり、旅人でした。 ―― そう、私です! */
#define rep(i, l, r) for(int i = (l), i##_end_ = (r); i <= i##_end_; ++i)
#define drep(i, l, r) for(int i = (l), i##_end_ = (r); i >= i##_end_; --i)
#define fi first
#define se second
#define mp(a, b) make_pair(a, b)
#define Endl putchar('\n')
#define whole(v) ((v).begin()), ((v).end())
#define bitcnt(s) (__builtin_popcount(s))
/** @warning no forced type conversion */
#define rqr(x) ((x) * (x))
#define y0 FUCK_UP
#define y1 MOTHER_FUCKER
#define console(...) fprintf(stderr, __VA_ARGS__)
typedef long long ll;
typedef unsigned long long ull;
typedef std::pair<int, int> pii;
template<class T> inline T fab(T x) { return x < 0 ? -x : x; }
template<class T> inline void chkmin(T& x, const T rhs) { x = std::min(x, rhs); }
template<class T> inline void chkmax(T& x, const T rhs) { x = std::max(x, rhs); }
template<class T> inline void myswap(T& x, T& y) { x ^= y ^= x ^= y; }
#ifdef USING_FREAD
inline char qkgetc() {
# define BUFFERSIZE 1 << 20
static char BUF[BUFFERSIZE], *p1 = BUF, *p2 = BUF;
return p1 == p2 && (p2 = (p1 = BUF) + fread(BUF, 1, BUFFERSIZE, stdin), p1 == p2) ? EOF : *p1++;
# undef BUFFERSIZE
}
# define CHARRECEI qkgetc()
#else
# define CHARRECEI getchar()
#endif
template<class T> inline T readret(T x) {
x = 0; int f = 0; char c;
while (!isdigit(c = CHARRECEI)) if(c == '-') f = 1;
for (x = (c ^ 48); isdigit(c = CHARRECEI); x = (x << 1) + (x << 3) + (c ^ 48));
return f ? -x : x;
}
template<class T> inline void readin(T& x) {
x = 0; int f = 0; char c;
while (!isdigit(c = CHARRECEI)) if (c == '-') f = 1;
for (x = (c ^ 48); isdigit(c = CHARRECEI); x = (x << 1) + (x << 3) + (c ^ 48));
if (f) x = -x;
}
template<class T, class... Args> inline void readin(T& x, Args&... args) {
readin(x), readin(args...);
}
template<class T> inline void writln(T x, char c = '\n') {
if (x < 0) putchar('-'), x = -x;
static int __stk[55], __bit = 0;
do __stk[++__bit] = x % 10, x /= 10; while (x);
while (__bit) putchar(__stk[__bit--] ^ 48);
putchar(c);
}
} // namespace Elaina
using namespace Elaina;
const int Maxn = 1e5;
const int Maxl = 1e4;
const int Blo = 320;
int op[Maxn + 5], u[Maxn + 5], x[Maxn + 5], qid[Maxn + 5];
int deg[Maxn + 5];
vector<int> g[Maxn + 5];
int n, m, q;
int bel[Maxn + 5], bl[Maxn + 5], br[Maxn + 5], bcnt;
inline void input() {
readin(n, m, q);
int a, b;
rep (i, 1, m) {
readin(a, b);
if (a == b) continue;
g[a].push_back(b), ++deg[b];
}
rep (i, 1, q) {
readin(op[i], u[i]);
if (op[i] ^ 3) readin(x[i]);
else qid[i] = ++*qid;
}
}
int que[Maxn + 5], hd, tl;
inline void Topo() {
hd = 1;
rep (i, 1, n) if (!deg[i]) que[++tl] = i;
while (hd <= tl) {
int u = que[hd++];
for (const int& v: g[u]) if (!--deg[v])
que[++tl] = v;
}
// rep (i, 1, tl) console("%d%c", que[i], " \n"[i == tl]);
assert(tl == n);
}
int ans[Maxn + 5];
int enval[Maxn / Blo + 5][Maxn + 5], enmin[Maxn / Blo + 5][Maxn + 5];
int lasmodi[Maxn + 5];
bitset<Maxl + 5> to[Maxn + 5];
inline void solve(int ql, int qr) {
drep (i, n, 1) {
int u = que[i]; to[u].reset(); // don't forget to clear!!
if (ql <= u && u <= qr) to[u].set(u - ql);
for (const int& v: g[u]) to[u] |= to[v];
}
rep (id, 1, bcnt) {
rep (i, 1, n) lasmodi[i] = enval[id - 1][i];
rep (i, bl[id], br[id]) {
if (op[i] == 3 && ql <= u[i] && u[i] <= qr) {
rep (j, bl[id], i) if (op[j] == 1 && to[u[j]][u[i] - ql])
lasmodi[u[i]] = j;
// console("lasmodi == %d\n", lasmodi[u[i]]);
int cur = x[lasmodi[u[i]]];
// console("cur == %d\n", cur);
// No ST table !!!
// console("l == %d, r == %d\n", max(lasmodi[u[i]] + 1, bl[id]), i - 1);
rep (j, max(lasmodi[u[i]] + 1, bl[id]), i - 1)
if (op[j] == 2 && to[u[j]][u[i] - ql])
chkmin(cur, x[j]);
// console("bl == %d, br == %d\n", bel[lasmodi[u[i]]] + 1, id - 1);
rep (j, bel[lasmodi[u[i]]] + 1, id - 1)
chkmin(cur, enmin[j][u[i]]);
if (bel[lasmodi[u[i]]] != id && lasmodi[u[i]] > 0)
rep (j, lasmodi[u[i]] + 1, br[bel[lasmodi[u[i]]]])
if (op[j] == 2 && to[u[j]][u[i] - ql])
chkmin(cur, x[j]);
ans[qid[i]] = cur;
lasmodi[u[i]] = enval[id - 1][u[i]];
}
}
}
}
inline void prelude() {
for (int x = 1; (x - 1) * Blo + 1 <= q; ++x) {
bcnt = x;
bl[x] = (x - 1) * Blo + 1;
br[x] = min(x * Blo, q);
rep (i, bl[x], br[x]) bel[i] = x;
}
rep (i, 1, bcnt) {
rep (j, 1, n) enval[i][j] = enval[i - 1][j];
memset(enmin[i] + 1, 0x3f, n << 2);
rep (j, bl[i], br[i]) {
if (op[j] == 1) enval[i][u[j]] = j;
else if (op[j] == 2) chkmin(enmin[i][u[j]], x[j]);
// console("udp:> enval[%d, %d] == %d, enmin[%d, %d] == %d\n", i, u[j], enval[i][u[j]], i, u[j], enmin[i][u[j]]);
}
rep (j, 1, n) {
int u = que[j];
for (const int& v: g[u]) {
// printf("When u == %d, v == %d\n", u, v);
chkmax(enval[i][v], enval[i][u]);
chkmin(enmin[i][v], enmin[i][u]);
// console("udp:> enval[%d, %d] == %d, enmin[%d, %d] == %d\n", i, v, enval[i][v], i, v, enmin[i][v]);
}
}
}
}
signed main() {
freopen("dag.in", "r", stdin);
freopen("dag.out", "w", stdout);
// freopen("_log.out", "w", stderr);
input();
Topo();
prelude();
// console("finished prelude\n");
// rep (i, 1, bcnt) rep (j, 1, n)
// console("enval[%d, %d] == %d, enmin[%d, %d] == %d\n", i, j, enval[i][j], i, j, enmin[i][j]);
for (int i = 1; i <= Maxn / Maxl + 1; ++i) {
int ql = (i - 1) * Maxl + 1, qr = i * Maxl; chkmin(qr, n);
solve(ql, qr);
// console("solve [%d, %d]\n", ql, qr);
if (qr == n) break;
}
rep (i, 1, *qid) writln(ans[i]);
return 0;
}
