AtCoder Beginner Contest 240

前言

考场把前六题切了，但是 E 题和 F 题罚时了，所以也写一写。

---

ABC240 E - Ranges on Tree

题目传送门

---

分析

\(r\) 的最大值就是叶子的个数，如果将叶子按顺序编号，

那么每个点的区间就是[子树内最小叶子编号,最大叶子编号]

直接一遍dfs就可以了（我一开始没看完题目直接输出dfs序了QWQ）

---

代码

//考场写的是长链剖分，但好像根本没用上，因为没必要所以考后重写了简单一点的代码
#include <iostream>
using namespace std;
const int N=200011;
struct node{int y,next;}e[N<<1];
int n,as[N],et=1,tot,l[N],r[N];
void dfs(int x,int fa){
	l[x]=tot+1;
	bool flag=1;
	for (int i=as[x];i;i=e[i].next)
	    if (e[i].y!=fa) dfs(e[i].y,x),flag=0;
	if (flag) ++tot;
	r[x]=tot;
}
int main(){
	ios::sync_with_stdio(0);
	cin>>n;
	for (int i=1;i<n;++i){
		int x,y; cin>>x>>y;
		e[++et]=(node){y,as[x]},as[x]=et;
		e[++et]=(node){x,as[y]},as[y]=et;
	}
	dfs(1,0);
	for (int i=1;i<=n;++i) cout<<l[i]<<" "<<r[i]<<endl;
	return 0;
}

---

ABC240 F - Sum Sum Max

题目传送门

---

分析

两次前缀和的答案是一个二次函数的形式，如果开口向下对称轴处取最大值，否则其中一个边界取最大值，

每一段都有可能成为最大值，所以就直接判断一下对称轴是否在区间内即可。

WA了五次的原因：对称轴为直线 \(x=-\frac{b}{2a}\)，连这都记错了QWQ

---

代码

#include <cstdio>
#include <cctype>
#include <cmath>
using namespace std;
typedef __int128 lll; lll T,n,m;
lll Sum,sum,ans,x[200011],y[200011];
lll max(lll a,lll b){return a>b?a:b;}
lll iut(){
	lll ans=0,f=1; char c=getchar();
	while (!isdigit(c)) f=(c=='-')?-f:f,c=getchar();
	while (isdigit(c)) ans=ans*10+c-48,c=getchar();
	return ans*f;
}
void print(lll ans){
	if (ans<0) ans=-ans,putchar('-');
	if (ans>9) print(ans/10);
	putchar(ans%10+48);
}
int main(){
	for (T=iut();T;--T){
		n=iut(),m=iut(),ans=-1e22,sum=Sum=0;
		for (int i=1;i<=n;++i){
			x[i]=iut(),y[i]=iut();
			ans=max(ans,Sum+sum+x[i]);
			ans=max(ans,Sum+y[i]*(y[i]+1)/2*x[i]+sum*y[i]);
			if (x[i]<0){
				long double k=-(x[i]+2.0*sum)/2.0/x[i];
				if (k>1&&k<y[i]){
					lll _k=floor(k),__k=ceil(k);
					ans=max(ans,Sum+_k*(_k+1)/2*x[i]+sum*_k);
					ans=max(ans,Sum+__k*(__k+1)/2*x[i]+sum*__k);
				}
			}
			Sum+=y[i]*(y[i]+1)/2*x[i]+sum*y[i],sum+=y[i]*x[i];
		}
	    print(ans),putchar(10);
	}
	return 0;
}

---

ABC240 G - Teleporting Takahashi

题目传送门

---

分析

三个维度一起求不行，考虑两个维度先求出来，

设 \(f[i]\) 表示横坐标和纵坐标共走 \(i\) 个来回的方案数。

那么就是枚举横坐标走了 \(j\) 个来回，那么纵坐标走了 \(i-j\) 个来回。

四种方向需要走的步数分别为 \(x+j,j,y+i-j,i-j\)

考虑尽量留较少的 \(j\) 以方便消去。

不妨先在当中选择 \(i\) 步来走 \(j\) 和 \(i-j\) 两个方向。

那也就是 \(\binom{x+y+i*2}{i}\binom{i}{j}\)

再在当中选 \(y+i-j\) 步，合起来就是

\(f[i]=\binom{x+y+i*2}{i}\sum_{j=0}^i\binom{x+y+i}{y+i-j}\binom{i}{j}\)

可以发现后式是一个范德蒙德卷积，直接合并即可

\(f[i]=\binom{x+y+i*2}{i}\binom{x+y+i*2}{y+i}\)

然后再将这 \(i\) 步插入第三维中即可。

---

