CF1043

找个下午打了场CF，结果被某uranus吊打......一千多名，过弱。

T1，一眼二分了，后来发现题解是O(1)的hhh

T2，题意精炼一下就是让你找一个串的循环节个数，直接n²枚举.....

T3，给你一个ab串，你依次考虑每个前缀，选择reverse这个前缀或者不操作。输出方案使得最后的字典序最小。

手玩一下就能发现，一定能构造出最小字典序，所有a都在b前面。

具体操作是每个整段的结尾字符那里翻转。

T4，给你10个1e5的排列，你需要从每个中提取连续的一段，使得这十段相同。求方案数。

考虑KMP(????)，就是我们线性的扫描第一个串，把它分成若干段十个串都相同的段，这样每段都可以拿公式计算。

第一次交的时候一个中间变量没开long long挂了，太SB了。

T5，题意有点长......就是给你n个人，你要把这n个人两两组队(就是n(n-1)/2次)各一次，每次解决两个任务a，b。

每个人解决a，b问题都有个代价。组队时一人解决一道题，会自动选择总代价最小的解决方案，代价累加到两个人身上。

问你这么多次下来每个人的总代价。

把式子min(A + b, B + a)变形一下：min(b - a, B - A) + a + A

然后就比较显然了.....显然可以用前缀和但是我SB的用了树状数组，不过复杂度一样。

贴个考场代码吧。

#include <bits/stdc++.h> 

inline void read(int &x) {
    x = 0;
    char c = getchar();
    while(c < '0' || c > '9') {
        c = getchar();
    }
    while(c >= '0' && c <= '9') {
        x = (x << 3) + (x << 1) + c - 48;
        c = getchar();
    }
    return;
}

typedef long long LL;
const int N = 300010;

LL xi[N], yi[N], dt[N], X[N], ans[N];
int n, pos[N]; 

struct TA {
    LL ta[N];
    inline void add(int i, LL v) {
        for(; i <= n; i += i & (-i)) {
            ta[i] += v;
        }
        return;
    }
    inline LL getsum(int i) {
        LL ans = 0;
        for(; i > 0; i -= i & (-i)) {
            ans += ta[i];
        }
        return ans;
    }
    inline LL ask(int l, int r) {
        if(r < l) {
            return 0;
        }
        if(l <= 1) { 
            return getsum(r);
        }
        return getsum(r) - getsum(l - 1);
    }
}cnt, sum;

int main() {
    
    int m;
    scanf("%d%d", &n, &m);
    LL tot = 0;
    for(int i = 1; i <= n; i++) {
        scanf("%lld%lld", &xi[i], &yi[i]);
        dt[i] = yi[i] - xi[i];
        X[i] = dt[i];
        tot += xi[i];
    }
    
    std::sort(X + 1, X + n + 1);
    int xx = std::unique(X + 1, X + n + 1) - X - 1;
    
    
    for(int i = 1; i <= n; i++) {
        int p = std::lower_bound(X + 1, X + xx + 1, dt[i]) - X;
        pos[i] = p;
        cnt.add(p, 1);
        sum.add(p, dt[i]);
    }
    
    for(int i = 1; i <= n; i++) {
        int p = pos[i];
        ans[i] += sum.ask(1, p) - dt[i];
        ans[i] += cnt.ask(p + 1, n) * dt[i];
        ans[i] += tot - xi[i] + xi[i] * (n - 1);
    }
    for(int i = 1, x, y; i <= m; i++) {
        scanf("%d%d", &x, &y);
        ans[x] -= std::min(xi[x] + yi[y], xi[y] + yi[x]);
        ans[y] -= std::min(xi[x] + yi[y], xi[y] + yi[x]);
    }
    
    for(int i = 1; i <= n; i++) {
        printf("%lld ", ans[i]);
    }
    
    return 0;
}

当时境况比较尴尬，写出来时发现比赛刚结束68s......

第一次交很SB的把long long用%d输出了。

最后1104名......F题听说很有趣，以后来填。

F 题意：给定n个数，从中选出尽量少的数，使得gcd为1。

不存在方案输出-1。n，值域<=300000。

解：正解是：有个结论，如果存在合法解，那么一定有一组合法解的个数不超过7。不会证...

然后设f[i][j]表示选i个数，gcd为j的方案数。

