2019-2020Nowcoder Girl初赛题解

　　写了一天计算几何，心态崩了，水一篇题解休息休息。

　　emmmm，如果您是一名现役OIer/CSPer，那看这篇文章也许并不能在你的生命中留下些什么（潮子语录），因为相比NOIP/CSP这个比赛其实比较简单。

　　在这里我不概括题意，因为现在有重现赛，所有人都可以看题。

A 牛妹爱整除

　　首先，你知道为什么10进制下%3具有如此美妙的性质吗？

　　用B进制来表示一个数：​$\sum_{i=0}^{\infin}a_iB^i$，我们希望：$(\sum_{i=0}^{\infin}a_iB^i)\%p=(\sum_{i=0}^{\infin}a_i)\%p$，因为 $a_i$ 是任意的，我们不能依赖它的性质，那唯一的方法就是让 $B$ 的任意次方 $\%p$ 都等于1了。可以发现，当且仅当 $B\%p=1$ ，这个式子才是成立的。对于这道题，我们直接输出k+1就可以了；事实上，只要不超过题目的最大限制，任意的 $xk+1$ 都可以。

　　

 # include <cstdio>
 # include <iostream>
 # define R register int

 using namespace std;

 int k;

 int main()
 {
     scanf("%d",&k);
     printf("%d",k+);
     return ;
 }

A

B 吃桃

　　从某种意义上来讲，这个是不是比A还简单？

　　设 $f[i]$ 表示 $i$ 节点向子树内能延伸的最长路径，一遍dfs找到最长的根路径...然后再dfs一遍输出，就没了...

　　

 # include <cstdio>
 # include <iostream>
 # define R register int

 using namespace std;

 const int N=;
 int n,k,h,x,y,firs[N],dp[N],dep[N];
 struct edge { int too,nex; }g[N<<];

 void add (int x,int y)
 {
     g[++h].nex=firs[x];
     firs[x]=h;
     g[h].too=y;
 }

 void dfs (int x)
 {
     int j;
     for (R i=firs[x];i;i=g[i].nex)
     {
         j=g[i].too;
         if(dep[j]) continue;
         dep[j]=dep[x]+;
         dfs(j);
         dp[x]=max(dp[x],dp[j]);
     }
     dp[x]++;
 }

 void redfs (int x)
 {
     printf("%d\n",x);
     if(dp[x]==) return;
     int j,ans=n+;
     for (R i=firs[x];i;i=g[i].nex)
     {
         j=g[i].too;
         if(dep[j]<dep[x]) continue;
         if(dp[j]+==dp[x]) ans=min(ans,j);
     }
     redfs(ans);
 }

 int main()
 {
     scanf("%d%d",&n,&k);
     for (R i=;i<n;++i)
     {
         scanf("%d%d",&x,&y);
         add(x,y); add(y,x);
     }
     dep[k]=; dfs(k);
     redfs(k);
     return ;
 }

B

C 背包

　　众所周知，一道题如果在题目名称里明示某种算法，那它往往不是这种算法。不过...这道题就是背包；

　　两种方法：dp[i]表示大小为i，价值最小是多少；dp[i]表示价值为i，体积最大是多少；

　　显然第二种比较快，但是众所周知牛客的机器非常神，所以第一种做法也能过（事实上我看了一眼直接背包的复杂度是2e8，感觉牛客2e8稳过，就没有再进行任何思考了）；最后补充一下，如果你也想尝试第一种方法，也许需要在转移时看一下放入这个物品后背包体积是否超过 $V$，这样数组只要开到 $V$；

　　

 # include <cstdio>
 # include <iostream>
 # define R register int

 using namespace std;

 const int N=;
 const int inf=;
 int n,V,v[N],w[N],dp[];
 int ans=inf;

 int main()
 {
     scanf("%d%d",&n,&V);
     for (R i=;i<=n;++i)
         scanf("%d%d",&v[i],&w[i]);
     for (R i=;i<=V;++i) dp[i]=inf;
     for (R i=;i<=n;++i)
     {
         for (R j=V-v[i];j<V;++j)
             ans=min(ans,dp[j]+w[i]);
         if(v[i]>=V) ans=min(ans,w[i]);
         for (R j=V;j>=v[i];--j)
             dp[j]=min(dp[j],dp[ j-v[i] ]+w[i]);
     }
     ans=min(ans,dp[V]);
     printf("%d",ans);
     return ;
 }

C

D 泡面

　　赛后zutter_告诉我我的做法可能假了，因为以前CF考过类似的题，当时被Hack了好多人；然后，最后的结论是这道题和CF的那个确实不是一个做法，所以我并没有假；

