第23次CSP认证题解

最新推荐文章于 2025-03-18 21:28:03 发布

RioWRLD

最新推荐文章于 2025-03-18 21:28:03 发布

阅读量4k

点赞数 19

分类专栏： CSP 笔记文章标签： c语言算法 c++ csp

本文链接：https://blog.csdn.net/m0_46223441/article/details/120599553

版权

笔记同时被 2 个专栏收录

4 篇文章

订阅专栏

CSP

2 篇文章

订阅专栏

这篇博客分享了作者在算法竞赛中的经验，包括数组推导、非零段划分问题的高效解决方案，以及脉冲神经网络的实现。作者详细解释了代码逻辑，并强调了优化空间使用和理解数据结构的重要性。此外，还介绍了动态规划和树链剖分等技术在解决特定问题中的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

这是我第一次参加CSP，一共得了260分，100,70,70,20,0。这两天试着写一下题解，大家哪里看不懂直接留言问我就好。

第一题：数组推导（100分）

当时不是这么写的，当时建了三个数组，再写的时候发现没必要，记住上一个B的值就可以了，这样可以节省空间（虽然没太大必要）

#include <bits/stdc++.h>
#define For(i,n) for(int i=0;i<n;i++)

using namespace std;

int n;
int lastb,b;
int aMax;
int aMin;
int sumMax=0;
int sumMin=0;

int main() {
    scanf("%d",&n);
    int b;
    For(i,n){
        scanf("%d",&b);
        if(i==0){
            aMax = b;
            aMin = b;
        }
        else{
            if(b>lastb){
                aMax = b;
                aMin = b;
            }
            else if(b==lastb){
                aMax = b;
                aMin = 0;
            }
        }
        lastb=b;
        sumMax+=aMax;
        sumMin+=aMin;
    }
    printf("%d\n%d\n",sumMax,sumMin);
    return 0;
}

第二题：非零段划分（100分）

下面这段这是满分代码，花了我好长时间，基本上是重写了一遍。减小时间复杂度的方法是通过上一次的非零段划分情况来推算这次的情况。
最近感觉优先队列是个挺好用的东西，不过这题的重点不在优先队列。重点是c[i]和lastc[i]这两个数组，它们表示的都是第i个数是否已经变成0。lastc是上一次的c。还有一个比较细节的地方是我从其他博客里看来的。首先，优先队列里存的是元素值与位置的映射，细节就在于多往里存个(0,0)和(0,n+1)，这样后续的处理就会更加方便。
大家看不懂优先队列的可以先把优先队列里的元素按顺序打印出来，应该就比较容易看懂了。
这题比较容易出错的点就是ans在什么时候加或减，if里的条件要写全，我一开始样例都对了，但就是爆0，后来自己写了个
5
1 2 1 2 1
的测试样例，才发现自己的if条件还有问题。

#include <bits/stdc++.h>

using namespace std;

int n;
int ans = 0;
int maxans = 0;
typedef pair<int, int> pii;
priority_queue<pii, vector<pii>, greater<pii>> Q;
bool lastc[500005];
bool c[500005];

int main() {
    int ai;
    scanf("%d", &n);
    Q.push(pii(0,0));
    for (int i = 1; i <= n; i++) {
        scanf("%d", &ai);
        Q.push(pii(ai, i));
    }
    Q.push(pii(0, n+1));
    memset(c, false, sizeof c);
    memset(lastc, false, sizeof c);
    pair<int, int> q = Q.top();
    Q.pop();
    int left = q.second;
    int right = q.second;
    while (!Q.empty()) {
        while (Q.top().first == q.first && !Q.empty()) {
            c[q.second] = true;
            if (q.second == Q.top().second - 1)
                ++right;
            else {
                if (left > 0 && !c[left - 1] && ((right < n+1 && !lastc[right + 1]) || right==n+1))
                    ++ans;
                if (right < n+1 && left > 0 && lastc[right + 1] && lastc[left - 1])
                    --ans;
                left = Q.top().second;
                right = Q.top().second;
            }
            q = Q.top();
            Q.pop();
        }
        c[q.second] = true;
        if (left > 0 && !c[left - 1] && ((right < n+1 && !lastc[right + 1]) || right==n+1))
            ++ans;
        if (right < n+1 && left > 0 && lastc[right + 1] && lastc[left - 1])
            --ans;
        if (maxans < ans)
            maxans = ans;
        //cout << q.first << " " << ans <<endl;
        if (!Q.empty()) {
            q = Q.top();
            Q.pop();
            left = q.second;
            right = q.second;
        }
        memcpy(lastc, c, sizeof c);
    }
    printf("%d", maxans);
    return 0;
}

