「JLOI2016」侦查守卫
题意
有一个 \(n\) 个点的树，有 \(m\) 个关键点需要被监视。可以在其中一些点上插眼，在 \(i\) 号点上放眼需要花费 \(w_i\) 的代价，可以监视距离 \(i\) 不超过 \(d\) 的所有点。
问将所有关键点都被监视所需要花费的最小代价。
\(m \le n \le 5 \times 10^5, d \le 20, w_i \le 1000\)
题解
\(d\) 很小，不难想到 \(\mathcal O(nd)\) 的 \(dp\) 。
令 \(f_{i, j}\) 为 \(i\) 向下 \(j\) 层有未被监视的点的最小代价。
令 \(g_{i, j}\) 为 \(i\) 向上 \(j\) 层都能被监视的最小代价。
状态很容易想。。但是转移就很恶心了。。
- 如果点 \(u\) 一定要被监视，那么令 \(f_{u, 0} = g_{u, 0} = w_u\) ，表示这个点被监视的代价。
然后从它的儿子 \(v\) 转移状态上来。
那么对于 \(g\) 有如下转移：
\[ g_{u, i} = \min\{g_{u, i} + f_{v, i}, g_{v, i + 1} + f_{u, i + 1}\} \]
前者意味着对于子树 \(v\) 向上 \(j\) 层都被此处覆盖了，后者就是考虑有一个儿子 \(v\) 能向上延伸 \(j + 1\) 层。
然后记得后缀 chkmin 。
对于 \(f\) 你就前缀 chkmin 并且注意 f[u][0] = g[u][0] 。
总结
对于有些最优化 \(dp\) ，可以记一下前缀 or 后缀 \(\min\) 的答案，转移会简单很多。。
代码
#include
#define For(i, l, r) for (register int i = (l), i##end = (int)(r); i <= i##end; ++i)
#define Fordown(i, r, l) for (register int i = (r), i##end = (int)(l); i >= i##end; --i)
#define Rep(i, r) for (register int i = (0), i##end = (int)(r); i < i##end; ++i)
#define Set(a, v) memset(a, v, sizeof(a))
#define Cpy(a, b) memcpy(a, b, sizeof(a))
#define debug(x) cout << #x << ": " << (x) << endl
using namespace std;
template inline bool chkmin(T &a, T b) { return b < a ? a = b, 1 : 0; }
template inline bool chkmax(T &a, T b) { return b > a ? a = b, 1 : 0; }
inline int read() {
int x(0), sgn(1); char ch(getchar());
for (; !isdigit(ch); ch = getchar()) if (ch == '-') sgn = -1;
for (; isdigit(ch); ch = getchar()) x = (x * 10) + (ch ^ 48);
return x * sgn;
}
void File() {
#ifdef zjp_shadow
freopen ("2024.in", "r", stdin);
freopen ("2024.out", "w", stdout);
#endif
}
const int N = 500100, inf = 0x3f3f3f3f;
int n, d, f[N][25], g[N][25];
vector G[N];
int w[N]; bool App[N];
void Dp(int u, int fa) {
if (App[u]) f[u][0] = g[u][0] = w[u];
For (i, 1, d) g[u][i] = w[u]; g[u][d + 1] = inf;
for (int v : G[u]) if (v != fa) {
Dp(v, u);
Fordown (i, d, 0)
g[u][i] = min(g[u][i + 1], min(g[u][i] + f[v][i], g[v][i + 1] + f[u][i + 1]));
f[u][0] = g[u][0];
For (i, 1, d)
f[u][i] = min(f[u][i] + f[v][i - 1], f[u][i - 1]);
}
}
int main () {
File();
n = read(); d = read();
For (i, 1, n) w[i] = read();
For (i, 1, read()) App[read()] = true;
For (i, 1, n - 1) {
int u = read(), v = read();
G[u].push_back(v); G[v].push_back(u);
}
Dp(1, 0);
printf ("%d\n", f[1][0]);
return 0;
} 「JLOI2016」方
题意
给你 \(n \times m\) 的方格图，有 \((n + 1) \times (m + 1)\) 个格点，禁止其中 \(k\) 个格点作为端点，问剩下的图有多少个格点正方形。（斜的也算）
\(n, m \le 10^6, k \le 2 \times 10^3\)
题解
竟然还有这种 shit 题。
\(k = 0\) 是我原来在 \(\text{NOIp}\) 模拟赛里面搬的一道水题。。。
然后有禁止的限制，不难想到容斥，然后后面的细节就贼烦了。
具体可以看看 zzq 的博客 ，因为太麻烦了，不想讲了。
前面那些优化并不是重点，重点在于如何容斥。。
你可以考虑对于单个正方形会被统计几次，然后依次凑系数就行啦。
zzq 那个按顺序枚举的方法十分优秀，不需要开
hash表存状态，直接最后除掉一个正方形被算进去的次数就行啦。
总结
容斥考虑对于一个点会被计算几次，然后凑系数就行了。
代码
#include
#define For(i, l, r) for (register int i = (l), i##end = (int)(r); i <= i##end; ++i)
#define Fordown(i, r, l) for (register int i = (r), i##end = (int)(l); i >= i##end; --i)
#define Rep(i, r) for (register int i = (0), i##end = (int)(r); i < i##end; ++i)
#define Set(a, v) memset(a, v, sizeof(a))
#define Cpy(a, b) memcpy(a, b, sizeof(a))
#define debug(x) cout << #x << ": " << (x) << endl
#define epb emplace_back
using namespace std;
template inline bool chkmin(T &a, T b) { return b < a ? a = b, 1 : 0; }
template inline bool chkmax(T &a, T b) { return b > a ? a = b, 1 : 0; }
inline int read() {
int x(0), sgn(1); char ch(getchar());
for (; !isdigit(ch); ch = getchar()) if (ch == '-') sgn = -1;
for (; isdigit(ch); ch = getchar()) x = (x * 10) + (ch ^ 48);
return x * sgn;
}
void File() {
#ifdef zjp_shadow
freopen ("2025.in", "r", stdin);
freopen ("2025.out", "w", stdout);
#endif
}
const int Mod = 1e8 + 7;
using ll = long long;
using PII = pair;
const int N = 2010;
int n, m, k, x[N], y[N];
inline int Count(int l, int r, int d) {
if (!l || !r || !d) return 0;
int res = 0, upp = min(l + r, d), pos[3] = {l + 1, r + 1, upp}, cl = 1;
sort(pos, pos + 3);
Rep (i, 3) {
int cr = pos[i]; if (cr > upp) break;
if (cr < 2 || cl == cr) continue; ++ cl;
int vl = min(r, cl - 1) - max(cl - l, 1) + 1,
vr = min(r, cr - 1) - max(cr - l, 1) + 1;
res = (res + 1ll * (vl + vr) * (cr - cl + 1) / 2) % Mod; cl = cr;
}
return res;
}
inline int Calc(int u, int d, int l, int r) {
return (Count(l, r, d) + Count(l, r, u) + Count(u, d, l) + Count(u, d, r)
+ min(l, d) + min(d, r) + min(r, u) + min(u, l)) % Mod;
}
const double eps = 1e-9;
inline bool check(double x, double y) {
if (fabs(x - int(x + 0.5)) >= eps || fabs(y - int(y + 0.5)) >= eps) return false;
int nx = int(x + 0.5), ny = int(y + 0.5);
return 0 <= nx && nx <= n && 0 <= ny && y <= m;
}
inline int check(PII S) {
return 0 <= S.first && S.first <= n && 0 <= S.second && S.second <= m;
}
set T;
struct Node { int x, y; } P[N];
int main () {
File();
n = read(); m = read(); k = read();
int ans = 0;
For (i, 1, min(n, m))
ans = (ans + 1ll * i * (n - i + 1) % Mod * (m - i + 1)) % Mod;
For (i, 1, k) {
P[i].x = x[i] = read(), P[i].y = y[i] = read();
T.insert(make_pair(x[i], y[i]));
ans = (ans - Calc(x[i], n - x[i], y[i], m - y[i]) + Mod) % Mod;
}
sort(P + 1, P + k + 1, [&](Node a, Node b) { return a.x != b.x ? a.x < b.x : a.y < b.y; } );
For (i, 1, k) x[i] = P[i].x, y[i] = P[i].y;
int cnt3 = 0, cnt4 = 0;
For (i, 1, k) For (j, i + 1, k) {
{
double midx = (x[i] + x[j]) / 2.0, midy = (y[i] + y[j]) / 2.0,
gapx = x[i] - midx, gapy = y[i] - midy;
if (check(midx - gapy, midy + gapx) && check(midx + gapy, midy - gapx)) {
++ ans;
}
}
for (int dir = -1; dir <= 1; dir += 2) {
int tx = x[i] - x[j], ty = y[i] - y[j];
PII T1 = make_pair(x[i] - ty * dir, y[i] + tx * dir);
PII T2 = make_pair(x[j] - ty * dir, y[j] + tx * dir);
if (!check(T1) || !check(T2)) continue;
int cnt = 0; ++ ans;
if (T.find(T1) != T.end()) ++ cnt;
if (T.find(T2) != T.end()) ++ cnt;
cnt3 += (cnt >= 1);
cnt4 += (cnt >= 2);
}
}
ans -= cnt3 / 2 + cnt4 / 4;
printf ("%d\n", (ans % Mod + Mod) % Mod);
return 0;
} 「JLOI2016」成绩比较
题意
有 \(n\) 个人 \(m\) 门学科，第 \(i\) 门的分数为不大于 \(u_i\) 的一个正整数。
定义 \(A\) 碾压 \(B\) 当且仅当 \(A\) 的每门学科的分数都不低于 \(B\) 的该门学科的分数。
已知第一个人第 \(i\) 门学科的排名为 \(r_i\) ，即这门学科不低于 \(n − r_i\) 人的分数，但一定低于 \(r_i−1\) 人的分数。
求有多少种方案使得第一个人恰好碾压了 \(k\) 个人。
两种方案不同当且仅当存在两个人的分数不同。
\(n \le 100, m \le 100, u_i \le 10^9\)
题解
原来听 h10 讲广义容斥的时候讲过。。现在不会做了。。
令 \(g_x\) 为第一个人至少碾压了 \(x\) 个人的方案数。
其实就是
\[ g_x = {n - 1 \choose x} \prod_{i = 1}^{m} {n - 1 - x \choose r_i - 1} A_i \]
其中 \(A_i\) 为对于第 \(i\) 门来说，所有人从小到大排分数合法的方案数。其余的意义就十分明显了，首先是选人，然后选剩下的人填这门比第一个人高的方案数。
其实就是
\[ A_i = \sum_{j = 1}^{u_i} (u_i - j)^{r_i - 1} j^{n - r_i} \]
这个显然是一个 \(n\) 次多项式，求出 \(n + 1\) 个点值，利用拉格朗日插值即可在 \(\mathcal O(n^2)\) 的时间内插出来，可以利用连续点值的性质优化到 \(\mathcal O(n)\) 。
最后不优化复杂度是 \(\mathcal O(n^2m)\) 的，已经完全足够了。
总结
计数题还是有很多式子可以形式化地写出来的。对于 至少 的方案数进行计算的时候，只需要考虑把不合法的位置全都用别的塞上去，那么剩下的就一定合法了。
代码
#include
#define For(i, l, r) for (register int i = (l), i##end = (int)(r); i <= i##end; ++i)
#define Fordown(i, r, l) for (register int i = (r), i##end = (int)(l); i >= i##end; --i)
#define Rep(i, r) for (register int i = (0), i##end = (int)(r); i < i##end; ++i)
#define Set(a, v) memset(a, v, sizeof(a))
#define Cpy(a, b) memcpy(a, b, sizeof(a))
#define debug(x) cout << #x << ": " << (x) << endl
using namespace std;
template inline bool chkmin(T &a, T b) { return b < a ? a = b, 1 : 0; }
template inline bool chkmax(T &a, T b) { return b > a ? a = b, 1 : 0; }
inline int read() {
int x(0), sgn(1); char ch(getchar());
for (; !isdigit(ch); ch = getchar()) if (ch == '-') sgn = -1;
for (; isdigit(ch); ch = getchar()) x = (x * 10) + (ch ^ 48);
return x * sgn;
}
void File() {
#ifdef zjp_shadow
freopen ("2026.in", "r", stdin);
freopen ("2026.out", "w", stdout);
#endif
}
const int N = 110, Mod = 1e9 + 7;
int n, m, k, u[N], r[N];
inline int fpm(int x, int power) {
int res = 1;
for (; power; power >>= 1, x = 1ll * x * x % Mod)
if (power & 1) res = 1ll * res * x % Mod;
return res;
}
int x[N], y[N];
int Inter(int maxn, int p) {
int res = 0;
For (i, 1, maxn) {
int cur = 1, coef = 1;
For (j, 1, maxn) if (i != j) {
cur = 1ll * cur * (p - x[j]) % Mod;
coef = 1ll * coef * (x[i] - x[j]) % Mod;
}
res = (res + 1ll * y[i] * cur % Mod * fpm(coef, Mod - 2)) % Mod;
}
return res;
}
inline int Calc(int p) {
For (i, 1, n + 1)
x[i] = i, y[i] = (y[i - 1] + 1ll * fpm(u[p] - i, r[p] - 1) * fpm(i, n - r[p])) % Mod;
return Inter(n + 1, u[p]);
}
int g[N], A[N], Comb[N][N];
int main () {
File();
n = read(); m = read(); k = read();
For (i, 0, n) {
Comb[i][0] = 1;
For (j, 1, i)
Comb[i][j] = (Comb[i - 1][j - 1] + Comb[i - 1][j]) % Mod;
}
For (i, 1, m) u[i] = read();
For (i, 1, m) r[i] = read();
For (i, 1, m) A[i] = Calc(i);
For (i, 1, n - 1) {
g[i] = Comb[n - 1][i];
For (j, 1, m)
g[i] = 1ll * g[i] * Comb[n - 1 - i][r[j] - 1] % Mod * A[j] % Mod;
}
int ans = 0;
For (i, k, n - 1)
ans = (ans + ((i - k) & 1 ? -1ll : 1ll) * Comb[i][k] * g[i]) % Mod;
printf ("%d\n", (ans + Mod) % Mod);
return 0;
}