Educational Codeforces Round 142 (A - F2)

赛时：A B C D
补题：A B C D E F1 F2
Rank: 1199

A

第一种操作只有对两个 $1$ 作用才会更优。

Copy
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <map>
#include <set>
#include <cstdlib>
#include <cmath>
#include <deque>
using namespace std;
#define pii pair<int,int>
#define mp make_pair
#define fi first
#define se second
const int N = 5e5 + 10;
int read()
{
    int x = 0, f = 1;
    char c = getchar();
    while (c < '0' || c > '9')
    {
        if (c == '-') f = -1;
        c = getchar();
    }
    while (c >= '0' && c <= '9')
    {
        x = (x << 1) + (x << 3) + (c ^ 48);
        c = getchar();
    }
    return x * f;
}
int T, n;
int a[N];
int main()
{
    T = read();
    while (T--)
    {
        n = read();
        for (int i = 1; i <= n; i++) a[i] = read();
        sort(a + 1, a + n + 1);
        int cnt = 0;
        for (int i = 1; i <= n; i++)
        {
            if (a[i] > 1) break;
            cnt++;
        }
        cnt = n - cnt + (cnt / 2) + (cnt % 2);
        printf("%d\n", cnt);
    }
    return 0;
}

B

首先用光所有 $a_1$，然后交替使用 $a_2, a_3$，最后使用 $a_4$。

Copy
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <map>
#include <set>
#include <cstdlib>
#include <cmath>
#include <deque>
using namespace std;
#define pii pair<int,int>
#define mp make_pair
#define fi first
#define se second
const int N = 5e5 + 10;
int read()
{
    int x = 0, f = 1;
    char c = getchar();
    while (c < '0' || c > '9')
    {
        if (c == '-') f = -1;
        c = getchar();
    }
    while (c >= '0' && c <= '9')
    {
        x = (x << 1) + (x << 3) + (c ^ 48);
        c = getchar();
    }
    return x * f;
}
int T, a, b, c, d, A, B, ans;
int main()
{
    T = read();
    while (T--)
    {
        a = read(), b = read(), c = read(), d = read();
        ans = a;
        A = a, B = a;
        if (a == 0)
        {
            puts("1");
            continue;
        }
        if (b >= c)
        {
            ans += c * 2;
            b -= c;
            if (B < b) ans += B + 1;
            else
            {
                B -= b; ans += b;
                ans += min(d, min(A, B) + 1);
            }
        }
        else
        {
            ans += b * 2;
            c -= b;
            if (A < c) ans += A + 1;
            else
            {
                A -= c; ans += c;
                ans += min(d, min(A, B) + 1);
            }
        }
        printf("%d\n", ans);
    }
    return 0;
}

C

设 $pos_i$ 为满足 $p_{pos_i} = i$ 的位置。
我们将 $i \in [1, \lfloor \frac{n}{2} \rfloor]$ 与 $n - i + 1$ 一起考虑，因为最优策略下，一定是 $i$ 和 $n - i + 1$ 操作。
首先，如果 $i$ 操作，那么 $j \in [1, i)$ 也得操作。
其次，如果 $pos_i > pos_{n - i + 1}$，那么 $i$ 需要操作。
最后，如果对于 $i \in [1, \lceil \frac{n}{2} \rceil]$，$pos_i < pos_{i - 1}$ 或者 $pos_{n - i + 1} > pos_{n - i + 2}$，那么 $i - 1$ 需要操作。
将所有需要操作的数取最大值，就是答案。

