jzoj6377. 【NOIP2019模拟2019.10.05】幽曲[埋骨于弘川]

题解

真的都快忘了。
首先，我们考虑排序，求出一个神奇的排列方式，也就是dfn序。
那么答案必定是在dfn序里面一些连续的段连接起来。
然后我们就判断这玩意儿是否满足在a里面出现过。

于是现在分两步走：

第一步，假如现在有一个数字A，我们要判断其是否可以出现在a里面。
我们现在就有一种构造思路就是：从高位开始构造，假设现在构造到第i位，一直加个位之后，满足当前这位等于数字A的第i位后，继续构造第i-1位。
那么我们发现可以用一个神奇的DP来实现这个判断过程。

设$f_{i,p,x}$表示当前做到第i位，最高位到第i位数字已经填完后最大的数字为p，个位为x开始，让第i位+1后个位变成$f_{i,p,x}$。
这个就可以从低位开始转移到高位，每次让低位进位k次即可。注意这个p，不然会被搞崩心态。
然后再设一个$g_{i,j,p,x}$表示的东东和上面类似，只是这个j表示的是让第i位进位到j。
转移的话就从j-1位进过去，利用f数值即可。

第二步，开始统计答案。
我们设$d{p}_{i,j,p,x}$表示当前走到dfn序中的第i位，当前弄出来的数字是第j位，且当前位置放的是$d[dfn[i]]$，最大值为p，各位从x开始的方案数。
我们发现，这个i是可以从$f{a}_i$到$i$这一段区间内转移过来的。
所以说，我们可以利用前缀和优化一下，时间复杂度就变成$O(n^2\ast k^2)$

小细节巨多无比。

标程

#include <iostream>
#include <cstring>
#include <cmath>
#include <cstdio>
#include <algorithm>
#include <cctype>
using namespace std;
const long long mo=998244353;
const int maxn=501;
const int maxm=11;

int n,m,a[maxn],x[maxn],y[maxn],gs;
int f[maxn][maxm][maxm];
int g[maxn][maxm][maxm][maxm];
long long dp[maxn][maxn][maxm][maxm],sum[maxn][maxn][maxm][maxm];
int tot,nex[maxn*2],las[maxn*2],tov[maxn*2];
int dfn[maxn],wz[maxn],fa[maxn],dep;
int tot1,nex1[maxn*2],las1[maxn*2],tov1[maxn*2];
int son[maxn][maxn];

__attribute__((optimize("-O3")))
void qsort(int x,int l,int r)
{
	int i=l;int j=r;
	int m=son[x][(i+j)/2];
	while (i<=j)
	{
		while (son[x][i]>m) i++;
		while (son[x][j]<m) j--;
		if (i<=j)
		{
			swap(son[x][i],son[x][j]);
			i++;j--;
		}
	}
	if (l<j) qsort(x,l,j);
	if (r>i) qsort(x,i,r); 
}

__attribute__((optimize("-O3")))
void insert(int x,int y)
{
	tot++;
	tov[tot]=y;
	nex[tot]=las[x];
	las[x]=tot;
}

__attribute__((optimize("-O3")))
void insert1(int x,int y)
{
	tot1++;
	tov1[tot1]=y;
	nex1[tot1]=las1[x];
	las1[x]=tot1;
}

__attribute__((optimize("-O3")))
void dfs(int x,int ff)
{
	gs++;
	dfn[x]=gs;
	wz[gs]=x;
	for (int i=las1[x];i>0;i=nex1[i])
	{
		if (tov1[i]!=ff)
		{
			fa[tov1[i]]=x;
			dfs(tov1[i],x);
		}
	}
}

__attribute__((optimize("-O3")))
void dfssort(int x,int ff)
{
	for (int i=las[x];i>0;i=nex[i])
	{
		if (tov[i]!=ff)
		{
			son[x][0]++;
			son[x][son[x][0]]=tov[i];
			dfssort(tov[i],x);
		}
	}
	qsort(x,1,son[x][0]);
	for (int i=1;i<=son[x][0];i++)
	{
		insert1(x,son[x][i]);
		insert1(son[x][i],x);
	}
}

