十一月训练总结

A. 能量水晶 / crystal

题面

2026 CSP-S T1,考了还是要讲一下。

首先显然这个东西具有贪心性:如果 \(a_x>a_y\),那么我消耗操作去把 \(a_x\) 升级必然比把 \(a_y\) 升级消耗的操作少,但是这两者达到了同样的效果,所以肯定选 \(a_x\) 更优。

那么我们按照 \(a\) 从小到大排序,问题相当于确定了一个末尾 \(r\),找到一个连续段开头 \(l\),使得将 \([l,r]\) 内的所有水晶升级所需次数不超过 \(m\)。那么对 \(a\) 做个前缀和 \(s\),问题转变为 \(a_r\cdot(r-l+1)-(s_r-s_{l-1})\le m\),此时我们需要找到最小的 \(l\)。

简单观察很容易发现 \(l\) 与上述条件成立的函数是单调的,所以我们可以直接二分解。当然再观察你会发现所有区间也是单调的,所以可以用双指针做到线性。复杂度 \(O(n)\)。

代码:

const int N=5e5+6;
int n,m,a[N],s[N];
signed main()
{
	n=read(),m=read();
	read(a+1,a+n+1);
	sort(a+1,a+n+1);
	for(int i=1;i<=n;i++)
	{
		s[i]=s[i-1]+a[i];
	}
	int ans=0;
	for(int l=1,r=1;r<=n;r++)
	{
		while(a[r]*(r-l+1)-(s[r]-s[l-1])>m)
		{
			l++;
		}
		ans=max(ans,r-l+1);
	}
	write(ans);
	return 0;
}

B. 地铁 / subway

题面

2026 CSP-S T2。

首先必须喷一下 CCF 的数据啊,你说 \(O(n^3\log n)\) 的全源 Dijkstra 放过去了我还能理解嘛,什么叫每次查询跑一次最短路也能过?!差评,必须差评!!!

首先一个很容易想到的做法是直接建图然后跑最短路,这样复杂度大致是 \(O(m^2\log m)\) 的,显然不是正解。

考虑为什么上面这个算法的复杂度这么高?显然因为坐地铁并不需要贡献,但是我们将其视为了边权为 \(0\),从而建了一些显然没有任何用的边。所以我们可以将一整条路线视作一个点,那么就可以在 \(n\) 条路线之间建图然后跑最短路。

因为每个点最多会在 \(d\) 条路径中出现,所以我们可以直接暴力枚举每个点在哪些路径中出现过。此时构建的复杂度是近似 \(O(\sum k_id)\) 的。

然后用 Floyd 跑一个全源最短路,时间复杂度 \(O(n^3)\)。

最后查询时也可以直接暴力枚举,时间复杂度 \(O(qd^2)\)。

总复杂度:\(O(\sum k_id+n^3+qd^2)\)。

代码(写成 Dijkstra 了多带了一个 \(\log\)):

const int N=506,M=5e5+6;
int n,m,d,q,a[M],mp[N][N],dis[N][N];
bool vis[N];
vector<pair<int,int>>v[N];
vector<int>vv[M],v1[M];
void dijkstra(int st,int *dis)
{
	for(int i=1;i<=n;i++)
	{
		dis[i]=2e18;
		vis[i]=0;
	}
	dis[st]=0;
	priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>>pq;
	pq.push(make_pair(dis[st],st));
	while(!pq.empty())
	{
		pair<int,int>p=pq.top();
		pq.pop();
		int u=p.second;
		if(vis[u])
		{
			continue;
		}
		vis[u]=1;
		for(auto i:v[u])
		{
			if(dis[i.first]>dis[u]+i.second)
			{
				dis[i.first]=dis[u]+i.second;
				pq.push(make_pair(dis[i.first],i.first));
			}
		}
	}
}
signed main()
{
	int C=read();
	n=read(),m=read(),d=read(),q=read();
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++)
		{
			mp[i][j]=2e18;
		}
	}
	read(a+1,a+m+1);
	for(int i=1,k;i<=n;i++)
	{
		k=read();
		for(int j=1,x,y;j<=k;j++)
		{
			x=read(),y=read();
			int len=vv[x].size();
			for(int l=0;l<len;l++)
			{
				mp[vv[x][l]][i]=mp[i][vv[x][l]]=min(mp[i][vv[x][l]],v1[x][l]+y);
			}
			v1[x].push_back(y);
			vv[x].push_back(i);
		}
	}
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++)
		{
			if(mp[i][j]<=(int)(1e18))
			{
				v[i].push_back(make_pair(j,mp[i][j]));
				v[j].push_back(make_pair(i,mp[i][j]));
			}
		}
	}
	for(int i=1;i<=n;i++)
	{
		dijkstra(i,dis[i]);
	}
	while(q--)
	{
		int x=read(),y=read(),ans=2e18;
		int len1=vv[x].size(),len2=vv[y].size();
		for(int i=0;i<len1;i++)
		{
			for(int j=0;j<len2;j++)
			{
				ans=min(ans,a[x]+a[y]+v1[x][i]+v1[y][j]+dis[vv[x][i]][vv[y][j]]);
			}
		}
		write(ans);
		putchar('\n');
	}
	return 0;
}

