Nowcoder 牛客练习赛23

Preface

终于知道YKH他们为什么那么喜欢打牛客网了原来可以抽衣服

那天晚上有空就也去玩了下，刷了一波水TM的YKH就抽到了，我当然是没有了

题目偏水，好像都是1A的。才打了一个半小时，回家就直接睡觉了

---

A 托米的赌球

送分题，考虑贪心的思想，由于要总数量最小，因此面额大的应该能选就选。

所以一路贪心下来即可。 CODE

#include<cstdio>
#include<cctype>
using namespace std;
const int A[7]={100,50,20,10,5,2,1},B[6]={50,20,10,5,2,1};
int n,a,b,p;
inline char tc(void)
{
    static char fl[100000],*A=fl,*B=fl;
    return A==B&&(B=(A=fl)+fread(fl,1,100000,stdin),A==B)?EOF:*A++;
}
inline void read(int &x)
{
    x=0; char ch; while (!isdigit(ch=tc()));
    while (x=(x<<3)+(x<<1)+ch-'0',isdigit(ch=tc()));
}
inline void write(int x)
{
    if (x>9) write(x/10);
    putchar(x%10+'0');
}
int main()
{
    //freopen("CODE.in","r",stdin); freopen("CODE.out","w",stdout);
    register int i; read(n);
    while (n--)
    {
        read(a); read(b); p=0;
        for (i=0;i<7;++i) write(a/A[i]),putchar(' '),a%=A[i];
        for (i=0;i<5;++i) write(b/B[i]),putchar(' '),b%=B[i]; write(b/B[5]); putchar('\n');
    }
    return 0;
}

---

B 托米的划分

首先我们发现一个十分显然的性质，每次划分时的两个数应当尽可能接近，这样乘积才会最小。

可以结合长方形周长确定，两边越接近面积越小来理解当然用二次函数证明之也可

然后考虑直接递归计算这个过程，这样貌似加上记忆化都是\(O(n)\)的。

随即我们发现这个可以打表，但是同样\(O(n)\)的时空复杂度难以接受。

然后我们就要发挥一下乱搞的技巧了，我们把\(10^6\)以内的数打表出来，然后剩下的直接递归处理即可。

这样递归层数很小足以通过。 CODE

#include<cstdio>
#include<cctype>
using namespace std;
const int N=1e6;
int t,n; long long d[N+5];
inline char tc(void)
{
    static char fl[100000],*A=fl,*B=fl;
    return A==B&&(B=(A=fl)+fread(fl,1,100000,stdin),A==B)?EOF:*A++;
}
inline void read(int &x)
{
    x=0; char ch; while (!isdigit(ch=tc()));
    while (x=(x<<3)+(x<<1)+ch-'0',isdigit(ch=tc()));
}
inline void write(long long x)
{
    if (x>9) write(x/10);
    putchar(x%10+'0');
}
inline void init(void)
{
    for (register int i=1;i<=N;++i)
    d[i]=d[i+1>>1]+d[i>>1]+1LL*(i+1>>1)*(i>>1);
}
inline long long solve(int x)
{
    if (x<=N) return d[x];
    return solve(x+1>>1)+solve(x>>1)+1LL*(x+1>>1)*(x>>1);
}
int main()
{
    //freopen("CODE.in","r",stdin); freopen("CODE.out","w",stdout);
    register int i; read(t); init();
    while (t--)
    {
        read(n); write(solve(n)); putchar('\n');
    }
    return 0;
}

---

C 托米的位运算

考虑转化问题，当给价最大化是，就是当它们的共同二进制位最大时就是最大给价。

所以贪心地从大到小枚举二进制位，满足以下条件即可：

• \(a_i\)最大二进制位为\(1\)
• 满足上一条的\(a_i\)的\(\operatorname{and}\)所得剩下的公有二进制位不小于目前的最高位

然后就轻松水过了。 CODE

#include<cstdio>
#include<cctype>
using namespace std;
typedef long long LL;
const LL N=1e5+5;
LL t,n,a[N],b[N],cnt,tot;
inline char tc(void)
{
    static char fl[100000],*A=fl,*B=fl;
    return A==B&&(B=(A=fl)+fread(fl,1,100000,stdin),A==B)?EOF:*A++;
}
inline void read(LL &x)
{
    x=0; char ch; while (!isdigit(ch=tc()));
    while (x=(x<<3)+(x<<1)+ch-'0',isdigit(ch=tc()));
}
inline void write(LL x)
{
    if (x>9) write(x/10);
    putchar(x%10+'0');
}
int main()
{
    //freopen("CODE.in","r",stdin); freopen("CODE.out","w",stdout);
    register LL i,j; read(n);
    for (i=1;i<=n;++i) read(a[i]);
    for (cnt=0,tot=(1LL<<31)-1,j=30;j>=0;--j)
    {
        for (cnt=0,i=1;i<=n;++i)
        if (a[i]&(1LL<<j)) b[++cnt]=a[i],tot&=a[i];
        if (tot%(1LL<<j)==0)
        {
            for (printf("%lld\n",cnt),i=1;i<cnt;++i)
            printf("%lld ",b[i]); printf("%lld",b[cnt]);
            break;
        }
    }
    return 0;
}

