HDU 多校 2023 Round #5 题解
HDU 多校 2023 Round #5 题解
\(\text{By DaiRuiChen007}\)
A. Typhoon
题目大意
给一条 \(n\) 个点构成的折线，\(q\) 次询问某个点到折线的最短距离。
数据范围：\(n,q\le 10^4\)。
思路分析
暴力枚举每一条线段，判断点到直线的垂足是否在线段上即可。
时间复杂度 \(\mathcal O(nm)\)。
代码呈现
#include<bits/stdc++.h>
#define ll long long
#define double long double
using namespace std;
const int MAXN=1e4+5;
const double inf=1e18,eps=1e-6;
struct Point { ll x,y; } a[MAXN];
Point operator -(Point x,Point y){x.x-=y.x,x.y-=y.y;return x;}
ll operator *(Point x,Point y){return abs(x.x*y.y-x.y*y.x);}
inline ll dis(Point A,Point B){
return (A.x-B.x)*(A.x-B.x)+(B.y-A.y)*(B.y-A.y);
}
inline double dist(Point p,Point A,Point B) {
ll a=dis(p,A),b=dis(p,B),c=dis(A,B);
if(c&&a+c>=b&&b+c>=a) return (A-p)*(A-B)/sqrt(c);
else return sqrt(min(a,b));
}
signed main() {
int n,q;
scanf("%d%d",&n,&q);
for(int i=1;i<=n;++i) scanf("%lld%lld",&a[i].x,&a[i].y);
for(Point p;q--;) {
scanf("%lld%lld",&p.x,&p.y);
double ans=inf;
for(int i=1;i<n;++i) ans=min(ans,dist(p,a[i],a[i+1]));
printf("%.4Lf\n",ans);
}
return 0;
}
B. GCD Magic
题目大意
给定 \(n,p\)，求下式的值：
\[\sum_{i=1}^n\sum_{j=1}^n\gcd(2^i-1,2^j-1)^p \]数据访问：\(n\le 10^9,p\le 10\)。
思路分析
首先根据辗转相除法可以证明 \(\gcd(2^i-1,2^j-1)=2^{\gcd(i,j)}-1\)，枚举 \(k=\gcd(i,j)\) 后莫比乌斯反演得到：
\[\begin{aligned}
\text{Answer}
&=\sum_{i=1}^n\sum_{j=1}^n2^{\gcd(i,j)}-1\\
&=\sum_{k=1}^n (2^k-1)^p\sum_{i=1}^n\sum_{j=1}^n[\gcd(i,j)=1]\\
&=\sum_{k=1}^n (2^k-1)^p\sum_{i=1}^{\lfloor n/k\rfloor}\sum_{j=1}^{\lfloor n/k\rfloor}\sum_{d\mid \gcd(i,j)}\mu(d)\\
&=\sum_{k=1}^n (2^k-1)^p\sum_{d=1}^{\lfloor n/k\rfloor}\mu(d)\left\lfloor\dfrac{n}{kd}\right\rfloor^2\\
&=\sum_{t=1}^n\left\lfloor\dfrac nt\right\rfloor^2\sum_{k\times d=t} \mu(d)(2^k-1)^p
\end{aligned}
\]
若定义 \(f(k)=(2^k-1)^p\)，则对 \(\left\lfloor\dfrac nt\right\rfloor\) 做整除分块后相当于块筛 \(f*\mu\) 的前缀和，记 \(f*\mu=g\)，注意到 \(g*1=f\)，因此根据杜教筛可以得到：
\[S(n)=\sum_{i=1}^nf(i)-\sum_{i=2}^nS\left(\left\lfloor\dfrac ni\right\rfloor\right)
\]
其中 \(S(n)\) 表示 \(g(i)\) 的前缀和，做一遍杜教筛即可，\(f(i)\) 前缀和可以直接二项式展开成求 \(p+1\) 个等差数列的前缀和。
时间复杂度 \(\mathcal O((k\sqrt n+n^{2/3})\log n)\)，瓶颈在计算 \(f(i)\) 的前缀和以及 \(S(n)\) 在 \(1\sim n^{2/3}\) 范围内的点值。
代码呈现
#include<bits/stdc++.h>
using namespace std;
const int MAXN=1e6+5,MOD=998244353;
int n,m,k,B,mu[MAXN],C[15][15];
vector <int> primes,Mu;
bool isc[MAXN];
int idx1[MAXN],idx2[MAXN],val[MAXN];
int s0[MAXN],res[MAXN];
inline int ksm(int a,int b=MOD-2,int p=MOD) {
int ret=1;
while(b) ret=(b&1?1ll*ret*a%p:ret),a=1ll*a*a%p,b=b>>1;
return ret;
}
inline int idx(int k) { return k<=B?idx1[k]:idx2[n/k]; }
inline int calc(int n) {
int ans=k&1?(MOD-n):n;
for(int j=1,p=1;j<=k;++j) {
p=(p<<1)%MOD;
int tmp=1ll*(ksm(p,n)-1)*p%MOD*ksm(p-1)%MOD*C[k][j]%MOD;
if((k-j)&1) ans=(ans+MOD-tmp)%MOD;
else ans=(ans+tmp)%MOD;
}
return ans;
}
inline void solve() {
scanf("%d%d",&n,&k),m=0,B=sqrt(n);
for(int l=1,r;l<=n;l=r+1) {
r=n/(n/l),val[++m]=n/l;
if(val[m]<=B) idx1[val[m]]=m;
else idx2[n/val[m]]=m;
}
memset(s0,0,sizeof(s0));
for(int i=1,p=1;i<MAXN;++i) {
p=(p<<1)%MOD;
int f=ksm(p-1,k);
for(int j:Mu) {
if(i*j>=MAXN) break;
if(mu[j]==1) s0[i*j]=(s0[i*j]+f)%MOD;
else s0[i*j]=(s0[i*j]+MOD-f)%MOD;
}
}
for(int i=1;i<MAXN;++i) s0[i]=(s0[i]+s0[i-1])%MOD;
for(int i=m;i>=1;--i) {
int t=val[i];
if(t<MAXN) res[i]=s0[t];
else {
res[i]=calc(t);
for(int l=2,r;l<=t;l=r+1) {
r=t/(t/l);
res[i]=(res[i]+MOD-1ll*(r-l+1)*res[idx(t/l)]%MOD)%MOD;
}
}
}
int ans=0;
for(int l=1,r;l<=n;l=r+1) {
r=n/(n/l);
int sum=l==1?res[idx(r)]:(res[idx(r)]+MOD-res[idx(l-1)])%MOD;
ans=(ans+1ll*(n/l)*(n/l)%MOD*sum%MOD)%MOD;
}
printf("%d\n",ans);
}
signed main() {
mu[1]=1;
for(int i=2;i<MAXN;++i) {
if(!isc[i]) mu[i]=-1,primes.push_back(i);
for(int p:primes) {
if(i*p>=MAXN) break;
isc[i*p]=true,mu[i*p]=-mu[i];
if(i%p==0) { mu[i*p]=0; break; }
}
}
for(int i=1;i<MAXN;++i) if(mu[i]!=0) Mu.push_back(i);
for(int i=0;i<=10;++i) {
C[i][0]=1;
for(int j=1;j<=i;++j) C[i][j]=C[i-1][j]+C[i-1][j-1];
}
int T;
scanf("%d",&T);
while(T--) solve();
return 0;
}
C. String Magic (Easy Version)
题目大意
给定长度为 \(n\) 的字符串 \(S\)，求有多少 \(p,k\) 满足 \(S[p,p+k-1]=S[p+k,p+2k-1]\) 且两个串均为回文。
数据访问：\(n\le 10^5\)。
思路分析
容易发现前一半与后一半相等的条件可以转化成 \(S[p,p+2k-1]\) 回文。
考虑枚举 \(i=p+k\)，求出以 \((i-1,i)\) 中间位置为回文中心的最远右端点 \(R_i\)，不妨假设 \(2\mid k\)，那么枚举 \(S[p+k,p+2k+1]\) 的回文中心 \((j-1,j)\)，容易发现 \((i,j)\) 合法当且仅当 \(2j-i-1\le R_i,j>i,R_j\ge 2j-i-1\)。
稍作变换，我们要求的就是 \(\left(i,\left\lfloor \dfrac{i+R_i+1}2\right\rfloor\right]\) 区间内满足 \(2j-R_j-1\le i\) 的数有几个，显然是一个二位偏序模型，直接主席树维护或离线后树状数组维护都可以，\(2\nmid k\) 的情况同理，写出对应的限制条件然后二位偏序即可。
时间复杂度 \(\mathcal O(n\log n)\)。
代码呈现
#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int MAXN=1e5+5;
char str[MAXN],ss[MAXN<<1];
int rd[MAXN<<1];
class SegmentTree {
private:
struct Node {
int ls,rs,cnt;
} tr[MAXN*30];
inline void pushup(int p) { tr[p].cnt=tr[tr[p].ls].cnt+tr[tr[p].rs].cnt; }
int siz;
public:
inline void Clear() { siz=0; }
inline void Insert(int u,int l,int r,int q,int &p) {
tr[p=++siz]={0,0,0};
if(l==r) return tr[p].cnt=tr[q].cnt+1,void();
int mid=(l+r)>>1;
if(u<=mid) tr[p].rs=tr[q].rs,Insert(u,l,mid,tr[q].ls,tr[p].ls);
else tr[p].ls=tr[q].ls,Insert(u,mid+1,r,tr[q].rs,tr[p].rs);
pushup(p);
}
inline int Query(int ul,int ur,int l,int r,int q,int p) {
if(ul<=l&&r<=ur) return tr[p].cnt-tr[q].cnt;
int mid=(l+r)>>1,res=0;
if(ul<=mid) res+=Query(ul,ur,l,mid,tr[q].ls,tr[p].ls);
if(mid<ur) res+=Query(ul,ur,mid+1,r,tr[q].rs,tr[p].rs);
return res;
}
} oddpal,evnpal;
int ot[MAXN],et[MAXN]; //odd and even
int oR[MAXN],eR[MAXN];
inline void solve() {
oddpal.Clear(),evnpal.Clear();
memset(rd,0,sizeof(rd));
memset(ot,0,sizeof(ot));
memset(et,0,sizeof(et));
scanf("%s",str+1);
int n=strlen(str+1),m=2*n+1;
for(int i=1;i<=m;++i) ss[i]=(i%2==0)?(str[i/2]):'#';
ss[0]='{',ss[2*n+2]='}';
for(int i=1,l=0,r=0;i<=m;++i) {
if(i<=r) rd[i]=min(r-i+1,rd[r+l-i]);
while(ss[i+rd[i]]==ss[i-rd[i]]) ++rd[i];
if(i+rd[i]-1>r) l=i-rd[i]+1,r=i+rd[i]-1;
}
for(int i=1;i<=n;++i) { //odd palin(i)
int rad=rd[2*i]/2;
oR[i]=i+rad-1;
oddpal.Insert(2*i-oR[i],0,n,ot[i-1],ot[i]);
}
for(int i=1;i<=n;++i) { //even palin(i-1,i)
int rad=(rd[2*i-1]-1)/2;
eR[i]=i+rad-1;
evnpal.Insert(2*i-eR[i]-1,0,n,et[i-1],et[i]);
}
ll ans=0;
for(int i=1;i<=n;++i) {
ans+=oddpal.Query(0,i,0,n,ot[i-1],ot[(i+eR[i])/2]);
if(eR[i]==i) continue;
ans+=evnpal.Query(0,i,0,n,et[i],et[(i+eR[i]+1)/2]);
}
printf("%lld\n",ans);
}
signed main() {
int T;
scanf("%d",&T);
while(T--) solve();
return 0;
}
D. String Magic (Hard Version)
题目大意
给定长度为 \(n\) 的字符串 \(S\)，对 \(S\) 的每个前缀都求出上一问的答案。
数据访问：\(n\le 10^5\)。
思路分析
考虑右端点在 \(i\) 的串有多少个，用 PAM 维护插入 \(S_i\) 后的回文后缀，若没有新建本质不同回文后缀，直接用原来的答案即可，否则继承 \(fail\) 指针对应的更短后缀的答案，问题转化为判定某个 \((p,k)\) 是否合法，可以直接哈希，也可以在 PAM 上倍增看是否有长度恰好为 \(k/2\) 的串判断。
时间复杂度 \(\mathcal O(n\log n)\)。
代码呈现
#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int MAXN=1e5+5;
char str[MAXN];
struct PAM {
struct Node {
int len,fail,son[26];
} tr[MAXN];
int lst,tot;
inline void init() {
tr[0].len=0, tr[0].fail=1,memset(tr[0].son,0,sizeof(tr[0].son));
tr[1].len=-1,tr[1].fail=0,memset(tr[1].son,0,sizeof(tr[1].son));
tot=1,lst=0,str[0]='#';
}
inline int node(int len) {
++tot,tr[tot].len=len,tr[tot].fail=0;
memset(tr[tot].son,0,sizeof(tr[tot].son));
return tot;
}
inline int add(int i) {
int c=str[i]-'a';
auto get=[&](int x) {
while(str[i]!=str[i-tr[x].len-1]) x=tr[x].fail;
return x;
};
int p=get(lst);
if(!tr[p].son[c]) {
int q=node(tr[p].len+2);
tr[q].fail=tr[get(tr[p].fail)].son[c];
tr[p].son[c]=q;
}
return lst=tr[p].son[c];
}
} P;
int sum[MAXN],fa[MAXN][20];
bool vis[MAXN];
inline void solve() {
memset(fa,0,sizeof(fa));
memset(vis,false,sizeof(vis));
memset(sum,0,sizeof(sum));
scanf("%s",str+1);
P.init();
int n=strlen(str+1);
ll ans=0;
for(int i=1;i<=n;++i) {
int p=P.add(i);
if(!vis[p]) {
auto fail=[&](int p) { return P.tr[p].fail; };
auto len=[&](int p) { return P.tr[p].len; };
sum[p]=sum[fail(p)],fa[p][0]=fail(p),vis[p]=true;
for(int k=1;k<20;++k) fa[p][k]=fa[fa[p][k-1]][k-1];
if(len(p)%2==0) {
int u=p;
for(int k=19;~k;--k) if(len(fa[u][k])>=len(p)/2) u=fa[u][k];
if(len(u)==len(p)/2) ++sum[p];
}
}
ans+=sum[p];
printf("%lld ",ans);
}
puts("");
}
signed main() {
int T;
scanf("%d",&T);
while(T--) solve();
return 0;
}
E. Snake
题目大意
将 \(1\sim n\) 排到 \(m\) 个队列里，每个队列长度在 \([1,k]\) 之间，队列之间本质相同，但同一队列的元素先后顺序有影响，求方案数。
数据范围：\(n,m,k\le10^6\)。
思路分析
考虑构造形式幂级数，从 \(m=1\) 的情况入手，关于 \(n\) 的 EGF 就是 \(\hat F(x)=x^1+x^2+\cdots+x^k=\dfrac{x-x^{k+1}}{1-x}\)，答案即为 \(n![x^n]\hat F(x)\)。
然后考虑 \(m>1\) 的情况，根据 EGF 卷积的组合意义可以得到答案关于 \(n\) 的 EGF 就是 \(\dfrac 1{m!}\hat F^m(x)\)，因此答案为 \(\dfrac{n!}{m!}[x^n]\hat F^m(x)\)。
那么原问题就转化成了求 \([x^n](x-x^{k+1})^m\times (1-x)^{-m}\)，提出一个 \(x\) 得到 \([x^{n-m}](1-x^k)^m\times (1-x)^{-m}\)。
直接二项式定理拆开，其中 \((1-x)^{-m}\) 的 \(i\) 次项系数就是 \([x^i]=\binom{m+i-1}{m-1}\)，推式子得到：
\[\text{Answer}=\sum_{i=0}^{ik\le n-m} (-1)^i\binom mi\binom{n-ik-1}{m-1}
\]
预处理组合数后直接算就行，注意特判 \(mk<n\) 的情况。
时间复杂度 \(\mathcal O(n)\)。
代码呈现
#include<bits/stdc++.h>
using namespace std;
const int MAXN=1e6+5,MOD=998244353;
inline int ksm(int a,int b=MOD-2,int p=MOD) {
int ret=1;
while(b) ret=(b&1?1ll*ret*a%p:ret),a=1ll*a*a%p,b=b>>1;
return ret;
}
int fac[MAXN],inv[MAXN];
inline int binom(int n,int m) {
if(m<0||m>n) return 0;
return 1ll*fac[n]*inv[m]%MOD*inv[n-m]%MOD;
}
inline void solve() {
int n,m,k,ans=0;
scanf("%d%d%d",&n,&m,&k);
if(1ll*m*k<n) return puts("0"),void();
auto add=[&](int &x,int y) { x=(x+y>=MOD)?x+y-MOD:x+y; };
auto sub=[&](int &x,int y) { x=(x>=y)?x-y:x+MOD-y; };
for(int i=0;i<=m&&i*k<=n-m;++i) {
if(i&1) sub(ans,1ll*binom(m,i)*binom(n-i*k-1,m-1)%MOD);
else add(ans,1ll*binom(m,i)*binom(n-i*k-1,m-1)%MOD);
}
printf("%lld\n",1ll*ans*fac[n]%MOD*inv[m]%MOD);
}
signed main() {
fac[0]=1;
for(int i=1;i<MAXN;++i) fac[i]=1ll*fac[i-1]*i%MOD;
inv[MAXN-1]=ksm(fac[MAXN-1]);
for(int i=MAXN-1;i;--i) inv[i-1]=1ll*inv[i]*i%MOD;
int T;
scanf("%d",&T);
while(T--) solve();
return 0;
}
F. Touhou Red Red Blue
题目大意
顺次给你 \(n\) 个元素，和两个槽 \(A,B\) 初始为空，每个元素有一个颜色在 \(1\sim 3\) 之间，每当你拿到一个元素，你可以选择是否把这个元素保留，若保留：
- \(A\) 为空放进 \(A\) 中。
- 否则若 \(B\) 为空放进 \(B\) 中。
- 否则：
- 若两个槽中和你手中的元素都同色，扔掉这三个元素，得 \(1\) 分，然后将 \(A\) 替换成一个任意的元素。
- 若两个槽中和你手中的元素两两异色，扔掉这三个元素，然后将 \(A,B\) 都替换成一个任意的元素。
- 否则扔掉 \(A\)，把 \(B\) 放到 \(A\) 上，把你手中的元素放到 \(B\) 上。
求出最大可能的得分。
数据范围：\(n\le10^5\)。
思路分析
直接 dp，状态里记录每个槽的状态然后模拟即可。
时间复杂度 \(\mathcal O(n)\)。
代码呈现
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define MP make_pair
mt19937 rnd(time(0));
const int MAXN=1e5+5;
int f[MAXN][4][4];
void upd(int &x,int y){x=max(x,y);}
void solve(){
string s;cin>>s;
int n=s.length();
memset(f,-0x3f,sizeof(f));
f[0][0][0]=0;
for(int i=0;i<n;i++)
for(int j:{0,1,2,3})
for(int k:{0,1,2,3}) if(j>0||j==0&&k==0){
int ch=(s[i]=='R'?1:(s[i]=='B'?2:3));
upd(f[i+1][j][k],f[i][j][k]);
if(j==k&&k==ch){
for(int t:{0,1,2,3}) upd(f[i+1][t][0],f[i][j][k]+1);
}
if(j&&k&&j!=k&&k!=ch&&ch!=j){
for(int t:{0,1,2,3})
for(int l:{0,1,2,3}) upd(f[i+1][t][l],f[i][j][k]);
}
if(j&&k){
upd(f[i+1][k][ch],f[i][j][k]);
}
if(!j) upd(f[i+1][ch][0],f[i][j][k]);
else if(!k) upd(f[i+1][j][ch],f[i][j][k]);
}
int ans=0;
for(int i=1;i<=n;i++)
for(int j:{0,1,2,3}) for(int k:{0,1,2,3}) ans=max(ans,f[i][j][k]);
cout<<ans<<endl;
}
int main(){
ios::sync_with_stdio(false);
int _;cin>>_;
while(_--) solve();
}
G. Expectation (Easy Version)
题目大意
给一个初始为 \(0\) 的随机变量 \(x\)，有 \(n\) 轮操作，每轮有 \(p\) 的概率使 \(x\) 变成 \(x+1\)。
给定 \(m\)，求 \(\sum_{i=1}^x i^m\) 的期望。
数据范围：\(n\le 10^6,m\le 10^9\)。
思路分析
设 \(S(x)=\sum_{i=1}^x i^m\)，直接列式求 \(x=i\) 的概率得到 \(\mathrm{Answer}=\sum_{i=0}^n S(i)\times p^i\times (1-p)^{n-i}\times \binom ni\)，直接计算即可。
时间复杂度 \(\mathcal O(n\log m)\)。
代码呈现
#include<bits/stdc++.h>
using namespace std;
const int MAXN=1e6+5,MOD=998244353;
inline int ksm(int a,int b=MOD-2,int p=MOD) {
int ret=1;
while(b) ret=(b&1?1ll*ret*a%p:ret),a=1ll*a*a%p,b=b>>1;
return ret;
}
int fac[MAXN],inv[MAXN],P[MAXN],Q[MAXN];
inline void solve() {
int n,m,a,b,ans=0;
scanf("%d%d%d%d",&n,&m,&a,&b);
int p=1ll*a*ksm(b)%MOD,q=(1+MOD-p)%MOD;
for(int i=P[0]=Q[0]=1;i<=n;++i) P[i]=1ll*P[i-1]*p%MOD,Q[i]=1ll*Q[i-1]*q%MOD;
for(int k=1,f=0;k<=n;++k) {
f=(f+ksm(k,m))%MOD;
ans=(ans+1ll*f*P[k]%MOD*Q[n-k]%MOD*fac[n]%MOD*inv[k]%MOD*inv[n-k]%MOD)%MOD;
}
printf("%d\n",ans);
}
signed main() {
for(int i=fac[0]=inv[0]=1;i<MAXN;++i) inv[i]=ksm(fac[i]=1ll*i*fac[i-1]%MOD);
int T;
scanf("%d",&T);
while(T--) solve();
return 0;
}
H. Expectation (Hard Version)
题目大意
给一个初始为 \(0\) 的随机变量 \(x\)，有 \(n\) 轮操作，每轮有 \(p\) 的概率使 \(x\) 变成 \(x+1\)。
给定 \(m\)，求 \(\sum_{i=1}^x i^m\) 的期望。
数据范围：\(n\le 10^9,m\le 10^6\)。
思路分析
依然写出上式，考虑用下降幂和第二类斯特林数表示 \(i^m\)，稍作变换得到：
\[\begin{aligned}
\mathrm{Answer}
&=\sum_{i=0}^n \binom nip^i(1-p)^{n-i}\sum_{j=1}^i j^m\\[2ex]
&=\sum_{j=1}^i j^m\sum_{i=0}^n\binom nip^i(1-p)^{n-i}\\[2ex]
&=\sum_{j=1}^i\sum_{k=0}^m \begin{Bmatrix}m\\k\end{Bmatrix}\dfrac{m!}{(m-k)!}\sum_{i=0}^n\binom nip^i(1-p)^{n-i}\\[2ex]
&=\sum_{k=0}^m\begin{Bmatrix}m\\k\end{Bmatrix}k!\sum_{i=k}^n\binom nip^i(1-p)^{n-i}\sum_{j=k}^i\binom{j}{k}\\[2ex]
&=\sum_{k=0}^m\begin{Bmatrix}m\\k\end{Bmatrix}k!\sum_{i=k}^n\binom nip^i(1-p)^{n-i}\sum_{j=k}^i\binom{j+1}{k+1}-\binom{j}{k+1}\\[2ex]
&=\sum_{k=0}^m\begin{Bmatrix}m\\k\end{Bmatrix}k!\sum_{i=k}^n\binom nip^i(1-p)^{n-i}\binom{i+1}{k+1}\\[2ex]
&=\sum_{k=0}^m\begin{Bmatrix}m\\k\end{Bmatrix}k!\left(\sum_{i=k}^np^i(1-p)^{n-i}\binom ni\binom{i}{k+1}+\sum_{i=k}^np^i(1-p)^{n-i}\binom ni\binom{i}{k}\right)\\[2ex]
&=\sum_{k=0}^m\begin{Bmatrix}m\\k\end{Bmatrix}k!\left(\binom{n}{k+1}\sum_{i=k}^np^i(1-p)^{n-i}\binom{n-k-1}{i-k-1}+\binom nk\sum_{i=k}^np^i(1-p)^{n-i}\binom{n-k}{i-k}\right)\\[2ex]
&=\sum_{k=0}^m\begin{Bmatrix}m\\k\end{Bmatrix}k!\left(\binom{n}{k+1}p^{k+1}+\binom nkp^k\right)\\[2ex]\\
\end{aligned}
\]
最后两行之间省略的过程见下：
\[\sum_{i=k}^np^i(1-p)^{n-i}\binom{n-k}{i-k}=\sum_{t=0}^{n-k}p^{t+k}(1-p)^{n-k-t}\binom{n-k}{t}=p^k(p+(1-p))^{n-k}=p^k
\]
另一个求和式也是同理可以化简，因此只需要求出斯特林数的第 \(m\) 行元素即可，可以用一个简单的容斥处理：
\[\begin{aligned}
\begin{Bmatrix}m\\k\end{Bmatrix}
&=\dfrac 1{k!}\sum_{i=0}^k\binom ki(-1)^i(k-i)^m\\
&=\sum_{i=0}^k\dfrac{(-1)^i}{i!}\times\dfrac{(k-i)^m}{(k-i)!}
\end{aligned}
\]
一遍 NTT 即可求出，然后根据上式计算答案即可。
时间复杂度 \(\mathcal O(m\log m)\)。
代码呈现
#include<bits/stdc++.h>
using namespace std;
const int MAXN=(1<<21)+5,MOD=998244353,INV=(MOD+1)/3;
inline int ksm(int a,int b=MOD-2,int m=MOD) {
int ret=1;
while(b) {
if(b&1) ret=1ll*ret*a%m;
a=1ll*a*a%m;
b=b>>1;
}
return ret;
}
int rev[MAXN];
inline void NTT(int *f,int len,int op) {
for(int i=0;i<len;++i) if(i<rev[i]) swap(f[i],f[rev[i]]);
for(int s=2;s<=len;s=s<<1) {
int u=ksm(op==1?3:INV,(MOD-1)/s);
for(int i=0;i<len;i+=s) {
for(int j=i,w=1;j<i+s/2;++j) {
int x=f[j],y=1ll*w*f[j+s/2]%MOD;
f[j]=(x+y>=MOD)?x+y-MOD:x+y;
f[j+s/2]=(x>=y)?x-y:x+MOD-y;
w=1ll*w*u%MOD;
}
}
}
if(op==-1) {
int inv=ksm(len);
for(int i=0;i<len;++i) f[i]=1ll*f[i]*inv%MOD;
}
}
int fac[MAXN],inv[MAXN],binom[MAXN];
int F[MAXN],S[MAXN];
inline void solve() {
int n,m,a,b,p,ans=0;
scanf("%d%d%d%d",&n,&m,&a,&b),p=1ll*a*ksm(b)%MOD;
int lim=1<<(__lg(m*2)+1);
memset(S,0,sizeof(S)),memset(F,0,sizeof(F));
for(int i=0;i<=m;++i) S[i]=1ll*ksm(i,m)*inv[i]%MOD;
for(int i=0;i<=m;++i) F[i]=i&1?MOD-inv[i]:inv[i];
for(int i=0;i<lim;++i) {
rev[i]=(rev[i>>1]>>1);
if(i&1) rev[i]|=lim>>1;
}
NTT(S,lim,1),NTT(F,lim,1);
for(int i=0;i<lim;++i) S[i]=1ll*S[i]*F[i]%MOD;
NTT(S,lim,-1);
memset(binom,0,sizeof(binom)),binom[0]=1;
for(int i=1;i<=min(m+1,n);++i) binom[i]=1ll*binom[i-1]*(n-i+1)%MOD;
for(int i=0;i<=min(m+1,n);++i) binom[i]=1ll*binom[i]*inv[i]%MOD;
for(int k=0;k<=m;++k) {
int tmp=(1ll*binom[k]*ksm(p,k)%MOD+1ll*binom[k+1]*ksm(p,k+1)%MOD)%MOD;
ans=(ans+1ll*S[k]*fac[k]%MOD*tmp%MOD)%MOD;
}
printf("%d\n",ans);
}
signed main() {
fac[0]=1;
for(int i=1;i<MAXN;++i) fac[i]=1ll*fac[i-1]*i%MOD;
inv[MAXN-1]=ksm(fac[MAXN-1]);
for(int i=MAXN-1;i;--i) inv[i-1]=1ll*inv[i]*i%MOD;
int T;
scanf("%d",&T);
while(T--) solve();
return 0;
}
I. Tree
题目大意
给定一棵 \(n\) 个点的树以及一种树链剖分方式，要求对每条链建线段树，树根接在链顶的父亲上，求新树的最大深度。
数据范围：\(n\le 10^6\)。
思路分析
注意到每个节点线段树上对应的深度是可以 \(\mathcal O(1)\) 计算的，因此直接模拟求出每个点的深度即可。
时间复杂度 \(\mathcal O(n)\)。
代码呈现
#include<bits/stdc++.h>
using namespace std;
const int N=1e6+100;
inline char gc(){
static char buf[N],*p1=buf,*p2=buf;
if(p1==p2){
p2=(p1=buf)+fread(buf,1,N,stdin);
}
return *p1++;
}
inline int read(){
int x=0;char c=gc();
for(;c<'0'||c>'9';c=gc());
for(;c>='0'&&c<='9';c=gc())x=x*10+c-48;
return x;
}
int n;
int pre[N];
int hd[N],to[N],nxt[N],ec;
void ae(int u,int v){
++ec;
to[ec]=v;
nxt[ec]=hd[u];
hd[u]=ec;
}
int wson[N],dep[N];
int chsiz[N];
void dfs1(int u,int t){
chsiz[t]++;
for(int e=hd[u];e;e=nxt[e]){
int v=to[e];
dfs1(v,v==wson[u]?t:v);
}
}
void dfs2(int u,int t,int f){
if(u==t){
dep[u]=dep[f]+pre[chsiz[u]];
}else{
dep[u]=dep[t];
}
for(int e=hd[u];e;e=nxt[e]){
int v=to[e];
dfs2(v,v==wson[u]?t:v,u);
}
}
void solve(){
n=read();
ec=0;
memset(hd,0,sizeof(hd));
memset(chsiz,0,sizeof(chsiz));
int rt=0;
for(int i=1;i<=n;i++){
int f=read();
ae(f,i);
if(f==0){
rt=i;
}
}
for(int i=1;i<=n;i++){
wson[i]=read();
}
dep[rt]=0;
dfs1(rt,rt);
dfs2(rt,rt,rt);
int ans=0;
for(int i=1;i<=n;i++){
ans=max(ans,dep[i]);
}
printf("%d\n",ans);
return;
}
int main(){
for(int i=1,j=0;i<N;i++){
while((1<<j)<i) j++;
pre[i]=j+1;
}
int ttt=read();
while(ttt--){
solve();
}
return 0;
}
J. Cut The Tree
题目大意
给一棵 \(n\) 个节点的树，节点带权 \(a_i\)。
对于每个 \(u\)，定义 \(\mathrm{in}(u)\) 表示 \(u\) 子树内最大的一对 \(a_i\oplus a_j\)，\(\mathrm{out}(u)\) 表示 \(u\) 子树外最大的一对 \(a_i\oplus a_j\)。
求出最小的 \(|\mathrm{in}(u)-\mathrm{out}(u)|\)。
数据范围：\(n\le 2\times 10^5,V=\max\{a_i\}\le 10^9\)。
思路分析
首先考虑 \(\mathrm{in}(u)\)，直接 dsu on tree，每次继承重儿子得到的 01Trie 和答案，然后插入轻子树中的元素，时间复杂度 \(\mathcal O(n\log n\log V)\)。
然后考虑 \(\mathrm{out}(u)\)，先观察全局的最大异或对 \(p,q\)，对于任意一个不在 \(p\to 1\) 或 \(q\to 1\) 上的 \(u\)，\(\mathrm{out}(u)\) 就等于 \(a_p\oplus a_q\)，剩下的就是 \(1\to p\) 和 \(1\to q\) 上的点，从深到浅暴力枚举，每次插入当前节点的其他子树即可，每条链处理复杂度都是 \(\mathcal O(n\log V)\) 的。
分别处理，最后计算答案即可。
时间复杂度 \(\mathcal O(n\log n\log V)\)。
代码呈现
#include<bits/stdc++.h>
using namespace std;
const int MAXN=2e5+5,inf=2e9;
typedef array<int,2> Pair;
struct Trie {
int ans,tot;
Pair vers;
struct Node { Pair ch; int idx; } tr[MAXN*32];
inline void init() {
for(int i=0;i<=tot;++i) tr[i]={{0,0},0};
ans=0,tot=0,vers={-1,-1};
}
inline void insert(int idx,int val) {
int res=0,p=0;
for(int k=31;~k;--k) {
int x=(val>>k)&1;
if(!tr[p].ch[x]) tr[p].ch[x]=++tot;
p=tr[p].ch[x];
}
tr[p].idx=idx;
p=0;
for(int k=31;~k;--k) {
int x=(val>>k)&1;
if(tr[p].ch[x^1]) res|=1ll<<k,p=tr[p].ch[x^1];
else p=tr[p].ch[x];
}
if(res>ans) ans=res,vers={idx,tr[p].idx};
}
} Trie;
int fa[MAXN],a[MAXN],out[MAXN],in[MAXN];
vector <int> G[MAXN];
int dfn[MAXN],rnk[MAXN],dcnt=0,siz[MAXN],hson[MAXN];
inline void dfs0(int u,int Fa) {
fa[u]=Fa,rnk[dfn[u]=++dcnt]=u,siz[u]=1;
for(int v:G[u]) if(v^Fa) {
dfs0(v,u),siz[u]+=siz[v];
if(siz[hson[u]]<siz[v]) hson[u]=v;
}
}
inline void dfs1(int u) {
for(int v:G[u]) if(v!=fa[u]&&v!=hson[u]) {
dfs1(v),Trie.init();
}
if(hson[u]) dfs1(hson[u]);
Trie.insert(u,a[u]);
for(int v:G[u]) if(v!=fa[u]&&v!=hson[u]) {
for(int x=dfn[v];x<dfn[v]+siz[v];++x) Trie.insert(rnk[x],a[rnk[x]]);
}
in[u]=Trie.ans;
}
inline void solve() {
int n;
scanf("%d",&n);
for(int i=1;i<=n;++i) G[i].clear(),hson[i]=0;
Trie.init();
for(int i=1;i<=n;++i) scanf("%d",&a[i]),Trie.insert(i,a[i]);
for(int i=1;i<=n;++i) out[i]=Trie.ans;
for(int i=1,u,v;i<n;++i) {
scanf("%d%d",&u,&v);
G[u].push_back(v),G[v].push_back(u);
}
dcnt=0,dfs0(1,0);
Pair vers=Trie.vers;
for(int t:{0,1}) {
int p=vers[t];
Trie.init();
vector <int> ci;
for(int u=p;u!=1;u=fa[u]) ci.push_back(u);
ci.push_back(1),reverse(ci.begin(),ci.end());
for(int i=0;i<(int)ci.size();++i) {
int u=ci[i];
if(u>1) out[u]=Trie.ans;
if(u==p) break;
Trie.insert(u,a[u]);
for(int v:G[u]) if(v!=ci[i+1]&&v!=fa[u]) {
for(int x=dfn[v];x<dfn[v]+siz[v];++x) Trie.insert(rnk[x],a[rnk[x]]);
}
}
}
out[1]=0,Trie.init();
dfs1(1);
int ans=inf;
for(int i=2;i<=n;++i) ans=min(ans,abs(in[i]-out[i]));
printf("%d\n",ans);
}
signed main() {
int T;
scanf("%d",&T);
while(T--) solve();
return 0;
}
K. Cactus Circuit
题目大意
给一个 \(n\) 个点的仙人掌，每条边可以持续运行 \(t(e)\) 的时间，你要指定每条边开始运行的时间，使得任何时候这个仙人掌都是联通的。
数据范围：\(n\le 10^5\)。
思路分析
考虑每个环，显然只能是先断掉一条边，等有边无法运行时再加入，求出前三小的 \(t(e)\)，记为 \(t_1,t_2,t_3\)，可以证明最优解一定是断掉 \(t_1\) 或 \(t_2\)，此时代价是 \(\min(t_1+t_2,t_3)\)，否则运行时间一定不超过 \(t_2\)。
对每个环暴力考虑，可以先建一棵生成树，对于非树边暴力跳 LCA 并统计信息即可，也可以用 tarjan 来缩点，答案最后记得和非环边取 \(\min\)。
时间复杂度 \(\mathcal O(n)\)。
代码呈现
#include<bits/stdc++.h>
using namespace std;
const int MAXN=1e5+5,inf=2e9;
struct Edge { int u,v,w; };
int dsu[MAXN];
inline int find(int x) { while(x^dsu[x]) x=dsu[x]=dsu[dsu[x]]; return x; }
vector <Edge> G[MAXN];
int Fa[MAXN],dep[MAXN],wt[MAXN];
bool mark[MAXN];
inline void dfs(int u,int fa) {
dep[u]=dep[fa]+1;
for(auto e:G[u]) if(e.v^fa) Fa[e.v]=u,wt[e.v]=e.w,dfs(e.v,u);
}
inline void solve() {
int n,m;
cin>>n>>m;
vector <Edge> cyc;
for(int i=1;i<=n;++i) G[i].clear(),Fa[i]=dep[i]=wt[i]=mark[i]=0,dsu[i]=i;
for(int i=1,u,v,w;i<=m;++i) {
cin>>u>>v>>w;
int x=find(u),y=find(v);
if(x==y) cyc.push_back({u,v,w});
else {
G[u].push_back({u,v,w});
G[v].push_back({v,u,w});
dsu[x]=y;
}
}
dfs(1,0);
int ans=inf;
for(auto e:cyc) {
array <int,3> val={e.w,inf,inf};
auto add=[&](int w) {
val[2]=min(val[2],max(w,val[1]));
val[1]=min(val[1],max(w,val[0]));
val[0]=min(val[0],w);
};
for(int u=e.u,v=e.v;u!=v;) {
if(dep[u]<dep[v]) swap(u,v);
assert(!mark[u]);
add(wt[u]),mark[u]=true,u=Fa[u];
}
ans=min({ans,val[0]+val[1],val[2]});
}
for(int i=2;i<=n;++i) if(!mark[i]) ans=min(ans,wt[i]);
cout<<ans<<"\n";
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr),cout.tie(nullptr);
int T; cin>>T;
while(T--) solve();
return 0;
}
L. Counting Stars
题目大意
给定 \(n\) 个点 \(m\) 条边的无向图，定义 \(f(k)\) 表示图中有多少个 \(k\) 条边的菊花，求 \(f(2)\oplus f(3)\oplus\cdots\oplus f(n-1)\)。
数据范围：\(n,m\le 10^6\)。
思路分析
对于某个点 \(u\) 对 \(f(k)\) 的贡献就是 \(\binom{\mathrm{deg}(u)}k\)，枚举 \((1,\mathrm{deg}(u)]\) 的每个 \(k\) 暴力算即可，复杂度是 \(\mathcal O(\sum \mathrm{deg}(u))=\mathcal O(m)\) 的。
时间复杂度 \(\mathcal O(n+m)\)。
代码呈现
#include<bits/stdc++.h>
using namespace std;
const int MAXN=1e6+5,MOD=1e9+7;
inline int ksm(int a,int b=MOD-2,int p=MOD) {
int ret=1;
while(b) ret=(b&1?1ll*ret*a%p:ret),a=1ll*a*a%p,b=b>>1;
return ret;
}
int ans[MAXN],deg[MAXN],fac[MAXN],inv[MAXN];
inline int binom(int n,int m) {
if(m<0||m>n) return 0;
return 1ll*fac[n]*inv[m]%MOD*inv[n-m]%MOD;
}
inline void solve() {
int n,m;
cin>>n>>m;
memset(ans,0,sizeof(ans)),memset(deg,0,sizeof(deg));
for(int u,v;m--;) cin>>u>>v,++deg[u],++deg[v];
for(int i=1;i<=n;++i) {
auto add=[&](int &x,int y) { x=(x+y>=MOD)?x+y-MOD:x+y; };
for(int j=2;j<=deg[i];++j) add(ans[j],binom(deg[i],j));
}
int res=0;
for(int i=2;i<n;++i) res^=ans[i];
cout<<res<<"\n";
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr),cout.tie(nullptr);
fac[0]=1;
for(int i=1;i<MAXN;++i) fac[i]=1ll*fac[i-1]*i%MOD;
inv[MAXN-1]=ksm(fac[MAXN-1]);
for(int i=MAXN-1;i;--i) inv[i-1]=1ll*inv[i]*i%MOD;
int T; cin>>T;
while(T--) solve();
}