C. 迁徙 / migrate

题面

2026 CSP-S T3。

首先一个比较显然的结论是说如果正好有两条路径,那么这两条路径必然只有一个点不同,且不同的这两个点必然是相邻的。所以我们可以尝试枚举这对相邻点对的位置,然后计算它前面有多少个合法起点、多少个合法终点。

当然你也可以设 DP:设 \(f_i\) 表示以 \(i\) 为终点且路径条数正好是 \(1\) 的方案数,\(g_i\) 表示以 \(i\) 为终点且路径条数正好是 \(2\) 的方案数,\(h_i\) 表示走到 \(i-1,i\) 的路径条数都正好是 \(1\) 的方案数。那么显然分类讨论然后转移即可,代码不算很复杂。

时间复杂度:\(O(n)\)。

代码:

const int N=2e6+6;
int n,d,a[N],la[N],nx[N],f[N],g[N],h[N];
signed main()
{
	int C=read(),T=read();
	while(T--)
	{
		n=read(),d=read();
		read(a+1,a+n+1);
		for(int i=1,l=1,r=1;i<=n;i++)
		{
			while(a[i]-a[l]>d)
			{
				l++;
			}
			while(r<n&&a[r+1]-a[i]<=d)
			{
				r++;
			}
			la[i]=l,nx[i]=r;
			f[i]=g[i]=h[i]=0;
		}
		int ans=0;
		for(int i=1;i<=n;i++)
		{
			if(la[i]<i)
			{
				ans+=g[la[i]];
			}
			if(la[i]<i-1)
			{
				ans+=h[la[i]+1];
			}
			if(nx[i]==i)
			{
				continue;
			}
			f[nx[i]]++;
			if(la[nx[i]]==i)
			{
				f[nx[i]]+=f[i];
				g[nx[i]]+=g[i];
			}
			if(la[nx[i]]==i-1)
			{
				g[nx[i]]+=h[i];
			}
			if(nx[i]-1>i)
			{
				h[nx[i]]++;
				if(la[nx[i]-1]==i)
				{
					h[nx[i]]+=f[i];
				}
			}
		}
		write(ans);
		putchar('\n');
	}
	return 0;
}

D. 研发基地 / hub

题面

2026 CSP-S T4。

这题有点神了。

首先二分答案是很显然的,问题在于如何去判定答案是否正确。

我们可以将问题视作删掉一些点后正好剩下 \(k\) 个点且构成两个连通块。首先因为我们肯定要尽量少的取点,所以我们可以将深度 \(\le mid\) 的点全部都去掉,因为这些点显然可以不选。

那么我们就可以计算出实际上我们还需要删的点有多少个。

考虑剩下的这些点:首先所有的叶子节点必选,因为如果不选的话下面的点的最小距离的最大值就必然比 \(mid\) 大。其次度数大于 \(2\) 的必选,因为如果这些点不选的话连通块就会分成 \(2\) 个以上。那么可以删的实际上就是一段连续的度为 \(2\) 的点,也就是一段链。

考虑在一段链上这个问题怎么做。显然链上每个点都会有一个不在链上的子树,那么我们在链上选一段区间删除的时候,删完后剩余的点到这些子树里的点的距离也不能大于 \(mid\)。

我们可以记一个子树的最大深度为 \(f_x\),那么实际上就是要求在 \([mid-f_x,mid+f_x]\) 这之间必须有点存在,相应的也就限制了区间删除时的起点范围。我们只需要找到一个起点使得所有条件均满足即可。这个可以用差分做。

因为每个点只会被扫一遍,于是我们在 \(O(n\log n)\) 的复杂度内做出来了这道题。

代码:

const int N=1e6+6;
int n,k,d[N],f[N];
vector<int>v[N];
bool check(int x)
{
	int cnt=0;
	for(int i=1;i<=n;i++)
	{
		if(f[i]>x)
		{
			cnt++;
		}
	}
	cnt-=k;
	if(cnt<=0)
	{
		return true;
	}
	if(cnt>2*x)
	{
		return false;
	}
	for(int i=1;i<=n;i++)
	{
		d[i]=0;
		if(f[i]>x)
		{
			for(auto j:v[i])
			{
				if(f[j]>x)
				{
					d[i]++;
				}
			}
		}
	}
	for(int i=1;i<=n;i++)
	{
		if(d[i]<=0||d[i]==2)
		{
			continue;
		}
		for(auto j:v[i])
		{
			if(d[j]==2)
			{
				vector<int>vv;
				int pos=j,la=i;
				while(d[pos]==2)
				{
					d[pos]=-1;
					int mx=0,nx=0;
					for(auto k:v[pos])
					{
						if(f[k]<=x)
						{
							mx=max(mx,f[k]);
						}
						else if(k!=la)
						{
							nx=k;
						}
					}
					la=pos;
					pos=nx;
					vv.push_back(mx);
				}
				int len=vv.size();
				if(len<cnt)
				{
					continue;
				}
				int num=len-cnt+1;
				vector<int>c(num+1,0);
				for(int i=0;i<len;i++)
				{
					int l=x-vv[i];
					int lft=max(0ll,i+l-cnt+1);
					int rgt=min(num-1,i-l);
					if(lft<=rgt)
					{
						c[lft]++,c[rgt+1]--;
					}
				}
				int s=0;
				for(int i=0;i<num;i++)
				{
					s+=c[i];
					if(!s)
					{
						return true;
					}
				}
			}
		}
	}
	return false;
}
signed main()
{
	int C=read(),T=read();
	while(T--)
	{
		n=read(),k=read();
		for(int i=1,x,y;i<n;i++)
		{
			x=read(),y=read();
			v[x].push_back(y);
			v[y].push_back(x);
			d[x]++,d[y]++;
		}
		queue<int>q;
		for(int i=1;i<=n;i++)
		{
			if(d[i]==1)
			{
				q.push(i);
				f[i]=1;
			}
		}
		while(!q.empty())
		{
			int u=q.front();
			q.pop();
			for(auto i:v[u])
			{
				d[i]--;
				if(d[i]==1)
				{
					f[i]=f[u]+1;
					q.push(i);
				}
			}
		}
		int l=0,r=*max_element(f+1,f+n+1),ans=0;
		while(l<=r)
		{
			int mid=l+r>>1;
			if(check(mid))
			{
				ans=mid;
				r=mid-1;
			}
			else
			{
				l=mid+1;
			}
		}
		write(ans);
		putchar('\n');
		for(int i=1;i<=n;i++)
		{
			v[i].clear();
			d[i]=f[i]=0;
		}
	}
	return 0;
}

当然此题有 \(O(n)\) 做法,但是我太菜了根本听不懂。

E. 亚瑟王

题面

不算很难的概期题吧。

众所周知,期望具有线性性:

\[E[X_1+X_2+\dots+X_n]=E[X_1]+E[X_2]+\dots+E[X_n] \]

那么我们可以将这个问题看做每张卡牌的期望伤害,然后加在一起。

设第 \(i\) 张卡牌被使用的概率为 \(g_i\),那么最终答案可以转化为:

\[\sum d_ig_i \]

现在考虑怎么求 \(g_i\)。

首先 \(g_1\) 是好求的,显然就是 \(1-(1-p_1)^r\),也就是总概率减去一直不出来的概率。

现在问题是题目中有个限制是如果本轮已经出了牌那么需要立即停止,这个限制很烦。因此考虑 DP。

设 \(f_{i,j}\) 表示考虑了前 \(i\) 张牌,挑了 \(j\) 张牌出来的概率。考虑转移。

首先第一种就是第 \(i\) 张牌根本没有被选,那么就是 \(f_{i,j}=f_{i-1,j}\times(1-p_i)^{r-j}\)。

第二种就是第 \(i\) 张牌在某次游戏中被选了,那么就是 \(f_{i,j}=f_{i-1,j-1}\times(1-(1-p_i)^{r-j+1})\)。

最终计算 \(g_i\),显然此时的答案应该是 \(g_i=\sum_{j=0}^rf_{i-1,j}\times(1-(1-p_i)^{r-j})\)。

时间复杂度:\(O(nr)\)。

代码:

const int N=226;
struct card{
	long double p;
	int d;
}a[N];
int n,r;
long double g[N],pw[N][N],f[N][N];
signed main()
{
	int T=read();
	while(T--)
	{
		n=read(),r=read();
		for(int i=1;i<=n;i++)
		{
			cin>>a[i].p;
			a[i].d=read();
		}
		for(int i=1;i<=n;i++)
		{
			pw[i][0]=1;
			for(int j=1;j<=r;j++)
			{
				pw[i][j]=pw[i][j-1]*(1-a[i].p);
			}
		}
		memset(f,0,sizeof(f));
		memset(g,0,sizeof(g));
		f[1][0]=pw[1][r];
		f[1][1]=g[1]=1-pw[1][r];
		for(int i=2;i<=n;i++)
		{
			for(int j=0;j<=min(i,r);j++)
			{
				g[i]+=f[i-1][j]*(1-pw[i][r-j]);
				f[i][j]+=f[i-1][j]*pw[i][r-j];
				if(j)
				{
					f[i][j]+=f[i-1][j-1]*(1-pw[i][r-j+1]);
				}
			}
		}
		long double ans=0;
		for(int i=1;i<=n;i++)
		{
			ans+=g[i]*a[i].d;
		}
		printf("%0.10Lf\n",ans);
	}
	return 0;
}

F. houran 和芒果

题面

模拟赛 T3,eps 个人会线性啊。

首先考虑一个弱化版:如果每次是边不可以重复怎么做。显然我们可以直接贪心:假设所有的叶子全都被选了,那么以这些叶子为重要节点建一棵虚树,计算出叶子到最近的公共点之间的距离,然后按照这个从小到大排序并依次删除。每删除一个点就重新建立依次虚树,这次操作显然只需要修改相邻的两个叶子结点,所以可以做到 \(O(n\log n)\)。

在这道题中,因为是点不能重复,所以在一个分叉点上必然只能选择一条父亲到儿子的边。同样还是可以考虑贪心,不过直接贪心显然没有正确性,因此我们可以反贪。

我发现我不是很会反悔,简单提一下:我们设 \(f_x\) 表示以 \(x\) 为链顶时的答案。那么我们将 \(x\) 的所有儿子边全部按照边权从大到小排序,显然如果 \(p\) 在 \(q\) 之前,那么肯定是选 \(f_p+w_p+f_q\) 比选 \(f_p+w_q+f_q\) 优。

所以只有两种情况:\(f_p+w_p+f_q\) 和 \(f_q+w_q\),这两种情况作差就是 \(f_p+w_p-w_q\),也就是当前的最优答案减去 \(w_q\),所以反悔的过程大致就是判断当前 \(f_q+w_q\) 与 \(f_x\) 谁更大,如果 \(f_q+w_q\) 更大,那么就让 \(f_p=f_x-w_q\),然后 \(f_x=f_q+w_q\)。最后从大到小排序然后取前 \(m\) 大就行了。复杂度 \(O(n\log n)\)。

我们很容易发现上面那个做法把排序再干掉就能做到 \(O(n)\) 了,显然可以用计数排序,然后就做到线性了。

当然如果你不会反贪,我们也可以从 DP 的角度来看。设 \(f_{x,i}\) 表示以 \(x\) 为链顶,选了 \(i\) 条链时的最大价值。转移显然是形如 \(f_{x,i}=\max_{y\isin\operatorname{son}(x)}\{f_{x,i-z}+f_{y,z}\}\) 的东西。

这是一个 \((\max,+)\) 卷积合并。只要这两个 DP 都具有凸性,那么最终结果也必然具有凸性。

显然如果只是正常的做 \((\max,+)\) 卷积的话是能一直保持凸性的,但问题是我们还要选一条链并把它跟链顶之间的边计入贡献。

你会发现这无疑是困难的,一般做法可以多加一维 \(0/1\) 来表示是否选了链。但是我们可以将 \(w_y\) 从大到小排序,那么就会有形似上面的结论:即要么这条边不选,要么前面的链都不选。

所以我们会有第二个转移是 \(f_{x,i}=\max\{f_{y,i}+w_y\}\),那么这个 DP 还具不具有凸性呢?

我们考虑将上面的那个转移视作让 \(f_{x,0}\) 加上 \(w_y\) 后做 \((\max,+)\) 卷积,显然这是成立的,我们只需要证明出 \(f_{x,0}\) 在加上 \(w_y\) 后仍然保持凸性即可。

证明稍微有点复杂,大致就是说因为你的 \(w_y\) 是单调不降的,所以第一段的斜率会越来越大并且一直比第二段大,所以这个 DP 就能一直保持凸性。用可并堆随便维护一下差分数组即可。复杂度 \(O(n\log n)\)。

现在我们把这个问题放到可并堆上观察:你会发现我们似乎每次只关心差分最大的那个值(因为要在这上面减掉一个 \(w_y\)),那么我们可以将第二维省去,直接维护最大的差分值即可。最后排序然后做前缀和就能得到答案。

