模板大集合 - Part 3

已于 2024-08-21 12:59:38 修改
阅读量266 收藏 13
点赞数 11
分类专栏： 模板 文章标签： 算法 c++ 数据结构 笔记 其他
于 2024-08-21 12:56:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_49785217/article/details/141390741
版权

P3810 【模板】三维偏序（陌上花开）

CDQ分治：

#include<bits/stdc++.h>
using namespace std;

#define int long long

int rd() {
	int x = 0, w = 1;
	char ch = 0;
	while (ch < '0' || ch > '9') {
		if (ch == '-') w = -1;
		ch = getchar();
	}
	while (ch >= '0' && ch <= '9') {
		x = x * 10 + (ch - '0');
		ch = getchar();
	}
	return x * w;
}

void wt(int x) {
	static int sta[35];
	int f = 1;
	if(x < 0) f = -1,x *= f;
	int top = 0;
	do {
		sta[top++] = x % 10, x /= 10;
	} while (x);
	if(f == -1) putchar('-');
	while (top) putchar(sta[--top] + 48);
}

const int N = 2e5+5;

struct query{
    int x,y,z,w,ans;
};

bool cmpx(query a,query b) {
    if(a.x == b.x) {
        if(a.y == b.y)
            return a.z < b.z;
        return a.y < b.y;
    }
    return a.x < b.x;
}

bool cmpy(query a,query b) {
    if(a.y == b.y) 
        return a.z < b.z;
    return a.y < b.y;
}
#define lowbit(x) ((x) & (-x))
int n,k,c[N];
query a[N],b[N];

int t[N];

void add(int x,int k) {while(x < N) t[x] += k,x += lowbit(x);}

int ask(int x){int res = 0;while(x > 0) res += t[x],x -= lowbit(x);return res;}

void cdq(int l,int r) {
    if(l == r) return;
    int mid = (l + r) >> 1;
    cdq(l,mid),cdq(mid + 1,r);
    sort(a + l,a + mid + 1,cmpy);
    sort(a + mid + 1,a + r + 1,cmpy);
    int pl = l,pr;
    for(int pr = mid + 1;pr <= r;pr++) {
        while(a[pr].y >= a[pl].y && pl <= mid) 
            add(a[pl].z,a[pl].w),pl++;
        a[pr].ans += ask(a[pr].z);
    }
    for(int i = l;i<pl;i++)   
        add(a[i].z,-a[i].w);
}

signed main() {

    n = rd(),k = rd();
    for(int i = 1;i<=n;i++)
        b[i].x = rd(),b[i].y = rd(),b[i].z = rd();
    sort(b + 1,b + n + 1,cmpx);
    int C = 0,top = 0;
    for(int i = 1;i <= n;i++) {
        C++;
        if(b[i].x != b[i + 1].x || b[i].y != b[i + 1].y || b[i].z != b[i + 1].z) 
            a[++top] = b[i],a[top].w = C,C = 0;
    }
    cdq(1,top);
    for(int i = 1;i<=top;i++) 
        c[a[i].ans + a[i].w - 1] += a[i].w; 
    for(int i = 0;i<n;i++) 
        wt(c[i]),putchar('\n');

	return 0;
}

实用普通模板

借学长 c k a i n ckain ckain 的 实用模板
我为什么不写一个呢？因为我太懒了

原文章

Fast Read & Fast Write

int rd() {
	int x = 0, w = 1;
	char ch = 0;
	while (ch < '0' || ch > '9') {
		if (ch == '-') w = -1;
		ch = getchar();
	}
	while (ch >= '0' && ch <= '9') {
		x = x * 10 + (ch - '0');
		ch = getchar();
	}
	return x * w;
}

void wt(int x) {
	static int sta[35];
	int f = 1;
	if(x < 0) f = -1,x *= f;
	int top = 0;
	do {
		sta[top++] = x % 10, x /= 10;
	} while (x);
	if(f == -1) putchar('-');
	while (top) putchar(sta[--top] + 48);
}

Mod_int

template<int Mo> struct mint {
	int x;
	mint(int _x=0) {x=(_x+Mo)%Mo;}
	friend void print(mint a, char ch=0) {printf("%d", a.x); if(ch) putchar(ch);}
	friend mint qpow(mint a, int b) {
		mint re(1); for(; b; b>>=1, a=a*a) if(b&1) re=re*a; return re;
	}
    friend mint qpow(int a,int b) {
		mint re(1);for(; b; b >>= 1,a = (a * a) % Mo) if(b & 1) re = re * a;return re;
	}
	bool operator == (mint a) {return x==a.x;}
	bool operator != (mint a) {return x!=a.x;}
    bool operator == (int a) {return x==a;}
	bool operator != (int a) {return x!=a;}
	bool operator > (mint a) {return x>a.x;}
	bool operator < (mint a) {return x<a.x;}
	bool operator >= (mint a) {return x>=a.x;}
	bool operator <= (mint a) {return x<=a.x;}
    bool operator > (int a) {return x>a;}
	bool operator < (int a) {return x<a;}
	bool operator >= (int a) {return x>=a;}
	bool operator <= (int a) {return x<=a;}
	mint operator - () {return *this * (Mo-1);}
	friend mint operator + (mint a, mint b) {a.x+=b.x; if(a.x>=Mo) a.x-=Mo; return a;}
	friend mint operator - (mint a, mint b) {a.x-=b.x; if(a.x<0) a.x+=Mo; return a;}
	friend mint operator * (mint a, mint b) {return mint(1ll*a.x*b.x%Mo);}
	friend mint operator / (mint a, mint b) {return a*qpow(b, Mo-2);}
    friend mint operator + (mint a, int b) {a.x+=b; a.x = (a.x + b) % Mo; return a;}
	friend mint operator - (mint a, int b) {a.x-=b; a.x = (a.x - b + Mo) % Mo; return a;}
	friend mint operator * (mint a, int b) {return mint(1ll*a.x*b%Mo);}
	friend mint operator / (mint a, int b) {return a*qpow(mint(b), Mo-2);}
	mint operator += (mint a) {return *this=*this+a;}
	mint operator -= (mint a) {return *this=*this-a;}
	mint operator *= (mint a) {return *this=*this*a;}
	mint operator /= (mint a) {return *this=*this/a;}
    mint operator += (int a) {return *this=*this+a;}
	mint operator -= (int a) {return *this=*this-a;}
	mint operator *= (int a) {return *this=*this*a;}
	mint operator /= (int a) {return *this=*this/a;}
};

