2024初三集训模拟测试3

合集 - 2024寒假集训(10)

1.2024寒假年前集训日记2024-01-29 2.2024初三年前集训测试12024-01-31 3.2024初三年前集训测试22024-02-02 4.2024初三年前集训测试32024-02-05 5.2024寒假自主提升日记2024-02-14 6.2024寒假年后集训日记2024-02-15 7.2024初三集训模拟测试12024-02-18 8.2024初三集训模拟测试22024-02-19

9.2024初三集训模拟测试32024-02-22

10.2024初三集训模拟测试42024-02-22

2024初三集训模拟测试3

$T 1$ 计蒜客 T3726 排序 $0 p t s$

考虑先将 $a$ 数组进行升序排列。然后题意转化为了把 $1 \sim 2 n$ 平均分成 $2$ 组，使得每组乘积之和最小；把 $2 n + 1 \sim 4 n$ 平均分成 $2$ 组，使得每组乘积之和最大。
对于 $x_{1}, x_{2}, x_{3}, x_{4}$ 若存在 $x_{1} < x_{2} < x_{3} < x_{4}$ 则有 $x_{1} x_{2} + x_{3} x_{4} > x_{1} x_{3} + x_{2} x_{4} > x_{1} x_{4} + x_{2} x_{3}$ ,若加上等于号则有 $x_{1} x_{2} + x_{3} x_{4} \geq x_{1} x_{3} + x_{2} x_{4} \geq x_{1} x_{4} + x_{2} x_{3}$ 。
- 其实就是普及模拟2 T2 内积的结论的推广。

故最终 $\sum_{i = 2 n + 1}^{4 n} [i mod 2 = 1] \times x_{i} x_{i + 1} - \sum_{i = 1}^{n} x_{i} x_{2 n - i + 1}$ 即为所求。

点击查看代码

ll a[500001];
int main()
{
    ll n,ans=0,i;
    cin>>n;
    for(i=1;i<=4*n;i++)
    {
        cin>>a[i];
    }
    sort(a+1,a+1+4*n);
    for(i=1;i<=n;i++)
    {
        ans-=a[i]*a[2*n-i+1];
    }
    for(i=2*n+1;i<=4*n;i+=2)
    {
        ans+=a[i]*a[i+1];
    }
    cout<<ans<<endl;
    return 0;
}

设 $f_{i}$ 表示对 $[1, i]$ 完成最小覆盖大小 $\geq m i d$ 的覆盖后的最大总覆盖大小，状态转移方程为 $\begin{array}{r} f_{i} = max (f_{i - 1}, {max}_{j = i - w_{i}}^{i - m i d} {f_{j} + (i - j)}) = max (f_{i - 1}, {max}_{j = i - w [i]}^{i - m i d} {f_{j} - j} + i) \end{array}$ 。暴力进行转移即可。

点击查看代码

int w[600000],f[600000];
bool check(int mid,int n,int m)
{
    int i,j;
    memset(f,0,sizeof(f));
    for(i=1;i<=n;i++)
    {
        f[i]=f[i-1];
        if(i-w[i]>=0)
        {
            for(j=i-w[i];j<=i-mid;j++)
            {
                f[i]=max(f[i],f[j]+(i-j));
            }
        }
    }
    return f[n]>=m;
}
int main()
{
    int n,m,s,l=1,r,mid,i;
    cin>>n;
    for(i=1;i<=n;i++)
    {
        cin>>w[i];
    }
    cin>>s;
    r=m=ceil(1.0*n*s/100);
    while(l<=r)
    {
        mid=(l+r)/2;
        if(check(mid,n,m)==true)
        {
            l=mid+1;
        }
        else
        {
            r=mid-1;
        }
    }
    cout<<r<<endl;
    return 0;
}

正解

由于 $w_{i - 1} \geq w_{i} - 1$ ，故 $(i - 1) - w_{i - 1} \leq i - w_{i}$ ，故当 $i$ 增大时，有 $j$ 的上界增加了 $1$ ,下界减少了 $w_{i - 1} - (w_{i} - 1)$ ，使用单调队列维护即可。

点击查看代码

