Educational Codeforces Round 85 (Rated for Div. 2)

\(A. Level Statistics\)
每天都可能会有人玩游戏，同时一部分人会过关，玩游戏的人数和过关的人数会每天更新，问记录的数据是否没有矛盾

//#pragma GCC optimize("O3")
//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<bits/stdc++.h>
using namespace std;
function<void(void)> ____ = [](){ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);};

void solve(){
    int n, x = 0, y = 0;
    cin >> n;
    bool ok = true;
    for(int i = 1; i <= n; i++){
        int a, b;
        cin >> a >> b;
        if(a<x or b<y or b>a) ok = false;
        if(b-y>a-x) ok = false;
        x = a, y = b;
    }
    if(ok) cout << "YES" << endl;
    else cout << "NO" << endl;
}
int main(){
    ____();
    int T;
    for(cin >> T; T; T--) solve();
    return 0;
}

\(B - Middle Class\)
每次可以选几个人把钱均摊，问经过若干次操作之后最多有多少人的钱可以大于\(x\)
从大到小排序，然后判断前\(i\)个人均摊之后能否都大于\(x\)，找最大的\(i\)即可

//#pragma GCC optimize("O3")
//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<bits/stdc++.h>
using namespace std;
function<void(void)> ____ = [](){ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);};
const int MAXN = 1e5+7;
using LL = int_fast64_t;
int n,x,A[MAXN];
void solve(){
    cin >> n >> x;
    for(int i = 1; i <= n; i++) cin >> A[i];
    sort(A+1,A+1+n,greater<int>());
    LL tot = 0, pr = 0; 
    for(int i = 1; i <= n; i++){
        pr += x;
        tot += A[i];
        if(tot<pr){
            cout << i-1 << endl;
            return;
        }
    }
    cout << n << endl;
}
int main(){
    ____();
    int T;
    for(cin >> T; T; T--) solve();
    return 0;
}

\(C. Circle of Monsters\)
怪物站成一圈，每个怪物有血量\(A_i\)，和爆炸伤害\(B_i\)，每次打一颗子弹，可以扣除怪物\(1\)滴血，怪物血量\(\le0\)时死亡，死亡之后会对\(i+1\)个怪物造成相应的爆炸伤害，问最少多少子弹可以消灭所有怪物。
\(1~n\)复制一遍到\(n+1~2n\)，然后算上一个怪物爆炸的情况下这个怪物还需要多少子弹，求前缀和，然后枚举第一个打的怪物即可

//#pragma GCC optimize("O3")
//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<bits/stdc++.h>
using namespace std;
function<void(void)> ____ = [](){ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);};
const int MAXN = 6e5+7;
using LL = int_fast64_t;
int n;
LL A[MAXN],B[MAXN],cost[MAXN],sum[MAXN];
void solve(){
    cin >> n;
    for(int i = 1; i <= n; i++){
        cin >> A[i] >> B[i];
        A[i+n] = A[i]; B[i+n] = B[i];
    }
    for(int i = 2; i <= n * 2; i++){
        cost[i] = max(0ll,A[i]-B[i-1]);
        sum[i] = sum[i-1] + cost[i];
    }
    LL ret = 0x3f3f3f3f3f3f3f3f;
    for(int i = 1; i <= n; i++) ret = min(ret,A[i]+sum[i+n-1]-sum[i]);
    cout << ret << endl;
}
int main(){
    ____();
    int T;
    for(cin >> T; T; T--) solve();
    return 0;
}

\(D. Minimum Euler Cycle\)
给一张完全图，任意两个点\(u,v\)之间有\(u \rightarrow v, v \rightarrow u\)两条边，要求走完所有边并且走的点的标号的字典序最小，要求输出一段区间内的顶点标号。
假设为顶点数为\(n\)的完全图，则方案为：
\((1, 2, 1, 3, 1, 4 \cdots 1, n)(\ 2, 3, 2, 4 \cdots 2, n)(\ 3, 4, 3, 5 \cdots 3, n) \cdots (n-3, n-2, n-3, n-1, n-3, n)(\ n-2, n-1, n-2, n)(\ n-1, n)\ 1\)
用括号括出来的可以找出来规律

