2018年大连海事大学校赛（ACM竞赛高校联盟训练赛 第11场）题解
比赛地址：https://www.jisuanke.com/contest/1224（已添加到计蒜客题库）
A.Alice and Bob
博弈论+线段树
博弈论是最经典的Nim博弈，用线段树维护区间sg函数的异或值，然后区间更新就可以做。注意要预处理出每个子游戏的sg函数值。
代码：
#include
B.Date calculation
水题，数据也很水，怎么暴力都能过。
代码：
#include if(b==2&&f(a))
ans++;
b++;
if(b==13)
{
a++;
b=1;
}
}
ans+=d;
printf("%d\n",ans);
}
return 0;
}
C.DNA string
题目大意：给出n个字符串，每个字符串有一个权值，要求输出每个字符串在n个字符串中出现的总次数，以及每个字符串所有出现位置所在字符串的权值中，最大值与最小值。
考虑对于n各字符串建立AC自动机，将fail边反向，将会得到一棵fail树。正向fail边指向的是所在节点表示的字符串的最长后缀，因此，反向后的每个节点的fail边指向的是以该节点表示的字符串为后缀的字符串。可以得出，每个节点在fail树上的子孙个数就是这个节点所代表的字符串在自动机上出现的次数，建立自动机时保存单词的最后一个字母所在节点编号，之后对fail树进行dfs，统计每个节点的儿子个数，即可求出答案，因为一个节点可能被多个字符串包含，插入单词时要保存每个节点使用了多少次。
对于权值，建立自动机时保存每个节点对应的字符串的最大及最小权值，建立fail树后，查询每个词尾节点在fail树上的子孙节点的最大及最小权值，结果即为答案。可进行一遍dfs预处理出答案。
代码：
#include return son[id];
}
int dfs2(int id)
{
int l=ftree[id].size();
in[id]=num;
node[id]=1;
maxnum[num][0]=ma[id];
minnum[num][0]=mi[id];
num++;
for(int i=0;ireturn node[id];
}
void query(int id)
{
int now=ed[id];
int ans1=querymin(in[now],in[now]+node[now]-1);
int ans2=querymax(in[now],in[now]+node[now]-1);
printf("%d %d %d\n",son[now],ans1,ans2);
}
void ppp()
{
for(int i=1;iprintf("%d %d\n",i,minnum[i][0]);
printf("ans==%d\n",querymin(15,16));
}
int main()
{
int n;
int temp;
cin>>n;
init();
for(int i=1;i<=n;i++)
{
scanf("%s%d",s,&temp);
insert(s,temp,i);
}
build();
dfs(root);
dfs2(root);
RMQ(L-1);
// ppp();
for(int i=1;i<=n;i++)
{
query(i);
}
return 0;
}
D.Xcx’s f(x)
f(n,m)=∑i=1i≤n∑j=1j≤m(i+j)2[gcd(i,j)==2018] f ( n , m ) = ∑ i = 1 i ≤ n ∑ j = 1 j ≤ m ( i + j ) 2 [ g c d ( i , j ) == 2018 ]
=
20182∗f(⌊n2018⌋,⌊m2018⌋)=∑i=1i≤⌊n2018⌋∑j=1j≤⌊m2018⌋(i+j)2[gcd(i,j)==1] 2018 2 ∗ f ( ⌊ n 2018 ⌋ , ⌊ m 2018 ⌋ ) = ∑ i = 1 i ≤ ⌊ n 2018 ⌋ ∑ j = 1 j ≤ ⌊ m 2018 ⌋ ( i + j ) 2 [ g c d ( i , j ) == 1 ]
设：
p(x)=∑i=1i≤n∑j=1j≤m(i+j)2[gcd(i,j)==x] p ( x ) = ∑ i = 1 i ≤ n ∑ j = 1 j ≤ m ( i + j ) 2 [ g c d ( i , j ) == x ]
q(x)=∑i=1i≤n∑j=1j≤m(i+j)2[x|gcd(i,j)] q ( x ) = ∑ i = 1 i ≤ n ∑ j = 1 j ≤ m ( i + j ) 2 [ x | g c d ( i , j ) ]
根据两函数定义可知：
q(x)=∑x|dmin(n,m)p(d) q ( x ) = ∑ x | d m i n ( n , m ) p ( d )
所以由莫比乌斯反演显然可得：
p(x)=∑x|dmin(n,m)u(dx)q(d) p ( x ) = ∑ x | d m i n ( n , m ) u ( d x ) q ( d )
所以问题就转化成了求解 p(1)=∑min(n,m)i=1u(i)q(i) p ( 1 ) = ∑ i = 1 m i n ( n , m ) u ( i ) q ( i ) 的值。
进一步化简我们可以发现：
q(x)=x2∗∑i=1i≤⌊nx⌋∑j=1j≤⌊mx⌋(⌊ix⌋+⌊jx⌋)2=x2∗r(⌊nx⌋,⌊mx⌋) q ( x ) = x 2 ∗ ∑ i = 1 i ≤ ⌊ n x ⌋ ∑ j = 1 j ≤ ⌊ m x ⌋ ( ⌊ i x ⌋ + ⌊ j x ⌋ ) 2 = x 2 ∗ r ( ⌊ n x ⌋ , ⌊ m x ⌋ )
r(x,y) r ( x , y ) 显然可以 O(1) O ( 1 ) 时间求解，所以：
p(1)=∑i=1min(n,m)u(i)∗i2∗r(⌊ni⌋,⌊mi⌋) p ( 1 ) = ∑ i = 1 m i n ( n , m ) u ( i ) ∗ i 2 ∗ r ( ⌊ n i ⌋ , ⌊ m i ⌋ )
所以预处理出 u(i)∗i2 u ( i ) ∗ i 2 的前缀和就可以通过把 r(⌊ni⌋,⌊mi⌋) r ( ⌊ n i ⌋ , ⌊ m i ⌋ ) 合并同类项，来使得每次查询的时间复杂度降为 O(n−−√) O ( n )
代码：
#includeif(!vis[i])
{
prime[cnt++]=i;
mu[i]=-1;
}
long long int j;
for(j=0;j1;
if(i%prime[j]==0){mu[i*prime[j]]=0;break;}
else mu[i*prime[j]]=-mu[i];
}
}
}
void init()
{
Init_mu();
sum_u[0]=0;
long long int i;
for(i=1;imod(sum_u[i-1]+mod(mu[i]*i*i));
}
int main()
{
int T;
long long int n,m,ans;
init();
scanf("%d",&T);
while(T--)
{
scanf("%lld%lld",&n,&m);
if(nlong long int t=n;n=m;m=t;}
n/=2018;m/=2018;
ans=0;
long long int i,last;
for(i=1,last=1;i<=m;i=last+1)
{
last=min(n/(n/i),(m/(m/i)));
ans=mod(ans+ (sum_u[last]-sum_u[i-1])*h(n/i,m/i) );
}
for(;i<=n;i=last+1)
{
last=(n/(n/i));
ans=mod(ans+ mod(sum_u[last]-sum_u[i-1])*h(n/i,0) );
}
printf("%lld\n",mod(mod(ans+MOD)*2018*2018));
}
}
E.Xcx’s g(x)
该数列在OEIS上面的标号为：A185456
简单做法可以是二分答案，即位置数量，对于每个二分出来的答案，记忆化递归计算能容纳多少个人（因为递归时座位数量是以接近二分的速度减小的，所以时间也不会很多）。时间复杂度 O(logn) O ( l o g n )
代码：
#include
F.Xcx ‘s chocolate
结论是：如果nm同奇偶，那么就算不能完全覆盖，如果nm不同奇偶，就可以完全覆盖。
下面证明：
1.如果nm都为奇数，那么巧克力的块数也为奇数，没办法分割成 1 * 2 的小块。
2.如果nm为一奇一偶，那么可以假设n为奇数，则巧克力可以分成2个 1 * (n-1) 和1个 n * (m-2) 的矩形巧克力块，显然这三块都是可以分割成 1 * 2 的小块的。
3.如果nm都是偶数，那么考虑对一个 n * m 的巧克力块进行 0 1 染色，使得与0相邻的方块都染色成 1，与1相邻的方块都染色成 0，那么显然，左上角和右下角被切去的方块的颜色是相同的，所以剩下的染色为0的方块和染色为1的方块的数量差为2，又因为每次切下一个1*2的方块都会使得染色为0和染色为1的方块数量同时减去1，所以最后一定会剩下两个颜色相同的方块，所以不可能完全切割。
代码：
#include
G.The lazy staff
典型的树状结构，先一遍dfs处理出所有人的效率值，然后一遍dp出所有节点到根节点区间的最大效率值，然后用tarjan算法算出m个节点的最近公共祖先，该节点的dp值就是答案，但是要注意，当lca点在m个节点内时，答案就是父节点的dp值。由于m总和<=n，倍增一般会被卡掉，需要用tarjan一次性求出全部询问的lca。
代码：
#include 2;
}
}
void get_dp(int x)
{
dp[x]=max(dp[fa[x]],p[x]);
int l=a[x].size();
for(int i=0;ivoid lca(int x)
{
int l;
l=s[x].size();
for(int i=0;iint t=s[x][i];
len[t]--;
if(first[t]==-1)
first[t]=x;
if(len[t]==0)
{
int res=find(first[t]);
int flag = 0;
int ll=s[res].size();
for(int j=0;jif(s[res][j]==t)
{
flag=1;
break;
}
if(flag==1)
res=fa[res];
ans[t]=dp[res];
}
}
l=a[x].size();
for(int i=0;iint main()
{
scanf("%d%d",&n,&m);
init();
fa[1]=1;
for(int i=2;i<=n;i++)
{
scanf("%d",&fa[i]);
a[fa[i]].push_back(i);
}
for(int i=1;i<=n;i++)
scanf("%d",&L[i]);
for(int i=1;i<=m;i++)
{
scanf("%d",&len[i]);
for(int j=1;j<=len[i];j++)
{
int x;
scanf("%d",&x);
s[x].push_back(i);
}
}
dfs(1);
get_dp(1);
lca(1);
for(int i=1;i<=m;i++)
printf("%d\n",ans[i]);
return 0;
}
H.Get number from the cube
裸的网络流最小割定理的应用，是经典的方格取数的三维版，卡EK，dinic就能过。
代码：
#include int t=e[x][i];
if(d[f[t].to]==-1&&f[t].w>0)
{
d[f[t].to]=d[x]+1;
q.push(f[t].to);
}
}
}
if(d[sum+1]>0) return true;
else return false;
}
int dfs(int x,int ff)
{
if(x==sum+1||ff==0)
return ff;
int s=0,fl;
int l=e[x].size();
for(int i=0;iint t=e[x][i];
if(d[f[t].to]==d[x]+1&&(fl=dfs(f[t].to,min(ff,f[t].w)))>0)
{
s+=fl;
ff-=fl;
f[i].w-=fl;
f[i^1].w+=fl;
}
}
return s;
}
int dinic()
{
int ans=0;
while(bfs())
{
ans +=dfs(0,INF);
}
return ans;
}
void add_edge(int from,int to,int w)
{
cnt++;
f[cnt].to=to;
f[cnt].w=w;
e[from].push_back(cnt);
cnt++;
f[cnt].to=from;
f[cnt].w=0;
e[to].push_back(cnt);
}
int main()
{
int n,m,h=0;
freopen("test.in","r",stdin);
freopen("test.output","w",stdout);
scanf("%d%d%d",&n,&m,&h);
sum=n*m*h;
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
for(int k=1;k<=h;k++)
{
scanf("%d",&a[i][j][k]);
s+=a[i][j][k];
}
cnt=-1;
num=0;
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
for(int k=1;k<=h;k++)
if((i+j+k)%2==1)
{
add_edge(0,++num,a[i][j][k]);
id[i][j][k]=num;
}
else
{
add_edge(++num,sum+1,a[i][j][k]);
id[i][j][k]=num;
}
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
for(int k=1;k<=h;k++)
{
if((i+j+k)%2==1)
{
if(i+1<=n) add_edge(id[i][j][k],id[i+1][j][k],INF);
if(j+1<=n) add_edge(id[i][j][k],id[i][j+1][k],INF);
if(k+1<=n) add_edge(id[i][j][k],id[i][j][k+1],INF);
if(i-1>0) add_edge(id[i][j][k],id[i-1][j][k],INF);
if(j-1>0) add_edge(id[i][j][k],id[i][j-1][k],INF);
if(k-1>0) add_edge(id[i][j][k],id[i][j][k-1],INF);
}
}
int ans=dinic();
printf("%d\n",s-ans);
return 0;
}
I.Ring traveling
设 Tk T k 为以访问 k k 个不同的点的首次到达事件。则 T1=0,T2=1 T 1 = 0 , T 2 = 1
设 r(k)=E(Tk–Tk−1)k=3,4…N r ( k ) = E ( T k – T k − 1 ) k = 3 , 4 … N 其值只与 N N 有关。
在时刻 Tk−1 T k − 1 处在边界点 X(Tk−1) X ( T k − 1 ) 且其相邻节点之一已被访问，另一个尚未访问，下一步会走到两节点之一 。
如果走到已访问节点，那么将会继续随机游动直到到达下一个边界节点，从已访问的节点到下一个边界的期望为 k–3 k – 3 。
所以：
r(k)=1+12[(k−3)+r(k)] r ( k ) = 1 + 1 2 [ ( k − 3 ) + r ( k ) ]
E(TN)=1+∑k=3k≤NE(Tk–Tk−1)=N(N−1)2 E ( T N ) = 1 + ∑ k = 3 k ≤ N E ( T k – T k − 1 ) = N ( N − 1 ) 2
代码：
#include
J.One hundred prisoners
因为盒子里面的数字为 [1,n] [ 1 , n ] ，且每个数字只出现了一次，所以会形成一个 n n 的置换，只要判断这个 n n 的置换是否存在一个大于 n2 n 2 的循环节，就可以知道这种策略是否可以使每个人都活下来。
第二问就是对于给定的 n n ，计算 n! n ! 种 n n 的全排列里面有多少全排列满足要求：“不存在长度不超过 n2 n 2 的循环节”。
简单地容斥+枚举一下就可以得到答案，注意要与处理一下阶乘的前缀和以及它们对应的逆元。另外最后还要求一个逆元。
代码：
#include1]*i);
}
}
int main()
{
long long int son=0,mot=0;
init();
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
}
memset(vis,0,sizeof(vis));
int ans=0,now,cnt;
for(int i=1;i<=n;i++)
{
if(vis[i]!=0)continue;
now=a[i];cnt=1;vis[i]=1;
while(now!=i)
{
vis[now]=1;
cnt++;now=a[now];
}
ans=max(ans,cnt);
}
mot=mod( fi[n]*inv(fi[n/2-1]) );
long long int i;
for(i=n/2+1;i<=n;i++)
{
son=mod(son+ mod( mot*inv(i) ) );
}
son=mod(mod(mot-son)+MOD);
if(ans<=n/2)printf("Yes ");
else printf("No ");
printf("%lld\n",mod(son*inv(mot)));
return 0;
}