　　首先我们把所有人按照 $t_i$ 从小到大排序；然后模拟接水的过程就好了...具体来讲，首先，维护一个值表示“当前接水的人什么时候能接完”，然后把所有 $t_i$ 小于这个数且还没有接水的人的编号扔进一个小根堆里；每次取出堆顶作为新的接水人；如果堆空了，那就说明有一段时间并没有人接水，我们直接找到下一个还没有接过水的人 $x$，将“当前接水的人什么时候能接完”修改为 $t_x+p$ 即可。

　　

 # include <cstdio>
 # include <iostream>
 # include <algorithm>
 # include <queue>
 # define R register int
 # define ll long long

 using namespace std;

 const int N=;
 int n,p,h,s;
 ll ans[N],T;
 struct peo
 {
     int pos,t;
 }a[N];
 priority_queue <int,vector<int>,greater<int> > q;

 bool cmp (peo a,peo b)
 {
     if(a.t==b.t) return a.pos<b.pos;
     return a.t<b.t;
 }

 int read()
 {
     int x=;
     char c=getchar();
     while (!isdigit(c)) c=getchar();
     while (isdigit(c)) x=(x<<)+(x<<)+(c^),c=getchar();
     return x;
 }

 int main()
 {
     scanf("%d%d",&n,&p);
     for (R i=;i<=n;++i)
         a[i].pos=i,a[i].t=read();
     sort(a+,a++n,cmp);
     a[n+].t=;
     h=; T=a[].t+p; ans[ a[].pos ]=T;
     int cg=;
     while(cg!=n)
     {
         while(h+<=n&&a[h+].t<=T) q.push(a[h+].pos),h++;
         int s=q.size();
         if(s==)
         {
             h++;
             ans[ a[h].pos ]=a[h].t+p;
             cg++;
             T=a[h].t+p;
             continue;
         }
         int x=q.top(); q.pop();
         T+=p; ans[x]=T; cg++;
     }
     for (R i=;i<=n;++i) printf("%lld ",ans[i]);
     return ;
 }

D

E 伪直径

　　这道题具有较强的欺骗性；一开始我没想明白，仿照求直径的树形dp设了两个状态：已经分叉过的路径和没有分叉过的路径；转移稍微有点复杂，但想起来很简单；就在我马上写完的时候，我突然想起两个路径可以互相包含...

　　好的，先说结论，这道题的答案就是树的直径-1；分两步来证明：首先，这个值一定能取到，方法是一条路径选直径，另一条路径去掉直径端点处的某一条边；其次，这确实是可能存在的最大值，因为如果存在两条路径的交是直径，且他们不相同，那么取出它们不相交的部分接到直径上，会使直径变长，这显然不合理，所以答案就是树的直径-1；

　　

 # include <cstdio>
 # include <iostream>
 # define R register int

 using namespace std;

 const int N=;
 const int inf=;
 int n,h,x,y,firs[N],dep[N];
 int f1[N],f2[N],e[N];
 struct edge { int too,nex; }g[N<<];

 void add (int x,int y)
 {
     g[++h].nex=firs[x];
     firs[x]=h;
     g[h].too=y;
 }

 void dfs (int x)
 {
     int j;
     for (R i=firs[x];i;i=g[i].nex)
     {
         j=g[i].too;
         if(dep[j]) continue;
         dep[j]=dep[x]+;
         dfs(j);
         if(f1[j]+>=f1[x]) f2[x]=f1[x],f1[x]=f1[j]+,e[x]=j;
         else f2[x]=max(f2[x],f1[j]+);
     }
 }

 void redfs (int x)
 {
     int j;
     for (R i=firs[x];i;i=g[i].nex)
     {
         j=g[i].too;
         if(dep[j]<dep[x]) continue;
         int t;
         if(e[x]==j) t=f2[x]+;
         else t=f1[x]+;
         if(t>=f1[j]) f2[j]=f1[j],f1[j]=t,e[j]=x;
         else f2[j]=max(f2[j],t);
         redfs(j);
     }
 }

 int main()
 {
     int ans=;
     scanf("%d",&n);
     for (R i=;i<n;++i)
     {
         scanf("%d%d",&x,&y);
         add(x,y); add(y,x);
     }
     dep[]=; dfs();
     redfs();
     for (R i=;i<=n;++i) ans=max(ans,f1[i]+f2[i]);
     printf("%d",ans-);
     return ;
 }

E

F 最大最小差

　　一道有点难度的题；

　　首先考虑一个暴力？$n^2$枚举区间，然后判断是否合理，不知道能得多少分？如果你认真思考一下这个过程，会发现很多枚举是无效的，举个例子：如果$(x,y)$的利润已经过高，那么$(x,y+1)$ 的利润只可能更高；再想一想，就会发现对于一个确定的 $x$ ，合法的右端点属于一个区间；我们是否可以通过某种方法直接找到这个区间呢？二分！怎么判断一个区间的利润呢？ST表查最大最小值！不过如果你每次同时处理 $m$ 种货物，$ST$表的空间可能就太大了，所以可以考虑对于每种货物分别计算合法的右端点，最后再对 $m$ 个区间求交；