最后还是利用计数排序替代边排序,用 nth_element 替代最后一个排序,即可做到 \(O(n)\)。

实现常数稍微有点大,给出一个不卡常的代码:

const int N=2e5+6,V=(1<<17);
int n,m,num,a[6],fa[N],w[N],cnt[V],id[N];
long long b[N],f[N];
vector<pair<int,int>>v[N];
void dfs(int x)
{
	for(auto i:v[x])
	{
		dfs(i.first);
		if(!f[x])
		{
			f[x]=f[i.first]+i.second;
			continue;
		}
		f[x]-=i.second;
		if(f[x]<f[i.first])
		{
			swap(f[x],f[i.first]);
		}
		b[++num]=f[i.first];
		f[x]+=i.second;
	}
}
signed main()
{
	n=read();
	read(fa+2,fa+n+1);
	read(w+2,w+n+1);
	int T=read();
	while(T--)
	{
		read(a,a+4);
		m=read();
		for(int i=2;i<=n;i++)
		{
			w[i]^=a[i&3];
			cnt[w[i]]++;
		}
		for(int i=V-2;i>=0;i--)
		{
			cnt[i]+=cnt[i+1];
		}
		for(int i=n;i>=2;i--)
		{
			id[cnt[w[i]]--]=i;
		}
		for(int i=1;i<n;i++)
		{
			v[fa[id[i]]].push_back(make_pair(id[i],w[id[i]]));
		}
		dfs(1);
		b[++num]=f[1];
		int k=min(num,m);
		nth_element(b+1,b+num-k,b+num+1);
		long long ans=0;
		for(int i=num-k+1;i<=num;i++)
		{
			ans+=b[i];
		}
		write(ans);
		putchar('\n');
		num=0;
		for(int i=1;i<=n;i++)
		{
			v[i].clear();
			f[i]=0;
		}
		for(int i=2;i<=n;i++)
		{
			w[i]^=a[i&3];
		}
		for(int i=0;i<V;i++)
		{
			cnt[i]=0;
		}
	}
	return 0;
}

G. Unbranched

题面

把连通分量理解成边双连通分量了我大概率是没救了。

首先你要搞清楚连通分量的意思其实就是连通块。

然后观察题目嘛,显然每个点的度数最大是 \(2\),那么这个图上就只会存在链和环两种图。

那么我们很容易猜出一个 DP:设 \(f_{i,j}\) 表示考虑了 \(i\) 个点,用了 \(j\) 条边时的方案数。转移思路显然只有两种:将当前点拼在前面或直接考虑一整个图。

我们会发现如果要考虑当前点拼在了前面某个图里面的话方案数并不好算,大概率还要再记一维,这样 DP 就变成 \(O(n^4)\) 了不可接受。所以考虑第二种转移。

对于最后一张图,枚举这张图上有 \(k\) 个点,那么考虑分类讨论:

  1. 如果这张图是链,那么从 \(f_{i-k,j-k+1}\) 转移过来,\(k\) 个点排列的方案数是 \(k!\),因为是无向边,所以这个链对称一遍跟原来还是一样的,所以最终方案数是 \(\frac{k!}{2}\)。特别的,如果这是一个孤点,那么方案数就是 \(1\)。

  2. 如果这张图是环,那么从 \(f_{i-k,j-k}\) 转移过来,\(k\) 个点排列的方案数是 \(k!\),因为环转一下是不变的,最多可以转 \(k\) 次,又因为是无向边,所以环对称一下还是原本的环,所以最终方案数是 \(\frac{k!}{2k}=\frac{(k-1)!}{2}\)。特别的,如果这个环上只有 \(2\) 个点,那么方案数是 \(1\)。

显然因为我们还要从 \(n-i+k\) 中选出 \(k\) 个点所以还需要乘一个 \(\binom{n-i+k}{k}\)。

因为我们还需要知道是否有大小为 \(L\) 的连通块出现过,所以只需要在 DP 后再加一维 \(0/1\) 表示是否出现过就行了。

但是这个 DP 显然是有问题的。具体而言,我们现在做的相当于给所有图都排好了序,但是正常的一张图是没有顺序的。一种比较自然的想法是我可以记录有多少张图,然后除掉图个数的排列方案数。但是这样我们肯定还要再记一维,不可接受。

考虑一个 trick:对于图计数问题,我们可以钦定当前图中一定存在一个点,然后让剩下的点加入进来,可以做到去重。那么我们就需要将上面的方案数改一下,改成 \(\binom{n-i+k-1}{k-1}\)。然后就行了。

时间复杂度:\(O(nmL)\)。

