[题解]CLYZ2018省选训(bao)练(zha)模拟赛 Day 2

初次见识了神奇的CDQ分治。

题目

T1：BZOJ 1093 / ZJOI 2007 最大半连通子图 (semi)（强连通分量+拓扑排序+DP）
T2：BZOJ 1272 / BeiJing WC 2008 Gate Of Babylon (babylon)（组合数学+容斥原理）
T3：BZOJ 2253 / BeiJing WC 2010 纸箱堆叠 (box)（DP+CDQ分治）

T1

分析

首先得到，一个强连通分量一定是半连通的。
把强连通分量缩点之后，可以得到一个拓扑图。下面，$sze[u]$为新图中点$u$所对应强连通分量的大小。
缩点之后，就很容易得出，一个半连通子图一定是拓扑图中的一条链，半连通子图的大小为这条链上所有点的$sze$之和。
所以，现在就是要求这个拓扑图的最长链（$sze$之和最大）。
考虑按照拓扑排序DP，$f[u]$表示以$u$为终点的最长链长度：
1、对于点$u$，如果点$u$的入度为$0$，则$f[u]=sze[u]$；
2、对于一条边：
$f[v]=\max(f[v],f[u]+sze[v])$。
最后的结果（下面记为$res$）就是所有点的$f$的最大值。
对于第二问，也是按拓扑排序DP，$g[u]$表示以$u$为终点的最长链个数：
1、对于点$u$，如果点$u$的入度为$0$，则$g[u]=1$。
2、对于一条边，如果有$f[v]=f[u]+sze[v]$，则：
$g[v]+=g[u]$。
最后结果就是对于所有满足$f[u]=res$的点$u$，这些点的$g$之和。

Source

#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
inline int read() {
    int res = 0; bool bo = 0; char c;
    while (((c = getchar()) < '0' || c > '9') && c != '-');
    if (c == '-') bo = 1; else res = c - 48;
    while ((c = getchar()) >= '0' && c <= '9')
        res = (res << 3) + (res << 1) + (c - 48);
    return bo ? ~res + 1 : res;
}
const int N = 1e5 + 5, M = 2e6 + 5;
int n, m, ZZQ, ecnt, nxt[M], adj[N], go[M], dfn[N], low[N], num, bel[N],
sze[N], times, top, stk[N], ecnt2, nxt2[M], adj2[N], go2[M],
H, T, Q[N], f[N], g[N], cnt[N], orz[N], TOT;
bool ins[N];
struct cyx {
    int u, v;
    cyx() {}
    cyx(int _u, int _v):
        u(_u), v(_v) {}
} ege[M];
inline bool comp(const cyx &a, const cyx &b) {
    if (a.u != b.u) return a.u < b.u;
    return a.v < b.v;
}
void add_edge(int u, int v) {
    nxt[++ecnt] = adj[u]; adj[u] = ecnt; go[ecnt] = v;
}
void add_edge2(int u, int v) {
    nxt2[++ecnt2] = adj2[u]; adj2[u] = ecnt2; go2[ecnt2] = v;
    cnt[v]++; orz[v]++;
}
void orzcyxdalao(int u) {
    dfn[u] = low[u] = ++times;
    stk[++top] = u; ins[u] = 1;
    for (int e = adj[u], v; e; e = nxt[e])
        if (!dfn[v = go[e]]) {
            orzcyxdalao(v);
            low[u] = min(low[u], low[v]);
        }
        else if (ins[v]) low[u] = min(low[u], dfn[v]);
    if (dfn[u] == low[u]) {
        int v; sze[bel[u] = ++num] = 1; ins[u] = 0;
        while (v = stk[top--], v != u) sze[bel[v] = num]++, ins[v] = 0;
    }
}
void DP() {
    int i; H = T = 0;
    for (i = 1; i <= num; i++) if (!cnt[i]) f[Q[++T] = i] = sze[i];
    while (H < T) {
        int u = Q[++H];
        for (int e = adj2[u], v; e; e = nxt2[e]) {
            if (!(--cnt[v = go2[e]])) Q[++T] = v;
            f[v] = max(f[v], f[u] + sze[v]);
        }
    }
    H = T = 0; for (i = 1; i <= num; i++) if (!orz[i]) g[Q[++T] = i] = 1;
    while (H < T) {
        int u = Q[++H];
        for (int e = adj2[u], v; e; e = nxt2[e]) {
            if (!(--orz[v = go2[e]])) Q[++T] = v;
            if (f[v] == f[u] + sze[v]) g[v] = (g[v] + g[u]) % ZZQ;
        }
    }
}
int main() {
    int i, x, y; n = read(); m = read(); ZZQ = read();
    for (i = 1; i <= m; i++) x = read(), y = read(), add_edge(x, y);
    for (i = 1; i <= n; i++) if (!dfn[i]) orzcyxdalao(i);
    for (i = 1; i <= n; i++) for (int e = adj[i]; e; e = nxt[e])
        if (bel[i] != bel[go[e]]) ege[++TOT] = cyx(bel[i], bel[go[e]]);
    sort(ege + 1, ege + TOT + 1, comp);
    for (i = 1; i <= TOT; i++) if (i == 1 || (ege[i].u != ege[i - 1].u
        || ege[i].v != ege[i - 1].v)) add_edge2(ege[i].u, ege[i].v);
    int res = 0, ans = 0;
    DP(); for (i = 1; i <= num; i++) ans = max(ans, f[i]);
    for (i = 1; i <= num; i++) if (ans == f[i]) res = (res + g[i]) % ZZQ;
    cout << ans << endl << res << endl;
    return 0;
}

