CCSP&CNCC游记

CCSP2026公开排行榜:https://ccsp-public.thusaac.com/ranklist/?password=CCSP2026SC1021

第一次参加CCSP是24年,因为大一CSP运气比较好,好像是370分,蹭到了参赛资格。
因为CCSP的颁奖是在CNCC,所以参加CCSP就还能去蹭一下CNCC,印象中24年CNCC好像包下了横店,但是有点久远,我已经记不清了。
但我还记得我是240分铁首,240分低罚时就是铜尾了,所以很遗憾痛失铜牌。

25年的时候,学校削了经费,导致只给我们报销一小部分钱,大家普遍不满,后来改成了削减报销名额。我大二的几场CSP都发挥得一般,结果就被踢出去了,没得到参赛资格。那一场好像是在哈尔滨,正好是我老家,痛失一次公费回家的机会。

终于到了26年,一边拿着CCSP的参赛资格,一边拿着CCF大学生启航计划的报销来到成都,我感觉现在的我,强的可怕。
然而最终还是离银牌线差了10分,遗憾打铜了。
33c8c93603bdb41b5d85dcfbd8c9c2b1

这是我
↑这是我
这是银牌线
↑这是银牌线
不应该啊,我觉得不应该啊。
难道说,我真的没有银牌水平?
c733cf5760b8715b5b1d21fbe50fee80
抱着强烈的不甘心,我开始了补题。

往年一般是前三题算法题+后两题超级无敌大模拟,今年一上来第一题就给我一个小模拟,吓懵了。
写了一会没写出来,看到榜上先做的第二题,我说对啊,我为什么要先做这个,应该先做简单的算法题才对啊。
然后去看T2,结果T2也不会,尴尬了。
上午就基本一直在这两题之间徘徊,幸好徘徊了半天两题都写出来了。
因为T1是模拟就没什么好讲的了。
T2感觉需要一点猜结论。
对于给定的一个任务序列
181006ee7faf9d82a907fe08b1e02d7a
排列任务顺序,是峰值内存最小化
image
此外,任务间存在依赖关系,合法序列是依赖图的拓扑序。
先考虑没有依赖关系的情况,显然直接按P-S降序排就好了。
如果有依赖关系怎么办呢?直觉上好像在求拓扑序的过程中按P-S降序维护无入度的set就好了。
然后我就WA了
3cf52a92452c0dcaf259cc3dcc8298f8
仔细一想,这样并不能保证瓶颈处最优。
我们想要:
\(pre_s[i-1]+p[i] \leq ans\)
也就是说:
\(pre_s[i] \leq ans+s[i]-p[i]\)
按p-s降序排序,就是按pre_s的上界升序排序。
然后不断取出第一个点,称其为瓶颈点。
将瓶颈点放入,若其入度不为0,先放入它的依赖点,它们的pre_s的上界肯定不比瓶颈点低。
这样就搞定了,取个最大值输出答案就好了。

做到这里是中午,我看着榜上200分银首的排名,一边吃午饭一边美美幻想有没有可能拿金,然后T3反手就给了我一巴掌。

T3
输入n个请求req
\(req[i]\)是\(req_{p[i]}\)的前\(k[i]\)个token再加额外\(m[i]\)个token组成
所以req可以非常长
有一个容量为c的缓存
求理论命中率上限
这里的token跟常规字符串不太一样,缓存中存的一个单元是某个token对应的前缀的结果,不是token一样就对应缓存中同一个东西,需要前缀一样才行。
失配是从第一个缓存中没有的前缀开始,后面全部失配,所以缓存中肯定不会跳着存,或者说在字典树上缓存里存的内容是一个包含字典树根节点的连通块。
b3ca49ab7e291b91b8a718c75b6b476e
8db66733fc1ad7589d6f6904116c8b0e
当时从榜上来看T3很难,实际上一点也不简单。
我就一个一个子任务去做。
对与①,缓存容量相当于无限大,出现过得所有内容都会命中,所以不用考虑最优策略了。唯一的难点是前面说的req可以非常长,具体来说是\(k[i]\)可以非常大,需要一种方法能直接跳转到\(req_{p[i]}\)的第\(k[i]\)个节点。
一开始的做法是一直向上跳转

int findpre(int i,int x)
{
    if(sz[p[i]]>=x)return findpre(p[i],x);
    return ton[make_pair(i,x)];
}

然而不知道为什么是WA而不是TLE
后来改成用map存信息避免重复访问

int findpre(int i,int x)
{
    if(ton[make_pair(i,x)]>0)return ton[make_pair(i,x)];
    return ton[make_pair(i,x)]=findpre(p[i],x);
}