自定义复数

struct C {
    double r,i;
    C() {r = 0,i = 0;}
    C(double a,double b) {r = a,i = b;}
    friend C operator + (const C &a,const C &b) {return C(a.r + b.r,a.i - b.i);}
    friend C operator - (const C &a,const C &b) {return C(a.r - b.r,a.i - b.i);}
    friend C operator * (const C &a,const C &b) {
		return C(a.r * b.r - a.i * b.i,a.r * b.i + a.i  * b.r);
	}
    void operator += (const C &b) {r += b.r;i += b.i;}
    void operator *= (const C &b) {double t = r;r = r * b.r - i * b.i;i = t * b.i + i * b.r;}
};

LinkFrontStar

const int N = 1e6;
struct edge{
int head[N],nxt[N<<1],to[N<<1],val[N<<1],cnt; 

edge(){memset(head,-1,sizeof(head));}

void addWithVal(int u,int v,int w) {
    nxt[cnt] = head[u];
    to[cnt] = v;
    val[cnt] = w;
    head[u] = cnt++;
}

void addWithoutVal(int u,int v) {
    nxt[cnt] = head[u];
    to[cnt] = v;
    head[u] = cnt++;
}
};

自动拆矩阵

const int K=10, P=998244353;

//！矩阵阶数
int m=8;

struct Mat{
	int c[K][K];
	Mat(bool bas=false){
		mset(c, 0);
		if(bas) for(int i=0; i<m; i++) c[i][i]=1;
	}
	int &operator ()(int i, int j){return c[i][j];}
	int operator ()(int i, int j)const{return c[i][j];}
	//debug
	Mat print(){
		for(int i=0; i<m; i++){
			for(int j=0; j<m; j++){
				debug("%d ", c[i][j]);
			}
			debug("\n");
		}
	}
	//
	Mat operator *(const Mat &o)const{
		Mat re;
		for(int i=0; i<m; i++){
			for(int j=0; j<m; j++){
				for(int k=0; k<m; k++){
					(re(i, j)+=(ll)c[i][k]*o(k, j)%P)%=P;
				}
			}
		}
		return re;
	}
};

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
template<typename T> T rnr(T l, T r){return l+rng()%(r-l+1);}

vector<Mat> choice;

//！输入矩阵列表
void give_choice(){
}

Mat get_rand_mat(){
	return choice[rnr(0, (int)choice.size()-1)];
}

int state[K][K];

void identify(){
	Mat o=get_rand_mat();
	for(int i=0; i<m; i++){
		for(int j=0; j<m; j++){
			state[i][j]=o(i, j);
		}
	}
	int T=20, TT=500;
	for(int _=1; _<=T; _++){
		o=Mat(true);
		for(int __=1; __<=TT; __++, o=o*get_rand_mat()){
			for(int i=0; i<m; i++){
				for(int j=0; j<m; j++) if(state[i][j]!=-1){
					if(state[i][j]!=o(i, j)) state[i][j]=-1;
				}
			}
		}
	}
}

void print(){
	//矩阵拆解的结果
	printf("\nchanged position:\n");
	for(int i=0; i<m; i++){
		for(int j=0; j<m; j++){
			if(state[i][j]==-1) printf("m%d%d, ", i, j);
		}
	}
	puts("");
	//输入矩阵拆解后的表达
	printf("\nmatrix choice:\n");
	for(int i=0; i<(int)choice.size(); i++){
		printf("Mat %d:\n", i);
		for(int j=0; j<m; j++){
			for(int k=0; k<m; k++) if(state[j][k]==-1){
				printf("m%d%d=%d, ", j, k, choice[i](j, k));
			}
		}
		puts("");
	}
	//单位矩阵拆解后的表达
	printf("Bas:\n");
	for(int j=0; j<m; j++){
		for(int k=0; k<m; k++) if(state[j][k]==-1){
			printf("m%d%d=%d, ", j, k, j==k);
		}
	}
	puts("");
	//矩阵乘法
	printf("\nmatrix and matrix:\n");
	for(int i=0; i<m; i++){
		for(int j=0; j<m; j++) if(state[i][j]==-1){
			printf("re.m%d%d=", i, j);
			bool first=true;
			for(int k=0; k<m; k++){
				if(!state[i][k] || !state[k][j]) continue;
				if(!first) printf("+");
				first=false;
				if(state[i][k]==-1 || state[k][j]==-1){
					state[i][k]==-1 ? printf("m%d%d", i, k) : printf("%d", state[i][k]);
					printf("*");
					state[k][j]==-1 ? printf("o.m%d%d", k, j) : printf("%d", state[k][j]);
				}
				else printf("%d", state[i][k]*state[k][j]);
			}
			printf(",\n");
		}
	}
	//向量乘矩阵
	printf("\nvector and matrix:\n");
	for(int i=0; i<m; i++){
		printf("re.v%d=", i);
		bool first=true, exist=false;
		for(int j=0; j<m; j++){
			if(!state[j][i]) continue;
			exist=true;
			if(!first) printf("+");
			first=false;
			printf("v%d*", j);
			state[j][i]==-1 ? printf("o.m%d%d", j, i) : printf("%d", state[j][i]);
		}
		if(!exist) printf("0");
		printf(",\n");
	}
}

