多项式快速幂小结

多项式快速幂

给出一个多项式 F ( x ) F(x) F(x) 以及常数 k k k,求出 G ( x ) ≡ F k ( x ) ( m o d x n ) G(x)\equiv F^k(x)\pmod {x^n} G(x)Fk(x)(modxn)

之前有学到 ln ⁡ \ln ln exp ⁡ \exp exp,就可以用来处理这样的指数问题。

两边同时取 ln ⁡ \ln ln 得到: ln ⁡ G ( x ) ≡ ln ⁡ ( F ( x ) ) k \ln G(x)\equiv\ln(F(x))^k lnG(x)ln(F(x))k,根据对数函数的性质,得到 ln ⁡ G ( x ) ≡ k ln ⁡ F ( x ) \ln G(x)\equiv k\ln F(x) lnG(x)klnF(x)

然后两边再同时取 exp ⁡ \exp exp,得到 G ( x ) ≡ e k ln ⁡ F ( x ) G(x)\equiv e^{k\ln F(x)} G(x)eklnF(x),接下来拉一拉 ln ⁡ \ln ln exp ⁡ \exp exp 的板子就好了。

发现上面有这样一条柿子: ln ⁡ G ( x ) ≡ k ln ⁡ F ( x ) \ln G(x)\equiv k\ln F(x) lnG(x)klnF(x),而我们的数据运算都是在模 998244353 998244353 998244353 下进行的,也就是说,让 k k k 998244353 998244353 998244353 取模不影响答案,那么就不需要高精度什么的了。

对于洛谷上的加强版,不保证 a 0 = 1 a_0=1 a0=1,是做不了多项式 ln ⁡ \ln ln 的,要分类讨论一下:

  1. a 0 > 1 a_0>1 a0>1,那么设 p = a 0 p=a_0 p=a0,有 F k ( x ) ≡ ( F ( x ) × i n v ( p ) ) k × p k F^k(x)\equiv (F(x)\times inv(p))^k\times p^k Fk(x)(F(x)×inv(p))k×pk,对于 F ( x ) × i n v ( p ) F(x)\times inv(p) F(x)×inv(p),它的 0 0 0 次项一定是 1 1 1,就可以做 ln ⁡ \ln ln 了,求完之后再乘 p k p^k pk 即可。
  2. a 0 = 0 a_0=0 a0=0,那么我们向右找到第一个系数不为 0 0 0 的项,假设是 x z x^z xz,那么让 F ( x ) F(x) F(x) 除以 x z x^z xz 即系数左移 z z z 位,然后像上面那样搞就好,搞完之后再乘 ( x z ) k (x^z)^k (xz)k 即可。

加强版代码如下(由于用了大量vector,需要开O2才能过):

#include <cstdio>
#include <cstring>
#include <vector>
#include <cmath>
#include <algorithm>
using namespace std;
#define maxn 800010
#define mod 998244353
#define bin(x) (1<<(x))