T2

分析

首先考虑一个问题：求把$m$拆分成$n$个非负整数的方案数。
先把问题转化一下：把$m$拆分成$n$个非负整数，相当于把$m+n$拆分成$n$个正整数。
而把$m+n$拆分成$n$个正整数，相当于把一个长度为$m+n$的线段切成$n$段。由于有$m+n-1$个位置可以切，要切$n-1$下，所以把$m+n$拆分成$n$个整数，方案数为$C_{m+n-1}^{n-1}$。
回到题目，考虑不限制数量的方案数：
显然答案为$\sum_{i=0}^mC_{i+n-1}^{n-1}$（下面记做$f(m,n)$）。
把这个式子化一下：
原式$=1+\sum_{i=1}^m(C_{i+n-2}^{n-1}+C_{i+n-2}^{n-2})$
$=1+\sum_{i=1}^mC_{i+n-2}^{n-1}+\sum_{i=1}^mC_{i+n-2}^{n-2}$
$=\sum_{i=1}^mC_{i+n-2}^{n-1}+\sum_{i=0}^mC_{i+n-2}^{n-2}$
$=\sum_{i=0}^{m-1}C_{i+n-1}^{n-1}+\sum_{i=0}^mC_{i+n-2}^{n-2}$
也就是说，$f(m,n)=f(m-1,n)+f(m-1,n-1)$
归纳一下，得出：$f(m,n)=C_{n+m}^n$。
此题的$n$，$m$很大，但是$P$只有$10^5$级别并且是质数，所以可以使用Lucas定理求得$C_{n+m}^n$。
而对于数量的限制，就可以使用容斥计算：
总方案数$=$不限制的方案数$-$有$1$种物品超限的方案数$+$有$2$种物品超限的方案数$-...$

Source