　　交上去，可能会TLE...因为ST表查询一次虽说是O(n)的，但是常数略大。有没有什么别的方法呢？发现随着枚举的做左端点不断增大，右端点的合法区间也是在不断右移的，所以可以用双指针维护这个合法区间，复杂度虽说还是 $O(n\log n)$的，但是这个 $\log n$ 只是求 $ST$表时用到的，所以就可以通过了。

　　赛后发现，这个最大最小值似乎可以通过单调队列维护，那么复杂度就是严格的 $O(nm)$ 啦！

　　啊，之前放上来的是一个WA+TLE的程序（因为我最后一次提交是在牛客提交框里改的，电脑上的还是原来那版错误的），经QQ上dalao提醒，现在已经改过来了。不过我的做法有点卡常，加上超级快读才通过...

　　

 # include <cstdio>
 # include <iostream>
 # define R register int
 # define ll long long
 # define getchar() (S==T&&(T=(S=BB)+fread(BB,,<<,stdin),S==T)?EOF:*S++)
 char BB[ << ], *S = BB, *T = BB; 

 using namespace std;

 const int N=;
 const int M=;
 int n,m,a[N],c[M],lg[N];
 int st1[N][],st2[N][];
 int lr[N],rr[N];
 ll ans;

 void build_ST()
 {
     for (R i=;i<=n;++i) st1[i][]=st2[i][]=a[i];
     for (R i=;i<=;++i)
         for (R j=;j<=n;++j)
         {
             if(j+(<<i)->n) break;
             st1[j][i]=min(st1[j][i-],st1[j+(<<(i-))][i-]);
             st2[j][i]=max(st2[j][i-],st2[j+(<<(i-))][i-]);
         }
 }

 int ask (int l,int r)
 {
     if(r>n) return -;
     if(r<) return -;
     int k=lg[r-l+];
     int ans1=min(st1[l][k],st1[ r-(<<k)+ ][k]);
     int ans2=max(st2[l][k],st2[ r-(<<k)+ ][k]);
     return ans2-ans1;
 }

 int ef1 (int id,int x)
 {
     int l=x,r=n,mid,ans=n+;
     while(l<=r)
     {
         mid=(l+r)>>;
         if(ask(x,mid)>=c[id]) ans=mid,r=mid-;
         else l=mid+;
     }
     return ans;
 }

 int ef2 (int id,int x)
 {
     int l=x,r=n,mid,ans=-n-;
     while(l<=r)
     {
         mid=(l+r)>>;
         if(ask(x,mid)<=c[id]) ans=mid,l=mid+;
         else r=mid-;
     }
     return ans;
 }

 int read()
 {
     int x=;
     char c=getchar();
     while (!isdigit(c)) c=getchar();
     while (isdigit(c)) x=(x<<)+(x<<)+(c^),c=getchar();
     return x;
 }

 void solve (int id)
 {
     for (R i=;i<=n;++i) a[i]=read();
     build_ST();
     int p1=ef1(id,),p2=ef2(id,);
     lr[]=max(lr[],p1); rr[]=min(rr[],p2);
     for (R i=;i<=n;++i)
     {
         if(p1<i) p1=i; if(p2<i) p2=i;
         while(p1<=n&&ask(i,p1)<c[id]) p1++;
         while(p2+<=n&&ask(i,p2+)<=c[id]) p2++;
         if(ask(i,p1)!=c[id]) lr[i]=n+; else lr[i]=max(lr[i],p1);
         if(ask(i,p2)!=c[id]) rr[i]=-n-; else rr[i]=min(rr[i],p2);
     }
 }

 int main()
 {
     scanf("%d%d",&n,&m);
     for (R i=;i<=n;++i) lg[i]=lg[i>>]+;
     for (R i=;i<=m;++i) c[i]=read();
     for (R i=;i<=n;++i) rr[i]=n;
     for (R i=;i<=m;++i)
         solve(i);
     for (R i=;i<=n;++i)
     {
         int l=lr[i],r=rr[i];
         if(l>r) continue;
         ans+=r-l+;
     }
     printf("%lld",ans);
     return ;
 }

F

　　由于对赛制不是很确定，以为类似CF，担心会FST，又检查来检查去，后来问了监考老师，才知道过了就是过了，于是愉快的交卷。反正假都请好了，干脆在家度过了一个快乐的晚上。

　　

Update：

　　我！ 没！ 了！ 啊！

　　这面试太太太太太太太难了吧！

　　我！ 自！ 闭！ 了！

　　还没面试的同学不要再问我面试考啥了，因为真真真真的很随机啊啊啊啊啊！