2024东北四省ccpc

F题

解题思路

数论

有限小数的条件

$\frac{p}{q}$ 在 $k$ 进制下是有限小数，当且仅当 $q$ 的所有质因数都是 $p$ 或 $k$ 的质因数。

即，若 $q$ 的质因数分解为 $q={\prod }_i{p}_i^{a_i}$，则每个 $p_i$ 必须满足 $p_i\mid p$ 或 $p_i\mid k$。

数学表达：
由于 $\frac{p}{q}$ 在 $k$ 进制下是有限小数，等价于 $q$ 能整除 $p\times k^{\infty }$（即 $q$ 的所有质因数必须来自 $p$ 或 $k$ 的质因数）。

1. 质因数分解

• 对 $p$ 和 $k$ 进行质因数分解，合并它们的质因数集合。
  • 设 $p$ 的质因数分解为 $p={\prod }_i{p}_i^{e_i}$。
  • 设 $k$ 的质因数分解为 $k={\prod }_i{p}_i^{f_i}$（可能与 $p$ 的质因数重叠）。
• 合并后的质因数集合即为所有可能的 $q$ 的质因数来源。

2. 构造合法的 $q$

$q$ 必须是这些质因数的乘积，且每个质因数的指数满足：

• 如果 $p_i$ 来自 $p$，则 $a_i\le e_i$。
• 如果 $p_i$ 来自 $k$，则 $a_i$ 可以任意大（因为 $k^{\infty }$ 可覆盖），但需保证 $q\le x$。

3. DFS 枚举所有可能的 $q$

• 使用深度优先搜索（DFS）枚举所有可能的 $q$ 的组合。
• 对于每个质因数 $p_i$，尝试其可能的指数 $a_i$（从 $0$ 开始，直到 $p_i^{a_i}\times \text{当前积}\le x$）。
• 统计所有满足 $q\le x$ 的组合。

#include <bits/stdc++.h>
using namespace std;
#define asd(i, a, b) for (int i = a; i <= b; i++)
#define int long long
const int inf = 0x3f3f3f3f3f3f3f3f, N = 1e6 + 5;
unordered_map<int, int> mp;//不能用map,会超时
int num[N], pri[N], cnt, ans, x;void dfs(int i, int now) 
{int j = num[i];while (true) {if (i <= cnt)dfs(i + 1, now);if (j && now <= x / pri[i]) {now *= pri[i];ans++;j--;} else {break;}}
}void split(int x, int y)
{for (int i = 2; i <= x / i; ++i){while (x % i == 0)x /= i, mp[i] += y;}if (x > 1)mp[x] += y;
}signed main()
{ios::sync_with_stdio(false);int p, k;cin >> p >> x >> k;split(p, 1);split(k, 64);for (auto i : mp){num[++cnt] = i.second;pri[cnt] = i.first;}dfs(1, 1);cout << ans + 1 << endl;return 0;
}

I题

解题思路

组合数学+dp

排列区间的覆盖

为了确保每一个位置 $i$ 都被至少一个长度为 $k$ 的排列区间覆盖，序列的开头和结尾必须分别有一个排列区间。

具体来说：

• 前 $k$ 个数字必须是一个排列（即 $[1,k]$ 是排列）
• 最后 $k$ 个数字也必须是一个排列（即 $[n-k+1,n]$ 是排列）

中间的排列区间可以重叠，但必须确保没有位置被"遗漏"。

---

动态规划定义

定义 $f_i$ 为长度为 $i$ 的满足条件的序列的数量。

初始条件：

• 对于 $i<k$，$f_i=0$（无法形成长度为 $k$ 的排列区间）
• 对于 $i=k$，$f_k=k!$（$1\sim k$ 的所有排列）

---

转移思路

对于 $i>k$，从较短的序列扩展而来：

1. 假设已有长度为 $j$ 的合法序列（$j\ge k$）
2. 在其末尾添加 $i-j$ 个数字（$i-j\le k$）
3. 确保：
   • 新序列的最后 $k$ 个数字是一个排列
   • 新添加部分不会在中间形成新的排列区间

引入辅助函数 $g_{i-j}$ 表示这种扩展方式数。

---

辅助函数 $g$ 的定义

$g_m$ 表示：

1. 在一个排列后添加 $m$ 个数字（$m\le k$）
2. 使得：
   • 最后 $k$ 个数字是新排列
   • 新添加的 $m$ 个数字内部不形成其他排列区间

计算公式：
$$g_m=m!-\sum _{j=1}^{m-1}{g}_j\times (m-j)!$$

其中：

• $m!$：不考虑限制的总方式数
• $g_j\times (m-j)!$：减去在位置 $j$ 提前形成排列区间的情况

---

动态规划转移方程

对于 $f_i$（$i>k$）：
$$f_i=\sum _{j=i-k}^{i-1}{f}_j\times g_{i-j}$$

表示从所有可能的 $f_j$ 转移而来，乘以对应的扩展方式数 $g_{i-j}$。

---

算法流程

1. 预处理计算 $g_1$ 到 $g_k$
2. 初始化 $f_0$ 到 $f_k$
3. 使用转移方程计算 $f_{k+1}$ 到 $f_n$
4. 最终结果：$f_n$

时间复杂度：

• 计算 $g$ 数组：$O(k^2)$
• 计算 $f$ 数组：$O(n\cdot k)$
• 总复杂度：$O(k^2+n\cdot k)$