第三题脉冲神经网络（100分）

这个是满分代码，在自己改的基础上参照了其他博主的做法，对Dmax取模来节省空间。
传送门
在这个过程中我遇到一个问题，我按着和其他博主一样的思路写的代码就是超时，后来我把放在神经元结构体里的w数组拿出来就不超时了，
这告诉我们一个道理，数组容量大的时候不要放在结构体里面。。

关于G数组的作用，有人问到了，我解释一下
在这里插入图片描述

#include <bits/stdc++.h>

using namespace std;

static unsigned long nex = 1;

/* RAND_MAX assumed to be 32767 */
int myrand() {
    nex = nex * 1103515245 + 12345;
    return ((unsigned) (nex / 65536) % 32768);
}

int N, S, P, T;
double ct;
double maxv = -DBL_MAX;
double minv = DBL_MAX;
double v, u, a, b, c, d;
int maxtim = -INT_MAX;
int mintim = INT_MAX;
struct SJY {
    double v, u, a, b, c, d;
    int tim;
} sjy[1005];

double getww[1005][1005];
vector<int> G[2005];
struct TU {
    int s, t;
    double w;
    int D;
};
vector<TU> tu;
int r[1005];
int maxD=0;

int main() {
    int sjyn = 0;
    int RN;
    scanf("%d%d%d%d", &N, &S, &P, &T);
    scanf("%lf", &ct);
    while (true) {
        scanf("%d%lf%lf%lf%lf%lf%lf", &RN, &v, &u, &a, &b, &c, &d);
        while (RN--) {
            sjy[sjyn].v = v;
            sjy[sjyn].u = u;
            sjy[sjyn].a = a;
            sjy[sjyn].b = b;
            sjy[sjyn].c = c;
            sjy[sjyn].d = d;
            sjy[sjyn].tim = 0;
            sjyn++;
        }
        if (sjyn == N)
            break;
    }
    for (int i = 0; i < P; i++)
        scanf("%d", &r[i]);
    int s, t, D;
    double w;
    for (int i = 0; i < S; i++) {
        scanf("%d%d%lf%d", &s, &t, &w, &D);
        G[s].push_back(i);
        tu.push_back({s, t, w, D});
        if(D>maxD)
            maxD=D;
    }
    maxD++;
    for (int nowt = 1; nowt <= T; nowt++) {
        for (int j = 0; j < N; j++) {
            double v1 = sjy[j].v, u1 = sjy[j].u;
            sjy[j].v = v1 + ct * (0.04 * v1 * v1 + 5 * v1 + 140 - u1) + getww[nowt%maxD][j];
            sjy[j].u = u1 + ct * sjy[j].a * (sjy[j].b * v1 - u1);
            getww[nowt%maxD][j] = 0;
            if (sjy[j].v >= 30) {
                sjy[j].tim++;
                sjy[j].v = sjy[j].c;
                sjy[j].u += sjy[j].d;
                for (int ii = 0; ii < G[j].size(); ii++) {
                    TU tu1(tu[G[j][ii]]);
                    getww[(nowt+tu1.D)%maxD][tu1.t] += tu1.w;
                }
            }
        }

        for (int j = 0; j < P; j++) {
            if (r[j] > myrand()) {
                for (int ii = 0; ii < G[j + N].size(); ii++) {
                    TU tu1(tu[G[j + N][ii]]);
                    getww[(nowt+tu1.D)%maxD][tu1.t] += tu1.w;
                }
            }
        }
    }
    for(int j=0;j<N;j++){
        if (sjy[j].v > maxv)
            maxv = sjy[j].v;
        if (sjy[j].v < minv)
            minv = sjy[j].v;
        if (sjy[j].tim > maxtim)
            maxtim = sjy[j].tim;
        if (sjy[j].tim < mintim)
            mintim = sjy[j].tim;
    }
    printf("%.3f %.3f\n", minv, maxv);
    printf("%d %d", mintim, maxtim);

    return 0;
}