int n,k,k_,length;char s[maxn];
void read(int &x)
{
	x=0;char ch=getchar();while(ch<'0'||ch>'9')ch=getchar();
	while(ch>='0'&&ch<='9'){x=(10ll*x+ch-'0')%mod;ch=getchar();}
}
int inv[maxn];
int ksm(int x,int y){int re=1;for(;(y&1?re=1ll*re*x%mod:0),y;y>>=1,x=1ll*x*x%mod);return re;}
#define INV(x) ksm(x,mod-2)
struct NTT{
	vector<int> w[30];NTT(){
		inv[1]=1;for(int i=2;i<=maxn-10;i++)inv[i]=1ll*(mod-mod/i)*inv[mod%i]%mod;
		for(int i=1,wn;i<=19;i++){
			w[i].resize(bin(i));w[i][0]=1;wn=ksm(3,(mod-1)/bin(i));
			for(int j=1;j<bin(i-1);j++)w[i][j]=1ll*w[i][j-1]*wn%mod;
		}
	}
	int limit,r[maxn];void dft(int *f,int lg,int type=0)
	{
		limit=bin(lg);if(type)reverse(f+1,f+limit);
		for(int i=1;i<limit;i++){r[i]=(r[i>>1]>>1)|((i&1)<<(lg-1));if(i<r[i])swap(f[i],f[r[i]]);}
		for(int mid=1,Lg=1;mid<limit;mid<<=1,Lg++)for(int j=0;j<limit;j+=(mid<<1))for(int i=0;i<mid;i++)
		{int t=1ll*f[j+i+mid]*w[Lg][i]%mod;f[j+i+mid]=(f[j+i]-t+mod)%mod;f[j+i]=(f[j+i]+t)%mod;}
	}
}ntt;
int A[maxn],B[maxn],C[maxn],M;
struct POLY{
	vector<int> a;int len;void rs(int N){a.resize(len=N);}POLY(){rs(M);};
	int &operator [](int x){return a[x];}
	friend POLY operator *(POLY A_,int x){for(int i=0;i<A_.len;i++)A_[i]=1ll*A_[i]*x%mod;return A_;}
	void dft(int *A_,int lg,int ln){for(int i=0;i<bin(lg);i++)A_[i]=(i<min(len,ln)?a[i]:0);ntt.dft(A_,lg);}
	void idft(int *A_,int lg,int ln){ntt.dft(A_,lg,1);rs(ln);for(int i=0;i<ln;i++)a[i]=1ll*A_[i]*inv[bin(lg)]%mod;}
	POLY Mul(POLY b,int ln=M){
		int lg=ceil(log2(2*ln-1));dft(A,lg,ln);b.dft(B,lg,ln);
		for(int i=0;i<bin(lg);i++)B[i]=1ll*A[i]*B[i]%mod;b.idft(B,lg,ln);return b;
	}
}F,G;
void getinv(POLY &f,POLY &g,int ln=M)
{
	if(ln==1){g.rs(1);g[0]=INV(f[0]);return;}getinv(f,g,(ln+1)>>1);
	int lg=ceil(log2(ln*2-1));f.dft(A,lg,ln);g.dft(B,lg,ln);
	for(int i=0;i<bin(lg);i++)B[i]=1ll*(2-1ll*A[i]*B[i]%mod+mod)%mod*B[i]%mod;g.idft(B,lg,ln);
}
POLY getinv(POLY &f,int ln=M){POLY g;getinv(f,g,ln);return g;};
POLY Jifen(POLY f){f.rs(f.len+1);for(int i=f.len-1;i>0;i--)f[i]=1ll*f[i-1]*inv[i]%mod;f[0]=0;return f;}
POLY Dao(POLY f){for(int i=0;i<f.len-1;i++)f[i]=1ll*f[i+1]*(i+1)%mod;f.rs(f.len-1);return f;}
POLY getln(POLY f,int ln=M){return Jifen(Dao(f).Mul(getinv(f,ln),ln-1));}
void getexp(POLY &f,POLY &g,int ln=M)
{
	if(ln==1){g.rs(1);g[0]=1;return;}getexp(f,g,(ln+1)>>1);
	POLY p=getln(g,ln);for(int i=0;i<ln;i++)p[i]=(f[i]-p[i]+mod)%mod;p[0]++;g=p.Mul(g,ln);
}
POLY getexp(POLY f,int ln){POLY g;getexp(f,g,ln);return g;}
POLY getksm(POLY f,int k,int k_,int ln=M)
{
	int st=0;while(!f[st]&&st<ln)st++;for(int i=0;i<ln;i++)f[i]=(i+st<ln?f[i+st]:0);
	int f_0=f[0];f_0=ksm(f_0,k_);f=getexp(getln(f*INV(f[0]),ln)*k,ln)*f_0;
	if(st)if(length<=9&&1ll*st*k<ln)for(int i=n-1;i>=0;i--)f[i]=(i>=st*k?f[i-st*k]:0);else f.rs(0),f.rs(ln); return f;
}

