【UOJ574】多线程计算【二元二项式反演】【定积分】【矩阵】【NTT 卷积】

最新推荐文章于 2022-01-30 16:13:32 发布
原创 最新推荐文章于 2022-01-30 16:13:32 发布 · 401 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

题意：有 n×mn\times mn×m 的网格，每个结点在 [0,1)[0,1)[0,1) 内的一个随机时刻被点亮。有 hhh 个数对 xi,yix_i,y_ixi​,yi​，对于一个瞬间状态，如果存在一个 xi,yix_i,y_ixi​,yi​ 使得恰好有 xix_ixi​ 行 yiy_iyi​ 列被点亮，则每单位时间产生值为斐波拉契第 kkk 项的贡献，kkk 为点亮的结点个数。求期望贡献之和 模 998244353998244353998244353。

1≤h≤n×m≤5×1051\leq h\leq n\times m\leq 5\times 10^51≤h≤n×m≤5×105

恰好不好搞，先容斥。显然一个时刻最多一个条件满足，所以求所有条件的贡献和就可以了。（其实多个条件是给部分分用的）

设 f(x,y)f(x,y)f(x,y) 表示钦定 xxx 行 yyy 列全亮的贡献之和，g(x,y)g(x,y)g(x,y) 表示恰好有 xxx 行 yyy 列全亮的贡献。

有

f(x,y)=∑i=xn∑j=ym(ix)(jy)g(i,j)f(x,y)=\sum_{i=x}^n\sum_{j=y}^{m}\binom ix\binom jyg(i,j)f(x,y)=i=x∑n​j=y∑m​(xi​)(yj​)g(i,j)

由二项式反演的推广可知

g(x,y)=∑i=xn∑j=ym(−1)i+j−x−y(ix)(jy)f(i,j)g(x,y)=\sum_{i=x}^n\sum_{j=y}^m(-1)^{i+j-x-y}\binom ix\binom jyf(i,j)g(x,y)=i=x∑n​j=y∑m​(−1)i+j−x−y(xi​)(yj​)f(i,j)

文末有这个东西的证明。

现在的问题是怎么求 f(i,j)f(i,j)f(i,j)。因为钦定必须亮的行列数给定后，可以计算出必须亮的结点的个数为 nm−(n−i)(m−j)nm-(n-i)(m-j)nm−(n−i)(m−j)，于是转换为下面这个问题：

  • 有 x+yx+yx+y 个结点，其中前 xxx 个必须亮，后 yyy 个随意，求总贡献。

（这个 x,yx,yx,y 和前面的 x,yx,yx,y 没有关系）

注意要乘个组合数。

这个贡献不是离散的，我们先要找点结论出来。考虑一个时刻 ttt，所有结点亮的概率都是独立的 ttt。那个斐波拉契实际上就是矩阵的幂，设转移矩阵为 MMM。

先用 y=0y=0y=0 的找点灵感，产生的贡献就是 MxtxM^xt^xMxtx。

求个积分

∫01Mxtxdt=1x+1Mx\int_0^1 M^xt^x dt=\frac{1}{x+1}M^x∫01​Mxtxdt=x+11​Mx

然后就可以用类似的思路推广出所有多项式的情况。

开始想的再套一个容斥上去，但式子十分精神污染。然后想的积分的时候强制后面的不选，然后推出了一模一样的式子……

考虑这些式子本质肯定都相同，你推不出来是数学不好。所以考虑运用一些成熟的结论多跳几步。

注意到后面任意选里面带的是组合数，可以考虑直接用二项式定理，然后直接把矩阵积分。即

∫01(tM)x(tM+1−t)ydt\int_0^1(tM)^x(tM+1-t)^y dt∫01​(tM)x(tM+1−t)ydt

右边直接拆不好搞，但注意到可以把 ttt 合并

∫01(tM)x(t(M−1)+1)ydt\int_0^1(tM)^x(t(M-1)+1)^y dt∫01​(tM)x(t(M−1)+1)ydt

