Codeforces 部分题目题解（口胡）

最新推荐文章于 2024-08-07 20:24:17 发布
最新推荐文章于 2024-08-07 20:24:17 发布
阅读量1k 收藏 1
点赞数
分类专栏： 杂文
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KsCla/article/details/78852164
版权

883D

题面

题目大意：给你一个长度为n的字符串，上面有牛(“P”)，草(“*”)和空地(“.”)。现在你给每一头牛规定一个方向，它会一直往前吃草，直到走到边界。每一份草只会被吃1次，要求输出最多吃多少草，以及在此基础下吃完最后一份草的最小时间。n<=1000000。

做法：很明显两头牛就可以吃完所有草，于是暴力处理0,1头牛的情况。然后由于具有单调性，考虑二分答案后贪心（时限3s不虚）。接下来证明两个小结论：

1.最前面的草，顶多会被它后面第二头牛吃掉。
这个从上图就可以看出。①中红色和蓝色的边分别比②中红色和蓝色的边长。

2.二分完阀值mid后，如果最前面的草后面mid处至少有两头牛，且第一头牛与第二头牛之间没有草，那么让第一头牛吃该草，第二头牛往后吃。
这个结论应该很显然……
但是如果两头牛中间有草怎么办呢？是不是让第二头牛往前吃，第一头牛往后吃就最优了？答案是否定的。我一开始按照这个思路写了个贪心，结果被下面这组数据卡掉了：
19
∗∗P.∗..∗..P..∗.∗P∗∗
（这组数据的最优方案应该是让第一，三头牛往前吃，第二头牛往后吃）
所以我们要用DP！记f[i]=j表示考虑完第i头牛之后，最多能处理完1~j处的草。然后根据上述思路用f[i-2]或f[i-1]转移即可。
我一开始把时限看成了1s，结果想了很久都想不出O(n)的做法QAQ

CODE：

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<stdio.h>
#include<algorithm>
using namespace std;

const int maxn=1000100;

int sum[maxn];
int f[maxn];
int id[maxn];

char s[maxn];
int a[maxn];

int n;
int cnt=0,num=0;

bool Judge(int x)
{
    f[0]=0;
    for (int i=1; i<=num; i++)
    {
        f[i]=0;
        int y=id[i];
        if (f[i-1]>=y-1) f[i]=max(f[i],y+x);
        if (f[i-1]<y-1)
            if (sum[y]-sum[ f[i-1] ])
                if (sum[max(0,y-x-1)]-sum[ f[i-1] ]>0) return false;
                else
                {
                    f[i]=max(f[i],y);
                    if ( i>=2 && sum[max(0,y-x-1)]-sum[ f[i-2] ]<=0 )
                        f[i]=max(f[i],id[i-1]+x);
                }
            else f[i]=max(f[i],y+x);
    }
    if ( f[num]>=n ||  sum[n]-sum[ f[num] ]<=0 ) return true;
    return false;
}

int Binary()
{
    int L=0,R=n;
    while (L+1<R)
    {
        int mid=(L+R)>>1;
        if ( Judge(mid) ) R=mid;
        else L=mid;
    }
    return R;
}

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

    scanf("%d",&n);
    scanf("%s",s);
    for (int i=1; i<=n; i++)
    {
        if (s[i-1]=='*') a[i]=0,cnt++;
        if (s[i-1]=='P') a[i]=1,id[++num]=i;
        if (s[i-1]=='.') a[i]=2;
    }
    if (num<=1)
        if (num==0) printf("0 0\n");
        else
        {
            int x=0,y=0;
            for (int i=1; i<=n; i++)
                if (a[i]==1) x=i;
            for (int i=1; i<=x; i++)
                if (a[i]==0) y++;

            int Le=0,Ri=0;
            for (int i=x; i>=1; i--)
                if (a[i]==0) Le=x-i;
            for (int i=x; i<=n; i++)
                if (a[i]==0) Ri=i-x;

            if (y>cnt-y) printf("%d %d\n",y,Le);
            else
                if (y<cnt-y) printf("%d %d\n",cnt-y,Ri);
                else
                    if (Le<Ri) printf("%d %d\n",y,Le);
                    else printf("%d %d\n",cnt-y,Ri);
        }
    else
    {
        sum[0]=0;
        for (int i=1; i<=n; i++)
        {
            sum[i]=sum[i-1];
            if (a[i]==0) sum[i]++;
        }
        int ans=Binary();
        printf("%d %d\n",cnt,ans);
    }

    return 0;
}