然后就过了①
接下来思考②
req总和1e6,也就是说可以线性的处理所有字符串了。
但是我们现在要考虑如何做到最优解
对于字典树上一个点x,如果它被访问的相邻两次时间为t1和t2,那就说明在缓存中占用[t1,t2]时间里的一份空间可以获得一份收益,这里所说的“时间”就是req的下标。
这样问题就转化成一个较简单的模型,把所有区间按照左端点排序,维护一个大小上限为c的set表示可用集,遇到左端点就把区间放入set,遇到右端点就移出set并结算收益,set塞满了就踢出去一个最差的(右端点最右的)。
说起来简单但其实我这里想了很久很久......

然而我们前面不是说,首次失配之后都会失配,所以缓存中存的是一个包含字典树根节点的连通块吗?
仔细想想,其实没有问题,因为在字典树上我每次访问一个节点都必然先访问它的父节点,所以如果对节点x有区间[t1,t2]能对答案产生贡献,必然有父节点fa[x]的区间[t1,t2]能对答案产生贡献,因此先放父节点可以保证缓存中实际上还是一个包含字典树根节点的连通块。
即使中间有访问父节点而不访问子节点的t3,也不会对这个结论产生影响,我们不可能不用父节点的[t1,t3][t3,t2]区间而先去使用子节点的[t1,t2]区间。所以做这个转化是合法的。

真的没问题吗?其实我场上并不确定。
虽然事后来看这个思路是对的,但场上我缺乏严谨思考,导致心里对这个做法的正确性有疑虑,在碰壁了几次以后以为是自己思路错了放弃了,然后转战T4去了,其实是我细节写错了......
(同时也是看榜时发现wqz大神都只拿了10分,于是认定②肯定不是我这种蒻苟能写出来的,思路肯定有问题,遂放弃)
findpre2函数表示在时间ti,寻找\(req[i]\)的第x个节点
我场上写的是↓

int findpre2(int i,int x,int ti)
{
    int now=1;
    if(x>0&&i>0)now=findpre2(p[i],min(x,sz[p[i]]),ti);
    for(int j=0;j<min(x-k[i],sz[i]-k[i]);j++)
    {
        now=nton[make_pair(now,e[i][j])];
        f(now,ti);
    }
    return now;
}

当时只考虑到递归时不能越过p[i]的大小,然而实际上\(req[i]\)只引用了\(req_{p[i]}\)的前\(k[i]\)个点,所以上界其实是\(k[i]\)而不是\(sz[p[i]]\)
应改为↓

int findpre2(int i,int x,int ti)
{
    int now=1;
    if(x>0&&i>0)now=findpre2(p[i],min(x,k[i]),ti); // !!!
    for(int j=0;j<x-k[i];j++) // !!!
    {
        now=nton[make_pair(now,e[i][j])];
        f(now,ti);
    }
    return now;
}

完整代码↓