直接考察这个式子的 x+ix+ix+i 项系数，它等于 Mx(yi)(M−1)iM^x\binom yi (M-1)^iMx(iy​)(M−1)i

所以积分后的总贡献就是

∑i=0y1x+i+1Mx(yi)(M−1)i\sum_{i=0}^y \frac 1{x+i+1}M^x\binom yi (M-1)^ii=0∑y​x+i+11​Mx(iy​)(M−1)i

暴力做这个东西，然后前面反演式也暴力算，可以做到 O((nm)2)\Omicron((nm)^2)O((nm)2)

注意到这个式子是卷积的形式

f(k)=∑i=0k1n−k+i+1Mn−kk!i!(k−i)!(M−1)i=Mn−kk!∑i=0k(M−1)ii!1(n−k+i+1)(k−i)!f(k)=\sum_{i=0}^k\frac 1{n-k+i+1}M^{n-k}\frac{k!}{i!(k-i)!}(M-1)^i\\=M^{n-k}k!\sum_{i=0}^k\frac{(M-1)^i}{i!}\frac 1{(n-k+i+1)(k-i)!}f(k)=i=0∑k​n−k+i+11​Mn−ki!(k−i)!k!​(M−1)i=Mn−kk!i=0∑k​i!(M−1)i​(n−k+i+1)(k−i)!1​

找不到更好的姿势，就直接糊了个矩阵 NTT 上去，荣获赛时最慢代码。

后面的反演式

g(x,y)=∑i=xn∑j=ym(−1)i+j−x−y(ix)(jy)f(i,j)g(x,y)=\sum_{i=x}^n\sum_{j=y}^m(-1)^{i+j-x-y}\binom ix\binom jyf(i,j)g(x,y)=i=x∑n​j=y∑m​(−1)i+j−x−y(xi​)(yj​)f(i,j)

(−1)x+yx!y!g(x,y)=∑i=xn∑j=ym(−1)i+ji!j!f(i,j)(i−x)!(j−y)!(-1)^{x+y}x!y!g(x,y)=\sum_{i=x}^n\sum_{j=y}^m\frac{(-1)^{i+j}i!j!f(i,j)}{(i-x)!(j-y)!}(−1)x+yx!y!g(x,y)=i=x∑n​j=y∑m​(i−x)!(j−y)!(−1)i+ji!j!f(i,j)​

两维是独立的，所以横着对每一行卷一次，再竖着对每一列卷一次就可以了。