int w[600000],f[600000];
bool check(int mid,int n,int m)
{
    deque<int>q;
    for(int i=1;i<=n;i++)
    {
        f[i]=f[i-1];
        if(i-mid>=0)
        {
            while(q.empty()==0&&f[q.back()]-q.back()<=f[i-mid]-(i-mid))
            {
                q.pop_back();
            }
            q.push_back(i-mid);
            while(q.empty()==0&&q.front()<=i-w[i]-1)
            {
                q.pop_front();
            }
            if(q.empty()==0)
            {
                f[i]=max(f[i],f[q.front()]-q.front()+i);
            }
        }
    }
    return f[n]>=m;
}
int main()
{
    int n,m,s,l=1,r,mid,i;
    cin>>n;
    for(i=1;i<=n;i++)
    {
        cin>>w[i];
    }
    cin>>s;
    r=n;
    m=ceil(1.0*n*s/100);
    check(1,n,m);
    while(l<=r)
    {
        mid=(l+r)/2;
        if(check(mid,n,m)==true)
        {
            l=mid+1;
        }
        else
        {
            r=mid-1;
        }
    }
    cout<<r<<endl;
    return 0;
}

$T 3$ 计蒜客 T3728 树上的宝藏 $0 p t s$

部分分
- $60 p t s$ ：设 $f_{x, 0}, f_{x, 1}$ 分别表示以 $x$ 为根节点的子树内，不选和选 $x$ 的方案数。状态转移方程为 ${\begin{cases} f_{x, 0} = \prod_{y \in S o n (x)}^{} (f_{y, 0} + f_{y, 1}) \\ f_{x, 1} = \prod_{y \in S o n (x)}^{} f_{y, 0} \end{cases}$ 。对于一条边 $(x, y)$ ，砍断这条边后，进行树形 $D P$ ，此时 $f_{x, 0} f_{y, 1} + f_{x, 1} f_{y, 0} + f_{x, 1} f_{y, 1}$ 即为所求。

正解

发现砍断操作可以用换根 $D P$ 优化。
- 钦定 $1$ 为根节点。
- 第一遍 $D F S$ 时，处理出 $f_{x, 0}, f_{x, 1}$ 。
- 第二遍 $D F S$ 时，进行换根。设 $g_{x, 0}, g_{x, 1}$ 表示以 $x$ 为整棵树的根节点时，不选和选 $x$ 的方案数，仍钦定 $1$ 为根节点。考虑根节点由 $f a_{x}$ 变为 $x (x \neq 1)$ 的过程中，以 $x$ 为根的子树内的节点对答案的贡献不变，要消除以 $x$ 为根的子树内的节点对以 $f a_{x}$ 为根的子树的影响，故状态转移方程为 ${\begin{cases} g_{x, 0} = f_{x, 0} \times (\frac{g_{f a_{x}, 0}}{f_{x, 0} + f_{x, 1}} + \frac{g_{f a_{x}, 1}}{f_{x, 0}}) \\ g_{x, 1} = f_{x, 1} \times \frac{g_{f a_{x}, 0}}{f_{x, 0} + f_{x, 1}} \end{cases}$ 。
对于一条边 $(x, y)$ ，进行分类讨论。
- 若不选 $x$ ，选 $y$ ，则有 $f_{y, 1} \times \frac{g_{x, 0}}{f_{y, 0} + f_{y, 1}}$ 即为所求。
- 若选 $x$ ，不选 $y$ ，则有 $f_{y, 0} \times \frac{g_{x, 1}}{f_{y, 0}} = g_{x, 1}$ 即为所求。
- 若选 $x, y$ ，则有 $f_{y, 1} \times \frac{g_{x, 1}}{f_{y, 0}}$ 即为所求。

点击查看代码

const ll p=998244353;
struct node
{
    ll nxt,to;
}e[700000];
ll head[700000],dep[700000],u[700000],v[700000],g[700000][2],f[700000][2],cnt=0;
void add(ll u,ll v)
{
    cnt++;
    e[cnt].nxt=head[u];
    e[cnt].to=v;
    head[u]=cnt;
}
ll qpow(ll a,ll b,ll p)
{
    ll ans=1;
    while(b>0)
    {
        if(b&1)
        {
            ans=ans*a%p;
        }
        b>>=1;
        a=a*a%p;
    }
    return ans;
}
void dfs(ll x,ll fa)
{
    f[x][0]=f[x][1]=1;
    dep[x]=dep[fa]+1;
    for(ll i=head[x];i!=0;i=e[i].nxt)
    {
        if(e[i].to!=fa)
        {
            dfs(e[i].to,x);
            f[x][0]=f[x][0]*((f[e[i].to][0]+f[e[i].to][1])%p)%p;
            f[x][1]=f[x][1]*f[e[i].to][0]%p;
        }
    }
}
void reroot(ll x,ll fa)
{
    if(x!=1)
    {
        ll f0=g[fa][0]*qpow((f[x][0]+f[x][1])%p,p-2,p)%p,f1=g[fa][1]*qpow(f[x][0],p-2,p)%p;
        g[x][0]=f[x][0]*((f0+f1)%p)%p;
        g[x][1]=f[x][1]*f0%p;
    }
    for(ll i=head[x];i!=0;i=e[i].nxt)
    {
        if(e[i].to!=fa)
        {
            reroot(e[i].to,x);
        }
    }
}
int main()
{
    ll n,sum1,sum2,sum3,i;
    cin>>n;
    for(i=1;i<=n-1;i++)
    {
        cin>>u[i]>>v[i];
        add(u[i],v[i]);
        add(v[i],u[i]);
    }
    dfs(1,0);
    g[1][0]=f[1][0];
    g[1][1]=f[1][1];
    reroot(1,0);
    for(i=1;i<=n-1;i++)
    {
        if(dep[v[i]]<dep[u[i]])
        {
            swap(u[i],v[i]);
        }
        sum1=((f[v[i]][1]*g[u[i]][0])%p)*qpow((f[v[i]][0]+f[v[i]][1])%p,p-2,p)%p;
        sum2=g[u[i]][1];
        sum3=((f[v[i]][1]*g[u[i]][1])%p)*qpow(f[v[i]][0]%p,p-2,p)%p;
        cout<<(((sum1+sum2)%p)+sum3)%p<<endl;
    }
    return 0;
}

$T 4$ 计蒜客 T3729 MEX $0 p t s$

Special Judge ： luogu P4137 Rmq Problem / mex

部分分

$10 p t s$

对于每个区间枚举左右端点，进行暴力求解。

点击查看代码

ll a[5000000],vis[5000000],ans[5000000];
int main()
{
    ll n,m,p,q,l,r,i;
    cin>>n>>m;
    for(i=1;i<=n;i++)
    {
        cin>>a[i];
    }
    for(l=1;l<=n;l++)
    {
        for(r=l;r<=n;r++)
        {
            for(i=l;i<=r;i++)
            {
                vis[a[i]]=1;
            }
            for(i=0;i<=m;i++)
            {
                if(vis[i]==0)
                {
                    ans[i]++;
                    break;
                }
            }
            for(i=0;i<=m;i++)
            {
                vis[i]=0;
            }
        }
    }
    cin>>p>>q;
    for(i=p;i<=q;i++)
    {
        cout<<ans[i]<<" ";
    }
    return 0;
}

$20 p t s$

使用莫队进行统计答案。

点击查看代码

int a[3000010],cnt[3000010],lscnt[3000010],ans[3000010],L[3000010],R[3000010],pos[3000010],klen,ksum;
struct ask
{
    int l,r,id;
}q[3000010];
bool q_cmp(ask a,ask b)
{
    return (pos[a.l]==pos[b.l])?(a.r>b.r):(a.l<b.l);
}
void init(int n,int m)
{
    klen=n/sqrt(m)+1;
    ksum=n/klen;
    for(int i=1;i<=ksum;i++)
    {
        L[i]=R[i-1]+1;
        R[i]=R[i-1]+klen;
    }
    if(R[ksum]<n)
    {
        ksum++;
        L[ksum]=R[ksum-1]+1;
        R[ksum]=n;
    }
    for(int i=1;i<=ksum;i++)
    {
        for(int j=L[i];j<=R[i];j++)
        {
            pos[j]=i;
        }
    }
}
void add(int cnt[],int x)
{
    cnt[a[x]]++;
}
void del(int cnt[],int x,int &sum)
{
    cnt[a[x]]--;
    sum=(cnt[a[x]]==0)?min(sum,a[x]):sum;
}
int main()
{
    int n,mm,m=0,x,y,l=1,r,anss=0,sum=0,tmp=0,lastblock=0,i,j;
    cin>>n>>mm;
    r=n;
    for(i=1;i<=n;i++)
    {
        cin>>a[i];
    }
    for(i=1;i<=n;i++)
    {
        for(j=i;j<=n;j++)
        {
            m++;
            q[m].l=i;
            q[m].r=j;
            q[m].id=m;
        }
    }
    init(n,m);
    sort(q+1,q+1+m,q_cmp);
    for(i=1;i<=n;i++)
    {
        add(cnt,i);
    }
    while(cnt[anss]>=1)
    {
        anss++;
    }
    for(i=1;i<=m;i++)   
    {
        if(pos[q[i].l]==pos[q[i].r])
        {
            sum=0;
            for(j=q[i].l;j<=q[i].r;j++)
            {
                add(lscnt,j);
            }
            while(lscnt[sum]>=1)
            {
                sum++;
            }
            for(j=q[i].l;j<=q[i].r;j++)
            {
                lscnt[a[j]]--;
            }
        }
        else
        {
            if(lastblock!=pos[q[i].l])
            {
                while(r<n)
                {
                    r++;
                    add(cnt,r);
                }
                while(l<L[pos[q[i].l]])
                {
                    del(cnt,l,anss);
                    l++;
                }
                tmp=anss;
                lastblock=pos[q[i].l];
            }
            while(r>q[i].r)
            {
                del(cnt,r,tmp);
                r--;
            }
            sum=tmp;
            while(l<q[i].l)
            {
                del(cnt,l,sum);
                l++;
            }
            while(l>L[pos[q[i].l]])
            {
                l--;
                add(cnt,l);
            }
        }
        ans[sum]++;
    }
    cin>>x>>y;
    for(i=x;i<=y;i++)
    {
        cout<<ans[i]<<" ";
    }
    return 0;
}

$30 p t s$

点击查看 APJifengc 写的题解

正解

点击查看 APJifengc 写的题解

原来的 std

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 5;
int n, m;
int arr[MAXN];
int last[MAXN];
int nxt[MAXN];
long long answer[MAXN];

struct SegmentTree {
    public:
        int min, num;
        long long sum;
        class LazyTag {
            public:
                int cover, tim;
                long long add;
                inline LazyTag() {
                    cover = -1;
                    add = 0;
                    tim = 0;
                }
                inline LazyTag(const int cover):cover(cover) {
                    add=tim=0;// Linux 下会出莫名错误，遂把这句话补上了
                    if (cover == -1) {
                        tim = 1;
                    }
                }
        } tag;
} sgt[MAXN << 2];

inline void PushUp(const int now) {
    sgt[now].min = min(sgt[now << 1].min, sgt[now << 1 | 1].min);
}
void Build(const int now = 1, const int left = 0, const int right = m) {
    if (left == right) {
        sgt[now].num = sgt[now].min = last[left];
        return;
    }
    Build(now << 1, left, (left + right) >> 1);
    Build(now << 1 | 1, ((left + right) >> 1) + 1, right);
    PushUp(now);
}
inline void Down(const SegmentTree::LazyTag tag,
                const int now, const int left, const int right) {
    sgt[now].sum += 1ll * sgt[now].num * tag.tim + tag.add;
    if (~tag.cover) {
        if (~sgt[now].tag.cover) {
            sgt[now].tag.add += 1ll * sgt[now].tag.cover * tag.tim + tag.add;
        } else {
            sgt[now].tag.tim += tag.tim;
            sgt[now].tag.add = tag.add;
        }
        sgt[now].num = sgt[now].min = tag.cover;
        sgt[now].tag.cover = tag.cover;
    } else {
        if (~sgt[now].tag.cover) {
            sgt[now].tag.add += 1ll * sgt[now].tag.cover * tag.tim;
        } else {
            sgt[now].tag.tim += tag.tim;
        }
    }
}
inline void PushDown(const int now, const int left, const int right) {
    Down(sgt[now].tag, now << 1, left, (left + right) >> 1);
    Down(sgt[now].tag, now << 1 | 1, ((left + right) >> 1) + 1, right);
    sgt[now].tag = SegmentTree::LazyTag();
}
void Updata(const int now_left, const int now_right,
            const int cover, const int now = 1,
            const int left = 0, const int right = m) {
    if (now_right < left || right < now_left) {
        return;
    }
    if (now_left <= left && right <= now_right) {
        Down(SegmentTree::LazyTag(cover), now, left, right);
        return;
    }
    PushDown(now, left, right);
    Updata(now_left, now_right, cover, now << 1, left, (left + right) >> 1);
    Updata(now_left, now_right, cover,
        now << 1 | 1, ((left + right) >> 1) + 1, right);
    PushUp(now);
}
inline void Time() {
    Down(SegmentTree::LazyTag(-1), 1, 1, m);
}
int Find(const int now_left, const int now_right,
        const int val, const int now = 1,
        const int left = 0, const int right = m) {
    if (now_right < left || right < now_left || val <= sgt[now].min) {
        return-1;
    }
    if (left == right && now_left <= left && right <= now_right) {
        return left;
    }
    int result(Find(now_left, now_right, val, now << 1 | 1,
                    ((left + right) >> 1) + 1, right));
    return ~result ? result : Find(now_left, now_right,
                                val, now << 1, left, (left + right) >> 1);
}
void GetAnswer(const int now = 1, const int left = 0, const int right = m) {
    if (left == right) {
        answer[left] = sgt[now].sum;
        return;
    }
    PushDown(now, left, right);
    GetAnswer(now << 1, left, (left + right) >> 1);
    GetAnswer(now << 1 | 1, ((left + right) >> 1) + 1, right);
}

int main() {
    scanf("%d%d", &n, &m);
    int last0 = 0;
    long long answer0 = 0;
    for (int i = 1; i <= n; i++) {
        scanf("%d", &arr[i]);
        if (arr[i] == 0) {
            answer0 += (i - last0 - 1ll) * (i - last0) >> 1;
            last0 = i;
        }
    }
    answer0 += (n - last0) * (n + 1ll - last0) >> 1;
    for (int i = 0; i <= m; i++) {
        last[i] = n + 1;
    }
    for (int i = n; i >= 1; i--) {
        nxt[i] = last[arr[i]];
        last[arr[i]] = i;
    }
    for (int i = 1; i <= m - 1; i++) {
        last[i] = max(last[i], last[i - 1]);
    }
    Build();
    for (int i = 1; i <= n; i++) {
        Time();
        int f = Find(arr[i], m, nxt[i]);
        if (~f) {
            Updata(arr[i], f, nxt[i]);
        }
    }
    GetAnswer();
    int l, r;
    scanf("%d%d", &l, &r);
    if (!l) {
        printf("%lld ", answer0);
        l = 1;
    }
    for (int i = l; i <= r; i++) {
        printf("%lld ", answer[i] - answer[i - 1]);
    }
    return 0;
}

点击查看代码

ll a[1000010],ans[1000010],last[1000010],nxt[1000010];
struct SMT
{
    struct SegmentTree
    {
        ll len,minn,sum,hsum,cover,tlazy,hlazy;
    }tree[4000010];
    #define lson(rt) (rt<<1)
    #define rson(rt) (rt<<1|1)
    void pushup(ll rt)
    {
        tree[rt].minn=min(tree[lson(rt)].minn,tree[rson(rt)].minn);
        tree[rt].sum=tree[lson(rt)].sum+tree[rson(rt)].sum;
        tree[rt].hsum=tree[lson(rt)].hsum+tree[rson(rt)].hsum;
    }
    void build(ll rt,ll l,ll r)
    {
        tree[rt].len=r-l+1;
        tree[rt].cover=-1;  tree[rt].tlazy=tree[rt].hlazy=0;
        if(l==r)
        {
            tree[rt].minn=tree[rt].sum=last[l];
            return;
        }
        ll mid=(l+r)/2;
        build(lson(rt),l,mid);  build(rson(rt),mid+1,r);
        pushup(rt);
    }
    void pushlazy(ll rt,ll cover,ll tlazy,ll hlazy)
    {
        tree[rt].hsum+=tree[rt].sum*tlazy+tree[rt].len*hlazy;
        tree[rt].hlazy+=hlazy;
        if(tree[rt].cover==-1)  tree[rt].tlazy+=tlazy;
        else  tree[rt].hlazy+=tree[rt].cover*tlazy;
        if(cover!=-1)
        {
            tree[rt].sum=tree[rt].len*cover;
            tree[rt].minn=tree[rt].cover=cover;
        }
    }
    void pushdown(ll rt)
    {
        pushlazy(lson(rt),tree[rt].cover,tree[rt].tlazy,tree[rt].hlazy);
        pushlazy(rson(rt),tree[rt].cover,tree[rt].tlazy,tree[rt].hlazy);
        tree[rt].cover=-1;  tree[rt].tlazy=tree[rt].hlazy=0;
    }
    void update(ll rt,ll l,ll r,ll x,ll y,ll val)
    {
        if(x<=l&&r<=y)
        {
            pushlazy(rt,val,0,0);
            return;
        }
        pushdown(rt);
        ll mid=(l+r)/2;
        if(x<=mid)  update(lson(rt),l,mid,x,y,val);
        if(y>mid)  update(rson(rt),mid+1,r,x,y,val);
        pushup(rt);
    }
    ll query(ll rt,ll l,ll r,ll x,ll y,ll val)
    {
        if(y<l||r<x||val<=tree[rt].minn)  return -1;
        if(x<=l&&r<=y&&l==r)  return l;
        ll mid=(l+r)/2,pos=query(rson(rt),mid+1,r,x,y,val);
        return (pos==-1)?query(lson(rt),l,mid,x,y,val):pos;
    }
    void ask(ll rt,ll l,ll r)
    {
        if(l==r)  
        {
            ans[l]=tree[rt].hsum;
            return;
        }
        pushdown(rt);
        ll mid=(l+r)/2;
        ask(lson(rt),l,mid);  ask(rson(rt),mid+1,r);
    }
}T;
int main()
{
// #define Isaac
#ifdef Isaac
    freopen("in.in","r",stdin);
    freopen("out.out","w",stdout);
#endif
    ll n,m,l,r,_ans=0,_last=0,pos,i;
    scanf("%lld%lld",&n,&m);
    for(i=1;i<=n;i++)
    {
        scanf("%lld",&a[i]);
        if(a[i]==0)
        {
            _ans+=(i-_last-1)*(i-_last)/2;  _last=i;
        }
    }
    scanf("%lld%lld",&l,&r);
    _ans+=(n-_last)*(n+1-_last)/2;
    for(i=0;i<=m;i++)  last[i]=n+1;
    for(i=n;i>=1;i--)
    {
        nxt[i]=last[a[i]];  last[a[i]]=i;
    }
    for(i=1;i<=m-1;i++)  last[i]=max(last[i],last[i-1]);
    T.build(1,0,m);
    for(i=1;i<=n;i++)
    {
        T.pushlazy(1,-1,1,0);
        pos=T.query(1,0,m,a[i],m,nxt[i]);
        if(pos!=-1)  T.update(1,0,m,a[i],pos,nxt[i]);
    }
    T.ask(1,0,m);
    if(l==0)
    {
        printf("%lld ",_ans);
        l=1;
    }
    for(i=l;i<=r;i++)  printf("%lld ",ans[i]-ans[i-1]);
    return 0;
}

总结

$T 1$ 场上结论没有猜出来，导致心态炸了。
$T 2$ 场上只看出来了二分答案，没有再接着去想，而且貌似还读错题了。
$T 3$ 场上读假题了。
$T 4$ 场上部分分没打，亏了。

posted @ 2024-02-22 07:00 hzoi_Shadow 阅读(50) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 2024初三集训模拟测试2

· 2024初三集训模拟测试4

· 2024初三集训模拟测试2

· 2024初三年后集训模拟测试3

公告

昵称： hzoi_Shadow
园龄： 1年9个月
粉丝： 100
关注： 181

+加关注

2025年3月

日

一

二

三

四

五

六

随笔分类 (336)

随笔档案 (336)

文章档案 (1)

2025年2月(1)

hzoi_Shadow

世上只有一种英雄主义，就是认清生活的真相后，依然热爱生活。纵使世界万般残酷，总有温暖值得守护……

2024初三集训模拟测试3

2024初三集训模拟测试3

$T 1$ 计蒜客 T3726 排序 $0 p t s$

$T 2$ 计蒜客 T3727 牛吃草 $0 p t s$

$T 3$ 计蒜客 T3728 树上的宝藏 $0 p t s$

$T 4$ 计蒜客 T3729 MEX $0 p t s$

总结

公告

搜索

常用链接

最新随笔

我的标签

积分与排名

合集 (25)

随笔分类 (336)

随笔档案 (336)

文章档案 (1)

阅读排行榜

评论排行榜

推荐排行榜

最新评论

世上只有一种英雄主义，就是认清生活的真相后，依然热爱生活。 纵使世界万般残酷，总有温暖值得守护……

T1 计蒜客 T3726 排序 0pts

T2 计蒜客 T3727 牛吃草 0pts

T3 计蒜客 T3728 树上的宝藏 0pts

T4 计蒜客 T3729 MEX 0pts

总结

公告

搜索

常用链接

最新随笔

积分与排名

合集 (25)

随笔分类 (336)

随笔档案 (336)

文章档案 (1)

世上只有一种英雄主义，就是认清生活的真相后，依然热爱生活。纵使世界万般残酷，总有温暖值得守护……

$T 1$ 计蒜客 T3726 排序 $0 p t s$

$T 2$ 计蒜客 T3727 牛吃草 $0 p t s$

$T 3$ 计蒜客 T3728 树上的宝藏 $0 p t s$

$T 4$ 计蒜客 T3729 MEX $0 p t s$