代码

#include <iostream>
using namespace std;
const int N=10000011,mod=998244353;
int n,m,x,y,z,fac[N],inv[N],ans,f[N];
int c(int n,int m){return 1ll*fac[n]*inv[m]%mod*inv[n-m]%mod;}
int main(){
	cin>>n>>x>>y>>z;
	if (x<0) x=-x;
	if (y<0) y=-y;
	if (z<0) z=-z;
	m=n,n-=x+y+z;
	if (n<0||(n&1)){
		cout<<0;
		return 0;
	}
	n>>=1,fac[0]=fac[1]=inv[0]=inv[1]=1;
	for (int i=2;i<=m;++i) inv[i]=1ll*(mod-mod/i)*inv[mod%i]%mod;
	for (int i=2;i<=m;++i) inv[i]=1ll*inv[i-1]*inv[i]%mod,fac[i]=1ll*fac[i-1]*i%mod;
	for (int i=0;i<=n;++i) f[i]=1ll*c(x+y+i*2,x+y+i)*c(x+y+i*2,y+i)%mod;
	for (int i=0;i<=n;++i) ans=(ans+1ll*f[n-i]*c(m,i)%mod*c(m-i,z+i)%mod)%mod;
	return !printf("%d",ans);
}

---

ABC240 Ex - Sequence of Substrings

题目传送门

---

分析

第一步模型转换才是最重要的。

如果将这个字符串的所有子串抽取出来，那么字典序严格递增要满足 \(r_i<l_{i+1}\)

这与求最长上升子序列很类似，或者换句话说，最长上升子序列的决策区间长度一定为 1。

可不可以将这道题转化成最长上升子序列，答案是肯定的。

在lower_bound之后不直接加入答案数组，而在到达子串末尾时再尝试添加到答案数组。

由于固定左端点的子串字典序一定单调递增，所以可以直接用一个双指针扫描，判断大小可以用哈希比较 \(LCP\) 做到一个 \(\log\)

那么就是 \(O(n^2\log n)\) 吗，显然不是，考虑到加入答案数组的子串长度一定可以不超过 \(\sqrt{2n}\)，所以子串长度只需要枚举到 \(\sqrt{2n}\) 级别。

所以最后时间复杂度为 \(O(n\sqrt{2n}\log{n})\)，考虑到空间复杂度也可以优化，

垃圾回收就可以做到 \(O(2n)\)（只有 \(\sqrt{2n}\) 个时刻需要保留，每个时刻最多保留 \(\sqrt{2n}\) 个决策）

---

代码

#include <cstdio>
#include <cmath>
using namespace std;
const int N=25011,mod=998244353; struct node{int y,w,next;}e[N<<1];
int h[N],p[N],n,mx,l[N],r[N],et,ans,as[N],st[N<<1],Top; char s[N];
int min(int a,int b){return a<b?a:b;}
int query(int l,int r){return (h[r]-1ll*h[l-1]*p[r-l+1]%mod+mod)%mod;}
bool geq(int lx,int rx,int ly,int ry){
	if (s[lx]!=s[ly]) return s[lx]>s[ly];
	int l=1,r=min(rx-lx+1,ry-ly+1),mn=r;
	while (l<r){
		int mid=(l+r+1)>>1;
		if (query(lx,lx+mid-1)==query(ly,ly+mid-1)) l=mid;
		    else r=mid-1;
	}
	if (r==mn) return rx-lx+1>ry-ly+1;
	    else return s[lx+r]>s[ly+r];
}
int main(){
	scanf("%d%s",&n,s+1),mx=sqrt(2*n);
	s[n+1]=50,l[ans=1]=r[1]=n+1,p[0]=1;
	for (int i=1;i<=n+1;++i) p[i]=331ll*p[i-1]%mod;
	for (int i=1;i<=n+1;++i) h[i]=(331ll*h[i-1]+s[i]-48)%mod;
	for (int i=1;i<=n;++i){
		for (int j=i,k=1;j<i+mx&&j<=n;++j){
			while (k<=ans&&geq(i,j,l[k],r[k])) ++k;
			if (Top) e[st[Top]]=(node){i,k,as[j]},as[j]=st[Top--];
			    else e[++et]=(node){i,k,as[j]},as[j]=et;
			if (k>ans) {++ans,l[ans]=r[ans]=n+1; break;}
		}
		for (int j=as[i];j;j=e[j].next){
			int I=e[j].y,J=i,t=e[j].w; st[++Top]=j;
			if (geq(l[t],r[t],I,J)) l[t]=I,r[t]=J;
		}
		as[i]=0;
	}
	return !printf("%d",ans);
}