__attribute__((optimize("-O3")))
int main()
{
//	freopen("data.in","r",stdin);
	freopen("buried.in","r",stdin);
	freopen("buried.out","w",stdout);
	scanf("%d%d",&n,&m);
	for (register int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
	}
	for (register int i=1;i<n;i++)
	{
		scanf("%d%d",&x[i],&y[i]);
		insert(x[i],y[i]);
		insert(y[i],x[i]);
	}
	dfssort(1,0);
	dfs(1,0);
	for (register int i=1;i<=n;i++)
	{
		for (register int p=0;p<m;p++)
		{
			for (register int x=0;x<m;x++)
			{
				f[i][p][x]=-1;
				for (register int a=0;a<m;a++)
				{
					g[i][p][a][x]=-1;
				}
			}
		}
	}
	for (register int i=0;i<m;i++)
	{
		for (register int x=0;x<m;x++)
		{
			if (i>0 || (i==0 && x>0))
			{
				register int j=x;
				while (j<m)
				{
					g[1][i][j][x]=j;
					j=j+max(j,i);
				}
				f[1][i][x]=j%m;
				g[2][i][1][x]=j%m;
			}
		}
	}
	for (register int i=0;i<m;i++)
	{
		for (register int x=0;x<m;x++)
		{
			g[2][i][0][x]=x;
			if (i>0 || (i==0 && x>0))
			{
				register int j=f[1][i][x];
				for (register int cs=2;cs<m;cs++)
				{
					g[2][i][cs][x]=f[1][max(i,cs-1)][j];
					j=f[1][max(i,cs-1)][j];
				}
			}
		}
	}
	
	for (register int i=2;i<=n;i++)
	{
		for (register int p=0;p<m;p++)
		{
			for (register int x=0;x<m;x++)
			{
				if (p>0 || (p==0 && x>0))
				{
					register int op=x;
					g[i][p][0][x]=x;
					for (register int j=0;j<m;j++)
					{
						op=f[i-1][max(p,j)][op];
						if (j<m-1) g[i][p][j+1][x]=op;
					}
					f[i][p][x]=op;
				}
			}
		}
	}
	for (register int i=3;i<=n;i++)
	{
		for (register int p=0;p<m;p++)
		{
			for (register int x=0;x<m;x++)
			{
				if (p>0 || (p==0 && x>0))
				{
					register int op=f[i-2][m-1][g[i-1][p][m-1][x]];
					g[i][p][1][x]=op;
				}
			}
		}
	}
	for (register int i=3;i<=n;i++)
	{
		for (register int p=0;p<m;p++)
		{
			for (register int x=0;x<m;x++)
			{
				g[i][p][0][x]=x;
				if (p>0 || (p==0 && x>0))
				{
					register int j=g[i][p][1][x];
					for (register int cs=2;cs<m;cs++)
					{
						g[i][p][cs][x]=f[i-1][max(p,cs-1)][j];
						j=f[i-1][max(p,cs-1)][j];
					}
				}
			}
		}
	}
	
	for (register int i=1;i<=n;i++)
	{
		dp[1][i][a[1]][g[i][0][a[1]][1]]=1;
		sum[1][i][a[1]][g[i][0][a[1]][1]]=1;
	}
	for (register int i=2;i<=n;i++)
	{
		for (register int p=0;p<m;p++)
		{
			for (register int x=0;x<m;x++)
			{
				for (register int w=1;w<=n-i+1;w++)
				{
					if (g[w][p][a[wz[i]]][x]>=0)
					{
						dp[i][w][max(p,a[wz[i]])][g[w][p][a[wz[i]]][x]]=
						(dp[i][w][max(p,a[wz[i]])][g[w][p][a[wz[i]]][x]]+sum[i-1][w+1][p][x]-sum[dfn[fa[wz[i]]]-1][w+1][p][x]+mo)%mo;
					}
				}
			}
		} 
		memcpy(sum[i],sum[i-1],sizeof(sum[i-1]));
		for (register int w=1;w<=n-i+1;w++)
		{
			for (register int x=0;x<m;x++)
			{
				for (register int p=0;p<m;p++)
				{
				//	if (g[w][p][a[wz[i]]][x]>=0)
					{
						sum[i][w][p][x]=
						(sum[i][w][p][x]+dp[i][w][p][x])%mo;
					}
				}
			}
		} 
	}
	long long ans=0;
	for (register int i=1;i<=n;i++)
	{
		for (register int j=a[wz[i]];j<m;j++)
		{
			ans=(ans+dp[i][1][j][a[wz[i]]])%mo;
		}
	}
	printf("%lld\n",ans);
}