#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
inline int read() {
    int res = 0; bool bo = 0; char c;
    while (((c = getchar()) < '0' || c > '9') && c != '-');
    if (c == '-') bo = 1; else res = c - 48;
    while ((c = getchar()) >= '0' && c <= '9')
        res = (res << 3) + (res << 1) + (c - 48);
    return bo ? ~res + 1 : res;
}
const int N = 20, Mod = 1e5 + 7;
int n, T, m, ZZQ, b[N], fac[Mod], inv[Mod], ans = 0;
int qpow(int a, int b) {
    int res = 1;
    while (b) {
        if (b & 1) res = 1ll * res * a % ZZQ;
        a = 1ll * a * a % ZZQ;
        b >>= 1;
    }
    return res;
}
int C(int x, int y) {
    if (!y) return 1;
    int u = C(x / ZZQ, y / ZZQ), v = x % ZZQ, w = y % ZZQ, z;
    if (v < w) z = 0;
    else z = 1ll * (1ll * fac[v] * inv[w] % ZZQ) * inv[v - w] % ZZQ;
    return 1ll * u * z % ZZQ;
}
void dfs(int dep, int tot, int orz) {
    if (dep == T + 1) {
        if (tot < 0) return;
        if (orz & 1) ans = (ans - C(n + tot, n) + ZZQ) % ZZQ;
        else ans = (ans + C(n + tot, n)) % ZZQ;
        return;
    }
    dfs(dep + 1, tot, orz);
    dfs(dep + 1, tot - b[dep] - 1, orz + 1);
}
int main() {
    int i; n = read(); T = read(); m = read(); ZZQ = read();
    for (i = 1; i <= T; i++) b[i] = read(); fac[0] = 1;
    for (i = 1; i <= ZZQ - 1; i++) fac[i] = 1ll * fac[i - 1] * i % ZZQ;
    inv[ZZQ - 1] = qpow(fac[ZZQ - 1], ZZQ - 2);
    for (i = ZZQ - 2; i >= 0; i--) inv[i] = 1ll * inv[i + 1] * (i + 1) % ZZQ;
    dfs(1, m, 0); cout << ans << endl;
    return 0;
}

T3

分析

考虑一个朴素的DP方案：
先求出所有纸箱的最短边（以下第$i$个纸箱的最短边记为$x_i$），次短边（以下第$i$个纸箱次短边记为$y_i$）和最长边（以下记为$z_i$），然后按照$x_i$从小到大排序。
这样，就变成了一个求最长严格上升子序列的问题，即$f[i]$为到了第$i$个纸箱，且必须选第$i$个纸箱的最优解：
$f[i]=1+\max\limits _{x_j<x_i,y_j<y_i,z_j<z_i}f[j]$
但这样显然是$O(n^2)$的，TLE。考虑优化。
考虑一般的LIS优化：一般的LIS，可以将序列离散化之后，用树状数组进行优化。但这里有$y$和$z$两个关键字，不能简单地用树状数组优化。
还是先离散化序列，设有一个平面，把每一个决策都看作一个点$(y_i,z_i)$，权值为$f[i]$。那么在不考虑$x_i$相等的情况下，
求$\max\limits _{x_j<x_i,y_j<y_i,z_j<z_i}f[j]$就是求点$(y_i-1,z_i-1)$的左下角的点的最大权值。决策结束之后，还需要把点$(y_i,z_i)$插入平面。因此，考虑CDQ分治，就能得到$O(n\log^2n)$的算法。但这与普通的CDQ分治有两点区别：
1、将$[l,r]$操作区间分成两个小的操作区间时，有时不能取中点作为分界点。假设分界点为$mid$，分成了$[l,mid]$和$[mid+1,r]$两个小操作区间，那么绝对不能有$x_{mid}=x_{mid+1}$，否则有可能使$f[i]$从满足$x_j=x_i$的转移过来。
2、必须要先递归左子区间，处理完左子区间对右子区间的贡献后再递归右子区间。

Source

