JLOI2016 简要题解

时间 2019-11-09

标签 jloi2016 jloi 简要题解繁體版

原文原文链接

「JLOI2016」侦查守卫

题意

有一个 \(n\) 个点的树，有 \(m\) 个关键点须要被监视。能够在其中一些点上插眼，在 \(i\) 号点上放眼须要花费 \(w_i\) 的代价，能够监视距离 \(i\) 不超过 \(d\) 的全部点。html

问将全部关键点都被监视所须要花费的最小代价。c++

\(m \le n \le 5 \times 10^5, d \le 20, w_i \le 1000\)git

题解

\(d\) 很小，不难想到 \(\mathcal O(nd)\) 的 \(dp\) 。优化

令 \(f_{i, j}\) 为 \(i\) 向下 \(j\) 层有未被监视的点的最小代价。spa

令 \(g_{i, j}\) 为 \(i\) 向上 \(j\) 层都能被监视的最小代价。debug

状态很容易想。。可是转移就很恶心了。。code

若是点 \(u\) 必定要被监视，那么令 \(f_{u, 0} = g_{u, 0} = w_u\) ，表示这个点被监视的代价。

而后从它的儿子 \(v\) 转移状态上来。htm

那么对于 \(g\) 有以下转移：blog

\[ g_{u, i} = \min\{g_{u, i} + f_{v, i}, g_{v, i + 1} + f_{u, i + 1}\} \]get

前者意味着对于子树 \(v\) 向上 \(j\) 层都被此处覆盖了，后者就是考虑有一个儿子 \(v\) 能向上延伸 \(j + 1\) 层。

而后记得后缀 chkmin 。

对于 \(f\) 你就前缀 chkmin 而且注意 f[u][0] = g[u][0] 。

总结

对于有些最优化 \(dp\) ，能够记一下前缀 or 后缀 \(\min\) 的答案，转移会简单不少。。

代码

#include <bits/stdc++.h>

#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<typename T> inline bool chkmin(T &a, T b) { return b < a ? a = b, 1 : 0; }
template<typename T> 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<int> 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 <bits/stdc++.h>

#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<typename T> inline bool chkmin(T &a, T b) { return b < a ? a = b, 1 : 0; }
template<typename T> 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<int, int>;

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<PII> 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 <bits/stdc++.h>

#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<typename T> inline bool chkmin(T &a, T b) { return b < a ? a = b, 1 : 0; }
template<typename T> 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;

}