#include<bits/stdc++.h>
using namespace std;
#define int long long
int t,n,a,b,c,x,num=1;
int p[100005],k[100005],m[100005],sz[100005];
int numseg=0;
int ttm[1000006],l[1000006],r[1000006];
vector<int>e[100005];
set<pair<int,int> >sl;
set<pair<int,int> >sr;
map<pair<int,int>,int>ton;
map<pair<int,int>,int>nton;
int findpre(int i,int x)
{
    if(sz[p[i]]>=x)return findpre(p[i],x);
    return ton[make_pair(i,x)];
    if(ton[make_pair(i,x)]>0)return ton[make_pair(i,x)];
    return ton[make_pair(i,x)]=findpre(p[i],x);
}
void f(int now,int i)
{
    if(ttm[now]>0)
    {
        numseg++;
        l[numseg]=ttm[now];
        r[numseg]=i;
        //printf("#%lld %lld %lld\n",l[numseg],r[numseg],numseg);
        sl.insert(make_pair(l[numseg],numseg));
    }
    ttm[now]=i;
    //printf("?%lld %lld\n",now,i);
}
int findpre2(int i,int x,int ti)
{
    int now=1;
    if(x>0&&i>0)now=findpre2(p[i],min(x,k[i]),ti);
    for(int j=0;j<x-k[i];j++)
    {
        now=nton[make_pair(now,e[i][j])];
        //printf("?%lld %lld\n",now,ti);
        f(now,ti);
        //printf("?%lld %lld\n",now,ti);
    }
    return now;
}
signed main()
{
    //freopen("C.in","r",stdin);
    a=0,b=0;
    scanf("%lld%lld",&n,&c);
    ton[make_pair(0,0)]=1;
    if(c==1000000000)
    {
        for(int i=1;i<=n;i++)
        {
            scanf("%lld%lld%lld",&p[i],&k[i],&m[i]);
            
            sz[i]=k[i]+m[i];
            b=b+sz[i];
            int now=findpre(i,k[i]);
            int re=sz[i];

            for(int j=1;j<=m[i];j++)
            {
                scanf("%lld",&x);
                if(nton[make_pair(now,x)]>0)
                {
                    now=nton[make_pair(now,x)];
                }
                else
                {
                    num++;
                    nton[make_pair(now,x)]=num;
                    now=nton[make_pair(now,x)];
                    if(re==sz[i])re=k[i]+j-1;
                }
                ton[make_pair(i,k[i]+j)]=now;
            }
            a=a+re;
        }
    }
    else
    {
        for(int i=1;i<=n;i++)
        {
            scanf("%lld%lld%lld",&p[i],&k[i],&m[i]);
            
            sz[i]=k[i]+m[i];
            b=b+sz[i];
            int now=findpre2(p[i],k[i],i);

            for(int j=1;j<=m[i];j++)
            {
                scanf("%lld",&x);
                e[i].push_back(x);
                if(nton[make_pair(now,x)]==0)
                {
                    num++;
                    nton[make_pair(now,x)]=num;
                }
                now=nton[make_pair(now,x)];
                f(now,i);
                ton[make_pair(i,k[i]+j)]=now;
            }
        }
        a=0;
        if(c!=0)
        {
            for(auto it:sl)
            {
                //printf("#%lld %lld\n",it.first,it.second);
                int k=it.second;
                if(sr.size()<c)
                {
                    sr.insert(make_pair(r[k],k));
                }
                else
                {
                    auto r1=*sr.begin();
                    if(r1.first<=l[k])
                    {
                        sr.erase(r1);
                        a++;
                        sr.insert(make_pair(r[k],k));
                    }
                    else
                    {
                        sr.insert(make_pair(r[k],k));
                        auto rr=*sr.rbegin();
                        sr.erase(rr);
                    }
                }
            }
            a+=sr.size();
            sr.clear();
        }
    }
    int x=__gcd(a,b);
    a/=x,b/=x;
    printf("%lld %lld",a,b);
    return 0;
}

场上调半天没调出来②,于是看T4去了
对于这个超绝大模拟,实在不想复述题意了
本身也没啥算法
我说白了做这种题跟坐牢有什么区别
唯一的区别就是坐牢至少刑期是确定的

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define MAXN 600005
int t,n,q,bid,id,ansnum=0;
int c,s;//块数,大小
int voidc;//可用块
int T=0;//逻辑时间

int idbnum=0;
map<int,int>idb,idb2;

int idpnum=0;
map<int,int>idp,idp2;


vector<int>ask;//decode的请求

//块属性
// int block_in_GPU[MAXN];//块是否在GPU内
int live[MAXN];//引用共享块的未终止请求数
int active[MAXN];//引用共享块的running请求数
string stateb[MAXN];//状态
set<int>IDLE;
// int protb[MAXN];//本轮保护的块


//请求属性
int blocknum[MAXN];
vector<int>e[MAXN];//引用的共享块
int p[MAXN];//输入数
int m[MAXN];//需生成数
int k[MAXN];//引用共享块数
int g[MAXN];//以生成数
string state[MAXN];//状态
set<int>RUNNING;
int prot[MAXN];//本轮保护的请求
vector<int>delb,delr;

int private_num(int id)
{
    return (p[id]-k[id]*s+g[id]-1)/s+1;
}
int new_private(int id)
{
    return ((p[id]-k[id]*s+g[id])/s+1)-((p[id]-k[id]*s+g[id]-1)/s+1);
}