875E

题面

题目大意：有n个城市，给出它们在数轴上的坐标。现在有两个人在s1和s2处，他们要按顺序走完这n个城市，求他们两个人最大距离的最小值。n<=100000。

做法：分析之后发现，它就是要你把这n个城市分成若干段，使得每一段的所有城市到上一段的最后一个城市的距离小于等于ans。二分答案之后用treap维护即可，时间复杂度 O(nlog2(n)) 。
然而这样做会被卡常（虽然CF的机子跑得灰常快）。
更优的方法是从后往前考虑。如果第n-1个城市在[a[n]-mid,a[n]+mid]的范围内，就可以无视掉第n个城市；否则就要求第n-2个城市在[a[n]-mid,a[n]+mid]与[a[n-1]-mid,a[n-1]+mid]的交集内，不存在则无解。这样时间就是 O(nlog(n)) 。

CODE（Treap）：

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<stdio.h>
#include<algorithm>
using namespace std;

const int maxn=100100;
const int oo=2000001000;

const long long M1=998244353;
const long long M2=1000000007;
const long long M3=1333333331;
typedef long long LL;
LL seed;

struct Tnode
{
    int val,id,min_id,fix;
    Tnode *lson,*rson;
} tree[maxn];
Tnode *Root;
int cur;

int Right[maxn];
int a[maxn];
int n,s1,s2;

int Rand()
{
    seed=(seed*M1+M2)%M3;
    return seed;
}

Tnode *New_node(int Val,int Id)
{
    cur++;
    tree[cur].val=Val;
    tree[cur].min_id=tree[cur].id=Id;
    tree[cur].fix=Rand();
    tree[cur].lson=tree[cur].rson=NULL;
    return tree+cur;
}

void Recount(Tnode *P)
{
    P->min_id=P->id;
    if (P->lson) P->min_id=min(P->min_id,P->lson->min_id);
    if (P->rson) P->min_id=min(P->min_id,P->rson->min_id);
}

void Right_turn(Tnode *&P)
{
    Tnode *W=P->lson;
    P->lson=W->rson;
    W->rson=P;
    P=W;
    Recount(P->rson);
    Recount(P);
}

void Left_turn(Tnode *&P)
{
    Tnode *W=P->rson;
    P->rson=W->lson;
    W->lson=P;
    P=W;
    Recount(P->lson);
    Recount(P);
}

void Insert(Tnode *&P,int Val,int Id)
{
    if (!P) P=New_node(Val,Id);
    else
        if ( Val<P->val || ( Val==P->val && Id<P->id ) )
        {
            Insert(P->lson,Val,Id);
            if ( P->lson->fix < P->fix ) Right_turn(P);
            else Recount(P);
        }
        else
        {
            Insert(P->rson,Val,Id);
            if ( P->rson->fix < P->fix ) Left_turn(P);
            else Recount(P);
        }
}

int Find_succ(Tnode *P,int Val,int Ans)
{
    if (!P) return Ans;
    if (Val<P->val)
    {
        Ans=min(Ans,P->id);
        if (P->rson) Ans=min(Ans,P->rson->min_id);
        return Find_succ(P->lson,Val,Ans);
    }
    return Find_succ(P->rson,Val,Ans);
}