#include <bits/stdc++.h>
using namespace std;
#define asd(i, a, b) for (int i = a; i <= b; i++)
#define int long long
const int inf = 0x3f3f3f3f3f3f3f3f, N = 1e5 + 5, mod = 998244353;
int dp[N], g[N], fac[N];void init(int k)
{fac[0] = 1;asd(i, 1, N - 1) fac[i] = fac[i - 1] * i % mod;asd(m, 1, k){g[m] = fac[m];asd(j, 1, m - 1){g[m] = (g[m] - g[j] * fac[m - j] % mod + mod) % mod;}}
}signed main()
{ios::sync_with_stdio(false);cin.tie(0);int n, k;cin >> n >> k;if (k > n){cout << 0 << endl;return 0;}init(k);asd(i, 1, k - 1) dp[i] = 0;dp[k] = fac[k];asd(i, k + 1, n){dp[i] = 0;int start = max(i - k, k);asd(j, start, i - 1){dp[i] = (dp[i] + dp[j] * g[i - j] % mod) % mod;}}cout << dp[n] << endl;return 0;
}

H题

解题思路

lca+树上差分+二分

1. 问题转化

• 将城市和铁路视为一棵无向树，选择首都即选择树的根。
• 铁路方向固定为从子节点指向父节点（指向首都）。
• 朋友会面城市为两人在当前根下的最近公共祖先（LCA）。
• 会面路径长度为两人到LCA的路径长度的最大值。

2. 关键观察

• 对于固定的根，所有朋友对的会面路径长度可以通过LCA快速计算。
• 直接枚举所有可能的根（城市）不可行（因为n是1e5量级），需要更高效的方法。

3. 二分答案

• 二分搜索可能的答案（最小化最大路径长度）。
• 对于每个候选值mid，验证是否存在一个根，使得所有朋友对的会面路径长度 ≤ mid。

4. 验证方法（check函数）

• 对于每对朋友(x_i, y_i)：
  • 若原始路径长度 ≤ mid，跳过。
  • 否则，限制根的位置必须满足：
    • 如果x_i到LCA的路径较长，则根必须在x_i的mid级祖先的子树内。
    • 否则，根必须在y_i的(dis[i]-mid-1)级祖先的子树外。
• 使用差分数组标记所有限制条件的交集，检查是否存在满足所有限制的根。

5. 复杂度分析

• 预处理（DFS和倍增数组）：O(n log n)
• 二分验证：O(m log n) 每次验证
• 总复杂度：O((n + m) log n)，适用于题目约束。

6. 输出结果

• 二分找到的最小满足条件的mid即为答案。

#include <bits/stdc++.h>
using namespace std;
#define asd(i, a, b) for (int i = a; i <= b; i++)
#define int long long
const int inf = 0x3f3f3f3f3f3f3f3f, N = 1e6 + 5;
int dep[N], o[N][22], sz[N], dfn[N], tot, x[N], y[N], dis[N], lca[N], n, m, pre[N];
vector<int> g[N];void dfs(int x, int f)
{dep[x] = dep[f] + 1;sz[x] = 1;o[x][0] = f;if (!dfn[x])dfn[x] = ++tot;for (int i = 1; i <= 20; ++i){o[x][i] = o[o[x][i - 1]][i - 1];}for (const auto &y : g[x]){if (y == f)continue;dfs(y, x);sz[x] += sz[y];}
}int getlca(int x, int y)
{if (dep[x] < dep[y])swap(x, y);for (int i = 20; i >= 0; --i){if (dep[o[x][i]] >= dep[y]){x = o[x][i];}}if (x == y)return x;for (int i = 20; i >= 0; --i){if (o[x][i] != o[y][i]){x = o[x][i];y = o[y][i];}}return o[x][0];
}int getfa(int u, int d)
{for (int i = 20; i >= 0; i--){if (d & (1 << i)){u = o[u][i];}}return u;
}bool check(int lim)
{int cnt = 0, vis = 0;asd(i, 1, m){if (dis[i] <= lim)continue;int distx = dep[x[i]] - dep[lca[i]];int disty = dep[y[i]] - dep[lca[i]];if (distx > lim){int u = getfa(x[i], lim);pre[dfn[u]]++;pre[dfn[u] + sz[u]]--;cnt++;}else{int u = getfa(y[i], dis[i] - lim - 1);pre[1]++;pre[dfn[u]]--;pre[dfn[u] + sz[u]]++;pre[n + 1]--;cnt++;}if (disty > lim){int u = getfa(y[i], lim);pre[dfn[u]]++;pre[dfn[u] + sz[u]]--;cnt++;}else{int u = getfa(x[i], dis[i] - lim - 1);pre[1]++;pre[dfn[u]]--;pre[dfn[u] + sz[u]]++;pre[n + 1]--;cnt++;}}int num = 0;asd(i, 1, n){num += pre[i];if (num == cnt)vis = 1;pre[i] = 0;}return vis;
}signed main()
{ios::sync_with_stdio(false);cin >> n >> m;asd(i, 1, n - 1){int u, v;cin >> u >> v;g[u].push_back(v);g[v].push_back(u);}dfs(1, 0);asd(i, 1, m){cin >> x[i] >> y[i];lca[i] = getlca(x[i], y[i]);dis[i] = dep[x[i]] + dep[y[i]] - 2 * dep[lca[i]];}int l = 0, r = n - 1;while (l <= r){int mid = (l + r) >> 1;if (check(mid))r = mid - 1;elsel = mid + 1;}cout << l << endl;return 0;
}