Copy
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <map>
#include <set>
#include <cstdlib>
#include <cmath>
#include <deque>
using namespace std;
#define pii pair<int,int>
#define mp make_pair
#define fi first
#define se second
const int N = 5e5 + 10;
int read()
{
    int x = 0, f = 1;
    char c = getchar();
    while (c < '0' || c > '9')
    {
        if (c == '-') f = -1;
        c = getchar();
    }
    while (c >= '0' && c <= '9')
    {
        x = (x << 1) + (x << 3) + (c ^ 48);
        c = getchar();
    }
    return x * f;
}
int T, n, ans;
int p[N], pos[N];
int main()
{
    T = read();
    while (T--)
    {
        n = read();
        for (int i = 1; i <= n; i++) p[i] = read(), pos[p[i]] = i;
        ans = 0;
        if (n == 1) {puts("0"); continue;}
        if (n == 2)
        {
            if (pos[1] == 1) puts("0");
            else puts("1");
            continue;
        }
        int cur = 0;
        for (int i = 1; i <= n / 2; i++)
            if (pos[i] > pos[n - i + 1]) cur = i;
        for (int i = 1; i <= (n + 1) / 2; i++)
            if (pos[i] < pos[i - 1] || pos[n - i + 1] > pos[n - i + 2]) cur = max(cur, i - 1);
        printf("%d\n", cur);
    }
    return 0;
}

D

对于一个 $p$ 序列，我们要求出是否有 $q$ 序列满足前 $k$ 位都有 $q_{p_i} = i$，相当于要求 $q$ 的第 $p_i$ 位为 $i$。
这是非常困难的，于是我们考虑反过来算。
已知一个 $q$ 序列，它对哪些 $p$ 如何贡献。
设 $pos_i$ 满足 $q_{pos_i} = i$，那么相当于要求 $p_i = pos_i$。
于是我们枚举 $j$ 属于 $1$ 到 $m$，然后让前缀等于 $pos_1, pos_2, ..., pos_j$ 的 $p$ 的序列的答案对 $j$ 取 $max$。
简单哈希加 $map$ 即可。

Copy
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <map>
#include <set>
#include <cstdlib>
#include <cmath>
#include <deque>
using namespace std;
#define pii pair<int,int>
#define mp make_pair
#define fi first
#define se second
const int N = 5e4 + 10, M = 15;
typedef long long ll;
int read()
{
    int x = 0, f = 1;
    char c = getchar();
    while (c < '0' || c > '9')
    {
        if (c == '-') f = -1;
        c = getchar();
    }
    while (c >= '0' && c <= '9')
    {
        x = (x << 1) + (x << 3) + (c ^ 48);
        c = getchar();
    }
    return x * f;
}
int T, n, m;
int a[N][M], p[M], pos[M];
map<ll, int> vis[M];
map<ll, int> ans[M];
ll count(int len)
{
    ll res = 0;
    for (int i = 1; i <= len; i++) res = (res * 10) + (ll)p[i] - 1ll;
    return res;
}
int main()
{
    T = read();
    while (T--)
    {
        n = read(), m = read();
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= m; j++) a[i][j] = read(), p[j] = a[i][j];
        }
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= m; j++) pos[a[i][j]] = j;
            for (int res = 1; res <= m; res++)
            {
                for (int j = 1; j <= res; j++) p[j] = pos[j];
                ans[res][count(res)]++;
            }
        }
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= m; j++) p[j] = a[i][j];
            int res = 0;
            for (int j = 1; j <= m; j++) if (ans[j][count(j)]) res = j;
            printf("%d ", res);
        }
        puts("");
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= m; j++) pos[a[i][j]] = j;
            for (int res = 1; res <= m; res++)
            {
                for (int j = 1; j <= res; j++) p[j] = pos[j];
                ans[res][count(res)] = 0;
            }
        }
    }
    return 0;
}

E

结论：$\le 10^{18}$ 的数最多有 $10^5$ 个因子，$\le 10^9$ 的数最多有 $10^3$ 个因子。
因此我们首先暴力枚举出 $m1, m2$ 的所有因子，然后直接做笛卡尔积求出 $10^6$ 个可能的因子。
排序后去重，接下来考虑对于某一个因子如何算出它最早在第几行出现。
这里有一个复杂度奇奇怪怪的神秘做法。
对于每一个因子 $i$，它出现的行数一定是它自己的因子，因此也一定是 $m$ 的因子。
于是我们二分找到最小的满足 $\lceil \frac{d_i}{d_j} \rceil \le n$ 的 $j$，然后从 $j$ 开始向上枚举，直到 $d_j$ 是 $d_i$ 的因子或 $d_j > n$。