int Find_prev(Tnode *P,int Val,int Ans)
{
    if (!P) return Ans;
    if (P->val<Val)
    {
        Ans=min(Ans,P->id);
        if (P->lson) Ans=min(Ans,P->lson->min_id);
        return Find_prev(P->rson,Val,Ans);
    }
    return Find_prev(P->lson,Val,Ans);
}

bool Judge(int x)
{
    Root=NULL;
    cur=-1;
    Insert(Root,-oo,n+1);
    Insert(Root,oo,n+1);
    for (int i=n; i>=1; i--)
    {
        int Succ=Find_succ(Root,a[i]+x,n+1);
        int Prev=Find_prev(Root,a[i]-x,n+1);
        Right[i]=min(Prev,Succ)-1;
        Insert(Root,a[i],i);
    }
    int now=0;
    int Succ=Find_succ(Root,s1+x,n+1);
    int Prev=Find_prev(Root,s1-x,n+1);
    now=max(now, min(Prev,Succ)-1 );
    Succ=Find_succ(Root,s2+x,n+1);
    Prev=Find_prev(Root,s2-x,n+1);
    now=max(now, min(Prev,Succ)-1 );
    for (int i=1; i<=n; i++)
    {
        if (i>now) return false;
        now=max(now,Right[i]);
    }
    return true;
}

int Binary()
{
    int L=0,R=1000000000;
    while (L+1<R)
    {
        int mid=(L+R)>>1;
        if ( Judge(mid) ) R=mid;
        else L=mid;
    }
    return R;
}

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

    scanf("%d%d%d",&n,&s1,&s2);
    seed=n;
    for (int i=1; i<=n; i++) scanf("%d",&a[i]);
    int ans=Binary();
    ans=max(ans, max(s1-s2,s2-s1) );
    printf("%d\n",ans);

    return 0;
}

CODE（区间交）：

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<stdio.h>
#include<algorithm>
using namespace std;

const int maxn=100100;

int a[maxn];
int n,s1,s2;

bool Judge(int x)
{
    int L=a[n]-x,R=a[n]+x;
    for (int i=n-1; i>=1; i--)
    {
        if ( L<=a[i] && a[i]<=R ) L=a[i]-x,R=a[i]+x;
        else
        {
            L=max(L,a[i]-x);
            R=min(R,a[i]+x);
            if (L>R) return false;
        }
    }
    if ( L<=s1 && s1<=R ) return true;
    if ( L<=s2 && s2<=R ) return true;
    return false;
}

int Binary()
{
    int L=0,R=1000000000;
    while (L+1<R)
    {
        int mid=(L+R)>>1;
        if ( Judge(mid) ) R=mid;
        else L=mid;
    }
    return R;
}

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

    scanf("%d%d%d",&n,&s1,&s2);
    for (int i=1; i<=n; i++) scanf("%d",&a[i]);
    int ans=Binary();
    ans=max(ans, max(s1-s2,s2-s1) );
    printf("%d\n",ans);

    return 0;
}

875F

题面

题目大意：给出m个三元组(a,b,c)，表示如果该组选择了a或b两个数中的一个，你就会获得c的报酬。每个数顶多属于一个组，每个组顶多选择一个数。要求最大化报酬和。a,b<=n，n,m<=200000。

做法：这就是道典型的二分图匹配嘛
将所有三元组按c从大到小排序，然后按顺序处理。对于第i个三元组，先查看ai和bi是否在同一个集合，是的话再看这个集合是否已经有一个环，有环则选不了；不在一个集合，就看两个集合是否都有环，都有环则选不了，否则获得c的贡献，然后合并ai和bi所在集合。时间复杂度为 O(nα(n)) 。

（代码因特殊原因不贴出）。
lhxQAQ老贼丧天良，我与珂朵莉共存亡！！！

891C

题面

