[ACNOI2022]我不会GF啊

题目

题目背景
雨。

用瓢泼已经不足以形容这雨了；水滴密集到近乎在空中连接成固体，视线无法穿透。

四下都是雨落在地上的敲击声——不，已经是轰鸣声——就像天空要将自己撞入大地那样迅猛。

$\mathsf{O}\mathsf{n}\mathsf{e}\mathsf{I}\mathsf{n}\mathsf{D}\mathsf{a}\mathsf{r}\mathsf{k}$ 往外望去，也只能看到雨。间杂的电闪雷鸣是唯一的光源。

$\mathsf{O}\mathsf{n}\mathsf{e}\mathsf{I}\mathsf{n}\mathsf{D}\mathsf{a}\mathsf{r}\mathsf{k}$ 坐在孤零零的帐篷里，在这片平原上显得微不足道。

忽而一声惊雷，$\mathsf{O}\mathsf{n}\mathsf{e}\mathsf{I}\mathsf{n}\mathsf{D}\mathsf{a}\mathsf{r}\mathsf{k}$ 那因恐惧而闭上的双眼再度睁开时，他看到一个巨大的白色身影，立在帐篷前。雨滴似乎不能侵染它半分。

$\mathsf{O}\mathsf{n}\mathsf{e}\mathsf{I}\mathsf{n}\mathsf{D}\mathsf{a}\mathsf{r}\mathsf{k}$ 知道那是什么。见过它的人，如果还侥幸活着，无一不陷入癫狂。$\mathsf{O}\mathsf{n}\mathsf{e}\mathsf{I}\mathsf{n}\mathsf{D}\mathsf{a}\mathsf{r}\mathsf{k}$ 只来得及写下扭曲的 ${\ell }_{\supset }\mathfrak{u}\gamma ı\mathfrak{n}\nu ȷ$，就已经不省人事。

醒时已破晓。$\mathsf{O}\mathsf{n}\mathsf{e}\mathsf{I}\mathsf{n}\mathsf{D}\mathsf{a}\mathsf{r}\mathsf{k}$ 看到了他这辈子永远不会忘记的一幕：

雨，兔子，漂浮的蛋。

这是他的话中唯一能够被辨认出的词汇了。

题目描述
你需要选出 $n$ 个 $[0,L]$ 中的整数（可以相同），满足最大值 $⩾\beta$ 而次大值 $<\alpha$，且最大值小于其他数字的和。额外限制每种数字最多选出 $k$ 个，请计算有多少种不同的选法。

两种选法不同，当且仅当某种数字的被选中次数不同。答案对 $(10^9+7)$ 取模。

数据范围与提示
$n⩽8$ 但 $L⩽10^9$ 。保证 $1<\alpha ⩽\beta ⩽L$ 。

思路

名兔名言：$n$ 越小，题越难。

好吧我摊牌了其实是我太菜了 😢

先放一个基础做法。大数字的比较，容易想到按二进制位 $\mathtt{d}\mathtt{p}$，就像此题。但怎么让数字有序？怎么统计同一种数字的数量？

我好像忘了 $n$ 超级小……可以 $3^{n-2}$ 记录相邻数字的大小关系（大于或等于或小于），然后用类似插头 $\mathtt{d}\mathtt{p}$ 的方式转移。

上面的做法没想到，考虑数学转化。告诫：不要用二元生成函数！真的是维度灾难 😭

坚持一元

还是不敏感 $\text{Burnside}$ 定理啊。正是在选择的元素无序时，它才能派上用场啊。只需给置换设定权值 $\omega (g)$ 使得 $\omega (G_H)f(H)$ 只在 $H$ 不含出现次数超过 $k$ 的颜色时 $=1$ 。

设 $G_H=⨁S_i^{c_i}$，这里的次方指直积，其中 $S_i$ 为 $i$ 元对称群。不难发现 $f(H)=\left(\genfrac{}{}{0ex}{}{n-1}{c_1,c_2,\dots ,c_{n-1}}\right)$ 。因此我们需要让 $\omega (S_i)=i!(i⩽k)$ 去抵消系数。

我们不妨猜测 $\omega (g)=\prod \nu (i{)}^{c_i}$ 。不难发现只需满足
$$\exp F(x)=\sum _{i=0}^k\frac{x^i}{i!}$$

其中
$$F(x)=\sum _{i=1}^{+\infty }\frac{\nu (i)x^i}{i}$$

为 $(i-1)!\nu (i)$ 的 $\mathrm{E}\mathrm{G}\mathrm{F}$ 。用多项式 $\ln$ 可求出 $F(x)$，因此也就得到了 $\omega (g)$ 的表达式。

由 $\text{Burnside}$ 定理，转而计算 $\sum \omega (g)|X^g|$ 。显然 $g$ 的循环指标可枚举。现在只需计算不动点权值和。

不动点权值