Copy
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <map>
#include <set>
#include <cstdlib>
#include <cmath>
#include <deque>
using namespace std;
#define pii pair<int,int>
#define mp make_pair
#define fi first
#define se second
const int N = 2e6 + 10;
#define int long long
int read()
{
    int x = 0, f = 1;
    char c = getchar();
    while (c < '0' || c > '9')
    {
        if (c == '-') f = -1;
        c = getchar();
    }
    while (c >= '0' && c <= '9')
    {
        x = (x << 1) + (x << 3) + (c ^ 48);
        c = getchar();
    }
    return x * f;
}
int T, n, m1, m2, cnt1, cnt2, cnt3, ans, cnt;
int a[N], b[N], c[N];
signed main()
{
    T = read();
    while (T--)
    {
        n = read(), m1 = read(), m2 = read();
        cnt1 = cnt2 = cnt3 = 0;
        ans = cnt = 0;
        for (int i = 1; i * i <= m1; i++)
        {
            if (m1 % i) continue;
            a[++cnt1] = i;
            if (i * i != m1) a[++cnt1] = m1 / i;
        }
        for (int i = 1; i * i <= m2; i++)
        {
            if (m2 % i) continue;
            b[++cnt2] = i;
            if (i * i != m2) b[++cnt2] = m2 / i;
        }
        sort(a + 1, a + cnt1 + 1);
        sort(b + 1, b + cnt2 + 1);
        for (int i = 1; i <= cnt1; i++)
            for (int j = 1; j <= cnt2; j++) c[++cnt3] = a[i] * b[j];
        sort(c + 1, c + cnt3 + 1);
        cnt3 = unique(c + 1, c + cnt3 + 1) - c - 1;
        for (int i = 1; i <= cnt3; i++)
        {
            int l = 1, r = i, mid, x = 0;
            while (l <= r)
            {
                mid = (l + r) >> 1;
                if ((c[i] + c[mid] - 1) / c[mid] <= n) r = mid - 1, x = mid;
                else l = mid + 1;
            }
            int flag = 0;
            for (int j = x; c[j] <= n; j++)
            {
                if (c[i] % c[j] == 0)
                {
                    flag = 1;
                    ans ^= c[j];
                    cnt++;
                    break;
                }
            }
        }
        printf("%lld %lld\n", cnt, ans);
    }
    return 0;
}

F1

结论：一个子点集不可能既不蓝联通也不红联通。
证明：
因为整个图为完全图，所以一个子点集及其相关的边也是完全图。
容易发现，保留所有蓝边和保留所有红边互为补图，接下来只需要证明一个完全图自己或者其补图至少有一个联通。
假设在原图中有两个之间没有边的联通块。
那么在补图中这两个联通块之间的所有点对都有连边，也就一定联通。
有了这个结论，我们只需要计算不存在同时蓝联通和红联通的染色方案即可。
显然整个图作为一个子图也是蓝联通/红联通的。
设 $f_i$ 表示 $i$ 个点，整个图蓝联通的方案数，$g_i$ 表示 $i$ 个点，整个图蓝联通/红联通的方案数。
如何转移？
枚举 $1$ 号点所在的极大蓝联通块大小 $j$，那么这种方案对 $f_i$ 的贡献是 $f_j g_{i - j} \binom{i - 1}{j - 1}$。
因为这个联通块是极大的，所以这 $j$ 个点到其余 $i - j$ 的所有边都必须是红色的，因此此时算出的是对整个图红联通方案数的贡献。
把红色和蓝色互换后所有子图的联通颜色也互换，所以整个图红联通的方案数等于整个图蓝联通的方案数，这样贡献的是对的。
于是有转移方程：$f_i = \sum_{j = 1}^{i-1} \limits f_j g_{i-j} \binom{i-1}{j-1}$，$g_i = 2f_i$。
容易发现第二条对 $i = 1$ 不成立，$f_1, g_1$ 特判即可。
答案是 $g_n - 2$。