题目大意：先给出一幅n个点，m条边的图（边按输入顺序编号）。然后有q个询问，每次询问给出数字k，再给出k条边的编号，问这k条边能不能同时存在于这幅图的最小生成树上。可以则输出”YES”，否则输出”NO”（均不含引号）。 n,m,q,∑k<=5∗105 。

做法：一开始写了个树上倍增，想着随便构一棵最小生成树，然后看路径最大值是否等于当前边权就可以了。然而这样连样例都过不了，因为同一个询问的边有可能相互冲突……
正确的方法是将所有边离线，按权值从小到大排序，权值相同则按所在询问的编号从小到大。要知道属于第i个询问，权值为val的边是否能存在于最小生成树上，就要将权值为1~val-1的边加进并查集里，并将其它权值为val的，属于第i个询问的边加进并查集，然后看两点是否连通。如果下一条边和当前边权值相同但不属于同一个询问，为了保证正确性，需要将权值为val的，属于第i个询问的边先退出并查集。时间复杂度 O(nlog(n)) 。

CODE：

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<stdio.h>
#include<algorithm>
using namespace std;

const int maxn=500100;

struct edge
{
    int u,v,w;
} e[maxn];

struct data
{
    int a,b,val,id;
} ask[maxn];
int cur=0;

int fa[maxn];
int Size[maxn];

int sak[maxn];
int tail=0;

bool ans[maxn];
int n,m,q;

bool Comp1(edge x,edge y)
{
    return x.w<y.w;
}

bool Comp2(data x,data y)
{
    return x.val<y.val || ( x.val==y.val && x.id<y.id );
}

int Find(int x)
{
    if (fa[x]==x) return x;
    return Find(fa[x]);
}

void Add(int x,int y)
{
    x=Find(x);
    y=Find(y);
    if (x==y) return;
    if (Size[x]<Size[y]) swap(x,y);
    fa[y]=x;
    Size[x]+=Size[y];
}

void Clear()
{
    while (tail)
    {
        int x=sak[tail];
        Size[ fa[x] ]-=Size[x];
        fa[x]=x;
        tail--;
    }
}

void Push(int x,int y)
{
    if (Size[x]<Size[y]) swap(x,y);
    fa[y]=x;
    Size[x]+=Size[y];
    sak[++tail]=y;
}

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

    scanf("%d%d",&n,&m);
    for (int i=1; i<=m; i++) scanf("%d%d%d",&e[i].u,&e[i].v,&e[i].w);
    scanf("%d",&q);
    for (int i=1; i<=q; i++)
    {
        int k;
        scanf("%d",&k);
        for (int j=1; j<=k; j++)
        {
            int x;
            scanf("%d",&x);
            cur++;
            ask[cur].a=e[x].u;
            ask[cur].b=e[x].v;
            ask[cur].val=e[x].w;
            ask[cur].id=i;
        }
        ans[i]=1;
    }

    sort(e+1,e+m+1,Comp1);
    sort(ask+1,ask+cur+1,Comp2);
    for (int i=1; i<=n; i++) fa[i]=i,Size[i]=1;
    int h1=1,h2=1;
    while (h2<=cur)
    {
        Clear();
        while ( e[h1].w<ask[h2].val && h1<=m ) Add(e[h1].u,e[h1].v),h1++;
        int t2=h2;
        while ( t2<=cur && ask[t2].val==ask[h2].val )
        {
            if (ask[t2].id!=ask[t2-1].id) Clear();
            int x=Find(ask[t2].a);
            int y=Find(ask[t2].b);
            if (x==y) ans[ ask[t2].id ]=0;
            else Push(x,y);
            t2++;
        }
        h2=t2;
    }
    for (int i=1; i<=q; i++)
        if (ans[i]) printf("YES\n");
        else printf("NO\n");

    return 0;
}

891B

题面

题目大意：给出一个长度为n的序列a，它有 2n−2 个非空真子集。现要求将a中的数打乱，构造出序列b，使得b的这些子集的对应位置之和与a的对应位置之和都不等。n<=22。a中的数互不相同。

