前言

和扬子曰大佬和慕容宝宝大佬一组，我压力巨大，而且掌机，累死我了，敲了一个下午的代码，他们两个人因为比我巨就欺负我QwQ。
依旧被二中学军爆锤，我真的好菜，慕容宝宝或者是扬子曰大佬来掌机一定成绩比我好。

A

签到题，用gets直接读字符串，判末尾就好了。

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
char s[1000005];
int main() {
    while (gets(s)) {
        int len = strlen(s);
        if (s[len - 1] == '.') s[len - 1] = '!';
        printf("%s\n", s);
    }
    return 0;
}

B

这道题目还是非常巧妙的，因为暴力要超时\(O(n^2)\)，那么如果要不满足构成三角形的条件，那么如果不能构成三角形的话，必须满足\(a[i]+a[i+1]>=a[i+2]\)，假设已经递增排序，那么很明显，斐波那契数列能够让不构成三角形最多，打表发现第56项就超过了数据范围，那么就60以内暴力，60以外直接输出yes。

#include <cstdio>
#include <algorithm>
#define N 200005
#define ll long long
using namespace std;
ll a[N], t[N];
int n, q;
int main() {
    scanf("%d%d", &n, &q);
    for (int i = 1; i <= n; i ++) {
        scanf("%lld", &a[i]);
    }
    while (q --) {
        int l, r;
        scanf("%d%d", &l, &r);
        if (l > r) {
            printf("NO\n");
        }
        else if (r - l + 1 > 60) {
            printf("YES\n");
        }
        else {
            int tot = 0;
            for (int i = l; i <= r; i ++) {
                t[++ tot] = a[i];
            }
            sort(t + 1, t + 1 + tot);
            bool fg = 0;
            for (int i = 1; i <= tot - 2; i ++) {
                if (t[i] + t[i + 1] > t[i + 2]) {
                    printf("YES\n");
                    fg = 1;
                    break;
                }
            }
            if (!fg) printf("NO\n");
        }
    }
    return 0;
}

D

有多少个不同的数。

#include <cstdio>
#include <map>
using namespace std;
map<int,bool>vis;
int n;
int main() {
    scanf("%d", &n);
    int ans = 0;
    for (int i = 1; i <= n; i ++) {
        int x;
        scanf("%d", &x);
        if (!vis[x]) ans++;
        vis[x] = 1;
    }
    printf("%d\n", ans);
    return 0;
}

E

E题算是一道非常有思维含量的一道题目，我们首先打表发现所有的奇数都是无解。偶数会发现，\(i\)和\(i+n/2\)的两条边都是相等的，那么就将两个点合并在一起就发现了是一个欧拉回路的问题。
代码咕咕掉了，没有调对。

H

求有多少个数对满足\(a_i^{a_j}>a_j^{a_i}\)。
稍微打几个表，就会发现4之后的都满足底数小的大，那么特判之前的就可以了

#include <cstdio>
#include <map>
#include <algorithm>
#define N 100005
using namespace std;
struct data {
    int x, id;
    data() {
        x = id = 0;
    }
    bool operator <(const data &rhs) const {
        return x < rhs.x;
    }
}a[N];
int ans[N], b[N];
map<int,int>mp;
int n;
int main() {
    scanf("%d", &n);
    for (int i = 1; i <= n; i ++) {
        scanf("%d", &a[i].x);
        b[i] = a[i].x;
        a[i].id = i;
        mp[a[i].x] ++;
    }
    sort(a + 1, a + 1 + n);
    int tot = 0;
    for (int i = 1; i <= n; i ++) {
        if (a[i].x == 1) ans[a[i].id] = 0;
        else {
            if (a[i].x != a[i - 1].x) {
                tot += mp[a[i].x];
                ans[a[i].id] = n - tot;
            }
            else {
                ans[a[i].id] = ans[a[i - 1].id];
            }
        }
    }
    for (int i = 1; i <= n; i ++) {
        if (b[i] == 2) ans[i] -= mp[3] + mp[4];
        if (b[i] == 3) ans[i] += mp[2];
    }
    for (int i = 1; i <= n; i ++) {
        printf("%d ", ans[i]);
    }
    return 0;
}

I

求双射的可能性
只要求出了25组那么第26组也被确定了，而且要建立双向关系。

#include <cstdio>
#include <cstring>
#define N 1000005
using namespace std;
char s1[N], s2[N];
int d1[30], d2[30];
int tot;
int main() {
    scanf("%s%s", s1, s2);
    int len = strlen(s1);
    memset(d1, 0, sizeof(d1));
    memset(d2, 0, sizeof(d2));
    for (int i = 0; i < len; i ++) {
        int x1 = s1[i] - 'a' + 1, x2 = s2[i] - 'a' + 1;
        if (d1[x1] == 0 && d2[x2] == 0) {
            ++tot;
            d1[x1] = x2;
            d2[x2] = x1;
            continue;
        }
        if (d1[x1] != 0 && d1[x1] != x2) {
            printf("Impossible");
            return 0;
        }
        if (d2[x2] != 0 && d2[x2] != x1) {
            printf("Impossible");
            return 0;
        }
        d1[x1] = x2;
        d2[x2] = x1;
    }
    if (tot == 25) {
        int p1, p2;
        for (int i = 1; i <= 26; i ++) {
            if (d1[i] == 0) p1 = i;
            if (d2[i] == 0) p2 = i;
        }
        d1[p1] = p2;
        d2[p2] = p1;
    }
    for (int i = 1; i <= 26; i ++) {
        if (d1[i] != 0) {
            printf("%c->%c\n", i + 'a' - 1, d1[i] + 'a' - 1);
        }
    }
    return 0;
}

J

答案就是\(max(0,n-k\times t)\)。
ps.开long long。

#include <cstdio>
#include <algorithm>
#define ll long long
using namespace std;
int main() {
    ll n, k, t;
    scanf("%lld%lld%lld", &n, &k, &t);
    printf("%lld\n", max(1ll * 0, n - k * t));
    return 0;
}

K

玄学精度误差，可证明海伦公式最小的误差在0.25之内，那么就在二分查找的时候稍微扩大范围就好了。

#include <cstdio>
#include <algorithm>
#include <cmath>
#define db double
using namespace std;
db s[4000005];
struct node {
    db x, y;
}a[255];
int n, q, tot;
db sqr(db x) {
    return x * x;
}
db dist(int i, int j) {
    return sqrt(sqr(a[i].x - a[j].x) + sqr(a[i].y - a[j].y));
}
int main() {
    scanf("%d%d", &n, &q);
    for (int i = 1; i <= n; i ++) {
        scanf("%lf%lf", &a[i].x, &a[i].y);
    }
    tot = 0;
    for (int i = 1; i <= n; i ++) {
        for (int j = i + 1; j <= n; j ++) {
            for (int k = j + 1; k <= n; k ++) {
                db a = dist(i, j), b = dist(j, k), c = dist(i, k);
                s[++ tot] = sqrt(fabs(a + b + c) / 2.0) * sqrt(fabs(a + b - c) / 2.0) * sqrt(fabs(a - b + c) / 2.0) * sqrt(fabs(-a + b + c)/ 2.0);
            }
        }
    }
    sort(s + 1, s + 1 + tot);
    while (q --) {
        db l, r;
        scanf("%lf%lf", &l, &r);
        int d1 = lower_bound(s + 1, s + 1 + tot, l - 0.25) - s;
        int d2 = upper_bound(s + 1, s + 1 + tot, r + 0.25) - s;
        printf("%d\n", d2 - d1);
    }
    return 0;
}