代码:

const int N=306,mod=1e9+7;
int n,m,mx,fac[N],inv[N],invv[N],f[N][N][2];
int calc1(int x)
{
	return MOD(fac[x]*(x==1?1:invv[2]),mod);
}
int calc2(int x)
{
	return MOD(fac[x-1]*(x==2?1:invv[2]),mod);
}
int C(int x,int y)
{
	return MOD(MOD(fac[x]*inv[y],mod)*inv[x-y],mod);
}
signed main()
{
	n=read(),m=read(),mx=read();
	fac[0]=fac[1]=1;
	inv[0]=inv[1]=1;
	invv[0]=invv[1]=1;
	for(int i=2;i<=n;i++)
	{
		fac[i]=MOD(fac[i-1]*i,mod);
		inv[i]=MOD((mod-mod/i)*inv[mod%i],mod);
		invv[i]=MOD((mod-mod/i)*invv[mod%i],mod);
	}
	for(int i=1;i<=n;i++)
	{
		inv[i]=MOD(inv[i]*inv[i-1],mod);
	}
	f[0][0][0]=1;
	for(int i=1;i<=n;i++)
	{
		for(int j=0;j<=m;j++)
		{
			for(int k=1;k<=min({mx,i,j+1});k++)
			{
				f[i][j][1]=MOD(f[i][j][1]+MOD(f[i-k][j-k+1][1]*C(n-i+k-1,k-1),mod)*calc1(k),mod);
				if(k!=mx)
				{
					f[i][j][0]=MOD(f[i][j][0]+MOD(f[i-k][j-k+1][0]*C(n-i+k-1,k-1),mod)*calc1(k),mod);
				}
				else
				{
					f[i][j][1]=MOD(f[i][j][1]+MOD(f[i-k][j-k+1][0]*C(n-i+k-1,k-1),mod)*calc1(k),mod);
				}
			}
			for(int k=2;k<=min({mx,i,j});k++)
			{
				f[i][j][1]=MOD(f[i][j][1]+MOD(f[i-k][j-k][1]*C(n-i+k-1,k-1),mod)*calc2(k),mod);
				if(k!=mx)
				{
					f[i][j][0]=MOD(f[i][j][0]+MOD(f[i-k][j-k][0]*C(n-i+k-1,k-1),mod)*calc2(k),mod);
				}
				else
				{
					f[i][j][1]=MOD(f[i][j][1]+MOD(f[i-k][j-k][0]*C(n-i+k-1,k-1),mod)*calc2(k),mod);
				}
			}
		}
	}
	write(f[n][m][1]);
	return 0;
}

H. 数数

题面

不是这不是数位 DP 板子吗?

首先一眼数位 DP,那么我们就会想到用差分的方法来分别计算 \([1,L-1]\) 和 \([1,R]\) 的答案最后相减即可。这个贡献显然需要拆到每一位上计算。

思考假设我当前在第 \(pos\) 位那么我可以做的贡献是多少。首先显然低位的可以选择 \([0,pos-1]\) 之间个数。那么如果当前这一位的数字是 \(num\),它能做的贡献就是 \(num\sum_{i=0}^{pos-1}B^i\)。当然低位有很多种选择方案,所以我需要单独记一个 \(h\) 表示低位当前的方案数是多少,于是这一位能做的贡献就是 \(h\cdot num\sum_{i=0}^{pos-1}B^i\)。

但是显然高位也有很多种方案,在这些方案中当前这一位如果不变那么就需要重复计算多次贡献。一种简单方法是我们可以将低位的方案数拆到高位的每一位上,高位每枚举一次就可以得到当前低位需要重复计算的贡献,然后重复计入即可。假设这个数是 \(g\),那么实际上的贡献应该是 \(g+h\cdot num\sum_{i=0}^{pos-1}B^i\)。

我们将最终答案计为 \(f\),那么当前这一位的答案应该就是低位的答案加上这一位的贡献,即 \(f+g+h\cdot num\sum_{i=0}^{pos-1}B^i\)。

暴力枚举转移我们就得到了这样一份代码:

const int N=1e6+6,mod=20130427;
struct bign{
	int len,x[N];
	bign()
	{
		len=0;
		memset(x,0,sizeof(x));
	}
	void init()
	{
		len=read();
		read(x+1,x+len+1);
		reverse(x+1,x+len+1);
	}
};
int B;
void fix(bign &a)
{
	for(int i=1;i<=a.len;i++)
	{
		if(a.x[i]<0)
		{
			a.x[i+1]--;
			a.x[i]+=B;
		}
	}
	while(a.x[a.len]==0&&a.len>1)
	{
		a.len--;
	}
}
bign operator - (bign a,int b)
{
	a.x[1]-=b;
	fix(a);
	return a;
}
bign L,R;
int n,a[N],pw[N];
struct DP{
	int f,g,h;
	void clear()
	{
		f=g=h=-1;
	}
}f[N];
DP calc(int pos,bool limit,bool head)
{
	if(!pos)
	{
		return (DP){0,0,1};
	}
	if(!limit&&!head&&f[pos].f!=-1)
	{
		return f[pos];
	}
	int mx=limit?a[pos]:B-1;
	DP g;
	g.f=g.g=g.h=0;
	for(int i=0;i<=mx;i++)
	{
		DP h=calc(pos-1,limit&&(i==mx),head&&(i==0));
		if(head&&(i==0))
		{
			g.f=MOD(g.f+h.f,mod);
			continue;
		}
		g.f=MOD(g.f+h.f+h.g+MOD(MOD(h.h*pw[pos-1],mod)*i,mod),mod);
		g.g=MOD(g.g+h.g+MOD(MOD(h.h*pw[pos-1],mod)*i,mod),mod);
		g.h=MOD(g.h+h.h,mod);
	}
	if(!limit&&!head)
	{
		f[pos]=g;
	}
	return g;
}
int solve(bign &x)
{
	n=x.len;
	for(int i=1;i<=n;i++)
	{
		a[i]=x.x[i];
	}
	for(int i=1;i<=n;i++)
	{
		f[i].clear();
	}
	return calc(n,1,1).f;
}
signed main()
{
	B=read();
	pw[0]=1;
	for(int i=1;i<N;i++)
	{
		pw[i]=MOD(pw[i-1]*B,mod);
	}
	for(int i=1;i<N;i++)
	{
		pw[i]=MOD(pw[i]+pw[i-1],mod);
	}
	L.init();
	R.init();
	if(L.len==1&&L.x[1]==0)
	{
		write(solve(R));
		return 0;
	}
	L=L-1;
	write(MOD(solve(R)-solve(L),mod));
	return 0;
}

这份代码的复杂度是 \(O(nB)\) 的,瓶颈在于每次转移。

当然通过观察你很容易发现如果当前这一位取在 \([1,mx-1]\) 之间,那么 limit 和 head 都是一样的,算出来的答案肯定也一样。所以我们可以将它合并,那么就只需要对 \(0\) 和 \(mx\) 分别单独计算一遍就行了。

时间复杂度:\(O(n)\)。

代码:

const int N=1e6+6,mod=20130427;
struct bign{
	int len,x[N];
	bign()
	{
		len=0;
		memset(x,0,sizeof(x));
	}
	void init()
	{
		len=read();
		read(x+1,x+len+1);
		reverse(x+1,x+len+1);
	}
};
int B;
void fix(bign &a)
{
	for(int i=1;i<=a.len;i++)
	{
		if(a.x[i]<0)
		{
			a.x[i+1]--;
			a.x[i]+=B;
		}
	}
	while(a.x[a.len]==0&&a.len>1)
	{
		a.len--;
	}
}
bign operator - (bign a,int b)
{
	a.x[1]-=b;
	fix(a);
	return a;
}
bign L,R;
int n,a[N],pw[N];
struct DP{
	int f,g,h;
	void clear()
	{
		f=g=h=-1;
	}
}f[N];
DP calc(int pos,bool limit,bool head)
{
	if(!pos)
	{
		return (DP){0,0,1};
	}
	if(!limit&&!head&&f[pos].f!=-1)
	{
		return f[pos];
	}
	int mx=limit?a[pos]:B-1;
	DP g;
	g.f=g.g=g.h=0;
	if(!mx)
	{
		DP h=calc(pos-1,limit,head);
		if(head)
		{
			g.f=MOD(g.f+h.f,mod);
		}
		else
		{
			g.f=MOD(g.f+h.f+h.g,mod);
			g.g=MOD(g.g+h.g,mod);
			g.h=MOD(g.h+h.h,mod);
		}
	}
	else
	{
		for(int i=0;i<=mx;i+=mx)
		{
			DP h=calc(pos-1,limit&&(i==mx),head&&(i==0));
			if(head&&(i==0))
			{
				g.f=MOD(g.f+h.f,mod);
				continue;
			}
			g.f=MOD(g.f+h.f+h.g+MOD(MOD(h.h*pw[pos-1],mod)*i,mod),mod);
			g.g=MOD(g.g+h.g+MOD(MOD(h.h*pw[pos-1],mod)*i,mod),mod);
			g.h=MOD(g.h+h.h,mod);
		}
	}
	int cnt=mx-1;
	if(cnt>0)
	{
		DP h=calc(pos-1,0,0);
		g.f=MOD(g.f+MOD(cnt*(h.f+h.g),mod)+MOD(MOD(h.h*pw[pos-1],mod)*MOD(cnt*(cnt+1)/2,mod),mod),mod);
		g.g=MOD(g.g+MOD(cnt*h.g,mod)+MOD(MOD(h.h*pw[pos-1],mod)*MOD(cnt*(cnt+1)/2,mod),mod),mod);
		g.h=MOD(g.h+MOD(cnt*h.h,mod),mod);
	}
	if(!limit&&!head)
	{
		f[pos]=g;
	}
	return g;
}
int solve(bign &x)
{
	n=x.len;
	for(int i=1;i<=n;i++)
	{
		a[i]=x.x[i];
	}
	for(int i=1;i<=n;i++)
	{
		f[i].clear();
	}
	return calc(n,1,1).f;
}
signed main()
{
	B=read();
	pw[0]=1;
	for(int i=1;i<N;i++)
	{
		pw[i]=MOD(pw[i-1]*B,mod);
	}
	for(int i=1;i<N;i++)
	{
		pw[i]=MOD(pw[i]+pw[i-1],mod);
	}
	L.init();
	R.init();
	if(L.len==1&&L.x[1]==0)
	{
		write(solve(R));
		return 0;
	}
	L=L-1;
	write(MOD(solve(R)-solve(L),mod));
	return 0;
}

