2024 萌新联赛 4

D 简单的素数

遍历 $1 \sim \sqrt{n}$ 即可

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <bits/stdc++.h>
using namespace std;
const int N = 1e8+10;
    
void solve(){
    int n,flag=0;
    cin>>n;
    for(int i=2;i*i<=n;i++){
        if(n%i==0){
            flag=1;
            break;
        }
    }
    cout<<(flag?"No\n":"Yes\n");
}

int main(){
    int t;
    cin>>t;
    while(t--)solve();
}

F 小雷的算式

按题意模拟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define ls now<<1
#define rs now<<1|1
const int N = 1e5+7, mod = 1e9+7;
#define int long long

void solve(){
    string s;
    cin>>s;
    int ans=0,tmp=0;
    vector<int>a;
    for(int i=0;i<s.size();i++){
        if(s[i]=='+'){
            a.push_back(tmp);
            ans+=tmp,tmp=0;
        }
        else{
            tmp*=10;
            tmp+=(s[i]-'0');
        }
    }
    a.push_back(tmp);
    ans+=tmp;
    sort(a.begin(),a.end(),greater<int>());
    cout<<a[0];
    for(int i=1;i<a.size();i++){
        cout<<"+"<<a[i];
    }
    cout<<endl<<ans<<endl;
}

signed main(){
    int t=1;
    // cin>>t;
    while(t--)solve();
    return 0;
}

H 聪明且狡猾的恶魔

$1$ 号恶魔为了保证自己能获胜，会给 $\frac{n}{2}$ 个恶魔一人一个金币，保证自己能获胜

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define ls now<<1
#define rs now<<1|1
const int N = 1e5+7, mod = 1e9+7;

void solve(){
    int n,x;
    cin>>x>>n;
    int ans=x;
    if(n&1)ans-=n/2;
    else ans-=n/2-1;
    cout<<ans<<endl;
}

int main(){
    ios::sync_with_stdio(0);
    cin.tie(0);cout.tie(0);
    int t=1;
    cin>>t;
    while(t--)solve();
    return 0;
}

B 小雷的神奇电脑

经验证，可得答案会在排序后相邻的两个元素中得出

同或结果即为：所有位都为 $1$ 的值减去二者的异或

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#include <bits/stdc++.h>
using namespace std;
#define int long long
signed main(){
    int n,m;
    cin>>n>>m;
    int a[n+100];
    for(int i=1;i<=n;i++){
        cin>>a[i];
    }
    int u[32],cnt=1;
    u[0]=1;
    for(int i=1;i<32;i++){
        cnt*=2;
        u[i]=u[i-1]+cnt;
    }
    sort(a+1,a+1+n);
    int ans=2e9;
    for(int i=1;i<n;i++){
        ans=min(ans,a[i]^a[i+1]);
    }
    cout<<u[m-1]-ans<<endl;
}

C 岗位分配

志愿者无差别，意思是分配到岗位上的是谁不重要，重要的是人数

先固定每个岗位该有的人，再对剩下的人分析

剩下的人每个人都有 $(n + 1)$ 种选择，那么我们的目标就是将他们分为 $(n + 1)$ 组，即用 $n$ 个隔板分开他们

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e5+7, mod = 998244353;

ll pre[N];

void init(){
    pre[0] = 1;
    for(int i = 1; i < N; i++){
        pre[i] = (pre[i-1] * i) % mod;
    }
}

ll rmod(ll a, ll m) {
    ll res = 1, y = m - 2;
    while (y > 0) {
        if (y % 2 == 1) res = (res * a) % m;
        a = (a * a) % m;
        y /= 2;
    }
    return res;
}

ll com(ll n, ll k) {
    if (k > n) return 0;
    return pre[n] * rmod(pre[k], mod) % mod * rmod(pre[n - k], mod) % mod;
}

ll mod_exp(ll base, ll exp, ll m) {
    ll res = 1;
    while (exp > 0) {
        if (exp % 2 == 1) res = (res * base) % m;
        base = (base * base) % m;
        exp /= 2;
    }
    return res;
}

void solve(){
    int n, m;
    cin >> n >> m;
    vector<int> a(n);
    ll ans = 1;
    for(int i = 0; i < n; i++){
        cin >> a[i];
        m-=a[i];
    }
    ans = (ans * com(m+n, m)) % mod;
    cout << ans << endl;
}

int main(){
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    int t = 1;
    init();
    // cin >> t;
    while(t--) solve();
    return 0;
}

I 马拉松

$x \rightarrow y$ 中间的点都忽略，找两侧各有几个点，相乘即为答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 3e5+7;

int n,x,y;
int s[N],vis[N];
vector<int>v[N];
bool onxy[N];

int dfs(int x){
    vis[x]=1;
    s[x]=1;
    if(x==y)onxy[x]=1;
    for(auto i:v[x]){
        if(!vis[i]){
            s[x]+=dfs(i);
            onxy[x]|=onxy[i];
        }
    }
    return s[x];
}

int main(){
    cin>>n>>x>>y;
    for(int i=1;i<n;i++){
        int x,y;
        cin>>x>>y;
        v[x].push_back(y);
        v[y].push_back(x);
    }
    dfs(x);
    int lx;
    for(auto i:v[x]){
        if(onxy[i]==1){
            lx=s[x]-s[i];
        }
    }
    cout<<1LL*lx*s[y]<<endl;
}

J 尖塔第四强的高手

LCA 板，小于 $1e5$ 的 fibonacci 数只有 $24$ 个，提前找到，再根据题意，对所有的点依次跑 LCA 即可

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define ls now<<1
#define rs now<<1|1
const int N = 1e5+7, mod = 1e9+7;