Hash_With_Two_Mod

不得不说 operator []很好用
尤其是用在矩阵上
比如写动态DP时
可以省去很多反直觉的 a.m[][]
直接使用 a[][]

struct Hash{
    const int mod_1 = 1e9+7,mod_2 = 1e9+9;
    int x,y;
    Hash(){}
    Hash(int _x,int _y) {x = _x,y = _y;}
    int operator [](const int pos) {return pos ? y : x;}
    friend Hash operator +(Hash a,Hash b) {
		return Hash((a[0] + b[0]) % a.mod_1,(a[1] + b[1]) % a.mod_2);
	}
    friend Hash operator -(Hash a,Hash b) {
		return Hash((a[0] - b[0] + a.mod_1) % a.mod_1,(a[1] - b[1] + a.mod_2) % a.mod_2);
	}
    friend Hash operator *(Hash a,Hash b) {
		return Hash((a[0] * b[0]) % a.mod_1,(a[1] * b[1]) % b.mod_2);
	} 
    void operator = (Hash a) {x = a.x,y = a.y;}
}base(131,13331);

超级快读

struct FastIO
{
#define get( ) getchar( )
#define put(x) putchar(x)
public:
    inline FastIO &operator >>(char &t)  { 
		t = get(); return *this; 
	}
    inline FastIO &operator >>(char *t)  { 
		while((*t = get()) != '\n') *(++t) = '\0'; 
		return *this; 
	}
    template <typename type>
    inline FastIO &operator >>(type &x)  { 
		x = 0; register int sig = 1; register char ch = get();
        while (ch < 48 || ch > 57) { if (ch == '-') sig = -1; ch = get(); }
		while (ch > 47 && ch < 58) x = (x << 3) + (x << 1) + (ch ^ 48),
        ch = get(); x *= sig; 
		return *this; 
	}
    template <typename type>
    inline FastIO &operator <<(type  x)  {
		if (!x) put('0'); if (x < 0) put('-'), x = -x; static char vec[50];
        register int len = 0; while (x) vec[len++] = x % 10 + '0', x /= 10;
    	while (len--) put(vec[len]); 
		return *this; 
	}
    template <typename type>                                  
    inline FastIO &operator <<(type *t)  {
		for (; *t; t++) put(*t); 
		return *this;
	}
    inline FastIO &operator <<(char  t)  { 
		put(t); 
		return *this;
	}
}IO;

【模板】“动态 DP”&动态树分治

题面：

题目描述

给定一棵 n n n 个点的树，点带点权。

有 m m m 次操作，每次操作给定 x , y x,y x,y，表示修改点 x x x 的权值为 y y y。

你需要在每次操作之后求出这棵树的最大权独立集的权值大小。

输入格式

第一行有两个整数，分别表示结点个数 n n n 和操作个数 m m m。

第二行有 n n n 个整数，第 i i i 个整数表示节点 i i i 的权值 a i a_i ai​。

接下来 ( n − 1 ) (n - 1) (n−1) 行，每行两个整数 u , v u, v u,v，表示存在一条连接 u u u 与 v v v 的边。

接下来 m m m 行，每行两个整数 x , y x,y x,y，表示一次操作，修改点 x x x 的权值为 y y y。

输出格式

对于每次操作，输出一行一个整数表示答案。

样例 #1
样例输入 #1
10 10
-11 80 -99 -76 56 38 92 -51 -34 47 
2 1
3 1
4 3
5 2
6 2
7 1
8 2
9 4
10 7
9 -44
2 -17
2 98
7 -58
8 48
3 99
8 -61
9 76
9 14
10 93
样例输出 #1
186
186
190
145
189
288
244
320
258
304
提示
数据规模与约定
  • 对于 30 % 30\% 30% 的数据，保证 n , m ≤ 10 n,m\le 10 n,m≤10。
  • 对于 60 % 60\% 60% 的数据，保证 n , m ≤ 1 0 3 n,m\le 10^3 n,m≤103。
  • 对于 100 % 100\% 100% 的数据，保证 1 ≤ n , m ≤ 1 0 5 1\le n,m\le 10^5 1≤n,m≤105， 1 ≤ u , v , x ≤ n 1 \leq u, v , x \leq n 1≤u,v,x≤n， − 1 0 2 ≤ a i , y ≤ 1 0 2 -10^2 \leq a_i, y \leq 10^2 −102≤ai​,y≤102。

dp 套 dp

首先，因为最大独立集的dp为

