精华内容
下载资源
问答
  • 第 6 章 MATLAB 数据分析与多项式计算 习题 6 一选择 1设 A=[1,2,3,4,5;3,4,5,6,7] 则 min(max(A) 的值是 B A 1 B 3 C 5 D 7 2 已知 a 为 3 3 矩阵则运行 mean(a)命令是 B A 计算 a 每行的平均值 B 计算 a 每列的...
  • 多项式题

    2020-06-30 15:33:00
    热身。 如果一个体积为vvv的物品无限个,那么其关于体积的普通生成函数为∑i=0xvi=11−xv\sum_{i=0}x^{vi} = \frac 1{1-x^v}∑i=0​xvi=1−xv1​ 如果一个体积为vvv的物品KKK个,那么其关于体积的普通生成函数...

    LOJ #556. 「Antileaf’s Round」咱们去烧菜吧

    求混合背包(某一体积的物品可能有无限个也可能有有限个),得到体积和为1...n1...n的方案数。

    热身题。
    如果一个体积为vv的物品有无限个,那么其关于体积的普通生成函数为i=0xvi=11xv\sum_{i=0}x^{vi} = \frac 1{1-x^v}
    如果一个体积为vv的物品有KK个,那么其关于体积的普通生成函数为i=0Kxvi=1xv(K+1)1xv\sum_{i=0}^K x^{vi} = \frac {1-x^{v(K+1)}}{1-x^v}
    将这些生成函数乘起来即可得到答案的生成函数。
    发现总项数可能达到n2n^2不能直接上多项式乘法,可以考虑对每个式子取ln\ln求和后求exp\exp
    ln(1x)\ln (1-x)泰勒展开可以得到为i=1xii\sum_{i=1} \frac {-x^i}{i}
    所以对于ln11xv=ln1xv=i=1xivi\ln \frac {1}{1-x^v} = - \ln 1-x^v = \sum_{i=1} \frac {x^{iv}}i
    ln1xv(K+1)1xv=i=1xivii=1xiv(K+1)i\ln \frac {1-x^{v(K+1)}}{1-x^v} = \sum_{i=1} \frac {x^{iv}}i - \sum_{i=1} \frac {x^{iv(K+1)}}i
    求出xivx^{iv}v=v0v=v_0的系数和后即可O(nlnn)O(n\ln n)求和得到ln\ln后的式子求和的生成函数。
    代码

    LOJ #6055. 「from CommonAnts」一道数学题 加强版

    社论
    fk(x)=i=1x1fk(i)+xk,fk(1)=1f_k(x) = \sum_{i=1}^{x-1} f_k(i) + x^{k},f_k(1) = 1
    这个式子是一个 nn阶递推,既不是齐次也不是线性。
    我们可以化一下式子变成常系数非齐次线性递推。
    fk(x)=fk(x1)+(i=1x2fk(i)+(x1)k)+xk(x1)k=2fk(x1)+xk(x1)kf_k(x) = f_k(x-1) + (\sum_{i=1}^{x-2}f_k(i) + (x-1)^{k}) + x^k- (x-1)^k \\= 2f_k(x-1)+x^k-(x-1)^k
    这是个一阶常系数非齐次线性递推。
    我们知道如果是齐次的话,因为这个递推式只有一阶,第nn项可以用递推式的特征根的nn次方之类用快速幂解决。
    变成齐次的方法很简单,
    构造递推式gk(x)=2gk(x1)xk+(x1)kg_k(x) = 2g_k(x-1)-x^k+(x-1)^k
    所以(fk(x)+gk(x))=2(fk(x1)+gk(x1))(f_k(x)+g_k(x)) = 2(f_k(x-1) + g_k(x-1))
    我们求的fk(x)=2x1(fk(1)+gk(1))gk(n)f_k(x)=2^{x-1}(f_k(1)+g_k(1))-g_k(n)
    考虑到我们需要的gk(x)g_k(x)只需要满足一个递推式,发现有且仅有一个k1k-1次多项式gk(x)g_k(x)满足这个方程。
    也就是说gk(x)g_k(x)可以是一个k1k-1次多项式。
    那么我们只需要求出gk(0...k1)g_k(0...k-1)即可拉格朗日插值得到gk(n)g_k(n),从而算出fk(n)f_k(n)
    分别求出 0...k0...kkk次方后,可以通过假设gk(0)g_k(0)递推得到gk(k)g_k(k),然后通过拉格朗日插值得到gk(k)g_k(k)的另一个表达式,解出gk(0)g_k(0)即可。

    Code

    LOJ #6391. 「THUPC2018」淘米神的树 / Tommy

    社论
    容易发现这个顺序其实类似于树的拓扑序反过来。
    当两个初始点重合的时候就是求树的拓扑序计数。
    经典结论:答案为n!i in treeszi\frac {n!}{\prod_{i \ in \ tree} sz_i},其中szisz_i是以初始黑点为根时ii的子树的大小。
    当两个初始点不重合时,新建一个点ss,将初始点和ss连边。
    那么我们将会得到一颗基环树,枚举环上的一条边割掉,我们就可以把问题看做以ss为初始黑点求树的拓扑序计数。
    考虑割掉的这条边,它左右两边的点中一定恰好有一个是环上最后一个被染成红色的点,所以对于一种情况有两种可能的割边(最后一个被染成红色的点左右有两条边),所以最后答案要÷2\div2

    在这里插入图片描述
    然后在两个初始黑点中选一个为根求出每个点的子树大小,其中两个初始黑点间的链的每个点的子树大小依次记为c1,c2...cnc_1,c_2...c_n,再在左边加一个c0=0c_0 = 0,注意这里c1...cnc_1...c_n是递增的。
    那么cicj|c_i - c_j|i>ji>j时的意义就是在jj+1j \rightarrow j+1这条链断开时的ii的子树大小。
    i<ji < j时的意义就是在jj+1j \rightarrow j+1这条链断开时的i+1i+1的子树大小。
    所以在断开jj+1j \rightarrow j+1时的链上的sz=i!=jcicj\prod sz = \prod_{i != j}|c_i - c_j|,不在链上的预处理即可。
    那么我们只需要求j1i!=jcicj\sum_{j} \frac 1{\prod_{i != j}|c_i - c_j|},发现这个东西和多项式快速插值的第一部分一模一样。
    具体的设F(x)=jxcjF(x) = \prod_{j} |x - c_j|,有i!=jcicj=F(x)xcix=ci\prod_{i != j}|c_i - c_j| = \left. \frac {F(x)}{x-c_i}\right|_{x=c_i}
    因为F(ci)=(cici)=0F(c_i)=(c_i-c_i)=0用洛必达法则,有:
    i!=jcicj=F(ci)\prod_{i != j}|c_i - c_j| = F(c_i)'
    分治 FFTFFT后求导套多点求值即可。

    Code

    LOJ #6609. 无意识的石子堆 加强版

    社论

    容斥做法:
    枚举有具体kk列放了两颗石子,具体的2n2k2n-2k列放了一颗石子的方案数为SkS_k
    ans=k=0n(mk)(mk2n2k)Skans = \sum_{k=0}^n \binom mk\binom {m-k}{2n-2k}S_k
    SkS_k,考虑容斥掉同一行的两颗石子不能在同一列这个限制。
    Sk=12n+ki=0k(ni)(ki)(1)ii!2i(2n2i)!S_k = \frac 1{2^{n+k}}\sum_{i=0}^k \binom ni\binom ki(-1)^ii!2^i(2n-2i)!
    这里枚举的ii是同一行的两颗石子在同一列的次数。
    统计时将同一行的两个石子看做不同,放在同一列的两个石子先后有顺序,这样统计2n2i2n-2i个石子放入剩下还空着的列时可以直接写(2n2i)!(2n-2i)!,相对应的需要在外面÷2n÷2k\div 2^n \div 2^k(有kk列可以放两个石子)。
    i!i!表示这ii行都分别有两个重合的石子,将他们分配给ii列的方案,2i2^i是因为这两个石子之间有顺序。
    Sk=n!k!2n+ki=0k1(ki)!(2)i(2n2i)!i!(ni)!S_k = \frac {n!k!}{2^{n+k}}\sum_{i=0}^k \frac 1{(k-i)!}\frac {(-2)^i(2n-2i)!}{i!(n-i)!}
    就可以卷积求出SkS_k,然后直接求得答案了。
    还有一种多项式expexp但是不写expexp的推法,本质应该有点类似,具体可以看上面的博客。
    Code

    LOJ #6703. 小 Q 的序列

    社论
    dp1:fi,j=fi1,j+fi1,j1(ai+j)dp1:f_{i,j} = f_{i-1,j} + f_{i-1,j-1}(a_i+j)fi,jf_{i,j}表示前ii个数选了jj数的贡献和。
    发现这个dpdp不太会做。
    换一下定义:fi,jf_{i,j}表示前ii个数选了iji-j个数的贡献和。
    dp2:fi,j=fi1,j1+fi1,j(ai+ij)=fi1,j1jfi1,j+fi1,j(ai+i)dp2:f_{i,j} = f_{i-1,j-1} + f_{i-1,j}(a_i+i-j) = f_{i-1,j-1} - jf_{i-1,j} + f_{i-1,j}(a_i+i)
    考虑组合意义(和第二类斯特林数相似):对于每个ii我们有三种选择,
    不选,代价×(ai+i)\times (a_i+i),
    选,加入前面jj个组中的一个,代价×(j)\times (-j)
    选,新建一个组,代价无变化。
    不选ii个的代价可以用分治FFTFFTi=1n(x+ai+i)\prod_{i=1}^n (x+a_i+i)
    ii个的代价,可以先考虑选一组的指数生成函数是(ex1)-(e^{-x}-1)(ex1)(e^x-1)是非空集合带标号的指数生成函数,我们这里除了第一个数,别的数加入还需要×1\times -1,所以是(ex1)-(e^{-x}-1)
    那么选 ii个的代价的生成函数就是exp(1ex)\exp (1-e^{-x}),注意是指数生成函数还需要除阶乘。
    然后将选和不选的生成函数卷积一下求xnx^n项即可。
    Code

    LOJ #6247. 九个太阳

    福利题快速幂模板题

    单位根反演:1ki=0k1wkij=[kj]\frac 1k\sum_{i=0}^{k-1} w^{ij}_{k} = [k|j]
    wkj=1w^j_{k} = 1时,即[kj][k|j]时,原式=kk=1=\frac kk = 1
    否则原式=1wkkjk(1wkj)=0=\frac {1-w^{kj}_k}{k(1-w^j_k)} = 0

    所以对于此题:i=0n[ki](ni)=1ki=0nj=0k1wkij(ni)\sum_{i=0}^n[k|i]\binom ni = \frac 1{k}\sum_{i=0}^n \sum_{j=0}^{k-1} w^{ij}_{k}\binom ni
    =1kj=0k1i=0nwkij(ni)=1kj=0k1(1+wkj)n=\frac 1k \sum_{j=0}^{k-1}\sum_{i=0}^n w^{ij}_k\binom ni = \frac 1k\sum_{j=0}^{k-1}(1+w^{j}_k)^n
    此题模数很友好,求出单位根后快速幂即可。
    Code

    LOJ #6289. 花朵

    fu,i,0/1f_{u,i,0/1}表示uu子树内选了ii个点,其中uu选没选为第三维的答案,
    那么树链剖分后建出全局平衡二叉树,对于虚儿子到父亲的转移即为fuf_{u}的分治FFTFFT
    对于重儿子到父亲,对重链分治,对于每一边求出gi,0/1,0/1g_{i,0/1,0/1}表示重链的某部分即下方的虚子树,头是否被选为第二维,尾是否被选为第三维。

    对重链分治的时候可以按照下面子树的szsz分治而非对半分治,可以优化常数。
    O(nlog3n)O(n\log ^3n)很好证明。

    但是有人说这样写是O(nlog2n)O(n\log^2n)
    Code

    LOJ #6363. 「地底蔷薇」

    F(x)=i=02(i2)xii!F(x) = \sum_{i=0} \frac {2^{\binom i2}x^i} {i!}有标号无向图数量。
    D(x)=ϑlnF(x)=[lnF(x)]xD(x) = \vartheta \ln F(x) = [\ln F(x) ']x即有根有标号联通无向图数量。
    B(x)=i=1bi+1xii!B(x) = \sum_{i=1} \frac {b_{i+1} x^i}{i!}bib_iii个点的无根有标号点双连通图数量。
    那么一个有根有标号联通无向图的根节点周围可以挂若干个包含根的点双,挂一个大小为i+1i+1的点双,那么除了根以外的ii个点,每个点删去和该点双其他点的连边后的连通块是一个有根有标号联通无向图。
    D(x)=xexp[i=1bi+1D(x)ii!]=xexpB[D(x)]D(x) = x \exp [\sum_{i=1} \frac {b_{i+1}D(x)^i}{i!}] = x \exp B[D(x)]
    假设G[D(x)]=xG[D(x)]=x即他们互为复合逆。
    那么D(G(x))=G(x)expB[D(G(x))]D(G(x)) = G(x) \exp B[D(G(x))]
    也即:x=G(x)expB(x)x = G(x) \exp B(x)
    B(x)=lnxG(x)B(x) = \ln \frac {x}{G(x)}
    lnD(x)x=C(x)\ln \frac {D(x)}x =C(x)
    则有C(G(x))=lnxG(x)=B(x)C(G(x)) = \ln \frac {x}{G(x)} = B(x)
    又根据扩展拉格朗日反演可以得到:
    [xn]B(x)=[xn]C(G(x))=[xn1]C(x)xnnD(x)n=[xn1]C(x)n×(xD(x))n=[xn1]C(x)nexp(nlnD(x)x)=[xn1]C(x)exp(nC(x))n[x^n]B(x) = [x^n]C(G(x)) = [x^{n-1}] \frac {C(x)'x^n}{nD(x)^n} = [x^{n-1}] \frac{C(x)'}n \times (\frac {x}{D(x)})^n = [x^{n-1}] \frac {C(x)'}n\exp(-n \ln \frac {D(x)}x) = [x^{n-1}]\frac {C(x)'\exp(-nC(x))}n
    首先可以看到
    在这里插入图片描述
    发现这个条件让你可以直接多次拉格朗日反演求出大小S\in S的所有点双连通图的方案数,设他的生成函数为C(x)C(x)
    然后和点双联通图计数一样的方法设答案为F(x)F(x)
    那么考虑包含根的点双,把这些点双的边删掉之后,所有的点都可以挂一个我们正在求的图也即F(x)F(x),然后自由组合。
    所以可以得到方程:
    F(x)=xexpC(F(x))F(x) = x \exp C(F(x))
    发现有:
    F(x)expC(F(x))=x\frac {F(x)}{\exp C(F(x))} = x
    所以F(x)F(x)xexpC(x)\frac x{\exp C(x)}互为复合逆。
    [xn]F(x)=[xn1]xnnxnexpC(x)n=[xn1]expnC(x)n[x^n]F(x) = [x^{n-1}]\frac {x^n}{n\frac {x^n}{\exp C(x)^n}} = [x^{n-1}]\frac {\exp nC(x)}n
    Code

    AtCoder - agc005_f Many Easy Problems

    题意:对于k=1...nk = 1...n,求在树上选kk个点的所有方案中,在这kk个点中某两个点的最短路径上的点数。
    发现对于选kk个点,答案是一个连通块,所以边数==点数1-1,所以我们计算总边数最后加上(nk)\binom nk即可。
    对于一条边(a,b)(a,b),它在这个连通块内即代表这kk个点不在同一边,假设一边的大小为szsz,则它在这个连通块内的方案数为(nk)(szk)(nszk)\binom nk - \binom {sz}k - \binom{n-sz}k
    将组合数拆开k!×(szk)=sz!(szk)!k! \times \binom {sz}k= \frac {sz! } {(sz-k)!}
    做一下差卷积即可将(szk)\binom {sz}k贡献到每个kk

    Code

    Codeforces 1096G Lucky Tickets

    0~9种有k种可用数字,求前n/2个数字和与后n/2个数字和相等的方案数
    对一个最高次数为99的多项式求它的10510^5次幂即可。
    可以直接做1e61e6NTTNTT然后把每个点值快速幂后再NTTNTT回来即可。
    也可以通过g=fk,g=kfk1fg = f^k , g' = kf^{k-1}f'得到gf=kgfg'f = kgf'
    ngnf0=i=19kifignii=19(ni)figning_nf_0 = \sum_{i=1}^9 kif_ig_{n-i} - \sum_{i=1}^9 (n-i)f_ig_{n-i},f0=0f_0=0可以通过平移多项式解决。
    从而O(81n)O(81n)得到g=fkg = f^k

    展开全文
  • 一直没有学fft,直到10天前打beijing online contest时,碰到了一个NTT的裸,发现必须要看看了 hexo博客配置一些问题,mathjax公式一直不能正常加载,可以访问我在cmdmarkdown上发布的版本 here 这几天看了一些...

    【写于2016-10-11,现在从hexo搬运过来】

    看了两天FFT
    一直没有学fft,直到10天前打beijing online contest时,碰到了一个NTT的裸题,发现必须要看看了

    hexo博客配置有一些问题,mathjax公式一直不能正常加载,可以访问我在cmdmarkdown上发布的版本 here
    这几天看了一些博客,发现它纯粹在数学上需要功底。FFT,NTT的题目中,简单的那部分基本可以分为两个方面:建模列出表达式+套版
    理解模板中那些纯粹属于FFT,NTT的做法并不难。难的是怎么用到题目中,这需要数学功底。。

    我就不在这里从头写了,网上已经有了很好的博客来讲解FFT
    首先,我决定尝试叙述一下逻辑关系:
    我们现在要解决的,是高效的计算多项式乘法,传统朴素的方法是 O(n^2) 的。
    而FFT,即快速傅里叶变换,通过某种技巧,使复杂度降到 O(nlogn) , 但是FFT的弱点在于,它的计算在复数域内进行,因此存在精度问题。
    于是有了NTT,即快速数论变换。这一变换是对FFT的改进,使得所有计算在(Z_p),即模p剩余系下考虑。因此,整数意义下的FFT问题可以用NTT来解决,从而避免精度误差。

    1. FFT

      贴出一些文章:

    这两篇文章说的很清楚。傅里叶变换建立在一些基础的处理手法和引理上。
    首先是多项式的点值表达,很好理解,一个n次一元多项式,与n个不同的点是相互确定的。这个可以从代数的角度上来理解。文章的推导也阐明了这点。
    点值表达给我们带来的是,我们想要表述一个多项式,只需任取n个不同的点,就能唯一地表述它。我们想要求一个多项式,只要设法找到n个不同的该多项式经过的点,就可以求出其系数表达。
    因此,我们接下来的工作就放在点值上来考虑。经验表明,只有真正想清楚了点值表达是什么以及它对下面的工作起到什么作用,才能更好地理解下面的推导。

    教程里已经推导了,单纯的去取n个点,来作点值表达,是可以完成多项式相乘计算的。然而,普遍的时间复杂度还是O(n^2) 的。

    到这时候,FFT才真正登场。
    FFT的做法是,同样基于点值表达,但是选了一组很巧妙的点,即n 重单位复根
    [ \omega_k = e^\frac{2k\pi}{n} , k = 0,1,2 … n-1 ]
    这组点的点值之间存在着巧妙的关系,使得我们可以用分治的思路来求解所有点值,复杂度降到O(nlogn)
    思想就是这些,剩下的就是引理,DFT&IDFT,Rader等等具体的一些东西了,上面的文章讲得很清楚了

    1. NTT
      多项式计算终极版(ACdreamer)
      关于gn的取法和原根的理解,这一篇说的比较好:
      原根与NTT
      正如刚才所说,FFT存在精度上的误差,有时候直接影响答案的正确输出。因此,针对整数意义上的问题,我们有NTT
      NTT是一个改进,我们选取一组新的点值
      [\omega_n=g^\frac{p-1}{n}]
      其中p为质数,n是2的方幂,且满足 n | (p-1)

    上面的文章证明了,wn具有同n重单位复根一样的那几条性质,因此可以代替n重单位复根来做计算。

    所以要写NTT,只需要改动取wn 的部分即可。
    我们需要的常数是大质数p,和它的原根g,p一般是取费马素数的形式,即:
    [p = c2^k+1 \quad c,k∈N_{+}]
    常用的是p = 479
    2^21+1 , 对应原根 g = 3
    p并不总是随便取的,有时候题目要求你取某个指定的模数p,如果模数p是费马素数,那么不用做任何改动,求出其原根,对应的做一些更改就好。
    原根的求法和更多的一些知识:这里
    (这个我还没仔细看。。目前做的题还很少。。)
    如果是任意的质数,听说的做法是找两个小的费马素数来分别算,然后再用crt来合并,好吧我还没做这类题。。

    目前想得到的一些自己对FFT,NTT的理解就是这样了,代码中有些细节的地方还需要我仔细琢磨,并没有搞得很透彻。

    几道题目:
    FFT入门题:
    hdu1402
    大数乘法,n位的大整数,实际上可以看成n次的多项式。两个大数的相乘,就可以理解成这两个多项式的乘法。在用FFT计算好乘法之外,我们额外做的就是进位和顺序调整了。

    #include <cstdio>
    #include <cstring>
    #include <iostream>
    #include <algorithm>
    #include <cmath>
    #include <vector>
    #include <utility>
    #include <string>
    #include <queue>
    //#define maxn 1024
    #define LL long long
    #define fp freopen("in.txt","r",stdin)
    #define fpo freopen("out9.txt","w",stdout)
    //#define judge
    using namespace std;
    const double eps = 1e-10;
    const double pi = acos(-1.0);
    const int maxn = 250050;
    const int INF = 0x3f3f3f3f;
    const double lg2 = log(2.0);
    const LL MOD = 1e9+7;
    #define MAX 5050
    struct Complex
    {
        double re,im;
        Complex(double re = 0.0, double im = 0.0)
        {
            this->re = re;
            this->im = im;
        }
        Complex operator -(const Complex &elem) const
        {
            return Complex(this->re - elem.re, this->im - elem.im);
        }
        Complex operator +(const Complex &elem) const
        {
            return Complex(this->re + elem.re, this->im + elem.im);
        }
        Complex operator *(const Complex &elem) const
        {
            return Complex(this->re * elem.re - this->im * elem.im, this->im*elem.re + this->re*elem.im);
        }
        void val(double re = 0.0, double im = 0.0)
        {
            this->re = re;
            this->im = im;
        }
    };
    Complex A[maxn],B[maxn];
    int res[maxn],len,multilen,len1,len2;
    char s1[maxn],s2[maxn];
    void swap(Complex &a, Complex &b)
    {
        Complex tmp = a;
        a = b, b=tmp;
    }
    void init()
    {
        len1 = strlen(s1),len2 = strlen(s2);
        multilen = max(len1,len2);
        len = 1;
        while(len<(multilen<<1)) len<<=1;
        for(int i = 0; i <len1; i++)
            A[i].val(s1[len1-i-1]-'0',0);
        for(int i = 0; i < len2; i++)
            B[i].val(s2[len2-i-1]-'0',0);
        for(int i = len1; i < len; i++)A[i].val();
        for(int i = len2; i < len; i++)B[i].val();
    }
    void rader(Complex y[])
    {
        for(int i = 1,j=len>>1,k; i < len-1; i++)
        {
            if(i<j) swap(y[i],y[j]);
            k = len>>1;
            while(j >= k)
            {
                j-=k;
                k>>=1;
            }
            if(j<k)j+=k;
        }
    }
    //op==1 DFT
    //op==-1 IDFT
    void FFT(Complex y[], int op)
    {
        rader(y);
        for(int h = 2; h <=len; h<<=1)
        {
            Complex wn(cos(op*2*pi/h),sin(op*2*pi/h));
            for(int i = 0; i < len; i +=h)
            {
                Complex w(1,0);
                for(int j = i; j < i+h/2; j++)
                {
                    Complex u = y[j];
                    Complex t = w * y[j + h/2];
                    y[j] = u + t;
                    y[j+h/2] = u - t;
                    w = w * wn;
                }
            }
        }
        if(op==-1)// for IDFT
        {
            for(int i = 0; i < len ; i++)
            {
                y[i].re/=len;
            }
        }
    }
    void convolution(Complex * A, Complex * B)
    {
        FFT(A,1),FFT(B,1);
        for(int i = 0; i <len; i++)
        {
            A[i] = A[i] * B[i];
        }
        FFT(A,-1);
        for(int i = 0 ; i < len; i++)
            res[i] = (int)(A[i].re +0.5);
    }
    void adjust(int * arr)
    {
        for(int i = 0; i < len ; i++)
        {
            res[i+1]+=res[i]/10;
            res[i]%=10;
        }
        while(--len && res[len]==0);
    }
    void print(int * arr)
    {
        for(int i = len; i>=0;i--)
        {
            printf("%c",arr[i]+'0');
        }
        printf("\n");
    }
    int main()
    {
        while(gets(s1)&&gets(s2))
        {
            init();
            convolution(A,B);
            adjust(res);
            print(res);
        }
    }

    51nod上有一道同样的题目,好像规模更大,我用fft和ntt做了两次,有趣的是NTT跑的比FFT快了不少。

    hdu4609
    n条线段,有各自的长度,任取三条,求能组成三角形的组合数目。
    这个题就不那么裸了,用到FFT的地方是,用num[]数组来存任意取两条线段能组成长度为i的方案数,基于两边之和大于第三边的原则,枚举三角形中的最长边来计数。然后去掉几类重复的情况,个人觉得这是更考察功底的地方。。kuangbin的题解

    /*************************************************************************
        > File Name: hdu4609.cpp
        > Author: skyword
        > Mail: skywordsun@gmail.com
        > Created Time: 2016年10月02日 星期日 11时11分32秒
     ************************************************************************/
    #include <iostream>
    #include <cstdio>
    #include <cstring>
    #include <cmath>
    #include <vector>
    #include <set>
    #include <algorithm>
    #include <queue>
    using namespace std;
    const double pi = acos(-1.0);
    #define maxn 400050
    #define ll long long
    #define fp freopen("in.txt","r",stdin);
    struct Complex
    {
        double re,im;
        Complex(double re=0.0, double im = 0.0)
        {
            this->re = re; this->im = im;
        }
        Complex operator +(const Complex &b)
        {
            return Complex(this->re + b.re, this->im + b.im);
        }
        Complex operator -(const Complex &b)
        {
            return Complex(this->re - b.re , this->im - b.im);
        }
        Complex operator *(const Complex &b)
        {
            return Complex(this->re*b.re - this->im*b.im , this->re*b.im + this->im*b.re);
        }
    };
    void rader(Complex y[],int len)
    {
        int i,j,k;
        for(i = 1,j=len/2; i<len-1;i++)
        {
            if(i<j) swap(y[i],y[j]);
            k = len/2;
            while(j >= k)
            {
                j-=k;
                k/=2;
            }
            if(j<k) j += k;
        }
    }
    void fft(Complex y[], int len , int op)
    {
        rader(y,len);
        for(int h = 2; h <= len; h<<=1)
        {
            Complex wn(cos(-op*2*pi/h),sin(-op*2*pi/h));
            for(int j = 0; j < len; j+=h)
            {
                Complex w(1,0);
                for(int k = j; k < j+h/2; k++)
                {
                    Complex u = y[k];
                    Complex t = w*y[k+h/2];
                    y[k] = u+t;
                    y[k+h/2] = u-t;//butterfly op
                    w = w* wn;
                }
            }
        }
        if(op == -1)
        {
            for(int i =0;i<len;i++)
            {
                y[i].re /= len;
            }
        }
    }
    Complex x[maxn];
    int a[maxn];
    ll num[maxn],sum[maxn];
    int t,n;
    int main()
    {
        scanf("%d",&t);
        while(t--)
        {
            scanf("%d",&n);
            memset(num,0,sizeof(num));
            for(int i = 0; i<n;i++)
            {
                scanf("%d",&a[i]);
                num[a[i]]++;
            }
            sort(a,a+n);
            int len1 = a[n-1]+1;
            int len = 1; // multilength
            while(len < 2*len1) len <<= 1;
            //init
            for(int i = 0; i<len1 ; i++) x[i] = Complex(num[i],0);
            for(int i = len1; i<len; i++) x[i] = Complex(0,0);
            fft(x,len,1);
            for(int i= 0; i<len;i++) x[i] = x[i] * x[i];
            fft(x,len,-1);
            for(int i = 0; i < len; i++)
            {
                num[i] = (ll)(x[i].re + 0.5);
            }
            len = 2*a[n-1];
            for(int i =0; i<n;i++)
                num[a[i] * 2]--;
            for(int i = 0; i <=len;i++) num[i]/=2;
            sum[0] = 0;
            for(int i = 1; i<=len;i++) sum[i] = sum[i-1] + num[i];
            ll cnt = 0;
            for(int i = 0; i<n;i++)
            {
                cnt += (sum[len]-sum[a[i]]);
                cnt -= (ll)(n-1-i) * i;
                cnt -= (n-1);
                cnt -= (ll)(n-1-i) * (n-2-i)/2;
            }
            ll all = (ll)n * (n-1) * (n-2)/6;
            double ans = (double)cnt/all;
            printf("%.7lf\n",ans);
        }
    }

    hdu5829

    这是今年多校第八场的1009.
    题意就叙述的很拗口。。我真的感觉有些出题人该好好润色一下英语表达了。。
    题目给了一个n元素的数集S,考虑任意的非空子集S0,考虑其前k大元素(如果子集本身元素数目小于k,就指的是其中全部元素)之和sum{s0}。对每一个给定的k,对所有子集,求sum的总和,即
    \sum_{ {s0} \subset S} sum{s_0}

    懒得写了。。网上有题解。。
    这个题用NTT做蛮好。更难的点是如何处理出卷积的形式。我自己琢磨了挺久的。。什么时候单独写个题解好了。。挺考验熟练度和功底

    #include <cstdio>
    #include <cstring>
    #include <iostream>
    #include <algorithm>
    #include <cmath>
    #include <vector>
    #include <utility>
    #include <string>
    #include <queue>
    //#define maxn 1024
    #define LL long long
    #define fp freopen("in.txt","r",stdin)
    #define fpo freopen("out9.txt","w",stdout)
    //#define judge
    using namespace std;
    const double eps = 1e-10;
    const double pi = acos(-1.0);
    const int maxn = (1e5+20);
    const int INF = 0x3f3f3f3f;
    const int p = 998244353;
    const int G = 3;
    const double lg2 = log(2.0);
    const LL MOD = 1e9+7;
    #define MAX 5050
    LL A[maxn<<2],B[maxn<<2];
    LL quick_mod(LL a, LL b, LL m)
    {
        LL ans = 1;
        while(b)
        {
            if(b&1) ans = ans * a % m;
            a = a * a%m;
            b >>= 1;
        }
        return ans;
    }
    void rader(LL y[], int len)
    {
        for(int i = 1,j=len/2; i < len-1; i++)
        {
            if(i < j) swap(y[i], y[j]);
            int k = len/2;
            while(j >= k)
            {
                j-=k;
                k/=2;
            }
            if(j < k)j+=k;
        }
    }
    void NTT(LL y[], int len , int op)
    {
        rader(y,len);
        for(int h = 2; h <= len; h <<=1)
        {
            LL wn = quick_mod(G,(p-1)/h,p);
            if(op == -1)
            {
                wn = quick_mod(wn,p-2,p);
            }
            // now wn is the rotation factor.
            for(int j = 0; j <len; j+=h)
            {
                LL w = 1;
                for(int k = j; k < j + h/2; k++)
                {
                    LL u = y[k];
                    LL t = (w * y[k + h/2])%p;
                    y[k] = (u + t)%p;
                    y[k + h/2] = (u - t + p)%p;
                    w = w * wn % p;
                }
            }
        }
        // for IDFT(or maybe we call it IFNT)
        if(op==-1)
        {
            LL inv = quick_mod(len , p-2, p);
            for(int i = 0; i <len; i++)
                y[i] = y[i] * inv % p;
        }
    }
    int n,t,a[maxn],ans[maxn];
    LL fac[maxn],tfac[maxn],inv_fac[maxn],inv_tfac[maxn];
    void init()
    {
        fac[0] = tfac[0] = inv_fac[0] = inv_tfac[0] =1;
        for(int i = 1; i < maxn ; i++)
        {
            fac[i] = fac[i-1] * i % p;
            tfac[i] = 2 * tfac[i-1] %p;
            inv_fac[i] = quick_mod(fac[i], p - 2, p);
            inv_tfac[i] = quick_mod(tfac[i], p - 2, p);
        }
    }
    int main()
    {
        init();
        scanf("%d",&t);
        while(t--)
        {
            scanf("%d",&n);
            for(int i = 1; i <= n; i++) scanf("%d",&a[i]);
            sort(a+1, a+1+n,greater<int>());
            int len = 1;
            while(len < ((n<<1)+1) ) len <<= 1;
            for(int i = 0; i < len ; i++)
            {
                if(i <= n)
                    A[i] = tfac[n-i] * inv_fac[i] % p;
                else A[i] = 0;
                if(i <= n && i >= 1)
                    B[i] = a[i] * fac[i-1] % p;
                else B[i] = 0;
            }
            reverse(B+1,B+1+n);
            NTT(A,len,1);
            NTT(B,len,1);
            for(int i = 0; i<len;i++)
            {
                A[i] = A[i] * B[i] % p;
            }
            NTT(A, len ,-1);
            for(int i = 1; i<=n; i++)
            {
                ans[i] =((inv_tfac[i] * inv_fac[i-1])%p) * A[n-i+1] %p;
            }
            for(int i = 1; i <=n;i++)
            {
                ans[i] = (ans[i] + ans[i-1]) % p;
            }
            for(int i = 1; i <=n;i++)
            {
                printf("%d ",ans[i]);
            }
            puts("");
        }
    }

    hihocoder1388 : Periodic Signal
    这题是今年北京网络赛的F题
    经过处理可以知道,核心在于计算
    min_{k=0}^{n-1}\sum_{i=0}^{n-1}a_ib_{(i+k)mod \, n}
    处理一下发现,这是个循环卷积。同样是经过一些变换,得到可以用NTT计算的形式,这个。。以后单独写题解吧。。
    目前我查到的做法其实挺多的。。
    单纯用FFT做的话,会损失精度,但是只是个别低位处出错,算出的k值依然是正确的,所以耍个赖,用FFT算出最优解的k值,然后手动算一下就行
    NTT,不会丢精度,一个难点是找足够大的质数p,这里找到的是p=5*2^{55}+1 ,我不知道他们怎么找到这个数的。。试出来的罢。
    它的原根(之一)是3

    #include <cstdio>
    #include <cstring>
    #include <iostream>
    #include <algorithm>
    #include <cmath>
    #include <vector>
    #include <utility>
    #include <string>
    #include <queue>
    //#define maxn 1024
    #define LL long long
    #define fp freopen("in.txt","r",stdin)
    #define fpo freopen("out9.txt","w",stdout)
    //#define judge
    using namespace std;
    const double eps = 1e-10;
    const double pi = acos(-1.0);
    const int maxn = 200020;
    const int INF = 0x3f3f3f3f;
    const LL p = 180143985094819841LL;
    const int G = 3;
    const double lg2 = log(2.0);
    const LL MOD = 1e9+7;
    #define MAX 5050
    LL wn[20];
    LL mul(LL x,LL y)
    {
        return (x*y-(LL)(x / (long double)p*y+1e-3)* p +p)%p;
    }
    LL quick_mod(LL a, LL b, LL m)
    {
        LL ans = 1;
        while(b)
        {
            if(b&1) ans = mul(ans , a );
            a = mul(a , a);
            b >>= 1;
        }
        return ans;
    }
    void getwn()
    {
        for(int i = 1; i <=18;i++)
        {
            int t = 1<<i;
            wn[i] = quick_mod(G,(p-1)/t,p);
        }
    }
    void rader(LL y[], int len)
    {
        for(int i = 1,j=len/2; i < len-1; i++)
        {
            if(i < j) swap(y[i], y[j]);
            int k = len/2;
            while(j >= k)
            {
                j-=k;
                k/=2;
            }
            if(j < k)j+=k;
        }
    }
    void NTT(LL y[], int len , int op)
    {
        rader(y,len);
        int id = 0;
        for(int h = 2; h <= len; h <<=1)
        {
            id++;
            // now wn is the rotation factor.
            for(int j = 0; j <len; j+=h)
            {
                LL w = 1;
                for(int k = j; k < j + h/2; k++)
                {
                    LL u = y[k];
                    LL t = mul(y[k + h/2], w);
                    y[k] = (u + t)%p;
                    y[k + h/2] = (u - t + p)%p;
                    w = mul(w , wn[id]);
                }
            }
        }
        // for IDFT(or maybe we call it IFNT)
        if(op==-1)
        {
            for(int i = 1; i < len/2; i++)
                swap(y[i], y[len-i]);
            LL inv = quick_mod(len , p-2, p);
            for(int i = 0; i <len; i++)
                y[i] = mul(y[i] , inv );
        }
    }
    int t,n;
    LL a[60060],b[60060];
    LL A[maxn],B[maxn],C[maxn],ans;
    LL sum = 0;
    void init()
    {
        for(int i = 0; i < maxn;i++)
        {
            if(i<60060)
                A[i]=B[i]=C[i]=a[i]=b[i]=0;
            else A[i]=B[i]=C[i]=0;
        }
    }
    int main()
    {
        getwn();
        scanf("%d",&t);
        while(t--)
        {
            init();
            sum = 0;
            scanf("%d",&n);
            for(int i = 0; i < n; i++)
            {
                scanf("%lld",&a[i]);
                sum += a[i] * a[i];
            }
            for(int i = 0; i < n; i++)
            {
                scanf("%lld",&b[i]);
                sum += b[i] * b[i];
            }
            int len = 1;
            while(len < (n<<1) ) len<<=1;
            for(int i = 0; i < n ; i++)
            {
                A[i] = a[i];
            }
            for(int i = 0; i < n; i++)
            {
                B[i] = b[n-1-i];
            }
            NTT(A,len,1);
            NTT(B,len,1);
            for(int i = 0; i < len; i++)
            {
                C[i] = mul(A[i],B[i]);
            }
            NTT(C,len,-1);
            ans = C[n-1];
            for(int i = 0 ; i < n-2; i++)
            {
                ans = max(ans, C[i]+C[i+n]);
            }
            sum -= (2LL*ans);
            printf("%lld\n",sum);
        }
    }

    就先写这么多吧。

    展开全文
  • 直接构造答案的生成函数 然后可以分治 FFT + 多项式 Ln #include<bits/stdc++.h> #define N 1600050 using namespace std; typedef long long ll; int read(){ int cnt = 0, f = 1; char ch = 0; while...

    传送门

    直接构造答案的生成函数

    F(x)=\sum_i f_i * x ^i=\sum_{i}\sum_{j}a_j^i*x ^i=\sum_j\sum_i(a_j*x)^i= \sum_j \frac{1} {1-a_j* x}=n-\sum_j\frac{-a_j*x}{1-a_j*x}=n-x\sum_j \frac{-a_j}{1-a_j*x}=n-x\sum_j (ln(1-a_j*x))'= n- x (ln\prod_j (1-a_j*x))'

    然后可以分治 FFT + 多项式 Ln


    #include<bits/stdc++.h>
    #define N 1600050
    using namespace std;
    typedef long long ll;
    int read(){
    	int cnt = 0, f = 1; char ch = 0;
    	while(!isdigit(ch)){ ch = getchar(); if(ch == '-') f = -1;}
    	while(isdigit(ch)) cnt = cnt*10 + (ch-'0'), ch = getchar();
    	return cnt * f;
    }
    const int Mod = 998244353, G = 3;
    int T, n; ll a[N], A[N], B[N], C[N], D[N], F[N], f[N], g[N];
    int up, bit, rev[N];
    ll add(ll a, ll b){ return (a + b) % Mod;}
    ll mul(ll a, ll b){ return a * b % Mod;}
    ll power(ll a, ll b){ ll ans = 1;
    	for(;b;b>>=1){ if(b&1) ans = mul(ans, a); a = mul(a, a);}
    	return ans;
    }
    void Init(int len){ len <<= 1; up = 1; bit = 0;
    	while(up < len) up <<= 1, bit++; 
    	for(int i = 0; i < up; i++) rev[i] = (rev[i>>1] >> 1) | ((i&1) << (bit-1));
    }
    void NTT(ll *a, int flag){
    	for(int i = 0; i < up; i++) if(i < rev[i]) swap(a[i], a[rev[i]]);
    	for(int i = 1; i < up; i <<= 1){
    		ll wn = power(G, (Mod - 1) / (i << 1));
    		if(flag == -1) wn = power(wn, Mod - 2);
    		for(int j = 0; j < up; j += (i<<1)){
    			ll w = 1;
    			for(int k = 0; k < i; k ++, w = mul(w, wn)){
    				ll x = a[k + j], y = mul(w, a[k + j + i]);
    				a[k + j] = add(x, y); a[k + j + i] = add(x, Mod - y);
    			}
    		}
    	}
    	if(flag == -1){
    		ll inv = power(up, Mod - 2);
    		for(int i = 0; i < up; i++) a[i] = mul(a[i], inv);
    	}
    } 
    void Solve(int l, int r, int len){
    	if(l == r){ a[l] = Mod-a[l]; return;}
    	int mid = (l+r) >> 1;
    	Solve(l, mid, len >> 1);
    	Solve(mid+1, r, len >> 1);
    	Init(len >> 1);
    	for(int i = 0; i < up; i++) A[i] = B[i] = 0;
    	A[0] = B[0] = 1;
    	for(int i = l; i <= mid; i++) A[i - l + 1] = a[i];
    	for(int i = mid+1; i <= r; i++) B[i - mid] = a[i];
    	NTT(A, 1); NTT(B, 1);
    	for(int i = 0; i < up; i++) A[i] = mul(A[i], B[i]);
    	NTT(A, -1);
    	for(int i = l; i <= r; i++) a[i] = A[i - l + 1];
    }
    void Inv(ll *a, ll *b, int len){
    	if(len == 1){ b[0] = power(a[0], Mod - 2); return;}
    	Inv(a, b, (len + 1) >> 1);
    	Init(len);
    	for(int i = 0; i < len; i++) F[i] = a[i];
    	for(int i = len; i < up; i++) F[i] = 0;
    	NTT(F, 1); NTT(b, 1);
    	for(int i = 0; i < up; i++) b[i] = mul(b[i], Mod + 2 - mul(b[i], F[i]));
    	NTT(b, -1);
    	for(int i = len; i < up; i++) b[i] = 0;
    }
    void Ln(ll *a, ll *b, int len){
    	for(int i = 1; i < len; i++) C[i-1] = mul(a[i], i); C[len - 1] = 0;
    	Inv(a, D, len);
    	Init(len);
    	NTT(C, 1); NTT(D, 1);
    	for(int i = 0; i < up; i++) C[i] = mul(C[i], D[i]);
    	NTT(C, -1);
    	for(int i = 1; i < up; i++) b[i] = mul(C[i-1], power(i, Mod-2));
    	b[0] = 0;
    	for(int i = 0; i < up; i++) C[i] = D[i] = 0;
    }
    int main(){
    	T = read();
    	while(T--){
    		memset(a, 0, sizeof(a));
    		n = read(); a[0] = 1;
    		for(int i = 1; i <= n; i++) a[i] = read();
    		int len = 1; while(len < (n + 1) << 1) len <<= 1;
    		Solve(1, n, len); Ln(a, f, n + 1);
    		for(int i = 1; i <= n + 1; i++) g[i-1] = mul(f[i], i);
    		for(int i = n; i >= 1; i--) g[i] = Mod - g[i-1]; 
    		ll ans = 0;
    		for(int i = 1; i <= n; i++) ans ^= g[i];
    		cout << ans << "\n";
    	} return 0;
    } 

     

    展开全文
  • 第19 勒让德多项式 球函数习题及解答————————————————————————————19.1 试证明,其中.19.2计算.【答案】19.3求积分.【答案 】19.4 求积分.【答案 】19.5 证明:19.6 证明:19.7 证明:...

    第19 勒让德多项式 球函数习题及解答

    ————————————————————————————

    19.1 试证明

    ,其中

    .

    19.2计算.

    【答案

    19.3求积分

    .

    【答案 】

    19.4 求积分

    .

    【答案 】

    19.5 证明:

    19.6 证明:

    19.7 证明:

    19.8 计算

    【答案

    19.9 求球内的调和函数,使得它满足边界条件

    .

    【答案 】

    19.10 求下列定解问题

    【答案

    】 1

    1

    P ()d 0

    n x x -=?

    1,2,3,n = 1

    221

    P ()d I x x x

    -=?0,2/3; 2,4/15; 0,2,0n I n I n I ====≠=1

    P ()d l I x x

    =?0,1; 1,1/2; 2,1,0;

    (21)!!

    21,1, (1)(22)!!k

    l I l I l k k I k l k k I k =====≥=-=+≥=-+1

    P ()d l I x x x

    =?120,1/2; 1,1/3; 21,1, 0;(22)!!

    2,1, (1)2(1)!(1)!k k

    l I l I l k k I k l k k I k k +=====+≥=-=≥=--+31332

    ()()55x P x P x =

    +1

    1

    110

    (1)()d ()d m

    m n n m n x P x x m x P x x

    --++=??1

    221

    2(21)

    (1)[()]d ,0,1,2,.

    21n n n x P x x n n -+'-=

    =+?

    111

    1

    (1) =P ()d ; (2) =(23)P ()d n n I x x x I x x x

    --+??(1)1,2/3;1,0;(2)0,4;1,2,0,1,0n I n I n I n I n I ==≠=====≠=u

    21|cos r u θ==2

    212

    (,)(cos )33u r P r θθ=+222

    2111()(sin )0, (01)sin |cos 2cos r u

    u r r r r

    r r u θθθθθ=?????+=?????=+?2

    111

    (,)2cos [cos(2)]323u r r r θθθ=+?++

    展开全文
  • noi 1.5第38 计算多项式的导数

    千次阅读 2018-08-11 10:50:13
    计算多项式的导函数是一件非常容易的任务。给定一个函数f(x),我们用f’(x)来表示其导函数。我们用x^n来表示x的n次幂。为了计算多项式的导函数,你必须知道三条规则: (1)、(C)’ = 0 如果C是常量 (2)、(C*x^n)’ ...
  • 对于多项式f(x)=ax3+bx2+cx+d和给定的a,b,c,d,x,计算f(x)的值,保留到小数点后7位。 【输入】 输入仅一行,包含5个实数,分别是x,及参数a、b、c、d的值,每个数都是绝对值不超过100的双精度浮点数。数与数之间以一...
  • 数值计算方法习题答案,由曾金平主编,湖南大学出版
  • 0.1087 0.0217 0.4130] >>D=rank(A) D=3 第3章非线性方程(组)求解与迭代法 1、多项式方程求解:roots(A),求多项式a在b处的值polyval(a,b) 2、非线性方程求解: fzero(fun,x0)求函数fun在x0附件的零值点 或者fzero...
  • 《计算机辅助设计》复习一、 填空:(每空1分,共63个空)取36分1. 以弧长为参数的曲线方程为_________方程,其切矢模长为_________。【自然参数方程,1】2. 在参数曲线的活动坐标系中,主法线和切线构成_________...
  • Time Limit: 1000ms Memory limit: 65536K 疑问?点这里^_^ 题目描述 多项式的描述如下: 1 - 1/2 + 1/3 - 1/4 + 1/5 - 1/6 + ... 现在请你求出该多项式的前n项的和。 输入 输入数据由2行组成,首先是...
  • 计算题:1. 将二进制数101101.101转换为十进制数、八进制数和十六进制数。2. 已知[x]原=10110101,求真值x及其x的补码和反码。3. 某计算机字长为8位,X=-0.01011,要求用补码算术移位方法求得下列机器数:(1)[0.5x]...
  • 比较经典的一些数值分析的试题以及详细解答。
  • 计算机组成习题答案及部分解析

    千次阅读 2019-06-19 13:33:02
    计算机组成习题答案+部分解题过程 一、填空 设二进制数X=2+100×(—0.10101100),用15个二进制位来表示它的浮点数,阶码用5位,其中阶符用2位;尾数用10位,其中符号用2位(2100中的100为二进制数) (1...
  • luogu P4726 多项式指数函数(模板FFT、多项式求逆、多项式对数函数) 手动博客搬家: 本文发表于20181127 08:39:42, 原地址https://blog.csdn.net/suncongbo/article/details/84559818 题目链接: ...
  • 老师布置作业,让给家里的初中小朋友出多项式,并批改,懒得算,敲个代码做个UI让自己算吧。。。 刚学的QT派上用场了,主要就两个文件,一个是界面,一个是算法,合起来就OK了! 界面的py文件: # -*- coding: utf-8...
  • 孙德文 计算机组成原理 习题答案 机械工业出版社小数无移码(9) —127= -1111111[—127]原 = 11111111B [—127]反 = 10000000B [—127]补 = 10000000B [—127]移 = 00000000B(10) —1[—1]原 = 10000001B [—1]反 = ...
  • 前五章课后答案计算题详解 目录 第一章: 第二章 第三章 第四章 第一章: 10、试在下列条件下比较电路交换和分组交换。要传送的报文共x(bit),从源站到目的站共经过k段链路,每段链路的传播时延为d(s)...
  • 多项式合集

    2021-02-20 19:13:39
    文章目录多项式合集拉格朗日插值问题背景结论推导拉格朗日插值与范德蒙矩阵开始全家桶之前形式化定义界快速傅里叶变换(FFT)复数基础从欧拉公式到单位圆多项式的表示法单位复数根DFTIDFT位逆序置换多项式乘法的实现...
  • 2014-15-1计算思维模拟参考答案 1.磁盘驱动器属于(C)设备。 A.输入 B.输出 C.输入和输出 D.以上均不是 2.下列存储器中存取速度最快的是( A )。 A.内存 B.硬盘 C.光盘 D.U盘 3.下列叙述中,正确的是...
  • 最新课件 习 一 3.已知函数在处的函数值试通过一个二次插值函数求的近似值并估计其误差 解 采用Lagrange插值多项式 其误差为 2采用Newton插值多项式 根据题意作差商表 一阶差商 二阶差商 0 4 2 1 6.25 2.5 2 9 3 ...
  • 计算多项式的导函数是一件非常容易的任务。给定一个函数f(x),我们用f’(x)来表示其导函数。我们用x^n来表示x的n次幂。为了计算多项式的导函数,你必须知道三条规则: (1)、©’ = 0 如果C是常量 (2)、(Cx^n)’ = Cn...
  • 由于特征值是一个2阶的,还需要计算导数。 定理 结论 例题 没必要展开成幂级数来算。一个函数如果展开成幂级数,他的取值范围就小了。因为谱半径要小于函数的收敛半径,不然没办法定义。 所以能不能不...
  • 计算方法模拟试题及参考答案.doc,答案齐全不存在漏洞,放心下载,希望对各位帮助,
  • 多项式学习

    2019-03-12 05:03:54
    补0:补成222个2n2n2n次多项式 求值:用FFT计算f1=DFT(v1),f2=DFT(v2)f_1=DFT(v_1),f_2=DFT(v_2)f1​=DFT(v1​),f2​=DFT(v2​).求的是点值 乘法:把两个向量乘起来 差值:计算IDFT(f)IDFT(f)IDFT(f) FFT模板带优化...
  • 计算机网络复习题( 三)计算题

    万次阅读 多人点赞 2019-06-21 12:53:48
    计算题从来都不会 看不懂 我放弃了 计算题(三) 1.收发两端之间的传输距离为1000km,信号在媒体上的传播速率为2×108m/s。试计算以下两种情况的发送时延和传播时延:(1)数据长度为107bit,数据发送速率为100kb...
  • OpenJudge NOI 1.5 38:计算多项式的导函数 题目中给的测试数据的格式是错的。 根据中输入描述来做输入,输入只有两行。 【题目考点】 1. 循环 【题解代码】 解法1: #include <bits/stdc++.h> using ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,545
精华内容 2,618
关键字:

多项式计算题有答案