Copy
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <map>
#include <set>
#include <cstdlib>
#include <cmath>
#include <deque>
using namespace std;
#define pii pair<int,int>
#define mp make_pair
#define fi first
#define se second
const int N = 5e3 + 10, mod = 998244353;
#define int long long
int read()
{
    int x = 0, f = 1;
    char c = getchar();
    while (c < '0' || c > '9')
    {
        if (c == '-') f = -1;
        c = getchar();
    }
    while (c >= '0' && c <= '9')
    {
        x = (x << 1) + (x << 3) + (c ^ 48);
        c = getchar();
    }
    return x * f;
}
int n;
int C[N][N], f[N], g[N];
signed main()
{
    n = read();
    C[0][0] = 1;
    for (int i = 1; i <= n; i++)
    {
        C[i][0] = 1;
        for (int j = 1; j <= i; j++) C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
    }
    f[1] = 1, g[1] = 1;
    for (int i = 2; i <= n; i++)
    {
        for (int j = 1; j < i; j++)
            f[i] = (f[i] + f[j] * g[i - j] % mod * C[i - 1][j - 1] % mod) % mod;
        g[i] = (f[i] * 2) % mod;
    }
    printf("%lld\n", (g[n] + mod - 2) % mod);
    return 0;
}

F2

将 $F1$ 中的式子拆开：$B_i = \sum_{j = 1}^{i-1} \limits B_{j}A_{i-j} \binom{i-1}{j-1}$。这里的 $B_i$ 对应 $f_i$，$A_i$ 对应 $g_i$。
$B_i = \sum_{j=0}^i \limits B_j A_{i-j}\dfrac{(i-1)!}{(i-j)!(j-1)!} = (i-1)!\sum_{j=0}^i \limits \dfrac{B_j}{(j-1)!} \dfrac{A_{i-j}}{(i-j)!}$。
设 $C_i = \dfrac{A_i}{i!}, D_i = \dfrac{B_i}{(i-1)!}$。
$B_i = (i-1)!\sum_{j=0}^{i} \limits C_{i-j}D_j$。
这是一个非常漂亮的卷积形式，可惜 $C_i$ 和 $D_i$ 都对 $B_i$ 有依赖性。
考虑根号重构，每 $B$ 个元素计算一次 $C$ 和 $D$ 的卷积。
假设当前计算到 $i$，上一次卷积的编号在 $t$，考虑如何利用卷积结果快速计算 $B_i$。
容易发现，对于 $i-j \le t, j \le t$ 的所有 $j$，$C_{i-j}D_j$ 的和正好在卷积中计算过，答案记在 $C$ 与 $D$ 卷积得到的 $c$ 数组第 $i$ 项。
换言之，$c_i = \sum_{j=i-t}^t \limits C_{i-j}D_j$。
距离 $B_i$ 中的求和式只差 $j < i-t$ 和 $j > t$ 的部分。
容易发现，这两部分的 $j$ 最多只有 $B$ 个，于是我们暴力计算这一部分的贡献即可。
$B_i = (i-1)!(c_i + \sum_{j=0}^{i-t-1} \limits C_{i-j}D_j + \sum_{j=t+1}^{i} \limits C_{i-j}D_j)$。
复杂度为 $O(\dfrac{n^2\log n}{B} + nB)$。
当 $B = \sqrt{n \log n}$ 时最优，为 $O(n\sqrt{n \log n})$。