#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
inline int read() {
    int res = 0; bool bo = 0; char c;
    while (((c = getchar()) < '0' || c > '9') && c != '-');
    if (c == '-') bo = 1; else res = c - 48;
    while ((c = getchar()) >= '0' && c <= '9')
        res = (res << 3) + (res << 1) + (c - 48);
    return bo ? ~res + 1 : res;
}
const int N = 2e5 + 5;
int A, ZZQ, n, orz[N][4], tot, T[N], tm[N], to[N];
struct cyx {
    int x, y, z, ans;
    cyx() {}
    cyx(int _x, int _y, int _z) :
        x(_x), y(_y), z(_z) {}
    friend inline bool operator < (cyx a, cyx b) {
        if (a.y != b.y) return a.y < b.y;
        return a.z < b.z;
    }
} a[N], c[N];
inline bool comp(const cyx &a, const cyx &b) {
    if (a.x != b.x) return a.x < b.x;
    if (a.y != b.y) return a.y < b.y;
    return a.z < b.z;
}
inline bool comp1(const cyx &a, const cyx &b) {
    return a.x < b.x;
}
inline bool comp2(const cyx &a, const cyx &b) {
    return a.y < b.y;
}
inline bool comp3(const cyx &a, const cyx &b) {
    return a.z < b.z;
}
void orzdalao(int x) {
    for (; x <= n * 3; x += x & -x)
        if (T[x] != 0) T[x] = 0;
        else return;
}
void change(int x, int v) {
    for (; x <= n * 3; x += x & -x)
        T[x] = max(T[x], v);
}
int ask(int x) {
    int res = 0;
    for (; x; x -= x & -x)
        res = max(res, T[x]);
    return res;
}
void czk_is_so_weak(int l, int r) {
    if (l == r) return;
    int i, mid = l + r >> 1, p1 = mid, p2 = mid + 1;
    if (a[p1].x == a[p2].x) {
        while (p1 >= l && a[p1].x == a[mid].x) p1--;
        while (p2 <= r && a[p2].x == a[mid + 1].x) p2++; p2--;
        if (p1 == l - 1 && p2 == r) return;
        if (p1 == l - 1) mid = p2; else if (p2 == r) mid = p1;
        else {
            int x = abs((r - p1) - (p1 - l + 1)),
                y = abs((r - p2) - (p2 - l + 1));
            mid = x < y ? p1 : p2;
        }
    }
    czk_is_so_weak(l, mid); sort(a + l, a + mid + 1);
    sort(a + mid + 1, a + r + 1); p1 = l; p2 = mid + 1;
    for (i = l; i <= r; i++)
        if (p2 > r || (p1 <= mid && a[p1].y < a[p2].y))
            change(a[p1].z, a[p1].ans), p1++;
        else a[p2].ans = max(a[p2].ans, ask(a[p2].z - 1) + 1), p2++;
    for (i = l; i <= mid; i++) orzdalao(a[i].z);
    sort(a + mid + 1, a + r + 1, comp);
    czk_is_so_weak(mid + 1, r);
}
int main() {
    freopen("box.in", "r", stdin);
    freopen("box.out", "w", stdout);
    int i, j, nxt, now = 1; A = read(); ZZQ = read(); n = read();
    for (i = 1; i <= n; i++) for (j = 1; j <= 3; j++)
        orz[i][j] = (now = 1ll * now * A % ZZQ);
    for (i = 1; i <= n; i++) sort(orz[i] + 1, orz[i] + 4);
    for (i = 1; i <= n; i++) c[i] = cyx(orz[i][1], orz[i][2], orz[i][3]);
    sort(c + 1, c + n + 1, comp1);
    tot = 0; for (i = 1; i <= n; i++) {
        if (i == 1 || c[i].x != c[i - 1].x) tot++;
        tm[i] = tot;
    }
    for (i = 1; i <= n; i++) c[i].x = tm[i];
    sort(c + 1, c + n + 1, comp2);
    tot = 0; for (i = 1; i <= n; i++) {
        if (i == 1 || c[i].y != c[i - 1].y) tot++;
        tm[i] = tot;
    }
    for (i = 1; i <= n; i++) c[i].y = tm[i];
    sort(c + 1, c + n + 1, comp3);
    tot = 0; for (i = 1; i <= n; i++) {
        if (i == 1 || c[i].z != c[i - 1].z) tot++;
        tm[i] = tot;
    }
    for (i = 1; i <= n; i++) c[i].z = tm[i];
    for (i = 1; i <= n; i++) a[i] = c[i], a[i].ans = 1;
    sort(a + 1, a + n + 1, comp);
    czk_is_so_weak(1, n); int ans = 0;
    for (i = 1; i <= n; i++) ans = max(ans, a[i].ans);
    cout << ans << endl;
    return 0;
}