NM-S00251（CSP-S 2024 ver.）

· · 休闲·娱乐

决斗（duel）

#include <iostream>
using namespace std;

int main(){

cout<<"不会"<<endl;
return 0;
}

超速检测（detect）

#include <bits/stdc++.h>
using namespace std;

struct FastInput {
    static const int BUFSIZE = 1 << 20;
    int idx, len;
    char buf[BUFSIZE];
    FastInput() : idx(0), len(0) {}
    inline char nextChar() {
        if (idx >= len) {
            len = fread(buf, 1, BUFSIZE, stdin);
            idx = 0;
            if (len == 0) return 0;
        }
        return buf[idx++];
    }
    template <typename T>
    bool read(T &out) {
        char c = 0;
        T sign = 1, val = 0;
        c = nextChar();
        if (!c) return false;
        while (c != '-' && (c < '0' || c > '9')) {
            c = nextChar();
            if (!c) return false;
        }
        if (c == '-') {
            sign = -1;
            c = nextChar();
        }
        for (; c >= '0' && c <= '9'; c = nextChar())
            val = val * 10 + (c - '0');
        out = val * sign;
        return true;
    }
};

struct Interval {
    int l, r;
};

const int MAXN = 100005;

int n, m, L, V;
int d[MAXN], v[MAXN], a[MAXN];
int p[MAXN];
vector<Interval> intervals;

inline long long velocitySq(int v, int a, int s) {
    return 1LL * v * v + 2LL * a * s;
}

inline bool compareIntervals(const Interval &a, const Interval &b) {
    if (a.r == b.r)
        return a.l < b.l;
    return a.r < b.r;
}

int main() {
    freopen("detect.in", "r", stdin);
    freopen("detect.out", "w", stdout);

    FastInput in;
    int T;
    in.read(T);

    while (T--) {
        in.read(n);
        in.read(m);
        in.read(L);
        in.read(V);

        for (int i = 0; i < n; ++i) {
            in.read(d[i]);
            in.read(v[i]);
            in.read(a[i]);
        }

        for (int i = 0; i < m; ++i) {
            in.read(p[i]);
        }

        intervals.clear();
        int firstAnswer = 0;

        for (int i = 0; i < n; ++i) {
            if (d[i] > p[m - 1]) continue;

            int left = 0, right = m - 1;
            while (left < right) {
                int mid = (left + right) >> 1;
                if (d[i] <= p[mid])
                    right = mid;
                else
                    left = mid + 1;
            }
            int firstDetector = left;

            if (a[i] >= 0) {
                long long finalVelSq = velocitySq(v[i], a[i], p[m - 1] - d[i]);
                if (finalVelSq <= 0 || finalVelSq <= 1LL * V * V) {
                    continue;
                }
                firstAnswer++;

                left = firstDetector;
                right = m - 1;
                while (left < right) {
                    int mid = (left + right) >> 1;
                    long long velSq = velocitySq(v[i], a[i], p[mid] - d[i]);
                    if (velSq <= 0 || velSq <= 1LL * V * V)
                        left = mid + 1;
                    else
                        right = mid;
                }
                intervals.push_back({left, m - 1});
            } else {
                long long firstVelSq = velocitySq(v[i], a[i], p[firstDetector] - d[i]);
                if (firstVelSq <= 0 || firstVelSq <= 1LL * V * V) {
                    continue;
                }
                firstAnswer++;

                left = firstDetector;
                right = m - 1;
                while (left < right) {
                    int mid = (left + right + 1) >> 1;
                    long long velSq = velocitySq(v[i], a[i], p[mid] - d[i]);
                    if (velSq <= 0 || velSq <= 1LL * V * V)
                        right = mid - 1;
                    else
                        left = mid;
                }
                intervals.push_back({firstDetector, left});
            }
        }

        sort(intervals.begin(), intervals.end(), compareIntervals);
        int currentEnd = -1;
        int requiredDetectors = 0;

        for (const auto &interval : intervals) {
            if (interval.l > currentEnd) {
                currentEnd = interval.r;
                requiredDetectors++;
            }
        }

        printf("%d %d\n", firstAnswer, m - requiredDetectors);
    }

    return 0;
}

染色（color）

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;

const int MAXN = 1000000 + 5;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    ifstream fin("color.in");
    ofstream fout("color.out");

    int testCases;
    fin >> testCases;

    while (testCases--) {
        int n;
        fin >> n;

        vector<ll> arr(n + 1), lastPosition(n + 1), dp(n + 1), prefixSum(n + 1);

        for (int i = 1; i <= n; ++i) {
            fin >> arr[i];
        }

        for (int i = 2; i <= n; ++i) {
            if (arr[i] == arr[i - 1]) {
                prefixSum[i] = prefixSum[i - 1] + arr[i];
            } else {
                prefixSum[i] = prefixSum[i - 1];
            }
        }

        for (int i = 1; i <= n; ++i) {
            dp[i] = dp[i - 1];
            if (lastPosition[arr[i]] != 0) {
                int prevPos = lastPosition[arr[i]];
                ll additionalValue = arr[i] + prefixSum[i] - prefixSum[prevPos + 1];
                dp[i] = max(dp[i], dp[prevPos + 1] + additionalValue);
            }
            lastPosition[arr[i]] = i;
        }

        fout << dp[n] << '\n';
    }

    return 0;
}
//如果你看到这里了 ，那我就可以告诉你一个“惊喜 ”
//我不知道会不会有人看这个代码，工整吧
//半个小时 才写出来的
//这个没有detect多
//我妈给我报的课我基本没上，纯跟AI学
//AI讲的可明白多了，还是1对1
//总之，看到的话不要惊讶
//昨天AI告诉我，可读的变量名可以让人读的更清楚 
//我本来没打算这么写来着，但是有趣的是Deepseek严厉的批评了我
//所以特意去英语速成啦 
//至于这个应该没人看见，因为是机器判题

擂台游戏（arena）

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000000 + 5;
int A[MAXN],c[MAXN];
int main(){
    ifstream fin("arena.in");
    ofstream fout("arena.out");
    long long n,m; 
    fin>>n>>m;
    for(int i=0;i<n;i++){fin>>A[i];}
    for(int i=0;i<m;i++){fin>>c[i];}
        fout<<0<<'\n';
    return 0;
}//错了这个，就不整理了

点击左上角绿色头像一口气看到大结局。

嘟嘟嘟嘟嘟，嘟嘟嘟。