string lei;
vector< pair<char,int> >ans;
void R(int id)
{
    ansnum++;
    ans.push_back(make_pair('R',idp2[id]));
    state[id]="WAITING";
    delr.push_back(id);
    //RUNNING.erase(id);
    voidc+=private_num(id);
    for(auto it:e[id])
    {
        active[it]--;
        if(active[it]==0)
        {
            stateb[it]="IDLE";
            IDLE.insert(it);
        }
    }
}
void B(int id)
{
    ansnum++;
    ans.push_back(make_pair('B',idb2[id]));
    stateb[id]="ABSENT";
    delb.push_back(id);
    //IDLE.erase(id);
    voidc++;
}
void find_space()
{
    while(voidc<0)
    {
        for(auto it:RUNNING)
        {
            if(prot[it])continue;
            R(it);
            if(voidc>=0)break;
        }
    }
    for(auto it:delr)
    {
        RUNNING.erase(it);
    }
    delr.clear();
    while(voidc<0)
    {
        for(auto it:IDLE)
        {
            B(it);
            if(voidc>=0)break;
        }
    }
    for(auto it:delb)
    {
        IDLE.erase(it);
    }
    delb.clear();
}
signed main()
{
    cin >> s>>c>>q;
    voidc=c;
    while(q--)
    {
        cin >> lei;
        if(lei=="CREATE_BLOCK")
        {
            cin>>bid;
            if(idb[bid]==0)
            {
                idbnum++;
                idb[bid]=idbnum;
                idb2[idbnum]=bid;
            }
            bid=idb[bid];
            stateb[bid]="ABSENT";
        }
        else if(lei=="DROP_BLOCK")
        {
            cin>>bid;
            bid=idb[bid];
            if(stateb[bid]=="IDLE")
            {
                IDLE.erase(bid);
                voidc++;
            }
        }
        else if(lei=="ADD")
        {
            cin>>id;
            if(idp[id]==0)
            {
                idpnum++;
                idp[id]=idpnum;
                idp2[idpnum]=id;
            }
            id=idp[id];
            cin>>k[id];
            for(int j=1;j<=k[id];j++)
            {
                cin>>bid;
                bid=idb[bid];
                e[id].push_back(bid);
                live[bid]++;
            }
            cin>>p[id]>>m[id];
            g[id]=0;
            state[id]="WAITING";
        }
        else if(lei=="CANCEL")
        {
            cin>>id;
            id=idp[id];
            if(state[id]=="FINISHED"||state[id]=="CANCELLED")continue;
            if(state[id]=="RUNNING")
            {
                voidc+=private_num(id);
                RUNNING.erase(id);
                for(auto it:e[id])
                {
                    live[it]--;
                    active[it]--;
                    if(active[it]==0)
                    {
                        stateb[it]="IDLE";
                        IDLE.insert(it);
                    }
                }
            }
            if(state[id]=="WAITING")
            {
                for(auto it:e[id])
                {
                    live[it]--;
                }
            }
            state[id]="CANCELLED";
        }
        else if(lei=="DECODE")
        {
            T++;
            cin>>n;
            for(int j=1;j<=n;j++)
            {
                cin>>id;
                id=idp[id];
                ask.push_back(id);
                prot[id]=1;
                if(state[id]=="WAITING")
                {
                    state[id]="RUNNING";
                    RUNNING.insert(id);
                    voidc-=private_num(id);
                    T+=private_num(id);
                    for(auto it:e[id])
                    {
                        if(stateb[it]=="ABSENT")
                        {
                            voidc--;
                            T++;
                        }
                        if(stateb[it]=="IDLE")IDLE.erase(it);
                        active[it]++;
                        stateb[it]="ACTIVE";
                    }
                }
                if(new_private(id))
                {
                    voidc--;
                }
                g[id]++;
            }
            find_space();
            for(auto it:ask)
            {
                prot[it]=0;
                if(g[it]==m[it])
                {
                    state[it]="FINISH";
                    RUNNING.erase(it);
                    voidc+=private_num(it);
                    for(auto itt:e[it])
                    {
                        live[itt]--;
                        active[itt]--;
                        if(active[itt]==0)
                        {
                            stateb[itt]="IDLE";
                            IDLE.insert(itt);
                        }
                    }
                }
            }
            cout<<"EVICT "<<ansnum<<" ";
            for(int ii=0;ii<ansnum;ii++)
            {
                cout<<ans[ii].first<<ans[ii].second<<" ";
            }
            cout<<endl;
            ans.clear();
            ask.clear();
            ansnum=0;
        }
    }
    
    return 0;
}

写了二百多行
场上de出一万个bug没de出第一万零一个
结尾ask忘了清空
T3和T4要是少一个失误这把就银了
太遗憾了
4542295f43200555512cc398a0b35ac9

T5呢?
哈哈我场上看都没敢看哈哈哈
8a5eef1cd6cd93e0cd65e5ba2cff0fcf

事已至此,那还说啥了
公费旅游去了
7c294f1aee08cfc221030254ab289088
be7569c4f965ceaa0a28b7a2535f9f10
e75a8111646cad6b4aa2d9095b7a9981
c0743283f1ded151f3b772423681b58e

posted @ 2026-10-27 01:58  离子键→_→  阅读(13)  评论(3)    收藏  举报