int main()
{
	scanf("%d %s",&n,s);M=n;F.rs(n);
	for(int i=0;i<n;i++)scanf("%d",&F[i]);
	length=strlen(s);for(int i=0;i<length;i++)k=(10ll*k+s[i]-'0')%mod,k_=(10ll*k_+s[i]-'0')%(mod-1);
	G=getksm(F,k,k_,n);for(int i=0;i<n;i++)printf("%d ",G[i]);
}
  • 1
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 在两个一元稀疏多项式相加的实验中,我们可以使用数组或链表来存储多项式的系数和指数,然后按照指数从小到大的顺序将两个多项式相加。具体来说,可以使用两个指针分别指向两个多项式的当前项,然后比较它们的指数大小,将指数较小的项加入结果多项式中,并将指向该项的指针向后移动一位,直到其中一个多项式的所有项都被加入结果多项式中。最后,将另一个多项式中剩余的项加入结果多项式中。 在使用数组存储多项式时,需要确定数组的大小,这取决于多项式的最高次项,因此可能会浪费一些空间。而使用链表存储多项式可以避免这种浪费,但需要额外的指针操作来维护链表的连接关系。因此,在实际应用中,需要根据具体情况选择适合的存储方式。 在实验中,我们可以通过测试不同大小和稀疏程度的多项式,比较两种存储方式在时间和空间上的效率。可以发现,对于稀疏多项式,使用链表存储可以显著减少空间的使用量,并且在相加操作中,链表存储方式也比数组存储方式更加高效。但对于稠密多项式,数组存储方式可能更加适合,因为它可以更快地访问数组中的元素。 ### 回答2: 在进行两个一元稀疏多项式相加的实验中,我发现了以下几个问题和小结。 首先,稀疏多项式的相加运算相对简单,只需要按照相同指数项的系数相加即可。在实验中,我将两个一元稀疏多项式表示为字典的形式,其中键是指数,值是系数。然后,我通过对两个字典中的键进行合并,并将相同指数项的系数相加得到结果多项式的字典表示。从实验的结果来看,这种方法非常高效和简便。 其次,一元稀疏多项式的存储和表示对于运算的效率有着重要的影响。在实验中,我采用了字典的数据结构来表示多项式,这是因为字典可以通过键值对的方式高效地存储非零系数,而且在查找操作时具有较高的效率。相比之下,使用数组或列表来表示多项式可能会浪费大量的存储空间和时间。 另外,实验中还需要注意处理两个字典中键的合并操作。在合并过程中,需要考虑可能存在的相同指数项的系数相加为0的情况,即结果多项式的稀疏性。为了确保结果多项式的稀疏性,我在相加操作中,只有当相同指数项的系数之和不为0时,才将其加入到结果字典中。 最后,我还发现在处理稀疏多项式相加时,字典的操作具有较高的效率。在合并键或合并系数的过程中,使用字典的方法可以避免遍历整个多项式,减少了时间复杂度。在实验中,我采用了Python的字典来实现多项式的相加操作,确保了运算的高效性。 综上所述,通过进行两个一元稀疏多项式相加的实验,我得出了使用字典来表示和处理稀疏多项式具有较高效率和简便性的结论。同时,我在实验中还对多项式的存储表示和相加操作进行了有效的优化,确保了实验的顺利进行。 ### 回答3: 在进行两个一元稀疏多项式相加实验的过程中,我发现了一些有趣的现象和规律。 首先,稀疏多项式指的是只有少数几项非零的多项式。在实验中,我选取了两个具有不同稀疏程度的多项式进行相加,并记录了它们相加后的结果。 通过实验,我发现两个一元稀疏多项式相加的结果仍然是一个稀疏多项式。这意味着即使两个多项式中有很多项为0,它们相加后依然会有很多项为0。这样的结果告诉我们,在进行多项式相加时,我们可以忽略那些对结果没有影响的0项,从而简化计算过程。 另外,实验还显示相加后多项式的次数可能发生变化。具体来说,如果两个多项式的次数不同,那么相加后的多项式的次数将取两个多项式中较高的次数。这是因为较高次数的多项式具有更多的项,而在相加的过程中会保留所有项。 总的来说,通过这个实验,我加深了对一元稀疏多项式相加的理解。稀疏多项式的特点使得相加的结果仍然是一个稀疏多项式,而多项式的次数可能会发生变化。这些发现可以帮助我们更好地处理多项式的相加运算,简化计算过程,提高效率。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值