f[i][j] = C(sum_j, i) - ∑f[i][j * d]

然后求出一个最小的i使得f[i][1] > 0即可。

#include <cstdio>
#include <algorithm>

typedef long long LL;
const int N = 300010, lm = 300000;
const LL mo[] = {998244353, (LL)(1e9 + 7)};

int sum[N], bin[N], n;
LL f[10][N], nn[N], invn[N], inv[N], MO;

inline LL C(int n, int i) {
    return nn[n] * invn[i] % MO * invn[n - i] % MO;
}

inline int cal(int turn) {
    MO = mo[turn];
    for(int i = 2; i <= lm; i++) {
        nn[i] = nn[i - 1] * i % MO;
        inv[i] = (MO - inv[MO % i]) * (MO / i) % MO;
        invn[i] = invn[i - 1] * inv[i] % MO;
    }
    for(int i = 1; i <= 7; i++) {
        for(int j = lm; j >= 1; j--) {
            if(sum[j] < i) {
                continue;
            }
            f[i][j] = C(sum[j], i);
            for(int k = 2; k * j <= lm; k++) {
                f[i][j] = (f[i][j] - f[i][j * k] + MO) % MO;
            }
            //printf("f %d %d = %d 
", i, j, f[i][j]);
        }
    }
    for(int i = 1; i <= 7; i++) {
        if(f[i][1]) {
            return i;
        }
    }
    return -1;
}

int main() {
    nn[0] = inv[0] = invn[0] = 1;
    nn[1] = inv[1] = invn[1] = 1;
    int n;
    scanf("%d", &n);
    for(int i = 1, x; i <= n; i++) {
        scanf("%d", &x);
        bin[x]++;
    }
    for(int i = 1; i <= lm; i++) {
        for(int j = 1; j * i <= lm; j++) {
            sum[i] += bin[i * j];
        }
    }

    int a = cal(0), b = cal(1);
    int ans = std::min(a, b);
    if(ans == -1) {
        printf("%d", std::max(a, b));
    }
    else {
        printf("%d", std::min(a, b));
    }
    return 0;
}

反演+二分解法：

首先二分答案，然后用反演求:选出k个，gcd为1的方案数。如果大于0就可行。

#include <bits/stdc++.h>

const int N = 300010, MO = 998244353;

int p[N], top, miu[N], bin[N], fac[N], inv[N], invn[N];
bool vis[N];

inline int C(int n, int m) {
    if(m > n || n < 0 || m < 0) return 0;
    return 1ll * fac[n] * invn[m] % MO * invn[n - m] % MO;
}

inline void getp(int n) {
    miu[1] = 1;
    for(int i = 2; i <= n; i++) {
        if(!vis[i]) {
            p[++top] = i;
            miu[i] = -1;
        }
        for(int j = 1; j <= top && i * p[j] <= n; j++) {
            vis[i * p[j]] = 1;
            if(i % p[j] == 0) {
                miu[i * p[j]] = 0;
                break;
            }
            miu[i * p[j]] = -miu[i];
        }
    }
    return;
}

inline int check(int k) {
    int ans = 0;
    for(int i = 1; i < N; i++) {
        (ans += miu[i] * C(bin[i], k)) %= MO;
        ans = (ans + MO) % MO;
    }
    return ans;
}

int main() {
    getp(N - 1);
    inv[0] = fac[0] = invn[0] = 1;
    inv[1] = fac[1] = invn[1] = 1;
    for(int i = 2; i < N; i++) {
        fac[i] = 1ll * fac[i - 1] * i % MO;
        inv[i] = 1ll * inv[MO % i] * (MO - MO / i) % MO;
        invn[i] = 1ll * invn[i - 1] * inv[i] % MO;
    }
    int n;
    scanf("%d", &n);
    for(int i = 1, x; i <= n; i++) {
        scanf("%d", &x);
        bin[x]++;
    }
    for(int i = 1; i < N; i++) {
        for(int j = i << 1; j < N; j += i) {
            (bin[i] += bin[j]) %= MO;
        }
    }

    int l = 1, r = n + 1;
    while(l < r) {
        int mid = (l + r) >> 1;
        if(check(mid)) {
            r = mid;
        }
        else {
            l = mid + 1;
        }
    }
    if(r == n + 1) printf("-1
");
    else printf("%d
", r);
    return 0;
}