做法：一道有点脑洞的构造题。
将a中的数从小到大排序，然后全体右移一位，最小的数变成最大。这样不包含原先最小数的集合，每个的和都变小了；包含了原先最小数的集合，考虑其补集，补集的和一定变小，所以该集合之和一定变大。

CODE：

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<stdio.h>
#include<algorithm>
using namespace std;

const int maxn=30;

struct data
{
    int val,id;
} a[maxn];
int n;

bool Comp1(data x,data y)
{
    return x.val<y.val;
}

bool Comp2(data x,data y)
{
    return x.id<y.id;
}

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

    scanf("%d",&n);
    for (int i=1; i<=n; i++) scanf("%d",&a[i].val),a[i].id=i;
    sort(a+1,a+n+1,Comp1);
    a[n+1].val=a[1].val;
    for (int i=1; i<=n; i++) a[i].val=a[i+1].val;
    sort(a+1,a+n+1,Comp2);
    for (int i=1; i<=n; i++) printf("%d ",a[i]);
    printf("\n");

    return 0;
}

883B

题面

题目大意：有n名军人，军衔等级从低到高为1到k中的整数。给你m对关系(xi,yi)，表示要满足军人xi的军衔高于军人yi的军衔。已知其中一些军人的军衔，求出任意一种所有军人可能的军衔的方案，并且每种军衔都至少存在一名军人，如无法满足条件输出“-1”。一开始给定数组r，r[i]不为0表示已知第i位军人的军衔为r[i]。 n,m,k<=2∗105 。

做法：一开始想错了贪心，导致WA了好多发，最后看了DLee大佬的代码才明白。
先将大小关系构出一个图，如果有环则无解。然后正反向拓扑一遍就可以知道每一个人军衔的下限Min与上限Max。现在的问题就变成了如何用这些区间覆盖1~k。我们从小到大考虑下限。假设当前做到i，则用一个堆维护所有Min<=i的区间的Max，每一次取出一个Max最小的来覆盖i。但如果堆里最小的Max都等于i，则令其答案一定要等于i。
接下来我们发现一个点的答案确定了之后，它所到达的点的Min会改变（变为当前点的答案+1）。于是干脆一开始先不要算出Min，边做边算，用一个链表存Min为某个值的人有哪些即可。

CODE：

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<stdio.h>
#include<algorithm>
using namespace std;

const int maxn=200100;

struct edge
{
    int obj;
    edge *Next;
} e[maxn*3];
edge *head[maxn];
edge *nhead[maxn];
int cur=-1;

int Heap[maxn];
int tail=0;

int Min[maxn];
int Max[maxn];
int ans[maxn];

int pin[maxn];
int pout[maxn];

int vis[maxn];
int que[maxn];
int he,ta;

int r[maxn];
int n,m,k;

void Add(edge **Head,int x,int y)
{
    cur++;
    e[cur].obj=y;
    e[cur].Next=Head[x];
    Head[x]=e+cur;
}

void Dfs(int node)
{
    vis[node]=1;
    for (edge *p=head[node]; p; p=p->Next)
    {
        int to=p->obj;
        if (vis[to]==1)
        {
            printf("-1\n");
            exit(0);
        }
        if (!vis[to]) Dfs(to);
    }
    vis[node]=2;
}

void Calc_Max()
{
    he=0,ta=1;
    for (int i=1; i<=n; i++)
    {
        Max[i]=k;
        if (!pout[i]) que[++ta]=i;
        if (r[i]) Max[i]=r[i];
    }
    while (he<ta)
    {
        int node=que[++he];
        for (edge *p=nhead[node]; p; p=p->Next)
        {
            int to=p->obj;
            Max[to]=min(Max[to],Max[node]-1);
            pout[to]--;
            if (!pout[to])
            {
                que[++ta]=to;
                if ( r[to]>Max[to] && r[to] )
                {
                    printf("-1\n");
                    exit(0);
                }
                if (r[to]) Max[to]=r[to];
            }
        }
    }
}