单个数字的选择的 $\mathrm{O}\mathrm{G}\mathrm{F}$ 为 $H(x)=\frac{1-x^{\alpha }}{1-x}$，因此循环指标为 $\prod x_i^{c_i}$ 时只需求 $\prod H(x^i{)}^{c_i}$ 。这很容易计算：暴力求出分母
$$M(x)=\prod _{i=1}^{n-1}(1-x^i{)}^{c_i}$$

后，分子就是 $M(x^{\alpha })$ 。

最终贡献中，$[x^t]\frac{M(x^{\alpha })}{M(x)}(t>\beta )$ 的系数是 ( min ⁡ { L + 1 , t } − β ) (\min\{L{+}1,t\}{-}\beta) (min{L+1,t}−β) 。那么事实上就是
$$\begin{array}{rl}& (L+1-\beta )\cdot [x^{+\infty }]\frac{M(x^{\alpha })}{(1-x)M(x)}\\ & -(L+1)\cdot [x^{L+1}]\frac{M(x^{\alpha })}{(1-x)M(x)}\\ & +[x^L]\frac{1}{1-x}{\left[\frac{M(x^{\alpha })}{M(x)}\right]}^{\prime }\\ & -[x^{\beta }]\frac{x}{1-x}{\left[\frac{M(x^{\alpha })}{M(x)}\right]}^{\prime }\\ & +\beta \cdot [x^{\beta }]\frac{M(x^{\alpha })}{(1-x)M(x)}\end{array}$$

不涉及求导的项，就是求 $\frac{M(x^{\alpha })}{(1-x)M(x)}$ 的远处值。注意到 $\mathrm{deg}M(x)=n-1$，暴力枚举分子的每一项，剩下的问题就是 $\frac{1}{\gamma (x)}$ 的远处值，显然就是个线性递推。总时间复杂度 $\mathcal{O}(n\mathcal{P}(n)\log L)$，其中 $\mathcal{P}(n)$ 是多项式乘法的复杂度。

涉及求导的项则是 $\frac{1}{1-x}{\left[\frac{M(x^{\alpha })}{M(x)}\right]}^{\prime }$ 的远处值。要么分子求导，这可以和上面一样通过暴力枚举每一项得到；要么分母求导，我们将得到
$$\frac{-M(x^{\alpha })M^{\prime }(x)}{(1-x)M(x{)}^2}$$

这看上去略显复杂。我们不妨找到其真正的样子
$$\frac{-M^{\prime }(x)}{M(x)}=\sum _{i=1}^{n-1}\frac{i{c}_i{x}^{i-1}}{1-x^i}$$

由于 $\sum i{c}_i=n-1$，不同的 $i$ 只有 $\sqrt{n}$ 个。就本题的数据范围而言，这有意义吗。枚举之，再做线性递推。总复杂度 $\mathcal{O}(n^{1.5}\mathcal{P}(n)\log L)$ 。

上述过程是对某个确定的 $g$ 的循环指标的求解，因此最终复杂度为 $\mathcal{O}(\text{Partition}(n)\cdot n^{1.5}\mathcal{P}(n)\log L)$ 。

代码

极限数据只需 $11\mathrm{m}\mathrm{s}$ 出结果，恐怖如斯。

建议使用 vector 实现 Polynomial 类，不然真的很难写。

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cctype>
#include <vector>
#include <initializer_list>
using llong = long long;
# define rep(i,a,b) for(int i=(a); i<=(b); ++i)
# define drep(i,a,b) for(int i=(a); i>=(b); --i)
# define rep0(i,a,b) for(int i=(a); i!=(b); ++i)
inline int readint(){
	int a = 0, c = getchar(), f = 1;
	for(; !isdigit(c); c=getchar()) if(c == '-') f = -f;
	for(; isdigit(c); c=getchar()) a = a*10+(c^48);
	return a*f;
}

const int MOD = 1e9+7;
inline llong qkpow(llong b, int q){
	llong a = 1;
	for(; q; q>>=1,b=b*b%MOD) if(q&1) a = a*b%MOD;
	return a;
}