于是又写成了代数大杂烩……

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cctype>
#include <vector>
#define MAXN (1<<20)+5
using namespace std;
const int MOD=998244353;
typedef long long ll;
inline int add(const int& x,const int& y){return x+y>=MOD? x+y-MOD:x+y;}
inline int dec(const int& x,const int& y){return x<y? x-y+MOD:x-y;}
inline int qpow(int a,int p)
{
	int ans=1;
	while (p)
	{
		if (p&1) ans=(ll)ans*a%MOD;
		a=(ll)a*a%MOD,p>>=1;
	}
	return ans;
}
#define inv(x) qpow(x,MOD-2)
inline int read()
{
	int ans=0;
	char c=getchar();
	while (!isdigit(c)) c=getchar();
	while (isdigit(c)) ans=(ans<<3)+(ans<<1)+(c^48),c=getchar();
	return ans;
}
int fac[MAXN],finv[MAXN];
struct mat
{
	int e[2][2];
	inline mat(const int& v=0)
	{
		e[0][0]=e[1][1]=v;
		e[0][1]=e[1][0]=0;	
	}	
	inline int* operator [](const int& i){return e[i];}
	inline const int* operator [](const int& i)const{return e[i];}
};
inline mat operator +(const mat& a,const mat& b)
{
	mat c;
	for (int i=0;i<2;i++)
		for (int j=0;j<2;j++)
			c[i][j]=add(a[i][j],b[i][j]);
	return c;
}
inline mat operator -(const mat& a,const mat& b)
{
	mat c;
	for (int i=0;i<2;i++)
		for (int j=0;j<2;j++)
			c[i][j]=dec(a[i][j],b[i][j]);
	return c;	
}
inline mat operator *(mat a,const int& b)
{
	for (int i=0;i<2;i++)
		for (int j=0;j<2;j++)
			a[i][j]=(ll)a[i][j]*b%MOD;
	return a;
}
inline mat operator *(const mat& a,const mat& b)
{
	mat c;
	for (int i=0;i<2;i++)
		for (int k=0;k<2;k++)
			for (int j=0;j<2;j++)
				c[i][j]=(c[i][j]+(ll)a[i][k]*b[k][j])%MOD;
	return c;
}
mat P[MAXN],Q[MAXN];
vector<int> f[MAXN],g[MAXN];
inline int C(const int& n,const int& m){return (ll)fac[n]*finv[m]%MOD*finv[n-m]%MOD;}
int l,lim,r[MAXN];
inline void init(){lim=1<<l;for (int i=0;i<lim;i++) r[i]=(r[i>>1]>>1)|((i&1)<<(l-1));}
int rt[2][24];
void ntt(mat* a,int type)
{
	for (int i=0;i<lim;i++) if (i<r[i]) swap(a[i],a[r[i]]);
	for (int L=0;L<l;L++)
	{
		int mid=1<<L,len=mid<<1;
		int Wn=rt[type][L+1];
		for (int s=0;s<lim;s+=len)
			for (int k=0,w=1;k<mid;k++,w=(ll)w*Wn%MOD)
			{
				mat x=a[s+k],y=a[s+mid+k]*w;
				a[s+k]=x+y,a[s+mid+k]=x-y;
			}
	}
	if (type)
	{
		int t=inv(lim);
		for (int i=0;i<lim;i++) a[i]=a[i]*t;
	}
}
void ntt(int* a,int type)
{
	for (int i=0;i<lim;i++) if (i<r[i]) swap(a[i],a[r[i]]);
	for (int L=0;L<l;L++)
	{
		int mid=1<<L,len=mid<<1;
		int Wn=rt[type][L+1];
		for (int s=0;s<lim;s+=len)
			for (int k=0,w=1;k<mid;k++,w=(ll)w*Wn%MOD)
			{
				int x=a[s+k],y=(ll)a[s+mid+k]*w%MOD;
				a[s+k]=add(x,y),a[s+mid+k]=dec(x,y);
			}
	}
	if (type)
	{
		int t=inv(lim);
		for (int i=0;i<lim;i++) a[i]=(ll)a[i]*t%MOD;
	}
}
mat F[MAXN],res[MAXN];
int A[MAXN],B[MAXN];
inline int calc(int x,int y)
{
	mat ans=P[x]*res[y]*fac[y];
	return add(ans[1][0],ans[1][1]);
}
int main()
{
	rt[0][23]=qpow(3,119),rt[1][23]=inv(rt[0][23]);
	for (int i=22;i>=0;i--)
	{
		rt[0][i]=(ll)rt[0][i+1]*rt[0][i+1]%MOD;
		rt[1][i]=(ll)rt[1][i+1]*rt[1][i+1]%MOD;
	}
	int n,m;
	n=read(),m=read();
	fac[0]=1;
	for (int i=1;i<=n*m;i++) fac[i]=(ll)fac[i-1]*i%MOD;
	finv[n*m]=qpow(fac[n*m],MOD-2);
	for (int i=n*m-1;i>=0;i--) finv[i]=(ll)finv[i+1]*(i+1)%MOD;
	P[0]=Q[0]=mat(1);
	mat p,q;
	p[0][0]=p[0][1]=p[1][0]=1;
	q[0][1]=q[1][0]=1,q[1][1]=MOD-1;
	for (int i=1;i<=n*m;i++) P[i]=P[i-1]*p,Q[i]=Q[i-1]*q;
	for (int i=0;i<=n;i++) f[i].resize(m+1),g[i].resize(m+1);
	for (l=0;(1<<l)<=2*n*m;l++);
	init();
	for (int i=0;i<=n*m;i++) F[i]=Q[i]*finv[i],A[i]=(ll)finv[i]*inv(n*m+1-i)%MOD;
	ntt(F,0),ntt(A,0);
	for (int i=0;i<lim;i++) res[i]=F[i]*A[i];
	ntt(res,1);
	for (int i=0;i<=n;i++)
		for (int j=0;j<=m;j++)
			f[i][j]=(ll)C(n,i)*C(m,j)%MOD*calc(i*m+j*n-i*j,(n-i)*(m-j))%MOD;
//	for (int i=0;i<=n;i++,puts(""))
//		for (int j=0;j<=m;j++)
//			printf("%d ",f[i][j]);
//	for (int i=n;i>=0;i--)
//		for (int j=m;j>=0;j--)
//		{
//			g[i][j]=f[i][j];
//			if (i<n) g[i][j]=add(g[i][j],g[i+1][j]);
//			if (j<m) g[i][j]=add(g[i][j],g[i][j+1]);
//			if (i<n&&j<m) g[i][j]=dec(g[i][j],g[i+1][j+1]);
//		}
	for (int i=0;i<=n;i++)
		for (int j=0;j<=m;j++)
		{
			f[i][j]=(ll)f[i][j]*fac[i]%MOD*fac[j]%MOD;
			if ((i+j)&1) f[i][j]=dec(0,f[i][j]);
		}
	for (l=0;(1<<l)<=(m<<1);l++);
	init();
	for (int T=0;T<=n;T++)
	{
		for (int i=0;i<lim;i++) A[i]=B[i]=0;
		for (int i=0;i<=m;i++) A[i]=f[T][i],B[i]=finv[m-i];
		ntt(A,0),ntt(B,0);
		for (int i=0;i<lim;i++) A[i]=(ll)A[i]*B[i]%MOD;
		ntt(A,1);
		for (int i=m;i<=2*m;i++) f[T][i-m]=A[i];
	}
	for (l=0;(1<<l)<=(n<<1);l++);
	init();
	for (int T=0;T<=m;T++)
	{
		for (int i=0;i<lim;i++) A[i]=B[i]=0;
		for (int i=0;i<=n;i++) A[i]=f[i][T],B[i]=finv[n-i];
		ntt(A,0),ntt(B,0);
		for (int i=0;i<lim;i++) A[i]=(ll)A[i]*B[i]%MOD;
		ntt(A,1);
		for (int i=n;i<=2*n;i++) f[i-n][T]=A[i];
	}
	for (int i=0;i<=n;i++)
		for (int j=0;j<=m;j++)
		{
			f[i][j]=(ll)f[i][j]*finv[i]%MOD*finv[j]%MOD;
			if ((i+j)&1) f[i][j]=dec(0,f[i][j]);
		}
	int ans=0;
	for (int T=read();T;T--)
	{
		int x,y;
		x=read(),y=read();
		ans=add(ans,f[x][y]);
	}
	cout<<ans;
	return 0;
}

