CF#534 Div2

本来都是挺简单的题，D和E都做过类似的题目，但是发挥还是不太理想

怎么说呢 感觉还是熟能生巧吧 希望自己能在寒假的比赛中有一个稳定的发挥吧

菜是原罪

 

A. Splitting into digits

 

#include <iostream>
#include <cstdio>
using namespace std;
int n;
int main() {
    scanf("%d",&n);
    printf("%d\n",n);
    for (int i=1;i<n;i++) printf("1 ");
    printf("1\n");
    return 0;
}

 

B.Game with string

 

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int L=100010;
int top,cnt;
char str[L];
int stk[L];
int main() {
    scanf("%s",str);
    int len=strlen(str);
    for (int i=0;i<len;i++) {
        if (!top||stk[top]!=str[i])
            stk[++top]=str[i];
        else
            cnt++,top--;
    }
    if (cnt&1) printf("Yes\n");
    else printf("No\n");
    return 0;
}

 

C.Grid game

 

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int L=1001;
char str[L]; int f1,f2;
int main() {
    scanf("%s",str);
    int len=strlen(str);
    for (int i=0;i<len;i++) {
        if (str[i]=='0') {
            if (!f1) f1=1,printf("1 1\n");
            else f1=0,printf("3 1\n");
        }
        else {
            f2++,printf("%d 2\n",f2);
            if (f2==4) f2=0;
        }
    }
    return 0;
}

 

D.Game with modulo

看到这个询问次数就想到了二分，但是如何二分呢

一开始将方向放在了质因数分解上面，想了大概二十分钟觉得一定不可行后换方向

考虑先排除模数是$2^{n}$的形式

这样每次查询$2^{n}$和$2^{n+1}$的结果就能得到模数所在的区间

而且能保证先单调增再单调减

再二分即可

 

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
char str[10];
int main() {
    while(1) {
        fflush(stdout);
        scanf("%s",str);
        if (str[0]=='e') break;
        if (str[0]=='s') {
            printf("? 0 %d\n",1<<29);
            fflush(stdout);
            scanf("%s",str);
            if (str[0]=='x') {
                int lim=1<<28;
                while(1) {
                    if (lim==0) {
                        printf("! 1\n");
                        break;
                    }
                    printf("? 0 %d\n",lim);
                    fflush(stdout);
                    scanf("%s",str);
                    if (str[0]=='y') {
                        printf("! %d\n",lim*2);
                        break;
                    }
                    lim>>=1;
                }
            }
            else {
                int d=2;
                while(1) {
                    printf("? %d %d\n", d, d*2);
                    fflush(stdout);
                    scanf("%s",str);
                    if (str[0]=='x') break;
                    d<<=1;
                }
                int l=d,r=2*d,ans;
                while(r-l>1) {
                    int mid=(l+r)>>1;
                    printf("? %d %d\n",l,mid);
                    fflush(stdout);
                    scanf("%s",str);
                    if (str[0]=='y') l=mid;
                    else r=mid;
                }
                printf("! %d\n",r);
            }
            fflush(stdout);
        }
    }
    return 0;
}

 

E.Johnny Solving

这种选择俩个中的一个回答的问题一般都是不满足一种那么一定存在一定的性质可以方便地推出另一个

那么根据第一个问题直接做一棵dfs生成树即可

如果不存在足够长的路径，那么一定存在至少$k$个叶子节点

由于每个点度数至少为$3$可推出每个叶子一定有对应的长度不能被$3$整除的环

 

#include <iostream>
#include <cstdio>
using namespace std;
const int N=250001;
const int M=1000001;
int n,m,k,cnt,maxid,top;
int first[N],nxt[M],to[M];
int fa[N],dep[N],son[N],sta[N]; bool vis[N];
void add(int a,int b) {
    to[++cnt]=b;
    nxt[cnt]=first[a];
    first[a]=cnt;
    return;
}
void dfs(int x) {
    vis[x]=1;
    if (dep[x]>dep[maxid]) maxid=x;
    for (int i=first[x];i;i=nxt[i])
        if (!vis[to[i]]&&to[i]!=fa[x]) {
            fa[to[i]]=x,son[x]++;
            dep[to[i]]=dep[x]+1;
            dfs(to[i]);
        }
    return;
}
void out() {
    for (int i=1;i<top;i++)
        printf("%d ",sta[i]);
    printf("%d\n",sta[top]),top=0;
    return;
}
void path(int st,int ed) {
    while(st!=ed)
        sta[++top]=st,st=fa[st];
    sta[++top]=ed;
    return;
}
int main() {
    scanf("%d%d%d",&n,&m,&k);
    for (int a,b,i=1;i<=m;i++) {
        scanf("%d%d",&a,&b);
        add(a,b),add(b,a);
    }
    dep[1]=1,dfs(1);
    if (dep[maxid]>=n/k) {
        printf("PATH\n%d\n",dep[maxid]);
        while(maxid!=1)
            printf("%d ",maxid),maxid=fa[maxid];
        printf("1\n");
    }
    else {
        int t[3];
        printf("CYCLES\n");
        for (int i=1;k&&i<=n;i++)
            if (!son[i]) {
                int tmp=0;
                for (int j=first[i];tmp<=2;j=nxt[j])
                    if (to[j]!=fa[i]) t[++tmp]=to[j];
                if (dep[t[1]]>dep[t[2]]) swap(t[1],t[2]);
                if ((dep[i]-dep[t[1]]+1)%3!=0)
                    printf("%d\n",dep[i]-dep[t[1]]+1),path(i,t[1]),out();
                else if ((dep[i]-dep[t[2]]+1)%3!=0)
                    printf("%d\n",dep[i]-dep[t[2]]+1),path(i,t[2]),out();
                else
                    printf("%d\n",dep[t[2]]-dep[t[1]]+2),path(t[2],t[1]),sta[++top]=i,out();
                k--;
            }
    }
    return 0;
}