Copy
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <map>
#include <set>
#include <cstdlib>
#include <cmath>
#include <deque>
using namespace std;
#define pii pair<int,int>
#define mp make_pair
#define fi first
#define se second
const int N = 2e5 + 10, G = 3, GI = 332748118, mod = 998244353, T = 1000;
#define int long long
int read()
{
    int x = 0, f = 1;
    char c = getchar();
    while (c < '0' || c > '9')
    {
        if (c == '-') f = -1;
        c = getchar();
    }
    while (c >= '0' && c <= '9')
    {
        x = (x << 1) + (x << 3) + (c ^ 48);
        c = getchar();
    }
    return x * f;
}
int n, t;
int qpow(int a, int b)
{
    int res = 1;
    while (b)
    {
        if (b & 1) res = (res * a) % mod;
        a = (a * a) % mod;
        b >>= 1;
    }
    return res;
}
void NTT(int len, int * a, int coe)
{
    for (int mid = 1; mid < len; mid <<= 1)
    {
        int Wn = qpow(((coe == 1) ? G : GI), (mod - 1) / (mid << 1));
        for (int i = 0; i < len; i += mid << 1)
        {
            int W = 1;
            for (int j = 0; j < mid; j++, W = (W * Wn) % mod)
            {
                int x = a[i + j], y = (a[i + j + mid] * W) % mod;
                a[i + j] = (x + y) % mod;
                a[i + j + mid] = (x - y + mod) % mod;
            }
        }
    }
}
int rev[N], c[N];
void mul(int len, int * a, int * b)
{
    for (int i = 1; i < len; i++) rev[i] = (rev[i >> 1] >> 1) + ((i & 1) ? (len >> 1) : 0);
    for (int i = 0; i < len; i++) if (i < rev[i]) swap(a[i], a[rev[i]]); NTT(len, a, 1);
    for (int i = 0; i < len; i++) if (i < rev[i]) swap(b[i], b[rev[i]]); NTT(len, b, 1);
    for (int i = 0; i <= len; i++) a[i] = (a[i] * b[i]) % mod;
    for (int i = 0; i < len; i++) if (i < rev[i]) swap(a[i], a[rev[i]]); NTT(len, a, -1);
    int inv = qpow(len, mod - 2);
    for (int i = 0; i <= len; i++) c[i] = (a[i] * inv) % mod;
}
int len;
int A[N], B[N], C[N], D[N], a[N], b[N], inv[N], fac[N];
void init()
{
    inv[0] = inv[1] = fac[0] = 1;
    for (int i = 1; i <= n; i++) fac[i] = (fac[i - 1] * i) % mod;
    for (int i = 2; i <= n; i++) inv[i] = (mod - mod / i) * inv[mod % i] % mod;
    for (int i = 1; i <= n; i++) inv[i] = (inv[i - 1] * inv[i]) % mod;
}
signed main()
{
    n = read(); init();
    len = 1;
    A[1] = B[1] = C[1] = D[1] = 1;
    for (int i = 2; i <= n; i++)
    {
        if (t * 2 < i)
        {
            for (int j = 0; j <= i; j++) B[i] = (B[i] + C[i - j] * D[j] % mod) % mod;
            B[i] = (B[i] * fac[i - 1]) % mod;
            A[i] = (B[i] * 2) % mod;
            C[i] = (A[i] * inv[i]) % mod;
            D[i] = (B[i] * inv[i - 1]) % mod;
        }
        else
        {
            B[i] = c[i];
            for (int j = 0; j < i - t; j++) B[i] = (B[i] + C[i - j] * D[j] % mod) % mod;
            for (int j = t + 1; j <= i; j++) B[i] = (B[i] + C[i - j] * D[j] % mod) % mod;
            B[i] = (B[i] * fac[i - 1]) % mod;
            A[i] = (B[i] * 2) % mod;
            C[i] = (A[i] * inv[i]) % mod;
            D[i] = (B[i] * inv[i - 1]) % mod;
        }
        if (i - t == T)
        {
            while (len <= i * 2) len <<= 1;
            for (int i = 0; i <= len; i++) a[i] = C[i], b[i] = D[i];
            mul(len, a, b);
            t = i;
        }
    }
    printf("%lld\n", (A[n] + mod - 2) % mod);
    return 0;
}