vector<int> v[N];
int d[N], f[N][32];
vector<int> a;

void dfs(int x, int y) {
    d[x] = d[y] + 1;
    f[x][0] = y;
    for (int i = 1; i <= 31; i++) {
        f[x][i] = f[f[x][i-1]][i-1];
    }
    for (int i = 0; i < v[x].size(); i++) {
        if (d[v[x][i]] == 0) dfs(v[x][i], x);
    }
}

int lca(int x, int y) {
    if (d[x] < d[y]) swap(x, y);
    for (int i = 31; i >= 0; i--) {
        if (f[x][i] != 0 && d[f[x][i]] >= d[y])
            x = f[x][i];
    }
    if (x == y) return x;
    for (int i = 31; i >= 0; i--) {
        if (f[x][i] != 0 && f[y][i] != 0 && f[x][i] != f[y][i]) {
            x = f[x][i];
            y = f[y][i];
        }
    }
    return f[x][0];
}

void solve() {
    int f1 = 1, f2 = 1;
    a.push_back(f1);
    a.push_back(f2);
    while (true) {
        int nxt = f1 + f2;
        if (nxt > N) break;
        a.push_back(nxt);
        f1 = f2;
        f2 = nxt;
    }
    
    int n, r, q;
    cin >> n >> r >> q;
    for (int i = 1; i < n; i++) {
        int x, y;
        cin >> x >> y;
        v[x].push_back(y);
        v[y].push_back(x);
    }
    dfs(r, 0);
    while (q--) {
        int x, k;
        cin >> x >> k;
        vector<int> tmp;
        for (int i = k; i < a.size(); i++) {
            if (x + a[i] > n) break;
            tmp.push_back(x + a[i]);
        }
        int ans=0;
        if(tmp.size()){
            ans = tmp[0];
            for (int i = 1; i < tmp.size(); i++) {
                ans = lca(ans, tmp[i]);
            }
        }
        cout << ans << endl;
    }
}

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    int t = 1;
    // cin >> t;
    while (t--) solve();
    return 0;
}

E AND

质数只有一个偶数 $2$，如果没有 $2$，就不可能有符合的区间，因为最后一位一定为 $1$

在有 $2$ 的时候，因为必须选 $2$，同时 $2, 3$ 这个区间也不符合，符合条件的就有 $r - l + 1 - 2$ 个，如果只有 $2$，要记得特判

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


#include <bits/stdc++.h>
using namespace std;
const int N = 1e8 + 10;

vector<int> prime;
bool isnp[N];

void pre(int n) {
    fill(isnp, isnp + n + 1, false);
    for (int i = 2; i <= n; i++) {
        if (!isnp[i]) prime.push_back(i);
        for (auto j : prime) {
            if (j * i > n) break;
            isnp[j * i] = true;
            if (i % j == 0) break;
        }
    }
}

void solve() {
    int x, y;
    cin >> x >> y;
    auto l = lower_bound(prime.begin(), prime.end(), x)-prime.begin();
    auto r = upper_bound(prime.begin(), prime.end(), y)-prime.begin();
    cout << (r - l) << " ";
    if (x == 2 && x == y || x > 2) cout << "0\n";
    else {
        cout << (r - l - 2) << endl;
    }
}

int main() {
    pre(N);
    int t;
    cin >> t;
    while (t--) solve();
    return 0;
}

K 比赛

用线段树，记录每个数字出现的次数，再从左到右，从右到左，各查询一遍，记录左右两次比 $a[i]$ 大、小、相等的有几个，最后得到答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59


#include <bits/stdc++.h>
using namespace std;
typedef long long lll;
#define ls (now << 1)
#define rs (now << 1 | 1)
const int N = 1e5 + 7, mod = 1e9 + 7;

int n, a[N], tr[N << 2], ll[N], lu[N], rl[N], ru[N], le[N], re[N];

void update(int now, int l, int r, int pos, int val) {
    if (l == r) {
        tr[now] += val;
        return;
    }
    int mid = (l + r) >> 1;
    if (pos <= mid) update(ls, l, mid, pos, val);
    else update(rs, mid + 1, r, pos, val);
    tr[now] = tr[ls] + tr[rs];
}

int query(int now, int l, int r, int s, int t) {
    if (s > r || t < l) return 0;
    if (s <= l && r <= t) return tr[now];
    int mid = (l + r) >> 1;
    return query(ls, l, mid, s, t) + query(rs, mid + 1, r, s, t);
}

void solve() {
    lll ans = 0;
    cin >> n;
    for (int i = 1; i <= n; i++) cin >> a[i];
    memset(tr, 0, sizeof(tr));
    for (int i = 1; i <= n; i++) {
        ll[i] = query(1, 1, N, 1, a[i]);
        lu[i] = query(1, 1, N, a[i], N);
        le[i] = query(1, 1, N, a[i], a[i]);
        update(1, 1, N, a[i], 1);
    }
    memset(tr, 0, sizeof(tr));
    for (int i = n; i > 0; i--) {
        rl[i] = query(1, 1, N, 1, a[i]);
        ru[i] = query(1, 1, N, a[i], N);
        re[i] = query(1, 1, N, a[i], a[i]);
        update(1, 1, N, a[i], 1);
        ans += 1LL * rl[i] * lu[i];
        ans += 1LL * ru[i] * ll[i];
        ans -= 1LL * re[i] * le[i];
    }
    cout << ans << endl;
}

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    int t;
    cin >> t;
    while (t--) solve();
    return 0;
}