一些板子

哈哈哈希

//一种好写且卡不掉的树哈希
//https://peehs-moorhsum.blog.uoj.ac/blog/7891
int hs(int x) {
    return x*x*x*1237123+19260817;
}
int h(int x) {
    int cur=hs(x&((1ll<<31ll)-1))+hs(x>>31ll);
    return cur;
}

离散化:

//离散化，可以处理一些跨越区间比较大的时候的位置关系，空间更紧凑 
int n,m;
int a[N],b[N],c[N];
int cnt=0;
//lower_bound 第一个大于等于x的数
//upper_bound 第一个大于x的数 
int main() {
	
	n=read();
	for(int i=1;i<=n;i++) {
		
		a[i]=read();
		b[i]=read();
		c[++cnt]=a[i];
		c[++cnt]=b[i];
		
	}
	sort(c+1,c+cnt+1);
	cnt=unique(c+1,c+cnt+1)-c-1;
	for(int i=1;i<=n;i++) {
		
		a[i]=lower_bound(c+1,c+cnt+1,a[i])-c-1; 
		b[i]=lower_bound(c+1,c+cnt+1,b[i])-c-1;
		
	}
	
	return 0;
}

阶乘逆元、组合数:

//只会手搓龟速费马小定理求逆元...
int ksm(int a,int b) {

	int ans=1;
	while(b) {

		if(b&1) ans*=a,ans%=mod;
		a=(a*a)%mod;
		b>>=1;

	}
	return ans;

}

int n,inv[N],jc[N];

int get_inv(int a,int b) {
	return a*(ksm(b,mod-2))%mod;
}

void inv_init() {
	
	inv[0]=jc[0]=1;
	for(int i=1; i<=n; i++) {

		jc[i]=jc[i-1]*i%mod;
		inv[i]=get_inv(inv[i-1],i)%mod;

	}
	
}

int C(int n,int m) {//n个里选m个 
	return (jc[n]*inv[n-m])%mod*inv[m]%mod;
}

signed main() {

	n=read();
	inv_init();
	//......
	return 0;
}

差分数组

利用记录与前一个数的差，预处理差分数组，这样利用前缀和可以从前到后恢复原来的数组，并更新起变化
再利用在修改的区间[l,r]，左边的d[l]打上加的修改标记，在右边d[r+1]打上减的修改标记，消除加号标记对之后的区间的影响，大概就是这样吧

int n,m;
int a[N],d[N],ans[N];

int main() {
	
	n=read();
	m=read();
	for(int i=1;i<=n;i++) {
		
		a[i]=read();
		d[i]=a[i]-a[i-1];
		
	} 
	for(int i=1;i<=m;i++) {
		
		int l=read(),r=read(),c=read();
		d[l]+=c;
		d[r+1]-=c;
		
	}
	for(int i=1;i<=n;i++) {
		
		ans[i]=ans[i-1]+d[i];
		printf("%d ",ans[i]);
		
	}
	 
	return 0;
}

矩阵快速幂

矩阵乘法中:
矩阵A长x宽y,矩阵B长y宽z,结果矩阵C长x宽z
对应矩阵中(i,j)的位置的结果是:
A的第i行和B的第j列各自的第i(i∈[1,y])个相乘再累加 

int n,k;

struct Matrix {

	int a[N][N];
	Matrix() {
		memset(a,0,sizeof(a));
	}
	
	void build() {//建立对角线为1的矩阵，即单位矩阵 
		for(int i=1;i<=n;i++) a[i][i]=1;
	}
	
	Matrix operator*(const Matrix &b) const {
		Matrix c;
		for(int k=1; k<=n; k++) {
			for(int i=1; i<=n; i++) {
				for(int j=1; j<=n; j++) {
					c.a[i][j]=(c.a[i][j]+a[i][k]*b.a[k][j])%mod;
				}
			}
		}
		return c;
	}

} ans,t;

void quick_pow(int K) {

	while(K) {
		if(K&1) ans=ans*t;
		t=t*t;
		K>>=1;
	}

}

signed main() {

	n=read();
	k=read();
	for(int i=1; i<=n; i++){
		for(int j=1; j<=n; j++){
			t.a[i][j]=read();
		}
	}
	ans.build();
	quick_pow(k);
	//...
	return 0;
}