void Insert(int x)
{
    Heap[++tail]=x;
    x=tail;
    while (x>1)
    {
        int y=x>>1;
        if ( Max[ Heap[y] ]<Max[ Heap[x] ] ) break;
        swap(Heap[x],Heap[y]);
        x=y;
    }
}

int Delete()
{
    int temp=Heap[1];
    Heap[1]=Heap[tail];
    tail--;
    int x=1;
    while (1)
    {
        int y=x,Left=x<<1,Right=Left|1;
        if ( Left<=tail && Max[ Heap[Left] ]<Max[ Heap[y] ] ) y=Left;
        if ( Right<=tail && Max[ Heap[Right] ]<Max[ Heap[y] ] ) y=Right;
        if (x==y) break;
        swap(Heap[x],Heap[y]);
        x=y;
    }
    return temp;
}

void Update(int node)
{
    for (edge *p=head[node]; p; p=p->Next)
    {
        int to=p->obj;
        pin[to]--;
        Min[to]=max(Min[to],ans[node]+1);
        if (!pin[to])
        {
            if ( r[to]<Min[to] && r[to] )
            {
                printf("-1\n");
                exit(0);
            }
            if (r[to]) Min[to]=r[to];
            Add(nhead,Min[to],to);
        }
    }
}

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

    scanf("%d%d%d",&n,&m,&k);
    for (int i=1; i<=n; i++) scanf("%d",&r[i]),head[i]=nhead[i]=NULL;
    for (int i=1; i<=m; i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        Add(head,y,x);
        pin[x]++;
        pout[y]++;
        Add(nhead,x,y);
    }

    for (int i=1; i<=n; i++)
        if (!vis[i]) Dfs(i);
    Calc_Max();
    for (int i=1; i<=n; i++)
        if (Max[i]<1)
        {
            printf("-1\n");
            return 0;
        }

    for (int i=1; i<=k; i++) nhead[i]=NULL;
    for (int i=1; i<=n; i++)
        if (!pin[i])
        {
            Min[i]=1;
            if (r[i]) Min[i]=r[i];
            Add(nhead,Min[i],i);
        }
    for (int i=1; i<=k; i++)
    {
        for (edge *p=nhead[i]; p; p=p->Next) Insert(p->obj);
        if (!tail)
        {
            printf("-1\n");
            return 0;
        }
        int x=Delete();
        ans[x]=i;
        Update(x);
        while ( tail && Max[ Heap[1] ]==i )
            x=Delete(),ans[x]=i,Update(x);
    }
    for (int i=1; i<=n; i++)
        if (!ans[i])
        {
            printf("-1\n");
            return 0;
        }

    for (int i=1; i<=n; i++) printf("%d ",ans[i]);
    printf("\n");

    return 0;
}

（持续待更）