struct Poly : public std::vector<int>{
	Poly(){ clear(); }
	Poly(std::initializer_list<int> args){
		std::initializer_list<int>::iterator it;
		for(it=args.begin(); it!=args.end(); ++it)
			emplace_back(*it); // just push
	}
	Poly getInv() const {
		assert(at(0) == 1);
		unsigned len = size(); int v = 0;
		Poly c; c.resize(len); c[0] = 1;
		for(unsigned i=1; i!=len; ++i,v=0){
			for(unsigned j=0; j!=i; ++j)
				v = int((v+llong(c[j])*at(i-j))%MOD);
			c[i] = v ? MOD-v : 0;
		}
		return c;
	}
	Poly getLn() const;
	Poly deri() const { // derivative
		unsigned len = size();
		Poly c; c.resize(len-1);
		for(unsigned i=1; i!=len; ++i)
			c[i-1] = int(llong(i)*at(i)%MOD);
		return c;
	}
	Poly inte() const { // integral
		unsigned len = size();
		Poly c; c.resize(len+1);
		for(unsigned i=1; i<=len; ++i)
			c[i] = int(qkpow(i,MOD-2)*at(i-1)%MOD);
		c[0] = 0; return c;
	}
	Poly extract_even() const {
		unsigned len = size();
		Poly c; c.resize((len+1)>>1);
		for(unsigned i=0; i<len; i+=2) c[i>>1] = at(i);
		return c;
	}
	Poly extract_odd() const {
		unsigned len = size();
		Poly c; c.resize(len>>1);
		for(unsigned i=1; i<len; i+=2) c[i>>1] = at(i);
		return c;
	}
	int at_far(int) const ;
};
Poly operator * (const Poly &a, const Poly &b){
	unsigned lena = a.size(), lenb = b.size();
	Poly c; c.resize(lena+lenb-1u, 0);
	for(unsigned i=0; i!=lena; ++i)
		for(unsigned j=0; j!=lenb; ++j)
			c[i+j] = int((c[i+j]+llong(a[i])*b[j])%MOD);
	return c;
}
Poly Poly::getLn() const {
	Poly res = (deri()*getInv()).inte();
	res.resize(size()); return res;
}
int Poly::at_far(int L) const {
	if(L < 0) return 0;
	Poly son; son.resize(1,1);
	for(Poly mom=*this; L; L>>=1){
		Poly nxt = mom; unsigned len = mom.size();
		for(unsigned i=1; i<len; i+=2)
			if(nxt[i]) nxt[i] = MOD-nxt[i];
		mom = (mom*nxt).extract_even(), son = son*nxt;
		if(L&1) son = son.extract_odd();
		else son = son.extract_even();
	}
	return son[0];
}

const int MAXN = 9;
int alpha, beta, L, chose[MAXN];
int at_far(const Poly &son, const Poly &mom, const int &n){
	unsigned len = std::min(son.size(),
		std::vector<int>::size_type(n/alpha)+1);
	int res = 0;
	for(unsigned i=0; i!=len; ++i)
		res = int((res+llong(son[i])*
			mom.at_far(n-alpha*i))%MOD);
	return res;
}
int check(const int &n){
	static Poly son; son.clear();
	son.resize(n+1,0), son[0] = 1;
	int res = L+1-beta;
	rep(t,1,n) rep(_,1,chose[t]){
		drep(i,n,t) son[i] = int((son[i]+MOD-son[i-t])%MOD);
		res = int(llong(res)*alpha%MOD);
	}
	Poly mom = son*Poly{1,MOD-1}; // (1-x)
	const unsigned len = son.size();
	for(unsigned i=0; i!=len; ++i){
		if(i > (L+1)/alpha) break; // too big
		res = int((res+llong(MOD-L-1)*son[i]
			%MOD*mom.at_far(L+1-alpha*i))%MOD); // -(L+1)[]
		res = int((res+llong(alpha*i)*son[i]
			%MOD*mom.at_far(L-alpha*i+1))%MOD); // +[]'
		res = int((res+llong(MOD-alpha*i)*son[i]
			%MOD*mom.at_far(beta-alpha*i))%MOD); // -[]'
		res = int((res+llong(beta)*son[i]
			%MOD*mom.at_far(beta-i*alpha))%MOD); // +b[]
	}
	rep(t,1,n) if(chose[t]){
		Poly nxt; nxt.resize(t+1, 0);
		nxt[0] = 1, nxt[t] = MOD-1;
		nxt = nxt*mom; // new fraction mother
		res = int((res+llong(t*chose[t])
			*at_far(son,nxt,L-t+1))%MOD); // +[]'
		res = int((res+llong(MOD-t*chose[t])
			*at_far(son,nxt,beta-t))%MOD); // -[]'
	}
	return res;
}

Poly coe; int ans, invjc[MAXN];
// @param n how many elements chosen
void dfs(const int &n, int t, int left, int omega){
	if(t == 1){
		chose[1] = left; // must use up
		ans = int((ans+llong(check(n))
			*omega%MOD*invjc[left])%MOD); return;
	}
	for(chose[t]=0; left>=0; left-=t,++chose[t]){
		dfs(n,t-1,left,int(omega // unordered
			*llong(invjc[chose[t]])%MOD));
		omega = int(llong(coe[t])*omega%MOD);
	}
}

int main(){
	int n = readint(); L = readint();
	beta = readint(), alpha = readint()+1;
	int maxcnt = readint();
	if(maxcnt == n) maxcnt = n-1;
	rep(i,invjc[0]=1,n) invjc[i] = int(
		qkpow(i,MOD-2)*invjc[i-1]%MOD);
	coe.resize(maxcnt+1,1);
	coe.resize(n,0); // pre-compute
	coe = coe.getLn(); // long enough
	dfs(n-1, n-1, n-1, 1);
	printf("%d\n",ans);
	return 0;
}