I. Sequence Growing Hard

题面

神题,想了两节课没想出来怎么做,题解的 DP 还是太神了。

首先把一个数插入进去还满足条件似乎并不是很好想,我们倒过来考虑(我说我怎么还是学不会逆向思维啊)。

那么现在就相当于给定 \(A_n\),你可以选择一个位置 \(i\) 并删除掉这个位置的数,考虑删除之后的比较过程是怎么样的:

  • 因为 \([1,i-1]\) 没有任何修改,所以完全一样没法比较。
  • \(s'_i=s_{i+1}\),那么如果 \(s'_i=s_i=s_{i+1}\),就要比较下一位,以此类推。

我们会发现比较过程是类似于找到 \(i\) 之后连续的最后一个与 \(a_i\) 值相同的位置 \(k\),然后让 \(a_{k+1}\lt a_k\) 条件就成立。

我们会发现删掉 \([i,k]\) 中的任何一个位置上的数结论都一样,为了防止重复计算我们可以钦定每次只删 \(k\),于是条件瞬间变成了 \(a_i\gt a_{i+1}\)(\(i\) 表示删除的位置)。

那么我们可以设 \(f_{i,j}\) 表示考虑一个长度为 \(i\) 的串 \(A_i\),这个串可以用的数有 \(j\) 个。我们枚举这 \(j\) 个数中最小数第一次出现的位置 \(k\),那么上面的结论告诉了我们如果要删掉 \(k\) 就必须把 \([k+1,i]\) 之间的数全删了。枚举第 \(k\) 个数在第 \(l\) 时刻被删了,那么显然有的一个转移是:

\[f_{i,j}=f_{i,j-1}+\sum_{k=1}^if_{k-1,j-1}f_{i-k,j}\sum_{l=i-k+1}^i\binom{l-1}{i-k} \]

后面那个东西显然是可以前缀和预处理的,于是我们就做到了 \(O(n^3)\) 的转移。

代码:

const int N=306;
int n,m,mod,f[N][N],C[N][N];
signed main()
{
	n=read(),m=read(),mod=read();
	C[0][0]=1;
	for(int i=1;i<=n;i++)
	{
		C[i][0]=1;
		for(int j=1;j<=i;j++)
		{
			C[i][j]=MOD(C[i-1][j-1]+C[i-1][j],mod);
		}
	}
	for(int j=0;j<=n;j++)
	{
		for(int i=1;i<=n;i++)
		{
			C[i][j]=MOD(C[i][j]+C[i-1][j],mod);
		}
	}
	for(int j=0;j<=m;j++)
	{
		f[0][j]=1;
	}
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			for(int k=1;k<=i;k++)
			{
				f[i][j]=MOD(f[i][j]+MOD(f[k-1][j-1]*f[i-k][j],mod)*C[i-1][i-k],mod);
			}
			f[i][j]=MOD(f[i][j]+f[i][j-1],mod);
		}
	}
	write(f[n][m]);
	return 0;
}
posted @ 2026-11-10 10:58  cwxcplh  阅读(22)  评论(0)    收藏  举报