---

D 托米的咒语

本来可能还想骗我们写写DFS增加下码量的，然后我用next_premutation水过去了

数据范围这么小，因此全排列来一发，考虑怎么判断

我们对于原来的字符串处理两个数组。\(f_{i,j}\)表示第\(i\)位之后（不包括\(i\)）最近的一个\(j\)字符的位置，\(fir_i\)表示字符\(i\)在串中最早出现的位置。

判断时直接\(O(9)\)向后跳即可，CODE

#include<cstdio>
#include<cctype>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=3005,P=15;
char s[N]; bool flag;
int f[N][P],num[P],fir[P],ans,n,now;
int main()
{
    register int i; scanf("%s",s+1); n=strlen(s+1);
    memset(f,63,sizeof(f));
    for (i=n-1;i>=1;--i)
    {
        memcpy(f[i],f[i+1],sizeof(f[i])); f[i][s[i+1]-'a'+1]=i+1;
        fir[s[i]-'a'+1]=i;
    }
    for (i=1;i<=9;++i) num[i]=i;
    do
    {
        for (now=fir[num[1]],flag=1,i=2;i<=9;++i)
        if (f[now][num[i]]<=n) now=f[now][num[i]]; else { flag=0; break; }
        ans+=flag;
    }while (next_permutation(num+1,num+10));
    return printf("%d",ans),0;
}

---

E 托米的数学

貌似是不可食用的数学题不会留着以后填坑

---

F托米的游戏

这题如果你光用脑子想可能会感到毫无头绪，但是如果拿起笔写一下式子就会发现这是个SB题。

考虑利用期望的线性性质来分析，总的期望轮数\(E\)等于各点的期望轮数\(e_i\)之和。

我们先DFS求出每个点的深度\(dep_i(dep_{rt}=1)\)，那么对于可能的情况只有两种：

1. 选中该点导致该点被砍去，那么此时的概率为\(\frac{1}{dep_x}\)（因为删去点的过程只与这个点的祖先个数（即深度）有关），期望贡献为\(1\)，则期望为\(\frac{1}{dep_x}\)
2. 选到该点的祖先导致该点被砍去，此时概率都不用算，因为期望贡献为\(0\)，乘一下就是\(0\)

因此答案就是\(\sum_{i=1}^n \frac{1}{dep_i}\)

CODE

#include<cstdio>
#include<cctype>
#include<cstring>
using namespace std;
const int N=100005,mod=998244353;
struct edge
{
    int to,next;
}e[N<<1];
int n,dep[N]={0,1},head[N],cnt,x,y,ans;
inline char tc(void)
{
    static char fl[100000],*A=fl,*B=fl;
    return A==B&&(B=(A=fl)+fread(fl,1,100000,stdin),A==B)?EOF:*A++;
}
inline void read(int &x)
{
    x=0; char ch; while (!isdigit(ch=tc()));
    while (x=(x<<3)+(x<<1)+ch-'0',isdigit(ch=tc()));
}
inline void double_add(int x,int y)
{
    e[++cnt].to=y; e[cnt].next=head[x]; head[x]=cnt;
    e[++cnt].to=x; e[cnt].next=head[y]; head[y]=cnt;
}
inline void inc(int &x,int y)
{
    if ((x+=y)>=mod) x-=mod;
}
inline int quick_pow(int x,int p)
{
    int tot=1;
    for (;p;x=1LL*x*x%mod,p>>=1) if (p&1) tot=1LL*tot*x%mod;
    return tot;
}
inline void DFS(int now,int fa)
{
    inc(ans,quick_pow(dep[now],mod-2));
    for (register int i=head[now];~i;i=e[i].next)
    if (e[i].to!=fa) dep[e[i].to]=dep[now]+1,DFS(e[i].to,now);
}
int main()
{
    //freopen("CODE.in","r",stdin); freopen("CODE.out","w",stdout);
    register int i; read(n); memset(head,-1,sizeof(head));
    for (i=1;i<n;++i) read(x),read(y),double_add(x,y);
    return DFS(1,-1),printf("%d",ans),0;
}

---

Postscript

好像Rank19吧比赛的时候后两题没写。反正没抽到衣服就是不高兴。