第四题收集卡牌（100分）

参照另一博主（隔壁李叟）的做法写的，传送门
这其实是一道相对来说比较简单的的状压dp，但是自己推dp水平太差了。

#include <bits/stdc++.h>

using namespace std;

int n, k;
double p[17];
double dp[1 << 17][77];
bool d[1 << 17][77];

double dfs(int t, int sum, int val, double l) {
    if (val + (sum - val) / k >= n)
        return sum;
    if (d[t][sum])
        return dp[t][sum];
    for (int i = 0; i < n; i++) {
        if (!((t >> i) & 1)) {
            dp[t][sum] += p[i] * dfs(t | (1 << i), sum + 1, val + 1, l + p[i]);
        }
    }
    if (t) {
        dp[t][sum] += l * dfs(t, sum + 1, val, l);
    }
    d[t][sum] = true;
    return dp[t][sum];
}

int main() {
    scanf("%d%d", &n, &k);
    for (int i = 0; i < n; i++) {
        scanf("%lf", &p[i]);
    }
    printf("%.10lf", dfs(0, 0, 0, 0));
    return 0;
}

第五题箱根山岳险天下（50分）

这题依然是看的其他人的题解，主要是参考的CSDN上另一位博主的代码，传送门
用到的知识是树链剖分线段树。
因为没有用LCT（动态树），所以只能拿50分。（异或操作强制在线，树链剖分要知道树的形态）。LCT目前我还没学，我上面发的那个博主写了，b站也有一个题解。大家可以自行搜索。

#include <bits/stdc++.h>

#define mid ((l+r)>>1)
#define lson rt<<1,l,mid
#define rson rt<<1|1,mid+1,r

using namespace std;

typedef long long ll;

const int maxm = 300000 + 10;

struct req {
    ll type, x2, s, l, r, y2;

    req(ll type, ll x2, ll s, ll l, ll r, ll y2)
            : type(type), x2(x2), s(s), l(l), r(r), y2(y2) {}
};

vector<req> R;
ll m, p, T;
//ll e = 0, beg[maxm], nex[maxm], to[maxm];
ll dep[maxm], siz[maxm], fa[maxm], son[maxm];
ll id[maxm], top[maxm], cnt = 0;
ll sum[maxm << 2], lazy[maxm << 2];
ll now, res, tot = 0,rt;
ll A = 0;
vector<ll> edge[maxm];
vector<pair<ll, ll> > E[maxm];

//inline void add(ll x, ll y) {
//    to[++e] = y;
//    nex[e] = beg[x];
//    beg[x] = e;
//}

inline void dfs1(ll x) {//x当前节点，f父亲，deep深度
    siz[x] = 1;
    ll maxson = 0;

    for (ll y:edge[x]) {
//        ll y = to[i];
        if (y == fa[x])
            continue;
        dfs1(y);
        siz[x] += siz[y];
        if (siz[y] > maxson) {
            son[x] = y;
            maxson = siz[y];
        }
    }
}

inline void dfs2(ll x, ll topf) {//x当前节点，topf当前链的最顶端的节点
    id[x] = ++cnt;
    top[x] = topf;
    if (!son[x])
        return;
    dfs2(son[x], topf);
    for (ll y:edge[x]) {
//        ll y = to[i];
        if (y == fa[x] || y == son[x])
            continue;
        dfs2(y, y);
    }
}

inline void pushdown(ll rt) {
    if (lazy[rt] != 1) {
        lazy[rt << 1] = (lazy[rt] * lazy[rt << 1]) % p;
        lazy[rt << 1 | 1] = (lazy[rt] * lazy[rt << 1 | 1]) % p;

        sum[rt << 1] = (lazy[rt] * sum[rt << 1]) % p;
        sum[rt << 1 | 1] = (lazy[rt] * sum[rt << 1 | 1]) % p;
        lazy[rt] = 1;
    }
}