附：二元二项式反演证明

g(x,y)=∑i=xn∑j=ym(ix)(jy)[i−x=0][j−y=0]g(i,j)g(x,y)=\sum_{i=x}^n\sum_{j=y}^m\binom ix\binom jy[i-x=0][j-y=0]g(i,j)g(x,y)=i=x∑n​j=y∑m​(xi​)(yj​)[i−x=0][j−y=0]g(i,j)

g(x,y)=∑i=xn∑j=ym(ix)(jy)∑a=0i−x∑b=0j−y(−1)a+b(i−xa)(j−yb)g(i,j)g(x,y)=\sum_{i=x}^n\sum_{j=y}^m\binom ix\binom jy\sum_{a=0}^{i-x}\sum_{b=0}^{j-y}(-1)^{a+b}\binom{i-x}a\binom{j-y}bg(i,j)g(x,y)=i=x∑n​j=y∑m​(xi​)(yj​)a=0∑i−x​b=0∑j−y​(−1)a+b(ai−x​)(bj−y​)g(i,j)

g(x,y)=∑i=xn∑j=ym∑a=0i−x∑b=0j−y(−1)a+b(ix+a)(x+ax)(jy+b)(y+by)g(i,j)g(x,y)=\sum_{i=x}^n\sum_{j=y}^m\sum_{a=0}^{i-x}\sum_{b=0}^{j-y}(-1)^{a+b}\binom i{x+a}\binom{x+a}{x}\binom{j}{y+b}\binom{y+b}{y}g(i,j)g(x,y)=i=x∑n​j=y∑m​a=0∑i−x​b=0∑j−y​(−1)a+b(x+ai​)(xx+a​)(y+bj​)(yy+b​)g(i,j)