{ f i , 0 = ∑ j ∈ s o n i max ⁡ ( f j , 0 , f j , 1 ) ; f i , 1 = ∑ j ∈ s o n i f j , 0 ; \begin{align*} \begin{cases} f_{i,0} = \sum_{j \in son_i} \max(f_{j,0},f_{j,1}); \\ f_{i,1} = \sum_{j \in son_i} f_{j,0}; \end{cases} \end{align*} {fi,0​=∑j∈soni​​max(fj,0​,fj,1​);fi,1​=∑j∈soni​​fj,0​;​​

这个 Σ \Sigma Σ 太烦了，我们考虑优化状态

我们将 i i i 的孩子分为重儿子和轻儿子

因为有了重链剖分，就有了轻儿子和重儿子之分

我们设 g i , 0 g_{i,0} gi,0​ 为 i i i 的轻儿子中可选可不选的最大值， G i , 1 G_{i,1} Gi,1​ 为 i i i 的轻儿子都不选的最大值

那么最大独立集的dp为

(ps:以下的 j j j 是 i i i 的重儿子)

{ f i , 0 = g i , 0 + max ⁡ ( f j , 0 , f j , 1 ) f i , 1 = g i , 1 + a i + f j , 0 ; \begin{align*} \begin{cases} f_{i,0} = g_{i,0} + \max(f_{j,0},f_{j,1}) \\ f_{i,1} = g_{i,1} + a_i + f_{j,0}; \end{cases} \end{align*} {fi,0​=gi,0​+max(fj,0​,fj,1​)fi,1​=gi,1​+ai​+fj,0​;​​

我们发现这个 g i , 1 + a i g_{i,1} + a_i gi,1​+ai​ 很难看，两个式子要尽量类似

所以我们将 a i a_i ai​ 划分到 g i , 1 g_{i,1} gi,1​ 中，即将 g i , 1 g_{i,1} gi,1​ 的定义改为，选该点且轻儿子都不选的最大值

那么最大独立集的dp为
{ f i , 0 = g i , 0 + max ⁡ ( f j , 0 , f j , 1 ) f i , 1 = g i , 1 + f j , 0 ; \begin{align*} \begin{cases} f_{i,0} = g_{i,0} + \max(f_{j,0},f_{j,1}) \\ f_{i,1} = g_{i,1} + f_{j,0}; \end{cases} \end{align*} {fi,0​=gi,0​+max(fj,0​,fj,1​)fi,1​=gi,1​+fj,0​;​​

接下来如何做呢？

我们不难发现 max ⁡ \operatorname{max} max 是有结合律的，而矩阵乘法也有

那么，我们再变形

{ f i , 0 = max ⁡ ( g i , 0 + f j , 0 , g i , 0 + f j , 1 ) f i , 1 = max ⁡ ( g i , 1 + f j , 0 , − ∞ ) ; \begin{align*} \begin{cases} f_{i,0} = \max(g_{i,0} + f_{j,0},g_{i,0} + f_{j,1}) \\ f_{i,1} = \max(g_{i,1} + f_{j,0},-\infty); \end{cases} \end{align*} {fi,0​=max(gi,0​+fj,0​,gi,0​+fj,1​)fi,1​=max(gi,1​+fj,0​,−∞);​​

那么，我们定义广义矩阵乘法，在链上push_up
广义矩阵乘法：

struct matrix{
int m[2][2];
matrix(){memset(m,-0x3f,sizeof(m));}
matrix(bool flag) {m[0][0] = m[1][1] = 1;}
int* operator [](const int pos) {return m[pos];}
friend matrix operator * (matrix a,matrix b) {
	matrix c;
	for(int k = 0;k<2;k++)
		for(int i = 0;i<2;i++)
			for(int j = 0;j<2;j++)
				c[i][j] = max(c[i][j],a[i][k] + b[k][j]);
	return c;
}
}w[N];

如何设计转移矩阵呢？

$$
\begin{bmatrix}
f_{i,0} \
f_{i,1} \
\end{bmatrix}

\mathrm{U} \times
\begin{bmatrix}
f_{j,0} \
f_{j,1} \
\end{bmatrix}
$$

求出 U \mathrm{U} U 就好了

不难计算，
U = [ g i , 0 g i , 0 g i , 1 − ∞ ] \mathrm{U} = \begin{bmatrix} g_{i,0} & g_{i,0} \\ g_{i,1} & -\infty \end{bmatrix} U=[gi,0​gi,1​​gi,0​−∞​]

然后是修改链的细节

我们要查询的是每条链汇聚到 root ⁡ \operatorname{root} root 上节点的总 ∗ \color{red}{*} ∗ 积

因为本题初始化 f i , 0 = 0 , f i , 1 = a i f_{i,0} = 0,f_{i,1} = a_i fi,0​=0,fi,1​=ai​，所以直接查询答案矩阵的 g i , 0 g_{i,0} gi,0​ 和 g i , 1 g_{i,1} gi,1​ 就可以了

在修改的时候，我们采取对原矩阵组进行修改，然后让线段树上的对于点直接读取原矩阵组

修改一个点，只会影响到这个链的链头的父亲（因为链头的父亲的矩阵就是由每一条链做 ∗ \color{red}{*} ∗ 积来的）

所以我们在修改完后，对链头的父亲进行一次更新（更新的值要查询修改前后整条链的矩阵 ∗ \color{red}{*} ∗ 积 ）

还有全局平衡二叉树的做法

我是蒟蒻，表示看不懂

请读者自行研究

树剖AC
AC-code:

#include<bits/stdc++.h>
using namespace std;
#define int long long
int rd() {
	int x = 0, w = 1;
	char ch = 0;
	while (ch < '0' || ch > '9') {
		if (ch == '-') w = -1;
		ch = getchar();
	}
	while (ch >= '0' && ch <= '9') {
		x = x * 10 + (ch - '0');
		ch = getchar();
	}
	return x * w;
}

void wt(int x) {
	static int sta[35];
	int f = 1;
	if(x < 0) f = -1,x *= f;
	int top = 0;
	do {
		sta[top++] = x % 10, x /= 10;
	} while (x);
	if(f == -1) putchar('-');
	while (top) putchar(sta[--top] + 48);
}
const int N = 1e5+5;
struct matrix{
int m[2][2];
matrix(){memset(m,-0x3f,sizeof(m));}
matrix(bool flag) {m[0][0] = m[1][1] = 1;}
int* operator [](const int pos) {return m[pos];}
friend matrix operator * (matrix a,matrix b) {
	matrix c;
	for(int k = 0;k<2;k++)
		for(int i = 0;i<2;i++)
			for(int j = 0;j<2;j++)
				c[i][j] = max(c[i][j],a[i][k] + b[k][j]);
	return c;
}
}w[N];
int n,m,a[N],head[N],nxt[N<<1],to[N<<1],cnt;
void init() {memset(head,-1,sizeof(head));cnt = 0;}
void add(int u,int v) {
	nxt[cnt] = head[u];
	to[cnt] = v;
	head[u] = cnt++;
}
int F[N][2];
int fa[N],top[N],son[N],siz[N],dep[N],id[N],low[N],_id[N];
void dfs1(int x,int f) {
	fa[x] = f;
	siz[x] = 1;
	dep[x] = dep[f] + 1;
	for(int i = head[x];~i;i = nxt[i]) {
		int y = to[i];
		if(y ^ f) {
			dfs1(y,x);
			siz[x] += siz[y];
			if(siz[son[x]] < siz[y]) son[x] = y;
		}
	}
}
int num;
void dfs2(int x,int topx) {
	id[x] = ++num;
	_id[num] = x;
	top[x] = topx;
	low[topx] = max(id[x],low[topx]);
	F[x][0] = 0,F[x][1] = a[x];
	w[x][0][0] = w[x][0][1] = 0;
	w[x][1][0] = a[x];
	if(!son[x]) return;
	dfs2(son[x],topx);
	F[x][0] += max(F[son[x]][0],F[son[x]][1]);
	F[x][1] += F[son[x]][0];
	for(int i = head[x];~i;i = nxt[i]) {
		int y = to[i];
		if(y ^ fa[x] && y ^ son[x]){
			dfs2(y,y);
			F[x][0] += max(F[y][0],F[y][1]);
			F[x][1] += F[y][0];
			w[x][0][0] += max(F[y][0],F[y][1]);
			w[x][0][1] = w[x][0][0];
			w[x][1][0] += F[y][0];
		}
	}
}

namespace sgt{
#define ls (p << 1)
#define rs (p << 1 | 1)
#define mid ((pl + pr) >> 1)
matrix t[N<<2];

void push_up(int p) {
	t[p] = t[ls] * t[rs];
}

void build(int p,int pl,int pr) {
	if(pl == pr) {
		t[p] = w[_id[pl]];
		return;
	}
	build(ls,pl,mid);
	build(rs,mid+1,pr);
	push_up(p);
}

void update(int p,int pl,int pr,int k) {
	if(pl == pr) {
		t[p] = w[_id[pl]];
		return;
	}
	if(k <= mid) update(ls,pl,mid,k);
	else update(rs,mid+1,pr,k);
	push_up(p);
}

matrix query(int p,int pl,int pr,int l,int r) {
	if(l <= pl && pr <= r) return t[p];
	if(r <= mid) return query(ls,pl,mid,l,r);
	else if(l > mid) return query(rs,mid+1,pr,l,r);
	else return query(ls,pl,mid,l,r) * query(rs,mid+1,pr,l,r);
}

}

void update(int u,int v) {
	w[u][1][0] += v - a[u];
	a[u] = v;
	matrix p,q;
	while(u) {
		p = sgt::query(1,1,n,id[top[u]],low[top[u]]);
		sgt::update(1,1,n,id[u]);
		q = sgt::query(1,1,n,id[top[u]],low[top[u]]);
		u = fa[top[u]];
		w[u][0][0] += max(q[0][0],q[1][0]) - max(p[0][0],p[1][0]);
		w[u][0][1] = w[u][0][0];
		w[u][1][0] += q[0][0] - p[0][0];
	}
}

signed main() {
	init();
	n = rd();m = rd();
	for(int i = 1;i<=n;i++)
		a[i] = rd();
	for(int i = 1;i<n;i++){
		int u = rd(),v = rd();
		add(u,v);add(v,u);
	}
	dfs1(1,0);dfs2(1,1);
	sgt::build(1,1,n);
	while(m--) {
		int x = rd(),y = rd();
		update(x,y);
		matrix ans = sgt::query(1,1,n,id[1],low[1]);
		wt(max(ans[0][0],ans[1][0]));
		putchar('\n');
	}
	return 0;
}

高斯消元

#include<bits/stdc++.h>
using namespace std;
const int N = 105;
const double Exp = 1e-12;
int n;
double a[N][N];
signed main() {
    scanf("%d",&n);
    for(int i = 1;i<=n;i++)
        for(int j = 1;j<=n + 1;j++)
            scanf("%lf",&a[i][j]);
    for(int i = 1;i<=n;i++){
        int mx = i;
        for(int j = i + 1;j<=n;j++)
            if(fabs(a[j][i]) > fabs(a[mx][i]))
                mx = j;
        if(mx != i)
            for(int j = 1;j<=n + 1;j++)
                swap(a[mx][j],a[i][j]);
        if(fabs(a[i][i]) < Exp) {
            puts("-1");
            return 0;
        }
        for(int j = 1;j<=n;j++) {
            if(j ^ i) {
                double p = a[j][i] / a[i][i];
                for(int k = 1;k<=n + 1;k++)
                    a[j][k] -= a[i][k] * p;
            }
        }
    }
    for(int i = 1;i<=n;i++) 
        printf("x%d=%.2lf\n",i,(fabs(a[i][n + 1] / a[i][i]) < Exp) ? 0:a[i][n + 1] / a[i][i]);
	return 0;
}

BSGS

#include<bits/stdc++.h>
using namespace std;
#define int long long
int rd() {
	int x = 0, w = 1;
	char ch = 0;
	while (ch < '0' || ch > '9') {
		if (ch == '-') w = -1;
		ch = getchar();
	}
	while (ch >= '0' && ch <= '9') {
		x = x * 10 + (ch - '0');
		ch = getchar();
	}
	return x * w;
}

void wt(int x) {
	static int sta[35];
	int f = 1;
	if(x < 0) f = -1,x *= f;
	int top = 0;
	do {
		sta[top++] = x % 10, x /= 10;
	} while (x);
	if(f == -1) putchar('-');
	while (top) putchar(sta[--top] + 48);
}

int p,b,n,base;
map<int,int> m;

int qpow(int x,int k) {
    int res = 1;
    while(k) {
        if(k & 1) res = (res * x) % p;
        x = (x * x) % p;
        k >>= 1;
    }
    return res;
}

bool bsgs(){
    int cur = 1;
    for(int i = 0;i<base;i++,cur = cur * b % p) {
        if(!m.count(cur)) m[cur] = i;
        if(cur == n) {
            printf("%lld",i);
            return true;
        }
    }
    for(int i = 1,now = 1;i <= base;i++) {
        now = now * cur % p;
        if(!now) continue;
        int key = qpow(now,p - 2) * n % p;
        if(m.count(key)) {
            printf("%lld",i * base + m[key]);
            return true;
        }
    }
    return false;
}

signed main() {

    p = rd(),b = rd(),n = rd();
    base = sqrt(p);
    if(!bsgs()) puts("no solution");

	return 0;
}

树Hash

#include<bits/stdc++.h>
using namespace std;

int rd() {
	int x = 0, w = 1;
	char ch = 0;
	while (ch < '0' || ch > '9') {
		if (ch == '-') w = -1;
		ch = getchar();
	}
	while (ch >= '0' && ch <= '9') {
		x = x * 10 + (ch - '0');
		ch = getchar();
	}
	return x * w;
}

void wt(int x) {
	static int sta[35];
	int f = 1;
	if(x < 0) f = -1,x *= f;
	int top = 0;
	do {
		sta[top++] = x % 10, x /= 10;
	} while (x);
	if(f == -1) putchar('-');
	while (top) putchar(sta[--top] + 48);
}
#define ull unsigned long long
const int N = 1e6+10;
const ull mask = chrono::steady_clock::now().time_since_epoch().count();
ull shift(ull x) {
    x ^= mask;
    x ^= x << 13;
    x ^= x >> 7;
    x ^= x << 17;
    x ^= mask;
    return x;
}
ull Hash[N];
vector<int> edge[N];
set<ull> trees;
int n;
void getHash(int x,int fa) {
    Hash[x] = 1;
    for(int i : edge[x]) {
        if(i == fa) continue;
        getHash(i,x);
        Hash[x] += shift(Hash[i]);
    }
    trees.emplace(Hash[x]);
}

signed main() {

    n = rd();
    for(int i = 1;i<n;i++) {
        int u = rd(),v = rd();
        edge[u].emplace_back(v);
        edge[v].emplace_back(u);
    }
    getHash(1,0);
    wt(trees.size());
	return 0;
}

异或基

#include<bits/stdc++.h>
using namespace std;
#define int long long
int rd() {
	int x = 0, w = 1;
	char ch = 0;
	while (ch < '0' || ch > '9') {
		if (ch == '-') w = -1;
		ch = getchar();
	}
	while (ch >= '0' && ch <= '9') {
		x = x * 10 + (ch - '0');
		ch = getchar();
	}
	return x * w;
}

void wt(int x) {
	static int sta[35];
	int f = 1;
	if(x < 0) f = -1,x *= f;
	int top = 0;
	do {
		sta[top++] = x % 10, x /= 10;
	} while (x);
	if(f == -1) putchar('-');
	while (top) putchar(sta[--top] + 48);
}
const int N = 55;
int n,k,a[N],ans;

void gauss() {
    for(int i = 62;i>=0;i--) {
        for(int j = k;j<n;j++) 
            if((a[j] >> i) & 1) {swap(a[k],a[j]);break;}
        if((a[k] >> i & 1) == 0) continue; 
        for(int j = 0;j<n;j++)
            if((a[j] >> i & 1) && j != k) 
                a[j] ^= a[k];
        k++;
        if(k == n) break;
    }
}

signed main() {

    n = rd();
    for(int i = 0;i<n;i++) a[i] = rd();
    gauss();
    for(int i = 0;i<k;i++) ans ^= a[i];
    wt(ans);

	return 0;
}

迪杰斯特拉

struct node{
    int x,d;
    node(int x,int d) : x(x),d(d){}
    friend bool operator < (node a,node b) {
        return a.d > b.d;
    }
};

int dis[N];
bool vis[N];
void dij() {
    memset(vis,0,sizeof(vis));
    memset(dis,0x3f,sizeof(dis));
    priority_queue<node> q;
    q.emplace(node(1,0));
    dis[1] = 0;
    while(q.size()) {
        node t = q.top();
        q.pop();
        if(vis[t.x]) continue;
        vis[t.x] = true;
        for(int i = g.head[t.x];~i;i = g.nxt[i]) {
            int y = g.to[i];
            if(dis[y] > dis[t.x] + g.val[i]) {
                dis[y] = dis[t.x] + g.val[i];
                q.emplace(node(y,dis[y]));
            }
        }
    }
}

EXGCD

void exgcd(int a,int b,int &x,int &y){
	if(b==0){
		x=1,y=0;
		return;
	}
	exgcd(b,a%b,y,x);
	y-=(a/b)*x;
}

CRT(China Remain Theory)

LL CRT(int k, LL *a, LL *r) {
    LL n = 1, ans = 0;

    for (int i = 1; i <= k; i++)
        n = n * r[i];

    for (int i = 1; i <= k; i++) {
        LL m = n / r[i], b, y;
        exgcd(m, r[i], b, y);  // b * m mod r[i] = 1
        ans = (ans + a[i] * m * b % n) % n;
    }

    return (ans % n + n) % n;
}

FFT

#include<bits/stdc++.h>
using namespace std;

const int N = 4.2e6;
const double pi = acos(-1);
int n,r[N];
struct C {
    double r,i;
    C() {r = 0,i = 0;}
    C(double a,double b) {r = a,i = b;}
    friend C operator + (const C &a,const C &b) {return C(a.r + b.r,a.i - b.i);}
    friend C operator - (const C &a,const C &b) {return C(a.r - b.r,a.i - b.i);}
    friend C operator * (const C &a,const C &b) {
		return C(a.r * b.r - a.i * b.i,a.r * b.i + a.i  * b.r);
	}
    void operator += (const C &b) {r += b.r;i += b.i;}
    void operator *= (const C &b) {double t = r;r = r * b.r - i * b.i;i = t * b.i + i * b.r;}
}f[N],g[N];

void FFT(C *a,const int op) {
    C W,w,t,*a0,*a1;
    int i,j,k;
    for(int i = 0;i<n;i++)
        if(i < r[i])
            swap(a[i],a[r[i]]);
    for(int i = 1;i<n;i <<= 1) 
        for(W = C(cos(pi / i),sin(pi / i) * op),j = 0;j < n;j += i << 1) 
            for(w = C(1,0),a1 = i + (a0 = a + j),k = 0;k < i; ++k,++a0,++a1,w *= W)
                t = *a1*w,*a1 = *a0 - t,*a0 += t;
}
int m,l = 0;
signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr),cout.tie(nullptr);

    cin>>n>>m;
    for(int i = 0;i<=n;i++) cin>>f[i].r;
    for(int i = 0;i<=m;i++) cin>>g[i].r;
    for(m += n,n = 1;n <= m;n <<= 1,++l);
    for(int i = 0;i<n;i++) r[i] = (r[i >> 1] >> 1 | ((i & 1)<<(l - 1))); // rader 映射
    FFT(f,1);FFT(g,1); // DFT
    for(int i = 0;i<n;i++) f[i] *= g[i]; // 整合成 f * g 函数的FFT
    FFT(f,-1);// 做一遍IDFT还原
    for(int i = 0;i<=m;i++) printf("%.0lf ",fabs(f[i].r)/n);

	return 0;
}
MingJunYi
关注
  • 11
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LLMs之PE：大模型核心技术—提示工程(Prompt Engineering)—拿来即用—实战应用技巧案例集合(如PC/CoT/ToT/ReACT/ScP/PCTS等思想，Broke/RTRWCO-
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
05-11 2122
引导推理方法。
尚硅谷实战项目-谷粒学院-part one
weixin_45720751的博客
05-26 3290
实战项目 mybatis-plus的使用 查询操作 application.properties文件 #springboot2.1后加cj，不会报警告 spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver #springboot2.1之后的版本需要加时区 spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?serverTimezone=GMT%2B8 spring.
3D Object DetectionFrom Point Cloud With Part-Awareand Part-Aggregation Network【翻译】
m0_58702532的博客
03-01 4555
摘要 基于激光雷达点云的3D目标检测是三维场景理解中的一个具有挑战性的问题，具有许多实际应用。 在本文中，在原始工作PointRCNN基础上扩展到一种新颖且强大的基于点云的3D检测框架，即部分感知和聚合神经网络(Part-A2 net）。 整个框架由部分感知阶段和部分聚合阶段组成。 部分感知阶段： 部分感知阶段首次充分利用源于3D地面真实框的免费部分监督，以同时预测高质量的3D提议和准确的目标内部分位置。 在同一提议中预测的目标内部分位置由新设计的Rol感知点云池模块分组，从而有效的表示来编码每
day22-back tracking-part01-7.24
bbrruunnoo的博客
07-24 1182
什么时候达到了终止条件，树中就可以看出，一般来说搜到叶子节点了，也就找到了满足条件的一条答案，把这个答案存放起来，并结束本层递归。对于参数，因为回溯算法需要的参数不像二叉树递归的时候那么容易一次性确定下来，所以一般是先写逻辑，然后需要什么参数，就填什么参数。- 什么是回溯：在二叉树系列中，我们已经不止一次，提到了回溯，回溯是递归的副产品，只要有递归就会有回溯。在上面我们提到了，回溯法一般是在集合中递归搜索，集合的大小构成了树的宽度，递归的深度构成的树的深度。，所有回溯法的问题都可以抽象为树形结构。
从零开始建立Rancher Catalog模板 - Part 1
Rancher
05-18 2183
从零开始，教你如何创建你自己的定制化Rancher Catalog模板。
npm下载的vue-3d-model的学习笔记
菜鸟karroy
03-20 3851
Part1 build文件夹 config文件夹 1、你用vue-cli模板构建的vue项目都会有这些文件，属于webpack相关配置； dev.env.js文件是开发环境的变量，npm run dev命令；在build文件下webpack.dev.conf可找到在什么地方引入了此变量； prod.env.js文件是生产环境的变量，npm run build命令；在build文件下webpack....
Word 模板引擎
weixin_42290901的博客
12-15 882
poi-tl(poi-template-language) https://github.com/Sayi/poi-tl Word 模板引擎，基于Apache POI - the Java API for Microsoft Documents。 What is poi-tl FreeMarker、Velocity基于文本模板和数据生成新的HTML页面、配置文件等，poi-tl是Word模板引擎，基于Microsoft Word模板和数据生成新的文档。 Word模板拥有丰富的样式，poi-tl在生
数据结构与算法-Part1——数据结构与算法的概念
leikang111的博客
04-01 971
数据与结构算法part1
LLaMA的解读与其微调(含LLaMA 2)：Alpaca-LoRA/Vicuna/BELLE/中文LLaMA/姜子牙
热门推荐
结构之法 算法之道
03-22 7万+
还开始研究一系列开源模型(包括各自对应的模型架构、训练方法、训练数据、本地私有化部署、硬件配置要求、微调等细节)​该项目部分一开始是作为此文《》的第4部分，但但随着研究深入 为避免该文篇幅又过长，将把『第4部分 开源项目』抽取出来 独立成本文。
Visual Studio进行Web性能测试- Part II
binhualiu1983的博客
06-12 1640
原文作者：Ambily.raj 对于一个多用户的应用程序，性能是非常重要的。性能不仅是执行的速度，它包括负载和并发方面。Visual Studio是可以用于性能测试的工具之一。Visual Studio Test版或Visual Studio 2010旗舰版为自动化测试提供了支持。 介绍 对于一个多用户的应用程序，性能是非常重要的。性能不仅是执行的速度，它包括负载和并发方面。性能测试是对
BasicQuiz-Part3
03-16
"BasicQuiz-Part3" 是一个与Java编程相关的学习资源，可能是某个课程或项目的一部分，主要目的是帮助初学者巩固和深化Java基础知识。这个压缩包文件的名称表明它可能是一个系列的第三部分，意味着前两部分可能已经...
利兄进阶素材库-PPT经典素材集合-part1
02-14
最经典的PPT素材，里边包含：笔刷素材、发布会类 PPT 案例素材、快闪动画模板及配乐、神奇动画、神器素材、中国风素材、背景素材、总结类PPT素材、5位大师级素材设计，素材资料共计2.4G之多，内容全面，由于平台资源...
POO-PART3:最后一个公安
04-06
标题中的"POO-PART3:最后一个公安"可能是指一系列关于面向对象编程（Object-Oriented Programming, OOP）的教程或课程的第三部分，这里的"公安"可能是课程的一个实例或者项目名称，与PHP编程语言相结合。在PHP中，...
homework-part-4
05-09
在"homework-part-4"这个项目中，我们可以看到它涉及到的是JavaScript编程的一个作业部分。JavaScript是一种广泛应用于Web开发的脚本语言，它主要用于客户端的网页交互，使得网页具备动态性与用户交互能力。在本作业...
ppt原始模板素材-69.pptx
11-02
"69.pptx" 是一个专为年终总结、年终汇报、工作总结以及工作汇报设计的素材资料库，提供了一套完整的模板集合，以帮助用户快速创建专业且吸引人的演示文稿。 PPT模板的设计通常包含精心挑选的颜色方案、布局、字体...
【Python】生成二维迷宫的算法
HarryXYC的博客
08-16 323
基于Pygame和PIL的迷宫生成器
代码随想录算法训练营第十七天（二叉树 五）
b1ankwall的博客
08-16 768
参加代码随想录第43期算法训练营day17|654.最大二叉树，617.合并二叉树，700.二叉搜索树中的搜索，98.验证二叉搜索树
【算法】马踏棋盘（骑士周游）问题回溯算法实现以及使用贪心算法优化
2302_78914800的博客
08-18 504
将马儿随机放在国际象棋的 8*8 棋盘的某个方格中，马儿按照“马走日”进行移动，要求每个方格只进入一次，走遍棋盘上全部 64 个方格。注意：马儿不同的走法会得到不同的结果，效率也会有影响。
Leetcode 219. 存在重复元素 II
最新发布
铁马冰河入梦来
08-20 210
哈希表解决存在重复元素二问题
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值