inline void insert(ll rt, ll l, ll r, ll v, ll y) {
    if (l == r) {
        sum[rt] = y;
        sum[rt] %= p;
        lazy[rt] = 1;
        return;
    } else {
        if (lazy[rt] != 1)
            pushdown(rt);
        if (v <= mid)
            insert(lson, v, y);
        if (v > mid)
            insert(rson, v, y);
        sum[rt] = (sum[rt << 1] + sum[rt << 1 | 1]) % p;
    }
}

inline void query(ll rt, ll l, ll r, ll L, ll R) {
    if (L <= l && r <= R) {
        res += sum[rt];
        res %= p;
        return;
    } else {
        if (lazy[rt] != 1)
            pushdown(rt);
        if (L <= mid)
            query(lson, L, R);
        if (R > mid)
            query(rson, L, R);
    }
}

inline void update(ll rt, ll l, ll r, ll L, ll R, ll k) {
    if (L <= l && r <= R) {
        lazy[rt] = (lazy[rt] * k) % p;
        sum[rt] = (sum[rt] * k) % p;
    } else {
        if (lazy[rt] != 1)pushdown(rt);
        if (L <= mid)update(lson, L, R, k);
        if (R > mid)update(rson, L, R, k);
        sum[rt] = (sum[rt << 1] + sum[rt << 1 | 1]) % p;
    }
}

inline ll qRange(ll x, ll y) {
    ll ans = 0;
    while (top[x] != top[y]) {
        if (dep[top[x]] < dep[top[y]])swap(x, y);
        res = 0;
        query(1, 1, tot, id[top[x]], id[x]);
        ans += res;
        ans %= p;
        x = fa[top[x]];
    }

    if (dep[x] > dep[y])swap(x, y);
    res = 0;
    query(1, 1, tot, id[x], id[y]);
    ans += res;
    return ans % p;
}

inline void updRange(ll x, ll y, ll k) {
    k %= p;
    while (top[x] != top[y]) {
        if (dep[top[x]] < dep[top[y]]) swap(x, y);
        update(1, 1, tot, id[top[x]], id[x], k);
        x = fa[top[x]];
    }
    if (dep[x] > dep[y]) swap(x, y);
    update(1, 1, tot, id[x], id[y], k);
}

inline ll find(ll x, ll y) {
    ll l = 0, r = E[x].size() - 1, ans = 0;
    while (l <= r) {
        ll mi = (l + r) >> 1;
        if (E[x][mi].first <= y) {
            ans = E[x][mi].second;
            l = mi + 1;
        } else
            r = mi - 1;
    }
    return ans;
}


int main() {
    ll type;
    scanf("%lld%lld%lld", &m, &p, &T);
    rt = now = 0;
    tot = 0;
    for (int i = 1; i <= m << 2; i++) {
        lazy[i] = 1;
        sum[i] = 0;
    }
    dep[0] = 0;
    for (ll t = 1, x2, y2, s, l, r; t <= m; t++) {
        scanf("%lld", &type);
        x2 = y2 = s = l = r = 0;
        if (type == 1) {
            scanf("%lld", &x2);
            if (x2 == 0) {
                now = fa[now];
            } else {
                s = ++tot;
                fa[tot] = now;
                dep[tot] = dep[now] + 1;
                edge[now].push_back(tot);
//                add(now, tot);
//                add(tot, now);
                E[dep[tot]].push_back({t, tot});
                now = tot;
            }
        } else if (type == 2) {
            scanf("%lld%lld%lld%lld", &s, &l, &r, &y2);
        } else if (type == 3) {
            scanf("%lld%lld%lld", &s, &l, &r);
        }
        R.push_back(req(type, x2, s, l, r, y2));
    }
    A = 0;
    tot++;
    dfs1(rt);
    dfs2(rt, rt);
    for (req re: R) {
        if (re.type == 1) {
            if (re.x2) {
                insert(1, 1, tot, id[re.s], re.x2 ^ A);
            }
        } else {
            ll x = find(re.l, re.s);
            ll y = find(re.r, re.s);
            if (re.type == 2) {
                updRange(x, y, re.y2 ^ A);
            } else {
                res = qRange(x, y);
                printf("%lld\n", res);
                if (T)
                    A = res;
            }
        }
    }
    return 0;
}