KsCla
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Codeforces 题解 （不断更新，一起上分）
DeathYmz的博客
08-02 2248
目录 Educational Codeforces Round 45 (Rated for Div. 2) Educational Codeforces Round 45 (Rated for Div. 2) 题目：A. Commentary Boxes题解 题目：B Micro-World 题解 题目：C Bracket Sequences Concatenation Problem 题解 题目：D Graph And Its Complement 题解 题目：E Po...
Codeforces 题目集锦
weixin_55355427的博客
10-27 959
我的CF账号：guozexin 如果题解有哪些疑惑的地方，可以直接在CF上找我的代码查看细节 1601A 这道题目乍一看很花哨，但和位运算有关的题目，手玩一下就可以把原题的操作换作一个很简单的操作。 本题中其实就是在同一位上选择k个1，使这k个1都变成0，若要使一位上的1都变成0，那这一位上1的个数需是k的倍数，所以我们对每一位上的1的个数取gcd，得到k，若k成立，则k的因数也一定成立，输出k的所有因数即可 1601B※ 青蛙爬井问题 在初学OI时也有一道这样的青蛙爬井的题目，当时a和b都是固定的，推出数
Codeforces题目泛做解题报告许昊然.pdf
05-21
来自2012，2013年国际信息奥林匹克金牌得主许昊然
codeforces 题解
忘梦心的博客
01-10 1283
1285A Mezo Playing Zoma 查看题解 字符串 1285B Just Eat It! 查看题解 最大连续子序列 1285C Fadi and LCM 查看题解 数论 1285D Dr. Evil Underscores 查看题解 dfs+位运算 ...
codeforces查看题解
最新发布
m0_62024160的博客
08-07 273
文章目录1. 步骤一：右键单击箭头指向位置，根据提示打开链接2. 步骤二：左键单击箭头指向位置3. 结果：红线上方是参考代码，下方是测试样例4. 补充：① 右边这个方框可以筛选想要查看代码的状态(Accepted、Wrong answer等)以及提交的语言② 下方这一栏可以按运行时间(或者内存损耗等)对代码进行排序 1. 步骤一：右键单击箭头指向位置，根据提示打开链接 2. 步骤二：左键单击箭头指向位置 3. 结果：红线上方是参考代码，下方是测试样例 4. 补充： ① 右边这个方框可以筛选想要查看代码
Codeforces 884 简要题解
weixin_30496431的博客
03-16 192
文章目录A题B题C题D题E题F题 传送门 A题 传送门 题意简述： 一个人要完成一件事总共需要ttt秒，现在有nnn天，每天有aia_iai​不能做事，问他可以在第几天做完。 思路：按照题意模拟。 代码： #include<bits/stdc++.h> #define ri register int using namespace st...
每日一题：codeforces题解(Peculiar Movie Preferences)
qq_52598198的博客
02-11 476
题目 B. Peculiar Movie Preferences time limit per test 2 seconds memory limit per test 512 megabytes input standard input output standard output Mihai plans to watch a movie. He only likes palindromic movies, so he wants to skip some (possibly zero) scenes t
这道题codeforces的简单题差点做了我一下午，你能解出来吗？
TechFlow的博客
09-30 819
大家好，今天周末算法专题选的问题是codeforces contest1400中的B题，RPG Protagonist，翻译过来就是RPG游戏当中主人公。看起来这个标题就很唬人，其实这也是codeforces的题目风格。 这道题的链接是：https://codeforces.com/contest/1400/problem/B 按照道理来说div2比赛当中的B题都不难，大概和LeetCode当中的Easy差不多，有时候要简单一些，有时候要难一些。一般来说属于大部分人都能做出来的题。但今天选的这道题有一点意外
leetcode题库-Coding.Python:基于Python的Leetcode、Codeforces部分题解和数据结构、算法专题
06-29
leetcode题库 简介 本库记录我基于python写过的开源程序。...基于python实现的OJ上的一些题目汇总。 () () () () () () 基于python的专题实现: (10种排序算法) (0-1背包, 完全背包, 多重背包，分组背包等) 拓扑排序
Codeforces 25E Test 题解
CMC_YXY的博客
12-17 344
字符串哈希习题
codeforces竞赛1141题解
爱玲姐姐的博客
05-22 1422
竞赛链接：http://codeforces.com/contest/1141 A. Game 23 题目大意： 对于两个数n,m,求n通过乘2或者乘3变成m所需要的次数。无解输出-1. 例如120 51840需要7次变换。 解题思路： 如果m%n不等于0，则无解。 如果n>m,则无解。 那么n到达m需要乘的步长为p = m / n，这个如果这个p能被2 3全部整除，则说明有解，否则无解。 ...
Codeforces 1110 简要题解
苟为蒟蒻又何妨
02-08 650
文章目录A题B题C题D题E题F题G题 传送门 众所周知ldxoildxoildxoi这种菜鸡选手是不会写HHH题的，因此该篇博客只有AAA题至GGG题的题解，实在抱歉。 A题 传送门 题意简述：给出b,kb,kb,k和a1,a2,...,aka_1,a_2,...,a_ka1​,a2​,...,ak​问bk−1a1+bk−2a2+...+akb^{k-1}a_1+b^{k-2}a_2+...+a_...
Codeforces #635题解
huayucaiji的博客
04-18 272
Codeforces round 635赛后解题报告 A. Ichihime and Triangle 首先这是一道几何题 那么我们知道，在此题中，x,y,zx,y,zx,y,z 满足 x≤y≤z,x+y>zx\leq y\leq z,x+y>zx≤y≤z,x+y>z。这是三角形三边的关系，很好理解。那么我们对这样一道构造题，又是在第一题，一定没什么难度。我们想是否能用 a,b,...
Codeforce题解：Shurikens
S__ph的博客
10-27 482
Codeforce 1413 D Shurikens 忍者买手里剑
codeforces #1 题解
知与谁i的博客
11-07 344
codeforces1A 题目链接：http://codeforces.com/problemset/problem/1/A 题意：给定一个n*m的矩形，然后给一个a*a的地板，求最少需要多少地板可以铺满这个矩形（不可以割断，可以重叠） 思路：做除法上取整，然后结果相乘即可，（注意相乘的结果用long long 保存） 【知识点】int数据范围 #include using names
Codeforces(1500题目汇总)
weixin_61426225的博客
02-21 628
开始板刷1500了，主要是最近卡1300-1400上不去，发现cf很多思维题要不是想不到，要不就是签的慢，被读题卡了心态就巨难受，一下就不想写了，而且现在学知识点容易陷入递归，学到一个知识点发现需要用其他知识点，然后又去学其他知识点，然后学完还需要对这些一堆知识点做题练习不然只会板子根本没有什么对算法深刻的理解。感觉不如这样去板刷，遇到不会的只学这个不去学太多，在题目中理解知识点应该比单纯泛泛去学可能效果会更好。也记录一下，自己1500刷多少，才能有提升。
【Codeforces 956D】Contact ATC 题解
蒟
05-27 489
题面：传送门 &nbsp;&nbsp;&nbsp;&nbsp;这场比赛我没现场打，只是闲得没事就Virtual Participate了一发。我怎么又开始随便找题做了？（雾 &nbsp;&nbsp;&nbsp;&nbsp;一看前3题都是普及组难度，我激动极了，哗啦哗啦全写完了（但是第3题还wa了一次，调了半天，可能我还是太弱了）。 &nbsp;&nbsp;&nbsp;&nbsp;看到了D...
Codeforce 1344A Hilbert s Hotel 题解
Brian_Pan_的博客
05-15 257
题目链接 题目大意 有一条数轴，在它的每个整数位置上有一个人 现在对于所有整数 kkk，位置 kkk 上的人会移动到位置 k+akmod  nk+a_{k \mod n}k+akmodn​ 问在所有人移动一次后，是否每个位置上都恰好有一个人 解题思路 我们可以把这题当成图论来做 对于每一个人的移动操作，我们把它视为一条有向边 [k,k+akmod  n][k,k+a_{k \mod n}][k,k+akmodn​] 注意，我么需要把每条边的起点与终点 mod  n\mod nmodn，使得 aaa 中的每一
Codeforces 中文题解（持续更新）
TGX的博客
01-30 2335
Codeforces近期比赛中文题解
程序算法题解大全：洛谷与CF经典题目详解
这份文档涵盖了多种编程竞赛平台（如Codeforces和洛谷）上的经典题目，包括CF1294F、CF1632E1/E2、CF1646D等，涉及到的问题类型广泛，如数据结构（如树、字符串）、动态规划、图论等。其中，CF1294F题解展示了如何...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值