g(x,y)=∑i=xn∑j=ym∑a=xi∑b=yj(−1)a+b−x−y(ia)(ax)(jb)(by)g(i,j)g(x,y)=\sum_{i=x}^n\sum_{j=y}^m\sum_{a=x}^{i}\sum_{b=y}^{j}(-1)^{a+b-x-y}\binom i{a}\binom{a}{x}\binom{j}{b}\binom{b}{y}g(i,j)g(x,y)=i=x∑n​j=y∑m​a=x∑i​b=y∑j​(−1)a+b−x−y(ai​)(xa​)(bj​)(yb​)g(i,j)

g(x,y)=∑a=xn∑b=ym(−1)a+b−x−y(ax)(by)∑i=xn∑j=ym(ix)(jy)g(i,j)g(x,y)=\sum_{a=x}^{n}\sum_{b=y}^{m}(-1)^{a+b-x-y}\binom{a}{x}\binom{b}{y}\sum_{i=x}^n\sum_{j=y}^m\binom ix \binom jyg(i,j)g(x,y)=a=x∑n​b=y∑m​(−1)a+b−x−y(xa​)(yb​)i=x∑n​j=y∑m​(xi​)(yj​)g(i,j)

g(x,y)=∑i=xn∑j=ym(−1)i+j−x−y(ix)(jy)f(i,j)g(x,y)=\sum_{i=x}^{n}\sum_{j=y}^{m}(-1)^{i+j-x-y}\binom{i}{x}\binom{j}{y}f(i,j)g(x,y)=i=x∑n​j=y∑m​(−1)i+j−x−y(xi​)(yj​)f(i,j)