//#pragma GCC optimize("O3")
//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<bits/stdc++.h>
using namespace std;
function<void(void)> ____ = [](){ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);};
using LL = int_fast64_t;
LL n, l, r;
void solve(){
    scanf("%I64d %I64d %I64d",&n,&l,&r);
    if(l==n*(n-1)+1){
        puts("1");
        return;
    }
    int stpos = 1;
    LL tot = 0;
    LL L = 0, R = n - 1;
    while(L<=R){
        LL mid = (L+R)>>1;
        if((n-1+n-mid)*mid<l) L = mid + 1;
        else R = mid - 1;
    }
    stpos = L;
    tot = (n-1+n-R)*R;
    int cur = stpos + (l-tot) / 2;
    bool tg = (((l-tot)&1)?true:false);
    for(LL i = l; i <= r; i++){
        if(stpos==n){
            printf("1 ");
            break;
        }
        if(tg){
            printf("%d ",stpos);
            cur++;
        }
        else{
            printf("%d ",cur);
            if(cur==n){
                stpos++;
                cur = stpos;
            }
        }
        tg = !tg;
    }
    puts("");
}

int main(){
    int T;
    for(scanf("%d",&T); T; T--) solve();
    return 0;
}

\(E. Divisor Paths\)
给出数\(D\)，以这个数建图，建图规则为：所有\(D\)的因子为顶点，\(u,v(u>v)\)两点之间连边的条件为：\(u%v==0 and u/v is prime\)，且边权为\(f(u)-f(v)\)，其中\(f(x)\)为\(x\)的因子数量，现在有\(Q\)次询问，每次询问\(u,v\)间的最短路条数。

首先我们假设要从\(u\)到\(v\)且\(u\%v==0\)，那么走的边必然是\(u\)比\(v\)分解之后多的质因子，略证：
首先假设命题成立
现在从\(a \rightarrow b\)，我们走多余质因子边：\(path(a,b)=a \rightarrow c \rightarrow b\)，则路径长度为：\(f(a)-f(c)+f(c)-f(b)=f(a)-f(b)\)，现在假设不走多余质因子边则：\(path(a,b)=a\rightarrow c \rightarrow d \rightarrow \cdots \rightarrow b\)，路径长度为\(f(a)-f(c)+f(d)-f(c)+dist(d,b)=f(a)-f(c)+f(d)-f(c)+f(d)-f(x)+dist(x,b)=dist(a,b)+2f(d)-2f(c)>dist(a,b)\)
如果\(u\%v\ne 0\)，则必然是先从\(u\)到\(gcd(u,v)\)，再从\(gcd(u,v)到v\)是最优的
如果两个数不互质的话可以先取\(gcd\)，然后必然能经过点\(1\)，然后只要找出\(1\)到各个点最短路的方案数即可。
假设\(x\)各个素因子的数量分别为\(P_1,P_2,\cdots,P_m\)，则最短路数量就是\(\frac{(\sum_{i=1}^{m}P_i)!}{\prod_{i=1}^{m}(P_i!)}\)

//#pragma GCC optimize("O3")
//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<bits/stdc++.h>
using namespace std;
function<void(void)> ____ = [](){ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);};
using LL = int_fast64_t;
const LL MOD = 998244353;
const int MAXN = 1e5+7;
LL D, q, fact[MAXN], invf[MAXN];
map<LL,LL> ret;
LL qpow(LL a, LL b){
    LL res = 1;
    while(b){
        if(b&1) res = res * a % MOD;
        b >>= 1;
        a = a * a % MOD;
    }
    return res;
}
void ikun(LL x){
    LL v = x;
    vector<int> vec;
    int tot = 0;
    for(LL i = 2; i * i <= x; i++){
        if(x%i!=0) continue;
        int cnt = 0;
        while(x%i==0) cnt++, x /= i;
        tot += cnt;
        vec.emplace_back(cnt);
        if(x==1) break;
    }
    if(x!=1) tot++;
    LL res = fact[tot];
    for(int p : vec) res = res * invf[p] % MOD;
    ret.insert(make_pair(v,res));
}
void solve(){
    fact[0] = 1;
    for(int i = 1; i < MAXN; i++) fact[i] = fact[i-1] * i % MOD;
    invf[MAXN-1] = qpow(fact[MAXN-1],MOD-2);
    for(int i = MAXN - 2; i >= 0; i--) invf[i] = invf[i+1] * (i+1) % MOD;
    cin >> D >> q;
    for(LL i = 1; i * i <= D; i++){
        if(D%i!=0) continue;
        ikun(i);
        if(i*i!=D) ikun(D/i);
    }
    while(q--){
        LL u, v;
        cin >> u >> v;
        LL g = __gcd(u,v);
        u /= g; v /= g;
        cout << ret.at(u) * ret.at(v) % MOD << endl;
    }
}
int main(){
    ____();
    solve();
    return 0;
}

原文地址：https://www.cnblogs.com/kikokiko/p/12679531.html