Lstdo
关注
在Linux机器上部署UOJ评测系统
不写博客
04-23 8882
前言 部署要求 开始部署 Ubuntu软件源更新 docker服务部署 获取UOJ最新社区版 安装UOJ 继续安装 UOJ相关操作 部署GUI管理系统 更多内容 前言学校里想要部署一套OJ，然后就选了UOJ。但是由于服务器还要一段时间（永远）才能到，所以就先拿了一台电脑作为试验机进行内网部署测试。非常感谢以下人： vfleaking 无私开放了UOJ的源码 阮行止 维护社区版本UOJ源
关于反演原理以及一个例子：二项式反演（世界上最垃圾的组合数学2）（坑）
蒟蒻QMQ
12-25 483
文章目录前言反演原理参考资料 前言 准备期末考就不做题了吧。。。 填一点坑。 反演原理 为了下文方便，我们定义一个函数Ui,j=[i=j]U_{i,j}=[i=j]Ui,j​=[i=j]，其中[q][q][q] 表示qqq成立时值为111，反之值为000。 首先我们有一个数列aaa，以及一个二元函数fi,jf_{i,j}fi,j​，以及一个已经知道的数列bbb。 aaa的生成法则为：ai=∑j=0ifi,jbj①a_{i}=\sum\limits_{j=0}^{i}f_{i,j}b_{j}①ai​=j=0∑
cuda笔记-一个Block多线程求卷积
IT1995的博客
12-15 1252
最近在学cuda，发现自己数学方面的知识不太够，C语言的知识也有待加强。 这里记录个笔记对矩阵求卷积。 逻辑是这样的： 1. 先CUDA生成一个16*16的矩阵； 2. 将这16*16的矩阵，外面包一层0，也就变成18*18的矩阵。 3. 然后再开18*18个线程，进行矩阵的卷积 程序运行截图如下： 源码如下： #include "cuda_runtime.h" #include "device_launch_parameters.h" #include "curand.h".
LOJ2527 HAOI2018 染色 生成函数、二项式反演、NTT
weixin_30650039的博客
03-17 180
传送门 调了1h竟然是因为1004535809写成了998244353 “恰好有\(K\)种颜色出现了\(S\)次”的限制似乎并不容易达到，考虑容斥计算。 令\(c_j\)表示强制\(j\)种颜色恰好出现\(S\)次，其他颜色随意染的方案数。可以通过生成函数知道 \(\begin{align*} c_j &= \binom{m}{j} n! [x^n] (\frac{x^k}{k!})^...
UOJ #574. 桂林的文件
dingjinhui4074的博客
09-05 131
【题目描述】： 桂林有N个不同的文件，现在他要创建N-1个文件夹（相同）来保存这些文件，每个文件夹内有且只有两个项目，每个项目可以是一个文件或者一个文件夹，问他有多少种不同的存储方式。 【输入描述】： 第一行一个正整数T，表示数据组数。 接下来T行每行一个正整数N。 【输出描述】： 共T行，在模19260817的意义下桂林的存储方式总数。 【样例输入】： 2 3 ...
C++性能优化系列——3D高斯核卷积计算(十)合并多线程并行区
yan31415的博客
10-19 944
void GaussSmoothCPU3DOptZYX(float* pSrc, int iDim[3], float* pKernel, int kernelSize[3], float* pDst, float* pBuffer) { //计算结果正确 //执行时间 16 dynamic GaussSmoothCPU3DOptZYX cost Time(ms) 338.4 //16 static GaussSmoothCPU3DOptZYX cost Time(ms) 590 //
[HAOI2018] 染色（二项式反演+NTT）
01-30 994
二项式发演堵在路上啦~
uoj-data-converter.zip
09-21
"UOJ Data Converter"是一个专门针对UOJ（Unreal Online Judge）平台的数据转换工具。这个工具的主要目的是帮助用户将特定格式的数据转换为UOJ系统所接受的输入输出格式，以便于在该在线判题系统上进行编程题目的...
南京大学服务器上搭建UOJ系统的保姆级步骤
09-30
从申请南京大学服务器开始，然后搭建docker系统，之后创建UOJ系统用于发布课堂作业，用于帮助助教进行UOJ系统搭建，帮助助教更好的完成老师布置的任务
UOJ数据转换工具使用指南
资源摘要信息:"UOJ Data Converter 是一款专门设计用于转换或处理与 UOJ（University Online Judge）相关的数据文件的工具。UOJ 是一个面向大学生和教育工作者的在线评测系统，旨在为编程竞赛和算法学习提供一个平台...
UOJ-System:通用在线法官（社区版）
03-11
环球在线法官 一款通用的在线评论系统。 特性 ... 多种部署方式，各取所需，省心省力，方便快捷。 各组成部分可单点部署，也可分离部署...将UOJ代码 向原项目或本项目贡献代码的人 给我们启发与灵感以及提供意见和建议的人
【集训队作业2018】矩阵玩小凹 NTT
weixin_30723433的博客
12-29 137
题目大意 　　有一个 \(n\times m\) 的矩阵 \(A\)，每个元素都是 \([0,1]\) 内的等概率随机实数，记 \(s_i=\sum_{j=1}^mA_{i,j}\)，求 \(\lfloor\min s_i\rfloor^k\) 的期望。 　　对 \(998244353\) 取模。 　　\(n\leq {10}^9,m\leq 5\times {10}^5,k\leq {10}^9...
数学基础：卷积（Convolution）
dexfire ’s blog
02-23 7556
卷积（Convolution） 卷积是一种积分变换的数学方法，与傅立叶变换有着密切的联系。在数字信号处理、通信系统、光学系统、神经网络计算许多方面得到了广泛应用。 在泛函分析中，卷积、旋积或摺积是通过两个函数g和h生成第三个函数f的一种数学算子，表征函数g与h经过翻折、平移之后重叠部分函数值乘积对重叠长度的积分。 定义 简单定义： 设f(x), g(x)是R1上的两个可积函数，作积分： ∫−∞∞f...
矩阵卷积运算的具体过程
qwj的博客
07-27 9752
矩阵卷积运算的具体过程，很简单   最近在看图像处理，卷积运算这一块也查了很多，但是感觉都写的太复杂，我这里简单的写一下卷积到底是一个什么计算过程。 假设有一个卷积核h，就一般为3*3的矩阵： 有一个待处理矩阵x： h*x的计算过程分为三步 第一步，将卷积核翻转180°，也就是成为了 第二步，将卷积核h的中心对准x的第一个元素，然后对应元素相乘后相加，没有元素的地方补0。...
比FFT还容易明白的NTT（快速数论变换）
热门推荐
路人黑的纸巾
08-17 3万+
NTTNTTNTT相关 一种快速数论变换算法，这种算法是以数论为基础，对样本点为的数论变换，按时间抽取的方法，得到一组等价的迭代方程，有效高速简化了方程中的计算公式·与直接计算相比，大大减少了运算次数。（见快速傅里叶变换）。 在计算机实现多项式乘法中，我们所熟知的快速傅里叶变换(FFT)是基于n次单位根 (omega) 的优秀性质实现的，而由于其计算时会使用正弦函数和余弦函数，在不...
【NTT】【二维卷积】最佳农场
氧化钠的博客
02-14 888
题意： 分析： 翻转矩阵后，就是个二维卷积。 所谓二维卷积，其实就是把位置(i,j)映射到一个多项式的第i*m+j次项，然后就是一维卷积。。。 说得牛逼其实很傻 多的位置用0补齐即可。 复杂度O(R∗C+R∗C∗log(R∗C))O(R*C+R*C*log(R*C))O(R∗C+R∗C∗log(R∗C)) #include&lt;cstdio&gt; #include&lt;cstring&g...
FFT&NTT数学解释
weixin_30412577的博客
06-01 456
FFT和NTT真是噩梦呢 既然被FFT和NTT坑够了，坑一下其他的人也未尝不可呢 前置知识 多项式基础知识 矩阵基础知识（之后会一直用矩阵表达） FFT：复数基础知识 NTT：模运算基础知识 单位根介绍 设有一个数a，使得an=1，其中n为满足an=1的最小正整数 满足条件的a有哪些呢？ 复数域上的(cos(2π/n)+sin(2π/n)*i)（一般用ωn表...
7-149 多线程计算 (20 分)
qq_54260963的博客
11-15 3338
7-149 多线程计算 (20 分) 已知某学校有n名教师，学校有m名学生，学校搞学生民意调查，每一位学生为每一位老师都打分，学生所打的所有的分数都集中到一个数组中。数据存放规律是，前m个数据是对1号老师的打分，接下来m个数据是对2号老师的打分，以此类推。请设计一个多线程的算法，计算出每一位老师的总打分。 输入格式: 第一行输入教师数，第二行输入学生数，第三行输入所有n*m个打分（整型），各个分数之间以一个空格分隔 输出格式: 按照教师原来的顺序，每行输出每一位老师的得分 输入样例: 在这里给出一组输入。例
MEC —— 优化内存与速度的卷积计算
shuzfan的专栏
08-20 1万+
本次介绍一种内存利用率高且速度较快的卷积计算方法。 来自ICML2017, 《MEC: Memory-efficient Convolution for Deep Neural Network》1. 背景工作目前的CNN模型中，全连接层往往在最后一层才会使用。 意思也就是说，网络的主体是由卷积层构成的。 因此，加快卷积层的计算对于整个网络的性能至关重要。目前，卷积的计算大多采用间接计算的方式，主要有
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值