# ACM 代码片段集

> Algorithm & Data Structure Snippets

**382** 个代码片段 · **8** 个一级分类 · **49** 个二级分类

*导出时间：2026-11-19 11:35*

---

## 目录

- **[1. 基础算法](#1-基础算法)**
  - [1.1 头文件与宏定义](#11-头文件与宏定义)
  - [1.2 GCD与LCM](#12-GCD与LCM)
  - [1.3 快速幂](#13-快速幂)
  - [1.4 对拍](#14-对拍)
  - [1.5 杂项](#15-杂项)
- **[2. 数据结构](#2-数据结构)**
  - [2.1 栈与队列](#21-栈与队列)
  - [2.2 二叉堆](#22-二叉堆)
  - [2.3 单调栈与单调队列](#23-单调栈与单调队列)
  - [2.4 并查集](#24-并查集)
  - [2.5 树状数组](#25-树状数组)
  - [2.6 线段树](#26-线段树)
  - [2.7 平衡树](#27-平衡树)
  - [2.8 主席树与可持久化](#28-主席树与可持久化)
  - [2.9 分块与莫队](#29-分块与莫队)
  - [2.10 珂朵莉树](#210-珂朵莉树)
  - [2.11 可并堆](#211-可并堆)
  - [2.12 CDQ分治与整体二分](#212-CDQ分治与整体二分)
  - [2.13 可并堆](#213-可并堆)
- **[3. 图论](#3-图论)**
  - [3.1 最短路](#31-最短路)
  - [3.2 最小生成树](#32-最小生成树)
  - [3.3 图的连通性](#33-图的连通性)
  - [3.4 二分图与最大匹配](#34-二分图与最大匹配)
  - [3.5 网络流](#35-网络流)
  - [3.6 负环与差分约束](#36-负环与差分约束)
  - [3.7 线段树优化建图](#37-线段树优化建图)
- **[4. 树上问题](#4-树上问题)**
  - [4.1 最近公共祖先LCA](#41-最近公共祖先LCA)
  - [4.2 树链剖分](#42-树链剖分)
  - [4.3 树论综合](#43-树论综合)
  - [4.4 Kruskal重构树](#44-Kruskal重构树)
  - [4.5 树形DP](#45-树形DP)
- **[5. 动态规划](#5-动态规划)**
  - [5.1 DP优化](#51-DP优化)
  - [5.2 背包问题](#52-背包问题)
  - [5.3 数位DP](#53-数位DP)
  - [5.4 插头DP](#54-插头DP)
- **[6. 字符串](#6-字符串)**
  - [6.1 KMP](#61-KMP)
  - [6.2 Manacher](#62-Manacher)
  - [6.3 Trie](#63-Trie)
  - [6.4 字符串Hash](#64-字符串Hash)
  - [6.5 最小表示法](#65-最小表示法)
  - [6.6 AC自动机与后缀数组](#66-AC自动机与后缀数组)
- **[7. 数论与数学](#7-数论与数学)**
  - [7.1 素数筛法](#71-素数筛法)
  - [7.2 组合数学与计数](#72-组合数学与计数)
  - [7.3 博弈论](#73-博弈论)
  - [7.4 多项式与FFT](#74-多项式与FFT)
  - [7.5 线性代数与高斯消元](#75-线性代数与高斯消元)
  - [7.6 线性基](#76-线性基)
- **[8. 计算几何](#8-计算几何)**
  - [8.1 凸包](#81-凸包)
  - [8.2 极角排序](#82-极角排序)
  - [8.3 计算几何综合](#83-计算几何综合)

---

## 1. 基础算法

### 1.1 头文件与宏定义

**ACM头文件** *(start)*

> 【ACM 竞赛通用头文件模板】
▪ solve() — 每轮测试的主解题函数（多测循环调用）
▪ main() — 程序入口，含 ios 加速、多组测试 t 的循环读入
▪ 预定义常量：N=2e5+1（数组上限）、MOD=1e9+7（常用模数）、INF=0x3f3f3f3f3f3f3f3f（64位无穷大）、PI=acos(-1.0)
▪ 类型别名：int→long long / LL / ll（防溢出）
适用于大多数 ACM/ICPC 算法题的快速开发起点，开箱即用。

```cpp
#include <bits/stdc++.h>
#define int long long
#define LL long long
#define ll long long
using namespace std;

const int N = 2e5+1;
const int MOD = 1e9+7;
const int INF = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1.0);

void solve() {
    
}

signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

// by vanadium-23
```

**CPP-start** *(CPP-start)*

> 【C++ 最简程序模板】
▪ main() — 空的程序入口，仅包含 #include <iostream> 和 using namespace std
适用于快速编写单文件测试代码、验证语法特性，或作为最小可运行 C++ 程序的骨架。

```cpp


#include <iostream>
using namespace std;

int main(){
    
    return 0;
}
```

### 1.2 GCD与LCM

**gcd 与 lcm** *(gcd)*

> 【最大公约数（GCD）与最小公倍数（LCM）】
▪ gcd(a, b) — 辗转相除法（欧几里得算法）：b==0 时返回 a，否则递归 gcd(b, a%b)
▪ lcm(a, b) — 最小公倍数：a / gcd(a,b) * b（先除后乘防止溢出）
时间复杂度 O(log min(a,b))。适用于约分、周期计算、分数通分等基础数论场景。

```cpp
int gcd(int a, int b) {
    return b ? gcd(b, a % b) : a;
}
int lcm(int a,int b){
    return a * b / gcd(a,b);
}
```

### 1.3 快速幂

**快速幂** *(binpow)*

> 【快速幂（二分幂）——无 MOD 版】
▪ binpow(a, b) — 计算 a^b，将指数按二进制拆分：b 的最低位为 1 时乘入结果；a 不断自乘；b 每次右移一位。
时间复杂度 O(log b)，空间 O(1)。注意无取模时结果可能溢出（b 较大时需要高精度或换用带 MOD 版）。

```cpp
long long binpow(long long a, long long b) {
    long long res = 1;
    while (b > 0) {
        if (b & 1) res = res * a;
        a = a * a;
        b >>= 1;
    }
    return res;
}
```

**快速幂带MOD** *(binpow-mod)*

> 【快速幂（二分幂）——带 MOD 版】
▪ binpow(a, b) — 计算 a^b % MOD，在每次乘法后取模防止中间结果溢出。算法流程：res=1；b>0 时若 b&1 则 res=res*a%MOD；a=a*a%MOD；b>>=1。
时间复杂度 O(log b)，空间 O(1)。适用于大数幂取模（RSA 加密、组合数取模、哈希计算等）。

```cpp
long long binpow(long long a, long long b) {
    long long res = 1;
    while (b > 0) {
        if (b & 1) res = res * a % MOD;
        a = a * a % MOD;
        b >>= 1;
    }
    return res % MOD;
}
```

**矩阵快速幂** *(mksm)*

> 【矩阵快速幂（mksm）】
代码包含 qpow 等核心函数，实现了 矩阵快速幂 的算法逻辑。

核心函数：
  Matrix qpow(Matrix a,int b) — 快速幂

核心结构体：Matrix

关键配置：
N=3,mod=1e9+7

```cpp
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int N=3,mod=1e9+7;
struct Matrix{
	int mat[N][N];
	Matrix(){memset(mat,0,sizeof(mat));}
	Matrix operator*(const Matrix& o)const{
		Matrix res;
		for(int i=0;i<N;++i){
			for(int k=0;k<N;++k){
				for(int j=0;j<N;++j){
					res.mat[i][j]=(res.mat[i][j]+mat[i][k]*o.mat[k][j])%mod;
				}
			}
		}
		return res;
	}
};

Matrix qpow(Matrix a,int b){
	Matrix res;
	for(int i=0;i<N;++i)res.mat[i][i]=1;
	while(b){
		if(b&1)res=res*a;
		a=a*a;
		b>>=1;
	}
	return res;
}
```

### 1.4 对拍

**data** *(fu)*

> 【data】
随机数据生成器模板，用于对拍测试的输入生成。

核心函数：
  LL fu(无参数) — 核心算法函数
  LL Rand(LL L,LL R) — 核心算法函数

说明：freopen("data.in","w",stdout);

适用场景：程序正确性验证（与暴力程序对比测试）

```cpp
#include<bits/stdc++.h>
#define LL long long
#define Re register LL
using namespace std;
const LL inf=1000,N=20;
LL vis[inf+5];char A[N+5],B[N+5];
inline LL fu(){return rand()%2?-1:1;}
inline LL Rand(LL L,LL R){
	LL a=R-L+1;
	LL b=(LL)rand()*rand()%a+1;
	b=b*rand()%a+1;
	b=b*rand()%a+1;
	b=b*rand()%a+1;
	b=b*rand()%a+1;
	return L+b-1;
}
LL lo[N],tp[N];
int main(){
//	freopen("data.in","w",stdout);
	srand(time(0));
	Re n=rand()%N+1;
	printf("%lld 0\n",n);
	for(Re i=1;i<=n;++i)printf("%lld ",Rand(1,inf));
}

```

**myprogram** *(sakura)*

> 【myprogram】
待测程序模板，与标准程序对拍验证正确性。

核心函数：
  void in(Re &x) — 核心算法函数
  void sakura(无参数) — 后缀数组

核心结构体：QAQ0

关键配置：
N=5e5+3

适用场景：程序正确性验证（与暴力程序对比测试）

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#define LL long long
#define Re register int
using namespace std;
const int N=5e5+3;
const LL inf=4e18+5;
int n,opt,A[N],B[N];
inline void in(Re &x){
	Re fu=0;x=0;char ch=getchar();
	while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=fu?-x:x;
}
struct QAQ0{
	int x;LL g[N],S[N],dp[N];
	inline void sakura(){
		for(Re i=1;i<=n;++i)in(x),S[i]=S[i-1]+x,dp[i]=inf;
		dp[0]=0,g[0]=S[0];
		for(Re i=1,p=0;i<=n;++i){
			while(p+1<i&&2*S[p+1]-g[p+1]<=S[i])++p;
			dp[i]=dp[p]+(S[i]-S[p])*(S[i]-S[p]),g[i]=S[p];
//			printf("i=%d, p=%d\n",i,p);
//			for(Re j=0;j<=p;++j)
//				if(dp[i]>=(tmp=dp[j]+(S[i]-S[j])*(S[i]-S[j])))
//					dp[i]=tmp,g[i]=S[j];
		}
//		for(Re i=0;i<=n;++i)printf("dp[%d]=%lld\n",i,dp[i]);
		printf("%lld\n",dp[n]);
	}
}T0;
int main(){
//	freopen("456.txt","r",stdin);
	in(n),in(opt);
	if(n<=5000)T0.sakura();
	fclose(stdin);
	fclose(stdout);
	return 0;
}

```

**std** *(sakura)*

> 【std】
标准程序（标程/暴力程序）模板，用作对拍的正确性基准。

核心函数：
  void in(Re &x) — 核心算法函数
  void sakura(无参数) — 后缀数组

核心结构体：QAQ0

关键配置：
N=5e5+3

说明：for(Re i=0;i<=n;++i)printf("dp[%d]=%lld\n",i,dp[i]);；freopen("456.txt","r",stdin);

适用场景：程序正确性验证（与暴力程序对比测试）

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#include<set>
#define LL long long
#define Re register int
using namespace std;
const int N=5e5+3;
const LL inf=4e18+5;
int n,opt,A[N],B[N];
inline void in(Re &x){
	Re fu=0;x=0;char ch=getchar();
	while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=fu?-x:x;
}
struct QAQ0{
	int x,g[N];LL tmp,S[N],dp[N];
	inline void sakura(){
		for(Re i=1;i<=n;++i)in(x),S[i]=S[i-1]+x,dp[i]=inf;
		dp[0]=0,g[0]=0;
		for(Re i=1,p=0;i<=n;/*printf("i=%d, p=%d\n",i,p),*/++i)
			for(Re j=0;j<i;++j)
				if(S[i]-S[j]>=S[j]-S[g[j]]&&dp[i]>=(tmp=dp[j]+(S[i]-S[j])*(S[i]-S[j])))
					dp[i]=tmp,g[i]=j,p=j;
//		for(Re i=0;i<=n;++i)printf("dp[%d]=%lld\n",i,dp[i]);
		printf("%lld\n",dp[n]);
	}
}T0;
int main(){
//	freopen("456.txt","r",stdin);
	in(n),in(opt);
	if(n<=5000)T0.sakura();
	fclose(stdin);
	fclose(stdout);
	return 0;
}

```

**对拍** *(system)*

> 【对拍】
对拍（程序正确性测试）相关模板。

说明：break;

适用场景：程序正确性验证（与暴力程序对比测试）

```cpp
#include<bits/stdc++.h>
#include<windows.h>
#define Re register int 
using namespace std;
int main(){
	Re sec=0.1,HYJ=0;// 随机数据生成时间，大约每0.1秒一次 
	sec*=1e3;
    while(1){
    	printf("第 %d 组数据：\n",++HYJ);
        system("data.exe>data.in");// 随机数据生成到文件 
        system("std.exe<data.in>std.out");// 运行标准程序 
        system("myprogram.exe<data.in>my.out");// 运行自己的程序（可能全WA但能跑通的程序）
        if(system("fc std.out my.out")){// 比较输出文件，fc比较文本文件不同返回1
            system("pause");
			printf("[corrupted string]");
            //break; 
        }
        Sleep(sec);
    }
}

```

### 1.5 杂项

**时间随机种子** *(random)*

> 【高质量随机种子生成】
▪ 使用 chrono::high_resolution_clock::now() 获取高精度时间戳
▪ time_since_epoch().count() 转为纳秒级整数作为种子
▪ srand() 设置随机种子
相比 time(0) 的秒级精度，chrono 的纳秒级时间戳提供更好的随机性。适用于需要随机化的算法（随机化快排、哈希防 Hack、模拟退火等）。

```cpp
auto now = chrono::high_resolution_clock::now();
auto seed = now.time_since_epoch().count();
srand(static_cast<unsigned int>(seed));
```

**扑克牌模板** *(poker)*

> 【扑克牌算法模板】
▪ Card — 牌面结构：suit（花色 0..3: C/D/H/S）、rank（点数 2..14，A=14）
  — GetSuit(ch) / GetRank(ch) — 字符→数值转换（'C'→0, 'A'→14, 'T'→10 等）
  — operator< / operator== — 按点数比较/判等
▪ CombEval — 牌型评估结构（从 5 张手牌 + 公共牌中识别）:
  — Type 枚举：Unspecified→HighCard→Pair→TwoPairs→Three→Straight→Flush→FullHouse→Four→StraightFlush→RoyalFlush（从低到高）
  — TryHighCard() — 任何牌都至少是高牌
  — TryPair() — 判断是否有一对，将对子移到末尾、其余按降序排列
  — TryTwoPairs() — 判断是否有两对，将非对子牌移到最前
  — TryThree() / TryStraight() / TryFlush() 等 — 依次判断各牌型
适用于德州扑克等扑克游戏的牌力判定与比较。

```cpp

struct Card
{
    int suit, rank; // 花色 0..3, 点数 2..14

    Card() : Card(0, 0) {}
    Card(char suit_ch, char rank_ch) : Card(GetSuit(suit_ch), GetRank(rank_ch)) {}
    Card(int suit, int rank) : suit(suit), rank(rank) {}

    static int GetSuit(char ch)
    {
        if (ch == 'C') return 0;
        if (ch == 'D') return 1;
        if (ch == 'H') return 2;
        return 3; // 'S'
    }
    static int GetRank(char ch)
    {
        if (ch == 'A') return 14;
        if (ch == 'K') return 13;
        if (ch == 'Q') return 12;
        if (ch == 'J') return 11;
        if (ch == 'T') return 10;
        return ch - '0';
    }

    bool operator < (const Card &rhs) const { return rank < rhs.rank; }
    bool operator == (const Card &rhs) const { return rank == rhs.rank && suit == rhs.suit; }
};


struct CombEval
{
    enum class Type : int
    {
        Unspecified = 0,
        HighCard,      // 高牌
        Pair,          // 一对
        TwoPairs,      // 两对
        Three,         // 三条
        Straight,      // 顺子
        Flush,         // 同花
        FullHouse,     // 葫芦
        Four,          // 四条
        StraightFlush, // 同花顺
        RoyalFlush,    // 皇家同花顺
    };

    CombEval() : CombEval(Type::Unspecified, {}) {}
    CombEval(Type type, const vector<Card> &cards) : type(type), cards(cards) {}

    

    // 高牌 — 任何牌都至少是高牌
    bool TryHighCard() { return true; }

    // 一对 — 找出唯一一对，将其余牌按点数降序排列到前面
    bool TryPair()
    {
        int id = -1;
        for (int i = 0; id == -1 && i <= 3; i++)
            if (cards[i].rank == cards[i + 1].rank)
                id = i;
        if (id == -1) return false;

        int main_rank = cards[id].rank;
        // 将对子移到末尾，其余牌按降序前置
        for (int i = 0, cnt = 0; i <= 4; i++)
            if (cards[i].rank != main_rank)
            {
                for (int j = i; j > cnt; j--)
                    swap(cards[j], cards[j - 1]);
                cnt++;
            }
        return true;
    }

    // 两对 — 找出两对，将非对子牌移到最前
    bool TryTwoPairs()
    {
        int id1 = -1, id2 = -1;
        for (int i = 0; i <= 3; i++)
            if (cards[i].rank == cards[i + 1].rank)
            {
                if (id1 == -1) id1 = i;
                else id2 = i;
                i++;
            }
        if (id1 == -1 || id2 == -1) return false;

        // 将单牌移到最前，便于比较
        for (int j = 8 - id1 * 2 - id2 * 2; j; j--)
            swap(cards[j], cards[j - 1]);
        return true;
    }

    // 三条 — 找出唯一三条，将其余牌按降序前置
    bool TryThree()
    {
        int id = -1;
        for (int i = 0; id == -1 && i <= 2; i++)
            if (cards[i].rank == cards[i + 1].rank && cards[i].rank == cards[i + 2].rank)
                id = i;
        if (id == -1) return false;

        int main_rank = cards[id].rank;
        for (int i = 0, cnt = 0; i <= 4; i++)
            if (cards[i].rank != main_rank)
            {
                for (int j = i; j > cnt; j--)
                    swap(cards[j], cards[j - 1]);
                cnt++;
            }
        return true;
    }

    // 顺子 — 判断是否连续；处理 A-2-3-4-5 特殊顺
    bool TryStraight()
    {
        for (int i = 1; i <= 3; i++)
            if (cards[i].rank != cards[i - 1].rank + 1)
                return false;
        if (cards[4].rank == cards[3].rank + 1)
            return true;
        // A-2-3-4-5 特殊顺：cards = {2,3,4,5,14}
        if (cards[4].rank == 14 && cards[0].rank == 2)
        {
            // 将 A 移到末尾 ⇒ {2,3,4,5,14} → {14,2,3,4,5}，便于比较
            for (int i = 4; i; i--)
                swap(cards[i], cards[i - 1]);
            return true;
        }
        return false;
    }

    // 同花 — 所有牌花色相同
    bool TryFlush()
    {
        for (const Card &card : cards)
            if (card.suit != cards[0].suit)
                return false;
        return true;
    }

    // 葫芦 — 三条 + 一对
    bool TryFullHouse()
    {
        if (!TryThree()) return false;
        return cards[0].rank == cards[1].rank;
    }

    // 四条 — 四张相同点数
    bool TryFour()
    {
        if (!TryThree()) return false;
        return cards[1].rank == cards[2].rank;
    }

    // 同花顺
    bool TryStraightFlush() { return TryFlush() && TryStraight(); }

    // 皇家同花顺 — 同花顺且最小牌为 10（10,J,Q,K,A）
    bool TryRoyalFlush()
    {
        if (!TryStraightFlush()) return false;
        return cards[0].rank == 10;
    }

    
    void Sort()
    {
        sort(cards.begin(), cards.end());
    }

    
    bool operator < (const CombEval &rhs) const
    {
        if (type != rhs.type)
            return int(type) < int(rhs.type);
        // 从最大牌开始比较
        for (int i = 4; i >= 0; i--)
            if ((cards[i] < rhs.cards[i]) || (rhs.cards[i] < cards[i]))
                return cards[i] < rhs.cards[i];
        return false;
    }
    bool operator == (const CombEval &rhs) const
    {
        return !(*this < rhs) && !(rhs < *this);
    }

    Type type;
    vector<Card> cards;
};


CombEval GetCombEval(const vector<Card> &cards)
{
    CombEval ret;
    ret.cards = cards;
    ret.Sort();

    bool ok = false;
    if (!ok && ret.TryRoyalFlush())    ret.type = CombEval::Type::RoyalFlush,    ok = true;
    ret.Sort();
    if (!ok && ret.TryStraightFlush()) ret.type = CombEval::Type::StraightFlush, ok = true;
    if (!ok && ret.TryFour())          ret.type = CombEval::Type::Four,          ok = true;
    if (!ok && ret.TryFullHouse())     ret.type = CombEval::Type::FullHouse,     ok = true;
    if (!ok && ret.TryFlush())         ret.type = CombEval::Type::Flush,         ok = true;
    if (!ok && ret.TryStraight())      ret.type = CombEval::Type::Straight,      ok = true;
    if (!ok && ret.TryThree())         ret.type = CombEval::Type::Three,         ok = true;
    if (!ok && ret.TryTwoPairs())      ret.type = CombEval::Type::TwoPairs,      ok = true;
    if (!ok && ret.TryPair())          ret.type = CombEval::Type::Pair,          ok = true;
    if (!ok && ret.TryHighCard())      ret.type = CombEval::Type::HighCard,      ok = true;
    return ret;
}
```

**n进制 转 m进制** *(n_to_ten)*

> 【n进制 转 m进制】
进制转换模板，在不同进制间转换数值表示。

核心函数：
  int n_to_ten(无参数) — 核心算法函数
  void ten_to_m(无参数) — 核心算法函数

关键配置：
N=1e5+3

```cpp
#include<cstdio>
const int N=1e5+3;
int n,m,x,tmp,ansl;char a[N],ans[N];
inline int n_to_ten(){
	int x=0;
	for(int i=0;a[i];++i){
        x*=n;
        if (a[i]>='A'&&a[i]<='F')x+=(a[i]-'A'+10);
        else x+=(a[i]-'0');
   }
   return x;
}
inline void ten_to_m(){
	do{
		tmp=x%m;
		if(tmp<10)ans[++ansl]='0'+tmp;
		else ans[++ansl]='A'+tmp-10;
		x/=m;
		
	}while(x);
}
int main(){
   scanf("%d%s%d",&n,a,&m);
   x=n_to_ten();
   ten_to_m();
   for(int i=ansl;i;--i)printf("%c",ans[i]);puts("");
}

```

**归并排序** *(optimize)*

> 【归并排序】
归并排序模板，O(N log N) 排序 + 统计逆序对。

核心函数：
  void in(int &x) — 核心算法函数
  void merge(Re L,Re mid,Re R) — 合并操作
  void Sort(Re L,Re R) — 核心算法函数

关键配置：
N=5e5+3

说明：printf("%lld",gs);//�������Ը���

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)
#include<cstdio>
#define Re register int
const int N=5e5+3;
int fu,n,s[N],b[N];long long gs;char ch;
inline void in(int &x){
	fu=x=0;ch=getchar();
	while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=fu?-x:x;
}
void merge(Re L,Re mid,Re R){
    Re i=L,j=mid+1,w=L;
    while(i<=mid&&j<=R){
        if(s[i]<=s[j])b[w++]=s[i++];
        else b[w++]=s[j++],gs+=mid-i+1;
    }
    for(;i<=mid;i++)b[w++]=s[i];
    for(;j<=R;j++)b[w++]=s[j];
    for(i=L;i<=R;i++)s[i]=b[i];
}
inline void Sort(Re L,Re R){
    if(L<R){
        Re mid=L+R>>1;
        Sort(L,mid),Sort(mid+1,R);
        merge(L,mid,R);
    }
}
int main(){
    in(n);
    for(Re i=1;i<=n;i++)in(s[i]);
    Sort(1,n);
    for(Re i=1;i<=n;i++)printf("%d ",s[i]); 
}

```

**快排** *(mysort)*

> 【快排】
基础算法/工具类模板。

核心函数：
  void mysort(int left, int right) — 核心算法函数

```cpp
#include<bits/stdc++.h>
using namespace std;
int data[100100],n;
void mysort(int left, int right){
	int mid=data[(left+right)/2];
	int i=left,j=right;
	while(i<=j){
		while(data[i]<mid)i++;
		while(data[j]>mid)j--;
		if(i<=j)swap(data[i++],data[j--]);
	}
	if(j>left)mysort(left,j);
	if(i<right)mysort(i,right);
}
int main(){	
	scanf("%d",&n);
	for(int i=1;i<=n;i++)scanf("%d",&data[i]);
	mysort(1,n);
	for(int i=1;i<=n;i++)printf("%d ",data[i]);
}

```

**快读 +快输 (int)** *(int+double)*

> 【快读 +快输 (int)（int+double）】
快速读入（Fast I/O）模板，加速整数读入。

核心函数：
  void in(Re &x) — 核心算法函数
  void print(Re x) — 核心算法函数
  LD LDin(无参数) — 核心算法函数

```cpp
#include<cstdio>
#define LD double
#define Re register int
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void print(Re x){
	if(x<0)putchar('-'),x=-x;
	if(x>9)print(x/10);putchar(x%10+'0');
}
inline LD LDin(){
	LD X=0,Y=1.0;int f=0;char c=getchar();
	while(c<'0'||c>'9')f|=c=='-',c=getchar(); 
	while(c>='0'&&c<='9')X=X*10+(c^48),c=getchar(); 
	if(c=='.'){c=getchar();while(c>='0'&&c<='9')X+=(Y/=10)*(c^48),c=getchar();}
	return f?-X:X;
}
int main(){}

```

**快速幂+龟速乘** *(cf_flow)*

> 【快速幂+龟速乘】
基础算法/工具类模板。

核心函数：
  int cf_flow(Re a,Re k) — 核心算法函数
  int cf(Re a,Re b) — 核心算法函数
  int mi_slow(Re a,Re k) — 核心算法函数
  int mi(Re x,Re k) — 核心算法函数

```cpp
#include<cstdio>
#define LL long long
#define Re register int
int a,b,P;
inline int cf_flow(Re a,Re k){// 递归 快速乘
	if(!k)return 0;
	Re x=1,y=cf_flow(a,k>>1);
	x=(LL)y+y%P;
	if(k&1)x=(LL)x+a%P;
	return x%P;
}
inline int cf(Re a,Re b){// 二进制法 快速乘 
	Re x=0;
	while(b){
		if(b&1)x=(x+a)%P;
		a=a*2%P,b>>=1;
	}
	return x%P;
}
inline int mi_slow(Re a,Re k){// 递归 快速幂 
	if(!k)return 1%P;
	Re x=1,y=mi_slow(a,k>>1);
	x=(LL)y*y%P;
	if(k&1)x=(LL)x*a%P;
	return x%P;
}
inline int mi(Re x,Re k){// 二进制法 快速幂 
	Re s=1;
    while(k){
    	if(k&1)s=(LL)s*x%P;
    	x=(LL)x*x%P,k>>=1;
    }
    return s%P;
}
int main(){}

```

**模拟退火  (A Star not a Tree？)** *(坐标系随机移动)*

> 【模拟退火  (A Star not a Tree？)（坐标系随机移动）】
随机化算法模板（模拟退火/爬山法），求近似全局最优解。

核心函数：
  void in(Re &x) — 核心算法函数
  LD calc(LD x,LD y) — 计算函数
  void Srand(Re seed) — 核心算法函数
  void fire(无参数) — 核心算法函数

关键配置：
N=1e6+3

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#define LD double
#define LL long long
#define Re register int
using namespace std;
const int N=1e6+3;
int n,HYJ,X[N],Y[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline LD calc(LD x,LD y){
	LD tmp=0;
	for(Re i=1;i<=n;++i)tmp+=sqrt((x-X[i])*(x-X[i])+(y-Y[i])*(y-Y[i]));
	return tmp;
}
inline void Srand(Re seed){
	srand(seed);Re a=rand()%10+1;
	while(a--)srand(rand());
}
LD ans,ansx,ansy;
const LD deltaT=0.99,maxT=4995,minT=1e-12;
inline void fire(){
	LD x=ansx,y=ansy,nowT=maxT;
	while(nowT>minT){
		LD nx=x+((rand()<<1)-RAND_MAX)*nowT;
		LD ny=y+((rand()<<1)-RAND_MAX)*nowT;
		LD nans=calc(nx,ny),deltaE=nans-ans;
		if(deltaE<0)ans=nans,ansx=x=nx,ansy=y=ny;
		else if(exp(-deltaE/nowT)>(LD)rand()/RAND_MAX)x=nx,y=ny;
		nowT*=deltaT;
	}
}
int main(){
//	freopen("123.txt","r",stdin);
	in(HYJ),Srand(20030825);
	while(HYJ--){
		in(n);
		for(Re i=1;i<=n;++i)in(X[i]),in(Y[i]);
		ans=calc(X[1],Y[1]),ansx=X[1],ansy=Y[1];
		fire(),fire(),fire(),fire(),fire();
		printf("%.lf\n",ans);
		if(HYJ)puts("");
	}
}

```

**模拟退火  (均分数据)** *(序列随机swap)*

> 【模拟退火  (均分数据)（序列随机swap）】
随机化算法模板（模拟退火/爬山法），求近似全局最优解。

核心函数：
  void in(Re &x) — 核心算法函数
  void Srand(Re seed) — 核心算法函数
  void Random(Re *A,Re n) — 核心算法函数
  LD calc(Re *A) — 计算函数
  void fire(无参数) — 核心算法函数

关键配置：
N=23

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#define LD double
#define LL long long
#define Re register int
using namespace std;
const int N=23;
int n,m,S,A[N];LD x0;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void Srand(Re seed){
	srand(seed);Re a=rand()%10+1;
	while(a--)srand(rand());
}
inline void Random(Re *A,Re n){
	for(Re i=1;i<=n;++i)swap(A[i],A[rand()%n+1]);
}
int x[N];
inline LD calc(Re *A){
	for(Re i=1;i<=m;++i)x[i]=0;
	for(Re i=1;i<=n;++i){
		Re w=1;
		for(Re j=2;j<=m;++j)if(x[j]<x[w])w=j;
		x[w]+=A[i];
	}
	LD tmp=0;
	for(Re i=1;i<=m;++i)tmp+=(x[i]-x0)*(x[i]-x0);
	return tmp/m;
}
int nowA[N],ansA[N];LD ans;
const LD deltaT=0.995,maxT=4995,minT=1e-15;
inline void fire(){
	for(Re i=1;i<=n;++i)nowA[i]=ansA[i];LD nowT=maxT;
	while(nowT>minT){
		Re x=rand()%n+1,y=rand()%n+1;
		swap(nowA[x],nowA[y]);
		LD nans=calc(nowA),deltaE=nans-ans;
		if(deltaE<0){for(Re i=1;i<=n;++i)ansA[i]=nowA[i];ans=nans;}
		else if(exp(-deltaE/nowT)>(LD)rand()/RAND_MAX);
		else swap(nowA[x],nowA[y]);
		nowT*=deltaT;
	}
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(m);
	for(Re i=1;i<=n;++i)in(A[i]),S+=A[i];x0=(LD)S/m;
	for(Re i=1;i<=n;++i)ansA[i]=A[i];
	Srand(965579261),Random(ansA,n),Srand(20030825);
	ans=calc(ansA),fire(),fire(),fire(),fire(),fire();
	printf("%.2lf\n",sqrt(ans));
}

```

**高精度乘法** *(普通写法)*

> 【高精度乘法（普通写法）】
高精度/大整数运算模板。

```cpp
#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
int main(){
    char a1[10005],b1[10005];
    int a[100005],b[100005],c[100005],lena,lenb,lenc,i,j,x;
    memset(a,0,sizeof(a));
    memset(b,0,sizeof(b));
    memset(c,0,sizeof(c));
    gets(a1);gets(b1);
    lena=strlen(a1);lenb=strlen(b1);
    for(i=0;i<=lena-1;i++) a[lena-i]=a1[i]-48;
    for(i=0;i<=lenb-1;i++) b[lenb-i]=b1[i]-48;
	for(i=1;i<=lena;i++){
	    x=0;                                               
	    for(j=1;j<=lenb;j++){
	        c[i+j-1]=a[i]*b[j]+x+c[i+j-1];
	        x=c[i+j-1]/10;
	        c[i+j-1] %= 10;
	    }
	    c[i+lenb]=x;                             
	}
	lenc=lena+lenb;
	while(c[lenc]==0&&lenc>1)lenc--;
	for(i=lenc;i>=1;i--)cout<<c[i];
	cout<<endl;
}

```

**高精度加法** *(普通写法)*

> 【高精度加法（普通写法）】
高精度/大整数运算模板。

```cpp
#include<bits/stdc++.h>
using namespace std;
int a[1000],b[1000],c[1000];
char st[1000];
int main(){
    scanf("%s",st);
    int lena,lenb,lenc;
    lena =strlen(st);
    for(int i=1;i<=lena;i++)a[i]=st[lena-i]-'0';
    scanf("%s",st);
    lenb=strlen(st);
    for(int i=1;i<=lenb;i++)b[i]=st[lenb-i]-'0';
    if(lena>lenb)lenc=lena;
    else lenc=lenb;
    for(int i=1;i<=lenc;i++){
        c[i]=a[i]+b[i]+c[i];
        c[i+1]=c[i+1]+c[i]/10;
        c[i]=c[i]%10;
    }
    if(c[lenc+1])lenc++;
    for(int i=lenc;i>0;i--)printf("%d",c[i]);
    return 0;	
}

```

**高精模板 (史上最全没有之一)** *(结构体)*

> 【高精模板 (史上最全没有之一)（结构体）】
基础算法/工具类模板。

核心函数：
  void CL(无参数) — 核心算法函数
  void pr(无参数) — 核心算法函数
  void re_l(无参数) — 核心算法函数
  LL toint(无参数) — 核心算法函数

核心结构体：Int

关键配置：
N=1e4+10

```cpp
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int base=1e8;
const int N=1e4+10;
int aux[N<<3];
struct Int{
    int s[N],l;
    inline void CL(){l=0;memset(s,0,sizeof(s));}
    inline void pr(){
        printf("%d",s[l]);
        for(Re i=l-1;i;i--)printf("%08d",s[i]);
    }
    inline void re_l(){
        Re i,x=0,k=1,L=0,fl,o;char c=getchar();
        for(;c<'0'||c>'9';c=getchar());
        for(;c>='0'&&c<='9';c=getchar()){if(!(L-1)&&!aux[L])L--;aux[++L]=c-'0';}
        CL();l=L/8+((o=L%8)>0);
        for(i=1;i<=o;i++)x=x*10+aux[i];
        if(o)s[l]=x;fl=!o?l+1:l;
        for(i=o+1,x=0;i<=L;i++,k++){
            x=x*10+aux[i];
            if(!(k^8))s[--fl]=x,x=k=0;
        }
        if(!l)l=1;
    }
    inline LL toint(){
        LL x=0;
        for(Re i=l;i;i--)x=x*base+s[i];
        return x;
    }
    inline Int operator=(Re b){
        CL();
        do s[++l]=b%base,b/=base;while(b>0);
        return *this;
    }
    inline Int operator=(LL b){
        CL();
        do s[++l]=b%base,b/=base;while(b>0);
        return *this;
    }
    inline Int operator+(const Re &b){
        Int c=*this;LL x=b;
        for(Re i=1;i<=l&&x;i++)x=x+c.s[i],c.s[i]=x%base,x/=base;
        if(x)c.s[++c.l]=x;
        return c;
    }
    inline Int operator+(const LL &b){
        Int c=*this;LL x=b;
        for(Re i=1;i<=l&&x;i++)x=x+c.s[i],c.s[i]=x%base,x/=base;
        if(x)c.s[++c.l]=x;
        return c;
    }
    inline Int operator+(Int &b){
        if(b.l<3)return *this+b.toint();
        Int c;LL x=0;Re k=l<b.l?b.l:l;c.CL(),c.l=k;
        for(Re i=1;i<=k;i++)x=x+s[i]+b.s[i],c.s[i]=x%base,x/=base;
        if(x)c.s[++c.l]=x;
        return c;
    }
    inline Int operator-(const Int &b){
        Int c,d=*this;LL x=0;c.CL();
        for(Re i=1;i<=l;i++){
            if((x=d.s[i])<b.s[i])d.s[i+1]--,x+=base;
            c.s[i]=x-b.s[i];
        }
        c.l=l;
        for(;!c.s[c.l]&&c.l>1;c.l--);
        return c;
    }
    inline Int operator-(const Re &b){Int c;return *this-(c=b);}
    inline Int operator-(const LL&b){Int c;return *this-(c=b);}
    inline Int operator*(const Re &b){
        Int c;LL x=0;c.CL();
        for(Re i=1;i<=l;i++)x=x+1LL*s[i]*b,c.s[i]=x%base,x/=base;
        for(c.l=l;x;x/=base)c.s[++c.l]=x%base;
        return c;
    }
    inline Int operator*(Int&b){
        if(b.l<2)return *this*b.toint();
        Int c;LL x;Re i,j,k;c.CL();
        for(i=1;i<=l;i++){
            x=0;
            for(j=1;j<=b.l;j++)x=x+1LL*s[i]*b.s[j]+c.s[k=i+j-1],c.s[k]=x%base,x/=base;
            if(x)c.s[i+b.l]=x;
        }
        for(c.l=l+b.l;!c.s[c.l]&&c.l>1;c.l--);
        return c;
    }
    inline Int operator*(const LL &b){
        Int c;
        if(b>2e9){c=b;return *this*c;}
        LL x=0;c.CL();
        for(Re i=1;i<=l;i++)x=x+b*s[i],c.s[i]=x%base,x/=base;
        for(c.l=l;x;x/=base)c.s[++c.l]=x%base;
        return c;
    }
    inline Int operator/(const Re &b){
        Int c;LL x=0;c.CL();
        for(Re i=l;i;i--)c.s[i]=(x*base+s[i])/b,x=(x*base+s[i])%b;
        for(c.l=l;!c.s[c.l]&&c.l>1;c.l--);
        return c;
    }
    inline Int operator/(const LL&b){
        Int c;LL x=0;c.CL();
        for(Re i=l;i;i--)c.s[i]=(x*base+s[i])/b,x=(x*base+s[i])%b;
        for(c.l=l;!c.s[c.l]&&c.l>1;c.l--);
        return c;
    }
    inline Int operator/(Int&b){
        if(b.l<2)return *this/b.toint();
        Int c,d;Re i,j,le,r,mid,k;c.CL();d.CL();
        for(i=l;i;i--){
            for(j=++d.l;j>1;j--)d.s[j]=d.s[j-1];
            d.s[1]=s[i];
            if(d<b)continue;
            le=k=0;r=base-1;
            while(le<=r){
                mid=(le+r)>>1;
                if(b*mid<=d)le=mid+1,k=mid;
                else r=mid-1;
            }
            c.s[i]=k,d=d-b*k;
        }
        for(c.l=l;!c.s[c.l]&&c.l>1;c.l--);
        return c;
    }
    inline Int operator%(const Re &b){
        Int c;LL x=0;c.CL();
        for(Re i=l;i;i--)x=(x*base+s[i])%b;
        return c=x;
    }
    inline Int operator%(const LL&b){
        Int c;LL x=0;c.CL();
        for(Re i=l;i;i--)x=(x*base+s[i])%b;
        return c=x;
    }
    inline Int operator%(Int&b){
        if(b.l<2)return *this%b.toint();
        Int c;Re i,j,le,r,mid,k;c.CL();
        for(i=l;i;i--){
            for(j=++c.l;j>1;j--)c.s[j]=c.s[j-1];
            c.s[1]=s[i];
            if(c<b)continue;
            le=k=0,r=base-1;
            while(le<=r){
                mid=(le+r)>>1;
                if(b*mid<=c)le=mid+1,k=mid;
                else r=mid-1;
            }
            c=c-b*k;
        }
        for(;!c.s[c.l]&&c.l>1;c.l--);
        return c;
    }
    inline Int operator+=(Int&b){return *this=*this+b;}
    inline Int operator+=(LL&b){return *this=*this+b;}
    inline Int operator+=(Re &b){return *this=*this+b;}
    inline Int operator-=(Int&b){return *this=*this-b;}
    inline Int operator-=(LL&b){return *this=*this-b;}
    inline Int operator-=(Re &b){return *this=*this-b;}
    inline Int operator*=(Int&b){return *this=*this*b;}
    inline Int operator*=(LL&b){return *this=*this*b;}
    inline Int operator*=(Re &b){return *this=*this*b;}
    inline Int operator/=(Int&b){return *this=*this/b;}
    inline Int operator/=(LL&b){return *this=*this/b;}
    inline Int operator/=(Re &b){return *this=*this/b;}
    inline Int operator%=(Int&b){return *this=*this%b;}
    inline Int operator%=(LL&b){return *this=*this%b;}
    inline Int operator%=(Re &b){return *this=*this%b;}
    inline bool operator<(const Int&b)const{
        if(l^b.l)return l<b.l;
        for(Re i=l;i;i--)if(s[i]^b.s[i])return s[i]<b.s[i];
        return 0;
    }
    inline bool operator<=(const Int&b)const{
        if(l^b.l)return l<b.l;
        for(Re i=l;i;i--)if(s[i]^b.s[i])return s[i]<b.s[i];
        return 1;
    }
    inline bool operator>(const Int&b)const{
        if(l^b.l)return l>b.l;
        for(Re i=l;i;i--)
            if(s[i]^b.s[i])return s[i]>b.s[i];
        return 0;
    }
    inline bool operator>=(const Int&b)const{
        if(l^b.l)return l>b.l;
        for(Re i=l;i;i--)if(s[i]^b.s[i])return s[i]>b.s[i];
        return 1;
    }
    inline bool operator==(const Int&b)const{
        if(l^b.l)return 0;
        for(Re i=l;i;i--)if(s[i]^b.s[i])return 0;
        return 1;
    }
    inline bool operator!=(const Int&b)const{
        if(l^b.l)return 1;
        for(Re i=l;i;i--)if(s[i]^b.s[i])return 1;
        return 0;
    }
    inline bool operator<(LL b)const{Int c;return *this<(c=b);}
    inline bool operator<=(LL b)const{Int c;return *this<=(c=b);}
    inline bool operator>(LL b)const{Int c;return *this>(c=b);}
    inline bool operator>=(LL b)const{Int c;return *this>=(c=b);}
    inline bool operator==(LL b)const{Int c;return *this==(c=b);}
    inline bool operator!=(LL b)const{Int c;return *this!=(c=b);}
    inline bool operator<(Re b)const{Int c;return *this<(c=b);}
    inline bool operator<=(Re b)const{Int c;return *this<=(c=b);}
    inline bool operator>(Re b)const{Int c;return *this>(c=b);}
    inline bool operator>=(Re b)const{Int c;return *this>=(c=b);}
    inline bool operator==(Re b)const{Int c;return *this==(c=b);}
    inline bool operator!=(Re b)const{Int c;return *this!=(c=b);}
};
Int a,b;
int main(){
    a.re_l();
    b.re_l();
    a.pr();printf("+");b.pr();printf("=");(a+b).pr();printf("\n");
    a.pr();printf("-");b.pr();printf("=");
    if(a<b){putchar('-');(b-a).pr();}
    else(a-b).pr();printf("\n");
    a.pr();printf("*");b.pr();printf("=");(a*b).pr();printf("\n");
    a.pr();printf("/");b.pr();printf("=");(a/b).pr();printf("\n");
    a.pr();printf("%%");b.pr();printf("=");(a%b).pr();printf("\n");
    if(a<b)printf("a<b\n");
    if(a<=b)printf("a<=b\n");
    if(a>b)printf("a>b\n");
    if(a>=b)printf("a>=b\n");
    if(a==b)printf("a==b\n");
    if(a!=b)printf("a!=b\n");
}

```

## 2. 数据结构

### 2.1 栈与队列

**单调栈** *(Largest Rectangle in a Histogram)*

> 【单调栈（Largest Rectangle in a Histogram）】
单调栈的算法实现模板。

```cpp
#include<algorithm>
#include<cstdio>
int i,n,t,wi,a[100005],Q[100005],W[100005];
long long ans;
int main(){
    while(scanf("%d",&n)!=EOF){
        if(!n)break;
        for(i=1;i<=n;i++)scanf("%d",&a[i]);
        ans=a[n+1]=t=0;
        for(i=1;i<=n+1;i++)
            if(a[i]>Q[t])Q[++t]=a[i],W[t]=1;
            else{
                wi=0;
                while(t&&a[i]<=Q[t])ans=std::max(ans,(long long)(wi+=W[t])*Q[t--]);
                Q[++t]=a[i],W[t]=wi+1;
            }
        printf("%lld\n",ans);
    }
}

```

**对顶栈** *(Editor)*

> 【对顶栈（Editor）】
对顶栈的算法实现模板。

关键配置：
N=1e6+5

```cpp
#include<algorithm>
#include<iostream>
#include<cstdio>
using namespace std;
const int N=1e6+5;
int m,x,tl,tr,L[N],R[N],f[N],s[N];char a;
int main(){
    while(scanf("%d",&m)!=EOF){
        s[0]=0;f[0]=-0xfffffff;tl=tr=0;
        while(m--){
            cin>>a;
            if(a=='I'){
                scanf("%d",&x);
                L[++tl]=x;
                f[tl]=max(f[tl-1],s[tl]=s[tl-1]+x);
            }
            else if(a=='R'){
                if(tr){
                    x=L[++tl]=R[tr--];
                    f[tl]=max(f[tl-1],s[tl]=s[tl-1]+x);
                }
            }
            else if(a=='Q')scanf("%d",&x),printf("%d\n",f[x]);
            else if(a=='L'){if(tl)R[++tr]=L[tl--];}
            else if(tl)tl--;
        }
    }
}

```

**表达式求值** *(加 减 乘 除 幂 括号)*

> 【表达式求值（加 减 乘 除 幂 括号）】
代码包含 mi, pop 等核心函数，实现了 表达式求值 的算法逻辑。

核心函数：
  LL mi(LL x,LL k) — 核心算法函数
  void pop(char fh) — 弹出元素

```cpp
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cctype>
#define LL long long
using namespace std;
int n,f,t1,t2,i,power[300],ch[40];
LL x,sum[40];string a;
LL mi(LL x,LL k){
    LL s=1;
    while(k){
        if(k&1)s=(s*x);
        x=(x*x);k>>=1;
    }
    return s;
}
inline void pop(char fh){
    t1--;t2--;
    if(fh=='+')sum[t1]+=sum[t1+1];
    if(fh=='-')sum[t1]-=sum[t1+1];
    if(fh=='*')sum[t1]*=sum[t1+1];
    if(fh=='/')sum[t1]/=sum[t1+1];
    if(fh=='^')sum[t1]=mi(sum[t1],sum[t1+1]);
}
int main(){
    cin>>a;a='('+a+')';n=a.size();
    power['(']=0;power['+']=power['-']=1;power['*']=power['/']=2;power['^']=3;
    while(i<n){
        x=0,f=0;
        while(isdigit(a[i]))x=x*10+a[i++]-'0',f=1;
        if(f)sum[++t1]=x;
        if(a[i]=='(')ch[++t2]=a[i++];
        if(a[i]==')'){
            while(ch[t2]!='(')pop(ch[t2]);
            i++;t2--;
        }
        if(power[a[i]]){
            if(a[i]=='-'&&a[i-1]=='('){
                x=0,i++;
                while(isdigit(a[i]))x=x*10+a[i++]-'0';
                sum[++t1]=-x;
            }
            else {
                while(power[a[i]]<=power[ch[t2]])pop(ch[t2]);
                ch[++t2]=a[i++];
            }
        }
    }
    while(t2)pop(ch[t2]);
    printf("%lld",sum[1]);
}

```

**单调队列：蚯蚓** *(f)*

> 【单调队列：蚯蚓】
代码包含 f, cmp 等核心函数，实现了 单调队列：蚯蚓 的算法逻辑。

核心函数：
  int f(无参数) — 核心算法函数
  bool cmp(int a,int b) — 核心算法函数

关键配置：
N=7100005

```cpp
#include<algorithm>
#include<cstdio>
using namespace std;
const int N=7100005;
int A[N],B[N],C[N],ans[N],h1,t1,h2,t2,h3,t3,s[100005],tmp,re,x,i,n,m,q,u,v,t;
double p;
inline int f(){
    int a=-0xfffffff;
    if(h1<=t1)a=max(a,A[h1]);
    if(h2<=t2)a=max(a,B[h2]);
    if(h3<=t3)a=max(a,C[h3]);
    if(h1<=t1&&a==A[h1])h1++;
    else if(h2<=t2&&a==B[h2])h2++;
    else h3++;
    return a;
}
inline bool cmp(int a,int b){return a>b;}
int main(){
    scanf("%d%d%d%d%d%d",&n,&m,&q,&u,&v,&t);
    p=1.0*u/v;h1=h2=h3=1;
    for(i=1;i<=n;i++)scanf("%d",&s[i]);
    sort(s+1,s+n+1,cmp);
    for(i=1;i<=n;i++)A[++t1]=s[i];
    for(i=1;i<=m;i++){
        x=f();
        x+=tmp;
        if(i%t==0)printf("%d ",x);
        re=p*x;
        B[++t2]=re-tmp-q;
        C[++t3]=x-re-tmp-q;
        tmp+=q;
    }
    printf("\n");
    for(i=h1;i<=t1;i++)ans[++ans[0]]=A[i];
    for(i=h2;i<=t2;i++)ans[++ans[0]]=B[i];
    for(i=h3;i<=t3;i++)ans[++ans[0]]=C[i];
    sort(ans+1,ans+ans[0]+1,cmp);
    for(i=1;i<=ans[0];i++)
        if(i%t==0)printf("%d ",ans[i]+tmp);
    return 0;
}

```

**滑动窗口** *(数组维护单调队列)*

> 【滑动窗口（数组维护单调队列）】
滑动窗口的算法实现模板。

关键配置：
N=1e6+5

```cpp
#include<algorithm>
#include<cstdio>
const int N=1e6+5;
int n,k,i,h,t,a[N],Q[N],D[N];
int main(){
    scanf("%d%d",&n,&k);
    for(i=1;i<=n;i++){
        scanf("%d",&a[i]);
        while(h<=t&&Q[t]>=a[i])t--;Q[++t]=a[i],D[t]=i;
        while(h<t&&D[h]+k-1<i)h++;
        if(i>=k)printf("%d ",Q[h]);
    }
    printf("\n");h=t=0;
    for(i=1;i<=n;i++){
        while(h<=t&&Q[t]<=a[i])t--;Q[++t]=a[i],D[t]=i;
        while(h<t&&D[h]+k-1<i)h++;
        if(i>=k)printf("%d ",Q[h]);
    }
}

```

**黑匣子** *(优先队列)*

> 【黑匣子（优先队列）】
黑匣子的算法实现模板。

```cpp
#include<bits/stdc++.h>
#define itn int
#define mian main
using namespace std;
int len,a[30005],piu,op;
char s;
priority_queue<int,vector<int>, greater<int> >sak;
priority_queue<int,vector<int>,less<int> >b;
int main(){
    while(scanf("%c",&s)){
        if(s=='A'){
            while(s!='(') scanf("%c",&s);
            scanf("%d",&a[++len]);
            getchar();
            piu++;
        }
        if(s=='G'){
            getchar();
            getchar();
			while(op<piu){
            	op++;
           	 	b.push(a[op]);
           	 	sak.push(b.top());
            	b.pop();
        	}
        	printf("%d ",sak.top());
        	b.push(sak.top());
        	sak.pop();
        }
        getchar();
    } 
    return 0;
}

```

### 2.2 二叉堆

**Huffman** *(荷马史诗)*

> 【Huffman（荷马史诗）】
代码包含 up, down, push, delet, in 等核心函数，实现了 Huffman 的算法逻辑。

核心函数：
  void up(Re p) — 核心算法函数
  void down(Re p) — 核心算法函数
  void push(Re x,Re d) — 压入元素
  void delet(Re p) — 核心算法函数
  void in(Re &x) — 核心算法函数

核心结构体：QAQ

```cpp
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
#include<algorithm>
#include<cstdio>
#define LL long long
#define Re register LL
using namespace std;
LL ans,fu,S,d,k,n,t,i,x;
struct QAQ{LL x,d;inline bool operator<(QAQ b)const{return x==b.x?d<b.d:x<b.x;}}Q[100011];
inline void up(Re p){
	while(p>1)
		if(Q[p]<Q[p>>1])swap(Q[p],Q[p>>1]),p>>=1;
		else break;
}
inline void down(Re p){
	int s=p<<1;
	while(s<=t){
		if(s<t&&Q[s|1]<Q[s])s++;
		if(Q[s]<Q[p])swap(Q[s],Q[p]),p=s,s<<=1;
		else break;
	}
}
inline void push(Re x,Re d){Q[++t].x=x,Q[t].d=d;up(t);}
inline void delet(Re p){swap(Q[p],Q[t--]);down(p);}
inline void in(Re &x){
    x=fu=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    if(fu)x=-x;
}
int main(){
	in(n),in(k);
	while(n--)in(x),push(x,0);
	while((t-1)%(k-1))push(0,0);
	while(t>1){
		x=k,S=0,d=0;
		while(x--)d=max(d,Q[1].d),S+=Q[1].x,delet(1);
		ans+=S,push(S,d+1);
	}
	printf("%lld\n%lld",ans,Q[1].d);
}

```

**二叉堆 (Supermarket)** *(小根堆)*

> 【二叉堆 (Supermarket)（小根堆）】
代码包含 cmp, CL, up, down, pop 等核心函数，实现了 二叉堆 (Supermarket) 的算法逻辑。

核心函数：
  bool cmp(QAQ a,QAQ b) — 核心算法函数
  void CL(无参数) — 核心算法函数
  void up(int p) — 核心算法函数
  void down(int p) — 核心算法函数
  void pop(无参数) — 弹出元素
  int top(无参数) — 获取栈顶/堆顶元素
  int size(无参数) — 获取大小/元素个数
  void push(int x) — 压入元素

核心结构体：QAQ, QWQ

```cpp
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
using namespace std;
struct QAQ{int w,d;}a[10003];
int ans,n,i;
inline bool cmp(QAQ a,QAQ b){return a.d!=b.d?a.d<b.d:a.w>b.w;}
struct QWQ{
	int heap[10003],t;
	inline void CL(){memset(heap,0,sizeof(heap));t=0;}
	inline void up(int p){
		while(p>1)
			if(heap[p>>1]>heap[p])swap(heap[p],heap[p>>1]),p>>=1;
			else break;
	}
	inline void down(int p){
		int s=(p<<1);
		while(s<=t){
			if(s<t&&heap[s]>heap[s|1])s++;
			if(heap[s]<heap[p]){
				swap(heap[s],heap[p]);
				p=s,s<<=1;
			}
			else break;
		}
	}
	inline void pop(){delet(1);}
	inline int top(){return heap[1];}
	inline int size(){return t;}
	inline void push(int x){heap[++t]=x;up(t);}
	inline void delet(int p){swap(heap[p],heap[t--]);down(p);}
}Q;
int main(){
    while(scanf("%d",&n)!=EOF){
        for(i=1;i<=n;i++)scanf("%d%d",&a[i].w,&a[i].d);
        sort(a+1,a+n+1,cmp);ans=0;Q.CL();
        for(i=1;i<=n;i++)
            if(Q.size()<a[i].d)Q.push(a[i].w);
            else if(Q.top()<a[i].w)Q.pop(),Q.push(a[i].w);
        while(Q.size())ans+=Q.top(),Q.pop();
        printf("%d\n",ans);
    }
}

```

### 2.3 单调栈与单调队列

**单调队列** *(monotonic_queue)*

> 【单调队列——滑动窗口最大值】
▪ maxSlidingWindow(nums, k) — 返回每个长度为 k 的滑动窗口的最大值：
  ① 维护双端队列 dq，存储候选最大值的下标（对应值从大到小单调递减）
  ② 队首过期（下标 < i-k+1）则 pop_front
  ③ 队尾值 ≤ 新值则 pop_back（维护单调性）
  ④ 将新下标 push_back，i≥k-1 时输出 nums[dq.front()]
每个元素入队/出队各一次，时间复杂度 O(N)。适用于滑动窗口最值、DP 单调队列优化。

```cpp
vector<int> maxSlidingWindow(vector<int>& nums, int k) {
    vector<int> res;
    deque<int> dq;
    int n = nums.size();
    for (int i = 0; i < n; ++i) {
        while (!dq.empty() && dq.front() < i - k + 1) {
            dq.pop_front();
        }
        while (!dq.empty() && nums[i] >= nums[dq.back()]) {
            dq.pop_back();
        }
        dq.push_back(i);
        if (i >= k - 1) {
            res.push_back(nums[dq.front()]);
        }
    }
    return res;
}
```

**单调栈类** *(monotonic_stack)*

> 【单调栈——Next Greater Element】
▪ nextGreaterElement(nums) — 返回每个元素右侧第一个比它大的元素值（不存在为 -1）：
  遍历数组，维护栈内元素对应值单调递减。当新元素 nums[i] > 栈顶对应值时，栈顶出栈并记录答案 res[栈顶]=nums[i]。最终将 i 入栈。
每个元素入栈出栈各一次，时间复杂度 O(N)。可改造成左侧更大、更小等变体。适用于 Next Greater Element、柱状图最大矩形、接雨水、股票价格跨度等。

```cpp
// 单调栈：寻找每个元素右侧第一个比它大的元素
vector<int> nextGreaterElement(vector<int>& nums) {
    int n = nums.size();
    vector<int> res(n, -1);
    stack<int> st;
    for (int i = 0; i < n; ++i) {
        while (!st.empty() && nums[i] > nums[st.top()]) {
            res[st.top()] = nums[i];
            st.pop();
        }
        st.push(i);
    }
    return res;
}
```

### 2.4 并查集

**并查集** *(bcj)*

> 【简单并查集（Union-Find）——数组实现 + 路径压缩】
▪ find(int num) — 查找 num 的根节点，同时进行路径压缩（将节点直接指向根），使后续查找接近 O(1)
▪ fd[] 向量 — 存储每个节点的父节点，初始化 fd[i]=i
整体时间复杂度接近 O(α(N))（反阿克曼函数），近似常数。适用于连通性判断、集合合并等基础场景。

```cpp
vector<int> fd(N, 0);
int find(int num) {
    if (fd[num] == num) {
        return num;
    } else {
        return fd[num] = find(fd[num]);
    }
}
```

**并查集** *(dsu)*

> 【并查集（DSU）类封装——路径压缩 + 按秩合并】
▪ DSU(n) — 构造函数，初始化 n 个独立元素，parent[i]=i，rank[i]=0
▪ init() — 重置所有元素为独立集合
▪ find(x) — 查找 x 的根节点，同时路径压缩（递归将 parent[x] 设为根）
▪ unite(x, y) — 合并 x 和 y 所在集合，按秩合并（rank 小的合并到 rank 大的上，rank 相等时根 rank+1）
▪ isConnected(x, y) — 判断 x 和 y 是否在同一集合
均摊时间复杂度 O(α(N))。适用于 Kruskal 最小生成树、连通分量统计等。

```cpp
class DSU {
private:
    vector<int> parent;
    vector<int> rank;
public:
    DSU(int n) {
        parent.resize(n);
        rank.resize(n, 0);
        for (int i = 0; i < n; ++i) {
            parent[i] = i;
        }
    }
    
    void init(){
        for (int i = 0; i < parent.size(); ++i) {
            parent[i] = i;
        }
    }

    int find(int x) {
        if (parent[x] != x) {
            parent[x] = find(parent[x]);
        }
        return parent[x];
    }
    
    void unite(int x, int y) {
        x = find(x);
        y = find(y);
        if (x == y) return;
        
        if (rank[x] < rank[y]) {
            parent[x] = y;
        } else {
            parent[y] = x;
            if (rank[x] == rank[y]) {
                rank[x]++;
            }
        }
    }
    
    bool isConnected(int x, int y) {
        return find(x) == find(y);
    }
};
```

**并查集** *(按秩合并 deep)*

> 【并查集（按秩合并 deep）】
并查集（Disjoint Set Union）模板，支持集合合并与连通性查询。

核心函数：
  void in(Re &x) — 核心算法函数
  int find(Re x) — 查找（并查集寻根/二分查找）
  void merge(Re x,Re y) — 合并操作

关键配置：
N=1e4+3

复杂度：均摊 O(α(N))，近似常数

适用场景：连通分量统计、Kruskal MST、区间合并问题

```cpp
#include<cstdio>
#define Re register int
const int N=1e4+3;
int n,x,y,T,op,fa[N],deep[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline int find(Re x){return x==fa[x]?x:find(fa[x]);}
inline void merge(Re x,Re y){
	x=find(x),y=find(y);
	if(x==y)return;
	if(deep[x]==deep[y])++deep[fa[x]=y];
	else if(deep[x]>deep[y])fa[y]=x;
	else fa[x]=y;
}
int main(){
	in(n),in(T);
	for(Re i=1;i<=n;++i)fa[i]=i;
	while(T--){
		in(op),in(x),in(y);
		if(op<2)merge(x,y);
		else puts(find(x)==find(y)?"Y":"N");
	}
}

```

**并查集** *(按秩合并 size)*

> 【并查集（按秩合并 size）】
并查集（Disjoint Set Union）模板，支持集合合并与连通性查询。

核心函数：
  void in(Re &x) — 核心算法函数
  int find(Re x) — 查找（并查集寻根/二分查找）
  void merge(Re x,Re y) — 合并操作

关键配置：
N=1e4+3

复杂度：均摊 O(α(N))，近似常数

适用场景：连通分量统计、Kruskal MST、区间合并问题

```cpp
#include<algorithm>
#include<cstdio>
#define Re register int
const int N=1e4+3;
int n,x,y,T,op,fa[N],size[N],deep[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline int find(Re x){return x==fa[x]?x:find(fa[x]);}
inline void merge(Re x,Re y){
	x=find(x),y=find(y);
	if(x==y)return;
	if(size[x]>size[y])std::swap(x,y);
	fa[x]=y,size[y]+=size[x];
}
int main(){
	in(n),in(T);
	for(Re i=1;i<=n;++i)fa[i]=i,size[i]=1;
	while(T--){
		in(op),in(x),in(y);
		if(op<2)merge(x,y);
		else puts(find(x)==find(y)?"Y":"N");
	}
}

```

**并查集** *(路径压缩)*

> 【并查集（路径压缩）】
并查集（Disjoint Set Union）模板，支持集合合并与连通性查询。

核心函数：
  void in(Re &x) — 核心算法函数
  int find(Re x) — 查找（并查集寻根/二分查找）

关键配置：
N=1e4+3

复杂度：均摊 O(α(N))，近似常数

适用场景：连通分量统计、Kruskal MST、区间合并问题

```cpp
#include<cstdio>
#define Re register int
const int N=1e4+3;
int n,x,y,T,op,fa[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline int find(Re x){return x==fa[x]?x:fa[x]=find(fa[x]);}
int main(){
	in(n),in(T);
	for(Re i=1;i<=n;++i)fa[i]=i;
	while(T--){
		in(op),in(x),in(y);
		if(op<2){if(find(x)!=find(y))fa[find(x)]=find(y);}
		else puts(find(x)==find(y)?"Y":"N");
	}
}

```

**信息传递** *(并查集实战)*

> 【信息传递（并查集实战）】
并查集（Disjoint Set Union）模板，支持集合合并与连通性查询。

核心函数：
  int min(int a,int b) — 核心算法函数
  int find(int x) — 查找（并查集寻根/二分查找）
  void sakura(int a,int b) — 后缀数组

复杂度：均摊 O(α(N))，近似常数

适用场景：连通分量统计、Kruskal MST、区间合并问题

```cpp
#include<cstdio>
#include<iostream> 
using namespace std;// 找图的最小环 
int minn=0x7fffff,n,f[200005],d[200005];
inline int min(int a,int b){if(a>b) return b;else return a;}

inline int find(int x){
	if(f[x]!=x){
		int l=f[x];
		f[x]=find(f[x]);
		d[x]+=d[l];
	}
	return f[x];
}

inline void sakura(int a,int b){
	int aa=find(a);int bb=find(b);
	if(aa!=bb){
		f[aa]=bb;
		d[a]=d[b]+1;
	}
	else
		minn=min(minn,d[a]+d[b]+1);
}

int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++) f[i]=i;
	for(int i=1;i<=n;i++){
		int x;
		scanf("%d",&x);
		sakura(i,x);
	}
	printf("%d",minn);
	return 0;
}


```

**打击罪犯** *(并查集实战)*

> 【打击罪犯（并查集实战）】
并查集（Disjoint Set Union）模板，支持集合合并与连通性查询。

核心函数：
  void add(int x,int y) — 加法更新
  int find(int x) — 查找（并查集寻根/二分查找）
  void unionn(int r1,int r2) — 核心算法函数
  void doit(无参数) — 核心算法函数

核心结构体：sakura

复杂度：均摊 O(α(N))，近似常数

适用场景：连通分量统计、Kruskal MST、区间合并问题

```cpp
#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
int fa[1001],n,k;
struct sakura{int u,v,next;}sak[4001];
int st[1001],tot=0;
int p[1001],pp[1001];

void add(int x,int y){
    tot++;
    sak[tot].u=x;
    sak[tot].v=y;
    sak[tot].next=st[x];
    st[x]=tot;
}

int find(int x){
    if (fa[x]!=x)
       fa[x]=find(fa[x]);
    return fa[x];
}

void unionn(int r1,int r2){
    fa[r1]=r2;
}

void doit(){
    int i,j;
    for (i=n-1;i>=1;i--){
    	pp[i]=1;
        for (j=st[i];j;j=sak[j].next){
            if (pp[sak[j].v]){
               	int r1=find(sak[j].u);
               	int r2=find(sak[j].v);
               	if (r1!=r2){
                  	unionn(r1,r2);
                  	p[r1]+=p[r2]; 
                  	p[r2]=p[r1];
            	}
            }
        }
        if (p[find(i)]>(n+1)/2){
            printf("%d",i);
        }
    }
}

int main(){
    scanf("%d",&n);
    pp[n]=1;
    for (int i=1;i<=n;i++){
        scanf("%d",&k);
        fa[i]=i;
        p[i]=1; 
        for (int j=1;j<=k;j++){
            int x;
            scanf("%d",&x);
            add(i,x);
        }
    }
    doit();
    return 0;
}

```

**格子游戏** *(二维并查集)*

> 【格子游戏（二维并查集）】
并查集（Disjoint Set Union）模板，支持集合合并与连通性查询。

核心函数：
  T s(int x,int y) — 核心算法函数

核心结构体：T

复杂度：均摊 O(α(N))，近似常数

适用场景：连通分量统计、Kruskal MST、区间合并问题

```cpp
#include<bits/stdc++.h>
using namespace std;
struct T{int x,y;}f[210][210];
int x,y,n,m;char c;T a1,a2;
T s(int x,int y){
    while((x==f[x][y].x)&&(y==f[x][y].y))return f[x][y];
    return s(f[x][y].x,f[x][y].y);
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            f[i][j].x=i,f[i][j].y=j;
    for(int i=1;i<=m;i++)
    {
        cin>>x>>y>>c;
        if(c=='D')a1=s(x,y),a2=s(x+1,y);
        else a1=s(x,y),a2=s(x,y+1);
        if(a1.x==a2.x&&a1.y==a2.y){
            printf("%d\n",i);return 0;
        }
        else f[a2.x][a2.y]=a1;
    }
    printf("draw");
    return 0;
}

```

**繁忙的都市** *(并查集+生成树)*

> 【繁忙的都市（并查集+生成树）】
并查集（Disjoint Set Union）模板，支持集合合并与连通性查询。

核心函数：
  int find(int x) — 查找（并查集寻根/二分查找）
  bool cmp(const sakura &a,const sakura &b) — 核心算法函数
  bool unions(int x,int y) — 核心算法函数

核心结构体：sakura

复杂度：均摊 O(α(N))，近似常数

说明：#include<bits/stdc++.h>

适用场景：连通分量统计、Kruskal MST、区间合并问题

```cpp
/*
            ���� 
           |   | 
           |   | 
           |   | 
      ������     ������ 
    |  ����ACʮ�ּ�   | 
     ������      ������ 
           |   | 
           |   | 
           |   | 
            ���� 
*/
//#include<bits/stdc++.h>
#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<algorithm>
int n,m,k,f[40001],sum;
struct sakura{
	int p,a,b,val;
}sak[40001];
inline int find(int x){return f[x]==x?x:find(f[x]);}
inline bool cmp(const sakura &a,const sakura &b){return a.val<b.val;}
inline bool unions(int x,int y){
	int fx=find(x),fy=find(y);
	if(fx==fy) return 0;
	else f[fy]=fx;
	return 1;
}
int main(){
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++) f[i]=i;
	for(int i=1;i<=m;i++)
		scanf("%d%d%d",&sak[i].a,&sak[i].b,&sak[i].val);
	std::sort(sak+1,sak+1+m,cmp);
	for(int i=1;i<=m;i++){
		if(unions(sak[i].a,sak[i].b)){
			k++;
			sum=sak[i].val;
		}
		if(k==n-1) break;
	}
	printf("%d %d",n-1,sum);
	return 0;
} 

```

**联络员** *(sort+并查集)*

> 【联络员（sort+并查集）】
并查集（Disjoint Set Union）模板，支持集合合并与连通性查询。

核心函数：
  int fi(int x) — 核心算法函数
  int cmp(const QAQ &a,const QAQ &b) — 核心算法函数

核心结构体：QAQ

复杂度：均摊 O(α(N))，近似常数

适用场景：连通分量统计、Kruskal MST、区间合并问题

```cpp
#include<algorithm>
#include<cstdlib>
#include<cstdio>
int g,i,j,n,m,p,x,y,c,ans,k,f[2010];
struct QAQ{int l,r,w;}a[40010];
inline int fi(int x){if(x!=f[x])f[x]=fi(f[x]);return f[x];}
inline int cmp(const QAQ &a,const QAQ &b){return a.w<b.w;}
int main(){
    scanf("%d%d",&n,&m);
    for(i=1;i<=n;i++)f[i]=i;
    for(i=1;i<=m;i++){
        scanf("%d%d%d%d",&p,&x,&y,&c);
        if(p==1){ans+=c,f[fi(y)]=fi(x);}
        else a[++g].l=x,a[g].r=y,a[g].w=c;
    }
    std::sort(a+1,a+g+1,cmp);
    for(i=1;i<=g;i++){
        x=fi(a[i].l),y=fi(a[i].r);
        if(x!=y){
            f[y]=x;k++;
            ans+=a[i].w;
        }
    }
    printf("%d",ans);
    return 0;
}

```

### 2.5 树状数组

**树状数组** *(bit)*

> 【树状数组（Fenwick Tree / BIT）模板类】
▪ BIT(n, in) — 构造函数，大小为 n，用 in[] 数组预处理填值（每个位置做一次 add）
▪ add(x, v) — 单点更新：位置 x 增加 v，通过 x+=lowbit(x) 向上更新所有父节点
▪ ask(x) — 前缀和查询：查询 [1, x] 的和，通过 x-=lowbit(x) 向上累加
▪ ask(l, r) — 区间和查询：差分实现 ask(r) - ask(l-1)
所有操作 O(log N)，常数远小于线段树。适用于动态维护前缀和、求逆序对等。

```cpp
template<class T> struct BIT {
    int n;
    vector<T> w;
    BIT(int n, auto &in) : n(n), w(n + 1) { // 预处理填值
        for (int i = 1; i <= n; i++) {
            add(i, in[i]);
        }
    }
    void add(int x, T v) {
        for (; x <= n; x += x & -x) {
            w[x] += v;
        }
    }
    T ask(int x) { // 前缀和查询
        T ans = 0;
        for (; x; x -= x & -x) {
            ans += w[x];
        }
        return ans;
    }
    T ask(int l, int r) { // 差分实现区间和查询
        return ask(r) - ask(l - 1);
    }
};
```

**一维：区间修改，区间查询** *(add)*

> 【一维：区间修改，区间查询】
树状数组（Fenwick Tree / BIT）模板，支持单点修改与区间查询。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re v) — 加法更新
  void add(Re L,Re R,Re v) — 加法更新
  LL ask(Re x) — 核心算法函数
  LL ask(Re L,Re R) — 核心算法函数

核心结构体：BIT

关键配置：
N=1e6+3

复杂度：单次操作 O(log N)，空间 O(N)

适用场景：动态前缀和、逆序对统计、二维偏序问题

```cpp
/*
            n        n
S[x]= (x+1)*��A[i] - ��i*A[i]
           i=1      i=1
*/
#include<cstdio>
#define LL long long
#define Re register int
const int N=1e6+3;
int n,x,y,z,T,op;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct BIT{
    LL C1[N],C2[N];
    inline void add(Re x,Re v){Re i=x;while(i<=n)C1[i]+=v,C2[i]+=(LL)x*v,i+=i&-i;}
    inline void add(Re L,Re R,Re v){add(L,v),add(R+1,-v);}
    inline LL ask(Re x){Re i=x;LL ans=0;while(i)ans+=(x+1)*C1[i]-C2[i],i-=i&-i;return ans;}
    inline LL ask(Re L,Re R){return ask(R)-ask(L-1);}
}TR;
int main(){
    in(n),in(T);
    for(Re i=1;i<=n;++i)in(x),TR.add(i,i,x);
    while(T--){
        in(op),in(x),in(y);
        if(op<2)in(z),TR.add(x,y,z);
        else printf("%lld\n",TR.ask(x,y));
    }
}

```

**一维：区间修改，单点查询** *(add)*

> 【一维：区间修改，单点查询】
树状数组（Fenwick Tree / BIT）模板，支持单点修改与区间查询。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re v) — 加法更新
  void add(Re L,Re R,Re v) — 加法更新
  LL ask(Re x) — 核心算法函数

核心结构体：BIT

关键配置：
N=5e5+3

复杂度：单次操作 O(log N)，空间 O(N)

适用场景：动态前缀和、逆序对统计、二维偏序问题

```cpp
#include<cstdio>
#define LL long long
#define Re register int
const int N=5e5+3;
int n,x,y,z,T,op;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct BIT{
    LL C[N];
    inline void add(Re x,Re v){while(x<=n)C[x]+=v,x+=x&-x;}
    inline void add(Re L,Re R,Re v){add(L,v),add(R+1,-v);}
    inline LL ask(Re x){LL ans=0;while(x)ans+=C[x],x-=x&-x;return ans;}
}TR;
int main(){
    in(n),in(T);
    for(Re i=1;i<=n;++i)in(x),TR.add(i,i,x);
    while(T--){
        in(op),in(x);
        if(op<2)in(y),in(z),TR.add(x,y,z);
        else printf("%lld\n",TR.ask(x));
    }
}

```

**一维：单点修改，区间查询** *(add)*

> 【一维：单点修改，区间查询】
树状数组（Fenwick Tree / BIT）模板，支持单点修改与区间查询。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re v) — 加法更新
  LL ask(Re x) — 核心算法函数
  LL ask(Re L,Re R) — 核心算法函数

核心结构体：BIT

关键配置：
N=5e5+3

复杂度：单次操作 O(log N)，空间 O(N)

适用场景：动态前缀和、逆序对统计、二维偏序问题

```cpp
#include<cstdio>
#define LL long long
#define Re register int
const int N=5e5+3;
int n,x,y,T,op;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct BIT{
    LL C[N];
    inline void add(Re x,Re v){while(x<=n)C[x]+=v,x+=x&-x;}
    inline LL ask(Re x){LL ans=0;while(x)ans+=C[x],x-=x&-x;return ans;}
    inline LL ask(Re L,Re R){return ask(R)-ask(L-1);}
}TR;
int main(){
    in(n),in(T);
    for(Re i=1;i<=n;++i)in(x),TR.add(i,x);
    while(T--){
        in(op),in(x),in(y);
        if(op<2)TR.add(x,y);
        else printf("%ld\n",TR.ask(x,y));
    }
}

```

**二维：区间修改，区间查询** *(add)*

> 【二维：区间修改，区间查询】
二维树状数组（2D BIT），支持矩阵子区域的前缀和/差分维护。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re y,Re v) — 加法更新
  void add(Re x1,Re y1,Re x2,Re y2,Re z) — 加法更新
  LL ask(Re x,Re y) — 核心算法函数
  LL ask(Re x1,Re y1,Re x2,Re y2) — 核心算法函数

核心结构体：BIT

关键配置：
N=2048+3

复杂度：单次操作 O(log N)，空间 O(N)

适用场景：动态前缀和、逆序对统计、二维偏序问题

```cpp
/*
                    n   m                 n   m                   n   m             n   m
s[x][y]=(x+1)*(y+1)*��  ��a[i][j] - (y+1)*��  ��a[i][j]*i - (x+1)*��  ��a[i][j]*j + ��  ��a[i][j]*i*j
                   i=1 j=1               i=1 j=1                 i=1 j=1           i=1 j=1
*/
#include<cstdio>
#define y1 yyyy
#define LL long long
#define Re register int
const int N=2048+3;
int n,m,x,x1,y1,x2,y2,op;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct BIT{
    LL C1[N][N],C2[N][N],C3[N][N],C4[N][N];
    inline void add(Re x,Re y,Re v){
        Re i=x;
        while(i<=n){
            Re j=y;
            while(j<=m)C1[i][j]+=v,C2[i][j]+=(LL)x*v,C3[i][j]+=(LL)y*v,C4[i][j]+=(LL)x*y*v,j+=j&-j;
            i+=i&-i;
        }
    }
    inline void add(Re x1,Re y1,Re x2,Re y2,Re z){
        add(x1,y1,z),add(x1,y2+1,-z),add(x2+1,y1,-z),add(x2+1,y2+1,z);
    }
    inline LL ask(Re x,Re y){
        Re i=x;LL ans=0;
        while(i){
            Re j=y;
            while(j)ans+=(LL)(x+1)*(y+1)*C1[i][j]-(LL)(y+1)*C2[i][j]-(LL)(x+1)*C3[i][j]+C4[i][j],j-=j&-j;
            i-=i&-i;
        }
        return ans;
    }
    inline LL ask(Re x1,Re y1,Re x2,Re y2){
        return ask(x2,y2)-ask(x2,y1-1)-ask(x1-1,y2)+ask(x1-1,y1-1);
    }
}TR;
int main(){
    in(n),in(m);
    while(~scanf("%d",&op)){
        in(x1),in(y1),in(x2),in(y2);
        if(op<2)in(x),TR.add(x1,y1,x2,y2,x);
        else printf("%lld\n",TR.ask(x1,y1,x2,y2));
    }
}

```

**二维：区间修改，单点查询** *(add)*

> 【二维：区间修改，单点查询】
二维树状数组（2D BIT），支持矩阵子区域的前缀和/差分维护。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re y,Re v) — 加法更新
  void add(Re x1,Re y1,Re x2,Re y2,Re z) — 加法更新
  LL ask(Re x,Re y) — 核心算法函数

核心结构体：BIT

关键配置：
N=4096+3

复杂度：单次操作 O(log N)，空间 O(N)

适用场景：动态前缀和、逆序对统计、二维偏序问题

```cpp
/*
(样例输入)
输入：
2 3 8
1 1 2 2 3 2
1 1 1 2 2 -3
2 1 1 
2 1 2 
2 1 3
2 2 1
2 2 2
2 2 3

输出
-3
-1
2
-3
-1
2
*/
#include<cstdio>
#define y1 yyyy
#define LL long long
#define Re register int
const int N=4096+3;
int n,m,T,x,x1,y1,x2,y2,op;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct BIT{
    LL C[N][N];
    inline void add(Re x,Re y,Re v){
        while(x<=n){Re j=y;while(j<=m)C[x][j]+=v,j+=j&-j;x+=x&-x;}
    }
    inline void add(Re x1,Re y1,Re x2,Re y2,Re z){
        add(x1,y1,z),add(x1,y2+1,-z),add(x2+1,y1,-z),add(x2+1,y2+1,z);
    }
    inline LL ask(Re x,Re y){
        LL ans=0;
        while(x){Re j=y;while(j)ans+=C[x][j],j-=j&-j;x-=x&-x;}
        return ans;
    }
}TR;
int main(){
    in(n),in(m),in(T);
    while(T--){
        in(op),in(x1),in(y1);
        if(op<2)in(x2),in(y2),in(x),TR.add(x1,y1,x2,y2,x);
        else printf("%lld\n",TR.ask(x1,y1));
    }
}

```

**二维：单点修改，区间查询** *(add)*

> 【二维：单点修改，区间查询】
二维树状数组（2D BIT），支持矩阵子区域的前缀和/差分维护。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re y,Re v) — 加法更新
  LL ask(Re x,Re y) — 核心算法函数
  LL ask(Re x1,Re y1,Re x2,Re y2) — 核心算法函数

核心结构体：BIT

关键配置：
N=4096+3

复杂度：单次操作 O(log N)，空间 O(N)

适用场景：动态前缀和、逆序对统计、二维偏序问题

```cpp
#include<cstdio>
#define y1 yyyy
#define LL long long
#define Re register int
const int N=4096+3;
int n,m,x1,y1,x2,y2,op;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct BIT{
    LL C[N][N];
    inline void add(Re x,Re y,Re v){
        while(x<=n){Re j=y;while(j<=m)C[x][j]+=v,j+=j&-j;x+=x&-x;}
    }
    inline LL ask(Re x,Re y){
        LL ans=0;
        while(x){Re j=y;while(j)ans+=C[x][j],j-=j&-j;x-=x&-x;}
        return ans;
    }
    inline LL ask(Re x1,Re y1,Re x2,Re y2){return ask(x2,y2)-ask(x2,y1-1)-ask(x1-1,y2)+ask(x1-1,y1-1);}
}TR;
int main(){
    in(n),in(m);
    while(~scanf("%d",&op)){
        in(x1),in(y1),in(x2);
        if(op<2)TR.add(x1,y1,x2);
        else in(y2),printf("%lld\n",TR.ask(x1,y1,x2,y2));
    }
}

```

**单点修改 ，区间查询 (Max)** *(取Max)*

> 【单点修改 ，区间查询 (Max)（取Max）】
树状数组（Fenwick Tree / BIT）模板，支持单点修改与区间查询。

核心函数：
  void in(Re &x) — 核心算法函数
  int max(Re a,Re b) — 核心算法函数
  void add(Re x,Re v) — 加法更新
  int ask(Re l,Re r) — 核心算法函数

核心结构体：BIT

关键配置：
N=1e5+3

复杂度：单次操作 O(log N)，空间 O(N)

适用场景：动态前缀和、逆序对统计、二维偏序问题

```cpp
#include<cstdio>
#define LL long long
#define Re register int
const int N=1e5+3;
int n,x,y,T,A[N];
inline void in(Re &x){
    int f=0;x=0;char ch=getchar();
    while(ch<'0'||ch>'9')f|=ch=='-',ch=getchar();
    while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
    x=f?-x:x;
}
inline int max(Re a,Re b){return a>b?a:b;}
struct BIT{
    int C[N];
    inline void add(Re x,Re v){while(x<=n)C[x]=max(C[x],v),x+=x&-x;}
    inline int ask(Re l,Re r){
        Re ans=0;
        while(l<=r){
            while(r-(r&-r)>=l)ans=max(ans,C[r]),r-=r&-r;
            ans=max(ans,A[r--]);
        }
        return ans;
    }
}TR;
int main(){
    in(n),in(T);
    for(Re i=1;i<=n;++i)in(A[i]),TR.add(i,A[i]);
    while(T--)in(x),in(y),printf("%d\n",TR.ask(x,y));
}

```

**普通平衡树** *(树状数组)*

> 【普通平衡树（树状数组）】
树状数组（Fenwick Tree / BIT）模板，支持单点修改与区间查询。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re v) — 加法更新
  int ask(Re x) — 核心算法函数
  int ask_kth(Re k) — 核心算法函数
   F(i,1,T) — 核心算法函数
   F(i,1,T) — 核心算法函数

关键配置：
N=1e5+3,inf=2147483647

复杂度：单次操作 O(log N)，空间 O(N)

适用场景：动态前缀和、逆序对统计、二维偏序问题

```cpp
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
#include<algorithm>
#include<cstdio>
#define Re register int
#define F(i,a,b) for(Re i=a;i<=b;++i)
#define lo(o) lower_bound(b+1,b+m+1,o)-b
#define P(x) if(op[i]==x)
using namespace std;
const int N=1e5+3,inf=2147483647;
int m,T,fu,C[N],a[N],b[N],Q[N],op[N]; 
inline void in(Re &x){
    x=fu=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
inline void add(Re x,Re v){while(x<=m)C[x]+=v,x+=x&-x;}
inline int ask(Re x){
	Re ans=0;
	while(x>0)ans+=C[x],x-=x&-x;
	return ans;
}
inline int ask_kth(Re k){
	Re l=0,r=m;
	while(l<r){
		Re mid=l+r>>1;
		if(ask(mid)>=k)r=mid;
		else l=mid+1;
	}
	return b[l];
}
int main(){
	in(T); 
    F(i,1,T){
    	in(op[i]),in(Q[i]);
    	if(op[i]!=4)b[++m]=Q[i];
    }
    sort(b+1,b+m+1),m=unique(b+1,b+m+1)-b-1;
    F(i,1,T){
    	P(1)add(lo(Q[i]),1);
    	P(2)add(lo(Q[i]),-1);
		P(3)printf("%d\n",ask(lo(Q[i])-1)+1);
		P(4)printf("%d\n",ask_kth(Q[i]));
		P(5)printf("%d\n",ask_kth(ask(lo(Q[i])-1)));
		P(6)printf("%d\n",ask_kth(ask(lo(Q[i]))+1));
    }
}

```

**炸勃龙** *(树状数组+扩展欧拉定理)*

> 【炸勃龙（树状数组+扩展欧拉定理）】
树状数组（Fenwick Tree / BIT）模板，支持单点修改与区间查询。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re k) — 加法更新
  LL ask(Re x) — 核心算法函数
  LL mi(Re x,Re k,Re P) — 核心算法函数
  LL sakura(Re l,Re r,Re P) — 后缀数组

关键配置：
N=5e5+3,Np=2e7

复杂度：单次操作 O(log N)，空间 O(N)

适用场景：动态前缀和、逆序对统计、二维偏序问题

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)
#include<cstdio>
#define LL long long
#define Re register LL
#define F(a,b) for(i=a;i<=b;++i)
const int N=5e5+3,Np=2e7;
LL i,j,n,x,l,r,K,T,fu,cnt,c[N],C[N],pan[Np+1],pri[Np+1],phi[Np+1];char ch;
inline void in(Re &x){
    x=fu=0;ch=getchar();
    while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
    while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();x=fu?-x:x;
}
inline void add(Re x,Re k){while(x<=n)C[x]+=k,x+=x&-x;}
inline LL ask(Re x){Re tmp=0;while(x)tmp+=C[x],x-=x&-x;return tmp;}
inline LL mi(Re x,Re k,Re P){
    Re s=1,ok=0,flag=0;ok|=(x>=P);x%=P;
    while(k){
        if(k&1){s*=x;flag|=(ok||s>=P);s%=P;}
        x*=x;ok|=(x>=P);x%=P;k>>=1;
    }
    return s+(flag?P:0);
}

inline LL sakura(Re l,Re r,Re P){
    if(P==1|l>r)return 1;
    return mi(ask(l),sakura(l+1,r,phi[P]),P);
}
int main(){
    for(i=2;i<=Np;++i){
        if(!pan[i])pri[++cnt]=i,phi[i]=i-1;
        for(j=1;j<=cnt;++j){
      		if(i*pri[j]>Np)break;
      		pan[i*pri[j]]=1;
      		if(i%pri[j])phi[i*pri[j]]=phi[i]*(pri[j]-1);
      		else{phi[i*pri[j]]=phi[i]*pri[j];break;}
   		}
    }
    in(n),in(T);
    F(1,n)in(x),add(i,x-l),l=x;
    while(T--){
        in(K),in(l),in(r),in(x);
        if(K<2)add(l,x),add(r+1,-x);
        else printf("%lld\n",sakura(l,r,x)%x);
    }
}

```

### 2.6 线段树

**带懒标记的线段数** *(Lazy_Segment_Tree_ask_add)*

> 【带懒标记的线段树——区间加 + 区间求和】
▪ build(datas, tree, rt, left, right) — 递归建树：叶子存 datas[left]，内部节点为左右子树之和
▪ pushDown(tree, rt, len) — 下传懒标记：将 rt 的 lazy 加到左右子节点（同步更新 data）
▪ updateRange(tree, rt, l, r, ul, ur, val) — 区间更新 [ul,ur] 加 val：若完全覆盖则 data+=val*len 并打 lazy，否则 pushDown 后递归更新左右子树
▪ query(tree, rt, l, r, ql, qr) — 区间查询 [ql,qr] 的和：类似 update，完全覆盖直接返回
所有操作 O(log N)。适用于区间加法+区间求和的经典问题。

```cpp
struct node{
    int data,lazy;
};

void build(const vector<int>&datas,vector<node>&tree,int rt,int left,int right){
    if(left == right){
        tree[rt].data=datas[left];
        return;
    }
    int mid = left+(right-left)/2;
    build(datas,tree,2*rt,left,mid);
    build(datas,tree,2*rt+1,mid+1,right);
    tree[rt].data = tree[2*rt].data+tree[2*rt+1].data;
}
void pushDown(vector<node>&tree,int rt, int len){
    if(tree[rt].lazy != 0){
        tree[rt*2].data += tree[rt].lazy * (len - len/2);
        tree[rt*2].lazy += tree[rt].lazy;
        tree[rt*2+1].data += tree[rt].lazy * (len/2); 
        tree[rt*2+1].lazy += tree[rt].lazy;
        tree[rt].lazy = 0;  
    }
}

int query(vector<node>&tree,int rt,int left,int right,int ql,int qr){
    if(ql > right || qr < left){
        return MIN;
    }
    if(ql <= left && qr >= right){
        return tree[rt].data;
    }
    int mid = left+(right-left)/2;
    pushDown(tree,rt,right-left+1);
    int leftsum = query(tree,2*rt,left,mid,ql,qr);
    int rightsum = query(tree,2*rt+1,mid+1,right,ql,qr);
    return leftsum+rightsum;
}
void updata(vector<node>&tree,int rt,int left,int right,int idx,int value){
    if(left == right){
        tree[rt].data = value;
        tree[rt].lazy = 0;
        return;
    }
    int mid = left+(right-left)/2;
    pushDown(tree,rt,right-left+1);
    if(idx<=mid){
        updata(tree,2*rt,left,mid,idx,value);
    }else{
        updata(tree,2*rt+1,mid+1,right,idx,value);
    }
    tree[rt].data = tree[2*rt].data+tree[2*rt+1].data;
}
void updataRange(vector<node>&tree,int rt,int left,int right,int ul,int ur,int value){
    if(ul>right||ur<left) return;
    
    if(ul<=left && ur >= right){
        tree[rt].data += value * (right - left + 1);
        tree[rt].lazy += value;
        return;
    }
    int mid = left+(right-left)/2;
    pushDown(tree,rt,right-left+1);
    updataRange(tree,2*rt,left,mid,ul,ur,value);
    updataRange(tree,2*rt+1,mid+1,right,ul,ur,value);
    tree[rt].data=tree[2*rt].data+tree[2*rt+1].data;
}
```

**线段树** *(LazySegmentTree-full)*

> 【通用懒标记线段树模板——Info + Tag 双模板参数】
▪ LazySegmentTree(init) — 构造函数，用 vector<Info> init 建树，内部 lambda build 递归构建
▪ pull(p) — 上推：info[p] = info[2p] + info[2p+1]（需重载 Info 的 + 运算符）
▪ apply(p, v) — 对节点 p 应用标记 v：info[p].apply(v); tag[p].apply(v)
▪ push(p) — 下推：apply(2p, tag[p]); apply(2p+1, tag[p]); 清空 tag[p]
▪ rangeApply(p, l, r, x, y, v) — 区间更新 [x,y] 应用标记 v
▪ rangeQuery(p, l, r, x, y) — 区间查询 [x,y]
▪ Tag 结构 — 懒标记（含 apply 方法），Info 结构 — 节点信息（含 apply 和 + 运算符）
通用模板，仅需定义 Info 和 Tag 即可适配各种线段树变体（求和/最值/异或等），O(log N)。

```cpp
template<class Info, class Tag> struct LazySegmentTree {
    int n;
    vector<Info> info;
    vector<Tag> tag;
    LazySegmentTree(vector<Info> init) {
        n = init.size();
        info.assign(4 * n, Info());
        tag.assign(4 * n, Tag());
        function<void(int, int, int)> build = [&](int p, int l, int r) {
            if (l == r) {
                info[p] = init[l - 1];
                return;
            }
            int m = (l + r) / 2;
            build(2 * p, l, m);
            build(2 * p + 1, m + 1, r);
            pull(p);
        };
        build(1, 1, n);
    }
    void pull(int p) {
        info[p] = info[2 * p] + info[2 * p + 1];
    }
    void apply(int p, const Tag &v) {
        info[p].apply(v);
        tag[p].apply(v);
    }
    void push(int p) {
        apply(2 * p, tag[p]);
        apply(2 * p + 1, tag[p]);
        tag[p] = Tag();
    }
    void rangeApply(int p, int l, int r, int x, int y, const Tag &v) {
        if (l > y || r < x) return;
        if (l >= x && r <= y) {
            apply(p, v);
            return;
        }
        push(p);
        int m = (l + r) / 2;
        rangeApply(2 * p, l, m, x, y, v);
        rangeApply(2 * p + 1, m + 1, r, x, y, v);
        pull(p);
    }
    Info rangeQuery(int p, int l, int r, int x, int y) {
        if (l > y || r < x) return Info();
        if (l >= x && r <= y) return info[p];
        push(p);
        int m = (l + r) / 2;
        return rangeQuery(2 * p, l, m, x, y) + rangeQuery(2 * p + 1, m + 1, r, x, y);
    }
};
struct Tag {
    LL x;
    Tag(LL x = 0) { this->x = x; }
    void apply(const Tag &t) { x += t.x; }
};
struct Info {
    LL x, l, r;
    Info(LL x = 0, LL l = 0, LL r = 0) { this->x = x; this->l = l; this->r = r; }
    void apply(const Tag &t) { if (t.x) x += t.x * (r - l + 1); }
};
Info operator+(const Info &a, const Info &b) { return Info(a.x + b.x, a.l, b.r); }
```

**线段树- mex** *(segment-tree-mex)*

> 【线段树——区间 MEX 查询】
▪ built(root, l, r) — 构建线段树，每个叶子对应一个值的出现位置（初始为 0），内部节点维护区间最小值 mins。同时记录 fa[pos] = 叶子在线段树中的节点编号
▪ modify(num, pos) — 将值 num 的出现位置更新为 pos，从叶子向上 push_up 更新 mins
▪ query(l) — 二分查询：从根向下走，若左子树的 mins ≥ l 则去右子树（左边全出现过），否则去左子树。最终返回第一个出现位置 < l 的值（即 MEX-1）
所有操作 O(log N)。适用于动态维护集合的 MEX 值、博弈论 SG 函数计算。

```cpp
struct tnode {
    int l, r;
    int mins;
};

struct Segment {
    tnode t[4 * N];
    int fa[4 * N];
    void built(int root, int l, int r) {
        """
        构建线段树
        :param root: 当前节点
        :param l: 左端点
        :param r: 右端点
        """
        t[root].l = l;
        t[root].r = r;
        if (l == r) {
            t[root].mins = 0;
            fa[l] = root;
            return;
        }
        int ch = root << 1;
        int mid = (l + r) >> 1;
        built(ch, l, mid);
        built(ch + 1, mid + 1, r);
        t[root].mins = min(t[ch].mins, t[ch + 1].mins);
    }
    void modify(int num, int pos) {
        """
        修改线段树
        :param num: 要修改的位置
        :param pos: 要修改的值
        """
        int root = fa[num];
        t[root].mins = pos;
        root >>= 1;
        while (root) {
            int ch = root << 1;
            t[root].mins = min(t[ch].mins, t[ch + 1].mins);
            root >>= 1;
        }
    }
    int query(int l) {
        """
        查询线段树
        :param l: 查询的左端点
        :return: 最小的未被覆盖的位置
        """
        int root = 1;
        while (t[root].l != t[root].r) {
            int ch = root << 1;
            if (t[ch].mins >= l) {
                root = ch + 1;
            } else {
                root = ch;
            }
        }
        return t[root].l - 1;
    }
} ST;

// int main() {
//     // 初始化线段树，假设值范围是1到n
//     int n;
//     cin >> n;
//     ST.built(1, 1, n);
//     // 示例：处理m次操作
//     int m;
//     cin >> m;
//     while (m--) {
//         int op, x, y;
//         cin >> op;
//         if (op == 1) {
//             cin >> x >> y;
//             ST.modify(x, y);
//         } else if (op == 2) {
//             cin >> x;
//             cout << ST.query(x) << '\n';
//         }
//     }
// }
```

**ST表求区间最值** *(RMQ)*

> 【ST表求区间最值（RMQ）】
线段树（Segment Tree）模板，支持区间操作的高效数据结构。

关键配置：
N=1e5+3,inf=2147483647

复杂度：建树 O(N)，单次操作 O(log N)

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
using namespace std;
const int N=1e5+3,inf=2147483647;
int i,j,n,k,m,a[N],lg[N],f1[N][18],f2[N][18];
int main(){
    scanf("%d%d",&n,&k);
    for(i=0;i<=17;i++)
        for(j=0;j<=n+1;j++)
            f1[i][j]=-inf,f2[i][j]=inf;
    lg[1]=0;for(i=2;i<=n;i++)lg[i]=lg[i>>1]+1;m=lg[n];
    for(i=1;i<=n;f2[i][0]=f1[i][0],i++)scanf("%d",&f1[i][0]);
    for(i=1;i<=m;i++)
        for(j=1;j+(1<<i)-1<=n;j++)
            f1[j][i]=max(f1[j][i-1],f1[j+(1<<i-1)][i-1]),f2[j][i]=min(f2[j][i-1],f2[j+(1<<i-1)][i-1]);
    m=lg[k];
    for(i=1;i+k-1<=n;i++)printf("%d %d\n",max(f1[i][m],f1[i+k-(1<<m)][m]),min(f2[i][m],f2[i+k-(1<<m)][m]));
}

```

**回文串** *(Manacher+SA+二分+ST表)*

> 【回文串（Manacher+SA+二分+ST表）】
线段树（Segment Tree）模板，支持区间操作的高效数据结构。

核心函数：
  void in(Re &x) — 核心算法函数
  void get_SA(无参数) — 获取值
  void get_Height(无参数) — 获取值
  void get_ST(无参数) — 获取值
  int ask_min(Re l,Re r) — 核心算法函数
  void check(Re x,Re len) — 判定/检查函数
  void sakura(无参数) — 后缀数组

核心结构体：Suffix_Array

关键配置：
N=3e5+5,logN=19

复杂度：建树 O(N)，单次操作 O(log N)

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=3e5+5,logN=19;
int n;char s[N];
inline void in(Re &x){
    Re f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Suffix_Array{
	int m,x[N],y[N],SA[N],cnt[N],rank[N],Height[N];
	inline void get_SA(){
		m=129;
		for(Re i=1;i<=n;++i)++cnt[x[i]=s[i]];
		for(Re i=2;i<=m;++i)cnt[i]+=cnt[i-1];
		for(Re i=n;i>=1;--i)SA[cnt[x[i]]--]=i;
		for(Re len=1;len<=n;len<<=1){
			Re t=0;
			for(Re i=n-len+1;i<=n;++i)y[++t]=i;
			for(Re i=1;i<=n;++i)if(SA[i]>len)y[++t]=SA[i]-len;
			for(Re i=1;i<=m;++i)cnt[i]=0;
			for(Re i=1;i<=n;++i)++cnt[x[i]];
			for(Re i=2;i<=m;++i)cnt[i]+=cnt[i-1];
			for(Re i=n;i>=1;--i)SA[cnt[x[y[i]]]--]=y[i],y[i]=0;
			swap(x,y),x[SA[1]]=m=1;
			for(Re i=2;i<=n;++i)
				x[SA[i]]=(y[SA[i]]==y[SA[i-1]]&&y[SA[i]+len]==y[SA[i-1]+len])?m:++m;
			if(m>=n)break;
		}
	}
	inline void get_Height(){
		for(Re i=1;i<=n;++i)rank[SA[i]]=i;
		for(Re i=1,k=0;i<=n;++i){
			if(rank[i]==1)continue;
			if(k)--k;
			Re j=SA[rank[i]-1];
			while(i+k<=n&&j+k<=n&&s[i+k]==s[j+k])++k;
			Height[rank[i]]=k;
		}
//		for(Re i=1;i<=n;++i)printf("%d ",Height[i]);puts("");
	}
	int lg[N],dp[N][20];
	inline void get_ST(){
		lg[0]=-1;
		for(Re i=1;i<=n;++i)dp[i][0]=Height[i],lg[i]=lg[i>>1]+1;
		for(Re j=1;j<=logN;++j)
			for(Re i=1;i+(1<<j)-1<=n;++i)
				dp[i][j]=min(dp[i][j-1],dp[i+(1<<j-1)][j-1]);
	}
	inline int ask_min(Re l,Re r){
		Re m=lg[r-l+1];
		return min(dp[l][m],dp[r-(1<<m)+1][m]);
	}
	int r[N<<1];char a[N<<1];LL ans;
	inline void check(Re x,Re len){
//		printf("x=%d, len=%d\n",x,len);
		x=rank[x];Re L=x,R=x;
		if(Height[x]>=len){
			Re l=2,r=x;
			while(l<r){
				Re mid=l+r>>1;
				if(ask_min(mid,x)>=len)r=mid;
				else l=mid+1;
			}
			L=r-1;
		}
		if(Height[x+1]>=len){
			Re l=x+1,r=n;
			while(l<r){
				Re mid=l+r+1>>1;
				if(ask_min(x+1,mid)>=len)l=mid;
				else r=mid-1;
			}
			R=l;
		}
		ans=max(ans,(LL)len*(R-L+1));
	}
	inline void sakura(){
		get_SA(),get_Height(),get_ST();
		a[m=0]='$',a[++m]='|';
		for(Re i=1;i<=n;++i)a[++m]=s[i],a[++m]='|';
		for(Re i=1,R=0,mid=0;i<=m;++i){
			r[i]=i<=R?min(r[(mid<<1)-i],R-i+1):1;
			while(a[i-r[i]]==a[i+r[i]]){
				++r[i];
				if(i+r[i]-1>R)check((i>>1)-(r[i]>>1)+1,r[i]-!(i+r[i]&1));
			}
			if(i+r[i]-1>R)mid=i,R=i+r[i]-1;
		}
//		for(Re i=1;i<=m;++i)printf("%d ",r[i]);puts("");
		printf("%lld\n",ans);
	}
}SA;
int main(){
//	freopen("123.txt","r",stdin);
//	freopen("my.txt","w",stdout);
	scanf("%s",s+1),n=strlen(s+1),SA.sakura();
}

```

**Escape Through Leaf** *(超哥线段树+线段树合并)*

> 【Escape Through Leaf（超哥线段树+线段树合并）】
线段树（Segment Tree）模板，支持区间操作的高效数据结构。

核心函数：
  void add(Re x,Re y) — 加法更新
  void in(Re &x) — 核心算法函数
  LL y(Re id,Re x) — 核心算法函数
  void change(Re &p,Re L,Re R,Re id) — 核心算法函数
  LL ask(Re p,Re L,Re R,Re x) — 核心算法函数
  int merge(Re p,Re q,Re L,Re R) — 合并操作
  void dfs(Re x,Re fa) — 深度优先搜索遍历

核心结构体：QAQ, Segment_Tree, QAQ

关键配置：
N=1e5+3

复杂度：建树 O(N)，单次操作 O(log N)

说明：freopen("123.txt","r",stdin);

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=1e5+3;
int n,m,x,y,o,cnt,k[N],A[N],B[N],pt[N],head[N];LL b[N],dp[N];
struct QAQ{int to,next;}a[N<<1];
inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Segment_Tree{
	#define pl tr[p].lp
	#define pr tr[p].rp
	#define mid ((L+R)>>1)
	int O;
	struct QAQ{int id,lp,rp;}tr[N*18*2*2];
	inline LL y(Re id,Re x){return (LL)k[id]*x+b[id];}
	inline void change(Re &p,Re L,Re R,Re id){
		if(!p){tr[p=++O].id=id;return;}
		if(L==R){if(y(id,L)<y(tr[p].id,L))tr[p].id=id;return;}
		if(k[id]>k[tr[p].id]){
			if(y(id,mid)<y(tr[p].id,mid))change(pr,mid+1,R,tr[p].id),tr[p].id=id;
			else change(pl,L,mid,id);
		}
		else{
			if(y(id,mid)<y(tr[p].id,mid))change(pl,L,mid,tr[p].id),tr[p].id=id;
			else change(pr,mid+1,R,id);
		}
	}
	inline LL ask(Re p,Re L,Re R,Re x){
		if(!p)return 1e18;
		if(L==R)return y(tr[p].id,x);
		LL ans=y(tr[p].id,x);
		if(x<=mid)return min(ans,ask(pl,L,mid,x));
		else return min(ans,ask(pr,mid+1,R,x));
	}
	inline int merge(Re p,Re q,Re L,Re R){
		if(!p||!q)return p+q;
		if(L==R){if(y(tr[p].id,L)>y(tr[q].id,L))tr[p].id=tr[q].id;return p;}
		pl=merge(pl,tr[q].lp,L,mid);
		pr=merge(pr,tr[q].rp,mid+1,R);
		change(p,L,R,tr[q].id);
		return p;
	}
}TR;
inline void dfs(Re x,Re fa){
	Re son=0;
	for(Re i=head[x],to;i;i=a[i].next)
		if((to=a[i].to)!=fa)son=1,dfs(to,x),pt[x]=TR.merge(pt[x],pt[to],-N,N);
	k[++cnt]=B[x],dp[x]=b[cnt]=son?TR.ask(pt[x],-N,N,A[x]):0;
	TR.change(pt[x],-N,N,cnt);
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),m=n-1;
	for(Re i=1;i<=n;++i)in(A[i]);
	for(Re i=1;i<=n;++i)in(B[i]);
	while(m--)in(x),in(y),add(x,y),add(y,x);
	dfs(1,0);
	for(Re i=1;i<=n;++i)printf("%lld\n",dp[i]);
}

```

**主席树-区间第k小** *(mid)*

> 【主席树-区间第k小】
可持久化线段树（主席树）模板，通过动态开点维护历史版本。

核心函数：
  void in(Re &x) — 核心算法函数
  void creat(Re &p,Re q,Re L,Re R,Re w) — 核心算法函数
  int ask(Re p,Re q,Re L,Re R,Re k) — 核心算法函数

核心结构体：President_Tree, QAQ

关键配置：
N=2e5+3,logN=18

复杂度：建树 O(N)，单次操作 O(log N)

说明：freopen("123.txt","r",stdin);

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=2e5+3,logN=18;
int n,m,x,y,z,T,b[N],A[N],pt[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct President_Tree{
    #define pl tr[p].lp
    #define pr tr[p].rp
    #define mid (L+R>>1)
    int O;
    struct QAQ{int S,lp,rp;}tr[N*(logN+1)];
    inline void creat(Re &p,Re q,Re L,Re R,Re w){
        p=++O,tr[p]=tr[q],++tr[p].S;
        if(L==R)return;
        if(w<=mid)creat(pl,tr[q].lp,L,mid,w);
        else creat(pr,tr[q].rp,mid+1,R,w);
    }
    inline int ask(Re p,Re q,Re L,Re R,Re k){
        if(L==R)return L;
        Re tmp=tr[pl].S-tr[tr[q].lp].S;
        if(tmp>=k)return ask(pl,tr[q].lp,L,mid,k);
        else return ask(pr,tr[q].rp,mid+1,R,k-tmp);
    }
}T1;
int main(){
//    freopen("123.txt","r",stdin);
    in(n),in(T);
    for(Re i=1;i<=n;++i)in(A[i]),b[i]=A[i];
    sort(b+1,b+n+1),m=unique(b+1,b+n+1)-b-1;
    for(Re i=1;i<=n;++i)T1.creat(pt[i],pt[i-1],1,m,lower_bound(b+1,b+m+1,A[i])-b);
    while(T--)in(x),in(y),in(z),printf("%d\n",b[T1.ask(pt[y],pt[x-1],1,m,z)]);
}

```

**区修，区查(gcd) (Interval GCD)** *(+)*

> 【区修，区查(gcd) (Interval GCD)（+）】
线段树（Segment Tree）模板，支持区间操作的高效数据结构。

核心函数：
  template<typename T>inline void in(T &x) — 核心算法函数
  LL abs(LL a) — 核心算法函数
  LL gcd(LL a,LL b) — 最大公约数
  void add(Re x,LL v) — 加法更新
  void add(Re L,Re R,LL v) — 加法更新
  LL ask(Re x) — 核心算法函数
  void pushup(Re p) — 上推更新节点信息
  void build(Re p,Re L,Re R) — 构建数据结构（建树/建图）

核心结构体：BIT, Segment_Tree

关键配置：
N=5e5+3

复杂度：建树 O(N)，单次操作 O(log N)

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#include<cstdio>
#define LL long long
#define Re register int
const int N=5e5+3;
int n,x,y,T;LL z,A[N];char op;
template<typename T>inline void in(T &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline LL abs(LL a){return a<0?-a:a;}
inline LL gcd(LL a,LL b){return !b?a:gcd(b,a%b);}
struct BIT{
    LL C[N];
    inline void add(Re x,LL v){while(x<=n)C[x]+=v,x+=x&-x;}
    inline void add(Re L,Re R,LL v){add(L,v),add(R+1,-v);}
    inline LL ask(Re x){LL ans=0;while(x)ans+=C[x],x-=x&-x;return ans;}
}TR0;
struct Segment_Tree{
    #define pl (p<<1)
    #define pr (p<<1|1)
    #define mid ((L+R)>>1)
    LL tr[N<<2];
    inline void pushup(Re p){tr[p]=gcd(tr[pl],tr[pr]);}
    inline void build(Re p,Re L,Re R){
        if(L==R){tr[p]=A[L]-A[L-1];return;}
        build(pl,L,mid),build(pr,mid+1,R);
        pushup(p);
    }
    inline void change(Re p,Re L,Re R,Re x,LL v){
        if(L==R){tr[p]+=v;return;}
        if(x<=mid)change(pl,L,mid,x,v);
        else change(pr,mid+1,R,x,v);
        pushup(p);
    }
    inline LL ask(Re p,Re L,Re R,Re l,Re r){
        if(l<=L&&R<=r)return abs(tr[p]);
        if(r<=mid)return ask(pl,L,mid,l,r);
        else if(l>mid)return ask(pr,mid+1,R,l,r);
        else return gcd(ask(pl,L,mid,l,r),ask(pr,mid+1,R,l,r));
    }
}TR;
int main(){
    in(n),in(T);
    for(Re i=1;i<=n;++i)in(A[i]),TR0.add(i,i,A[i]);
    TR.build(1,1,n);
    while(T--){
        scanf(" %c",&op),in(x),in(y);
        if(op=='Q')printf("%lld\n",gcd(TR0.ask(x),TR.ask(1,1,n,x+1,y)));
        else{
            in(z),TR0.add(x,y,z),TR.change(1,1,n,x,z);if(y<n)TR.change(1,1,n,y+1,-z);
        }
    }
}

```

**区修，区查(Sum)** *(+)*

> 【区修，区查(Sum)（+）】
带懒标记的线段树模板，支持区间修改与区间查询。

核心函数：
  void in(Re &x) — 核心算法函数
  void pushup(Re p) — 上推更新节点信息
  void updata(Re p,Re L,Re R,LL v) — 核心算法函数
  void pushdown(Re p,Re L,Re R) — 下传懒标记
  void build(Re p,Re L,Re R) — 构建数据结构（建树/建图）
  void change(Re p,Re L,Re R,Re l,Re r,Re v) — 核心算法函数
  LL ask(Re p,Re L,Re R,Re l,Re r) — 核心算法函数

核心结构体：Segment_Tree, QAQ

关键配置：
N=1e5+3

复杂度：建树 O(N)，单次操作 O(log N)

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#include<cstdio>
#define LL long long
#define Re register int
const int N=1e5+3;
int n,x,y,z,T,op,A[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Segment_Tree{
    #define pl (p<<1)
    #define pr (p<<1|1)
    #define mid ((L+R)>>1)
    struct QAQ{LL S,add;}tr[N<<2];
    inline void pushup(Re p){tr[p].S=tr[pl].S+tr[pr].S;}
    inline void updata(Re p,Re L,Re R,LL v){tr[p].S+=v*(R-L+1),tr[p].add+=v;}
    inline void pushdown(Re p,Re L,Re R){
        if(tr[p].add)updata(pl,L,mid,tr[p].add),updata(pr,mid+1,R,tr[p].add),tr[p].add=0;
    }
    inline void build(Re p,Re L,Re R){
        if(L==R){tr[p].S=A[L];return;}
        build(pl,L,mid),build(pr,mid+1,R);
        pushup(p);
    }
    inline void change(Re p,Re L,Re R,Re l,Re r,Re v){
        if(l<=L&&R<=r){updata(p,L,R,v);return;}
        pushdown(p,L,R);
        if(l<=mid)change(pl,L,mid,l,r,v);
        if(r>mid)change(pr,mid+1,R,l,r,v);
        pushup(p);
    }
    inline LL ask(Re p,Re L,Re R,Re l,Re r){
        if(l<=L&&R<=r)return tr[p].S;
        LL ans=0;pushdown(p,L,R);
        if(l<=mid)ans+=ask(pl,L,mid,l,r);
        if(r>mid)ans+=ask(pr,mid+1,R,l,r);
        return ans;
    }
}TR;
int main(){
    in(n),in(T);
    for(Re i=1;i<=n;++i)in(A[i]);
    TR.build(1,1,n);
    while(T--){
        in(op),in(x),in(y);
        if(op<2)in(z),TR.change(1,1,n,x,y,z);
        else printf("%lld\n",TR.ask(1,1,n,x,y));
    }
}

```

**区修，区查(Sum)** *(+,×)*

> 【区修，区查(Sum)（+,×）】
带懒标记的线段树模板，支持区间修改与区间查询。

核心函数：
  void in(Re &x) — 核心算法函数
  void pushup(Re p) — 上推更新节点信息
  void updata1(Re p,LL v) — 核心算法函数
  void updata2(Re p,Re L,Re R,LL v) — 核心算法函数
  void pushdown(Re p,Re L,Re R) — 下传懒标记
  void build(Re p,Re L,Re R) — 构建数据结构（建树/建图）
  void change(Re p,Re L,Re R,Re l,Re r,Re v,Re op) — 核心算法函数
  LL ask(Re p,Re L,Re R,Re l,Re r) — 核心算法函数

核心结构体：Segment_Tree, QAQ

关键配置：
N=1e5+3

复杂度：建树 O(N)，单次操作 O(log N)

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#include<cstdio>
#define LL long long
#define Re register int
const int N=1e5+3;
int n,x,y,z,T,P,op,A[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Segment_Tree{
    #define pl (p<<1)
    #define pr (p<<1|1)
    #define mid ((L+R)>>1)
    struct QAQ{LL S,mul,add;}tr[N<<2];
    inline void pushup(Re p){tr[p].S=(tr[pl].S+tr[pr].S)%P;}
    inline void updata1(Re p,LL v){
        tr[p].S=(LL)tr[p].S*v%P,tr[p].mul=(LL)tr[p].mul*v%P,tr[p].add=(LL)tr[p].add*v%P;
    }
    inline void updata2(Re p,Re L,Re R,LL v){(tr[p].S+=v*(R-L+1)%P)%=P,(tr[p].add+=v)%=P;}
    inline void pushdown(Re p,Re L,Re R){
        if(tr[p].mul!=1)updata1(pl,tr[p].mul),updata1(pr,tr[p].mul),tr[p].mul=1;
        if(tr[p].add)updata2(pl,L,mid,tr[p].add),updata2(pr,mid+1,R,tr[p].add),tr[p].add=0;
    }
    inline void build(Re p,Re L,Re R){
        tr[p].mul=1;
        if(L==R){tr[p].S=A[L]%P;return;}
        build(pl,L,mid),build(pr,mid+1,R);
        pushup(p);
    }
    inline void change(Re p,Re L,Re R,Re l,Re r,Re v,Re op){
        if(l<=L&&R<=r){if(op<2)updata1(p,v);else updata2(p,L,R,v);return;}
        pushdown(p,L,R);
        if(l<=mid)change(pl,L,mid,l,r,v,op);
        if(r>mid)change(pr,mid+1,R,l,r,v,op);
        pushup(p);
    }
    inline LL ask(Re p,Re L,Re R,Re l,Re r){
        if(l<=L&&R<=r)return tr[p].S;
        LL ans=0;pushdown(p,L,R);
        if(l<=mid)(ans+=ask(pl,L,mid,l,r))%=P;
        if(r>mid)(ans+=ask(pr,mid+1,R,l,r))%=P;
        return ans;
    }
}TR;
int main(){
    in(n),in(T),in(P);
    for(Re i=1;i<=n;++i)in(A[i]);
    TR.build(1,1,n);
    while(T--){
        in(op),in(x),in(y);
        if(op<3)in(z),TR.change(1,1,n,x,y,z,op);
        else printf("%lld\n",TR.ask(1,1,n,x,y));
    }
}

```

**区修，区查(Sum,min)** *(+,／)*

> 【区修，区查(Sum,min)（+,／）】
带懒标记的线段树模板，支持区间修改与区间查询。

核心函数：
  void in(Re &x) — 核心算法函数
  void pushup(Re p) — 上推更新节点信息
  void updata(Re p,Re L,Re R,LL v) — 核心算法函数
  void pushdown(Re p,Re L,Re R) — 下传懒标记
  void build(Re p,Re L,Re R) — 构建数据结构（建树/建图）
  void change(Re p,Re L,Re R,Re l,Re r,Re v) — 核心算法函数
  void change_div(Re p,Re L,Re R,Re l,Re r,Re v) — 核心算法函数
  LL ask_min(Re p,Re L,Re R,Re l,Re r) — 核心算法函数

核心结构体：Segment_Tree, QAQ

关键配置：
N=1e5+3

复杂度：建树 O(N)，单次操作 O(log N)

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#include<algorithm>
#include<cstdio>
#include<cmath>
#define LL long long
#define Re register int
#define div(a,b) floor((double)a/b)
using namespace std;
const int N=1e5+3;
int n,x,y,z,T,op,A[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Segment_Tree{
    #define pl (p<<1)
    #define pr (p<<1|1)
    #define mid ((L+R)>>1)
    struct QAQ{LL S,add,min,max;}tr[N<<2];
    inline void pushup(Re p){
        tr[p].S=tr[pl].S+tr[pr].S;
        tr[p].min=min(tr[pl].min,tr[pr].min);
        tr[p].max=max(tr[pl].max,tr[pr].max);
    }
    inline void updata(Re p,Re L,Re R,LL v){tr[p].S+=v*(R-L+1),tr[p].add+=v,tr[p].min+=v,tr[p].max+=v;}
    inline void pushdown(Re p,Re L,Re R){
        if(tr[p].add)updata(pl,L,mid,tr[p].add),updata(pr,mid+1,R,tr[p].add),tr[p].add=0;
    }
    inline void build(Re p,Re L,Re R){
        if(L==R){tr[p].S=tr[p].min=tr[p].max=A[L];return;}
        build(pl,L,mid),build(pr,mid+1,R);
        pushup(p);
    }
    inline void change(Re p,Re L,Re R,Re l,Re r,Re v){
        if(l<=L&&R<=r){updata(p,L,R,v);return;}
        pushdown(p,L,R);
        if(l<=mid)change(pl,L,mid,l,r,v);
        if(r>mid)change(pr,mid+1,R,l,r,v);
        pushup(p);
    }
    inline void change_div(Re p,Re L,Re R,Re l,Re r,Re v){
        if(l<=L&&R<=r&&(div(tr[p].max,v)-tr[p].max==div(tr[p].min,v)-tr[p].min)){
            updata(p,L,R,div(tr[p].max,v)-tr[p].max);return;
        }
        pushdown(p,L,R);
        if(l<=mid)change_div(pl,L,mid,l,r,v);
        if(r>mid)change_div(pr,mid+1,R,l,r,v);
        pushup(p);
    }
    inline LL ask_min(Re p,Re L,Re R,Re l,Re r){
        if(l<=L&&R<=r)return tr[p].min;
        LL ans=1e18;pushdown(p,L,R);
        if(l<=mid)ans=min(ans,ask_min(pl,L,mid,l,r));
        if(r>mid)ans=min(ans,ask_min(pr,mid+1,R,l,r));
        return ans;
    }
    inline LL ask_S(Re p,Re L,Re R,Re l,Re r){
        if(l<=L&&R<=r)return tr[p].S;
        LL ans=0;pushdown(p,L,R);
        if(l<=mid)ans+=ask_S(pl,L,mid,l,r);
        if(r>mid)ans+=ask_S(pr,mid+1,R,l,r);
        return ans;
    }
}TR;
int main(){
    in(n),in(T);
    for(Re i=1;i<=n;++i)in(A[i]);
    TR.build(1,1,n);
    while(T--){
        in(op),in(x),in(y),++x,++y;
        if(op<2)in(z),TR.change(1,1,n,x,y,z);
        else if(op<3)in(z),TR.change_div(1,1,n,x,y,z);
        else if(op<4)printf("%lld\n",TR.ask_min(1,1,n,x,y));
        else printf("%lld\n",TR.ask_S(1,1,n,x,y));
    }
}

```

**区修，区查(Sum)** *(Sqrt)*

> 【区修，区查(Sum)（Sqrt）】
线段树（Segment Tree）模板，支持区间操作的高效数据结构。

核心函数：
  template<typename T>inline void in(T &x) — 核心算法函数
  void pushup(Re p) — 上推更新节点信息
  void build(Re p,Re L,Re R) — 构建数据结构（建树/建图）
  void change(Re p,Re L,Re R,Re l,Re r) — 核心算法函数
  LL ask(Re p,Re L,Re R,Re l,Re r) — 核心算法函数

核心结构体：Segment_Tree, QAQ

关键配置：
N=1e5+3

复杂度：建树 O(N)，单次操作 O(log N)

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#include<algorithm>
#include<cstdio>
#include<cmath>
#define LL long long
#define Re register int
using namespace std;
const int N=1e5+3;
int n,x,y,z,T,op;LL A[N];
template<typename T>inline void in(T &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Segment_Tree{
    #define pl (p<<1)
    #define pr (p<<1|1)
    #define mid ((L+R)>>1)
    struct QAQ{LL S,max;}tr[N<<2];
    inline void pushup(Re p){
        tr[p].S=tr[pl].S+tr[pr].S;
        tr[p].max=max(tr[pl].max,tr[pr].max);
    }
    inline void build(Re p,Re L,Re R){
        if(L==R){tr[p].S=tr[p].max=A[L];return;}
        build(pl,L,mid),build(pr,mid+1,R);
        pushup(p);
    }
    inline void change(Re p,Re L,Re R,Re l,Re r){
        if(tr[p].max<=1)return;
        if(L==R){tr[p].max=tr[p].S=sqrt(tr[p].S);return;}
        if(l<=mid)change(pl,L,mid,l,r);
        if(r>mid)change(pr,mid+1,R,l,r);
        pushup(p);
    }
    inline LL ask(Re p,Re L,Re R,Re l,Re r){
        if(l<=L&&R<=r)return tr[p].S;
        LL ans=0;
        if(l<=mid)ans+=ask(pl,L,mid,l,r);
        if(r>mid)ans+=ask(pr,mid+1,R,l,r);
        return ans;
    }
}TR;
int main(){
    in(n);
    for(Re i=1;i<=n;++i)in(A[i]);
    TR.build(1,1,n),in(T);
    while(T--){
        in(op),in(x),in(y);if(x>y)swap(x,y);
        if(op)printf("%lld\n",TR.ask(1,1,n,x,y));
        else TR.change(1,1,n,x,y);
    }
}

```

**单修，区查(最大子段和)** *(+)*

> 【单修，区查(最大子段和)（+）】
线段树（Segment Tree）模板，支持区间操作的高效数据结构。

核心函数：
  void in(Re &x) — 核心算法函数
  void pushup(QAQ &A,const QAQ &L,const QAQ &R) — 上推更新节点信息
  void change(Re p,Re L,Re R,Re x,Re v) — 核心算法函数
  QAQ ask(Re p,Re L,Re R,Re l,Re r) — 核心算法函数

核心结构体：Segment_Tree, QAQ

关键配置：
N=5e4+3

复杂度：建树 O(N)，单次操作 O(log N)

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#include<algorithm>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=5e4+3;
int n,x,y,T,op,A[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Segment_Tree{
    #define pl (p<<1)
    #define pr (p<<1|1)
    #define mid ((L+R)>>1)
    struct QAQ{LL S,max,lmax,rmax;}tr[N<<2];
    inline void pushup(QAQ &A,const QAQ &L,const QAQ &R){
        A.S=L.S+R.S;
        A.lmax=max(L.lmax,L.S+R.lmax);
        A.rmax=max(R.rmax,R.S+L.rmax);
        A.max=max(max(max(L.max,R.max),max(A.lmax,A.rmax)),L.rmax+R.lmax);
    }
    inline void change(Re p,Re L,Re R,Re x,Re v){
        if(L==R){tr[p].S=tr[p].max=tr[p].lmax=tr[p].rmax=v;return;}
        if(x<=mid)change(pl,L,mid,x,v);
        else change(pr,mid+1,R,x,v);
        pushup(tr[p],tr[pl],tr[pr]);
    }
    inline QAQ ask(Re p,Re L,Re R,Re l,Re r){
        if(l<=L&&R<=r)return tr[p];
        if(r<=mid)return ask(pl,L,mid,l,r);
        else if(l>mid)return ask(pr,mid+1,R,l,r);
        else{QAQ ans;pushup(ans,ask(pl,L,mid,l,r),ask(pr,mid+1,R,l,r));return ans;}
    }
}TR;
int main(){
    in(n);
    for(Re i=1;i<=n;++i)in(A[i]),TR.change(1,1,n,i,A[i]);
    in(T);
    while(T--){
        in(op),in(x),in(y);
        if(op)printf("%lld\n",TR.ask(1,1,n,x,y).max);
        else TR.change(1,1,n,x,y);
    }
}

```

**整体DP  (Treeland Tour)** *(树上最长上升子序列)*

> 【整体DP  (Treeland Tour)（树上最长上升子序列）】
线段树（Segment Tree）模板，支持区间操作的高效数据结构。

核心函数：
  void add(Re x,Re y) — 加法更新
  void in(Re &x) — 核心算法函数
  void pushup(Re p) — 上推更新节点信息
  void change1(Re &p,Re L,Re R,Re x,Re v) — 核心算法函数
  void change2(Re &p,Re L,Re R,Re x,Re v) — 核心算法函数
  int ask1(Re p,Re L,Re R,Re l,Re r) — 核心算法函数
  int ask2(Re p,Re L,Re R,Re l,Re r) — 核心算法函数
  int merge(Re p,Re q,Re L,Re R) — 合并操作

核心结构体：QAQ, Segment_Tree, QAQ

关键配置：
N=6003

复杂度：建树 O(N)，单次操作 O(log N)

说明：freopen("123.txt","r",stdin);

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=6003;
int n,m,x,y,t,o,Ans,b[N],A[N],pt[N],head[N];
struct QAQ{int to,next;}a[N<<1];
inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Segment_Tree{
	#define pl (tr[p].lp)
	#define pr (tr[p].rp)
	#define mid ((L+R)>>1)
	int O;
	struct QAQ{int lp,rp,up,down;}tr[N*13*2];
	inline void pushup(Re p){
		tr[p].up=max(tr[pl].up,tr[pr].up);
		tr[p].down=max(tr[pl].down,tr[pr].down);
	}
	inline void change1(Re &p,Re L,Re R,Re x,Re v){
		if(!p)p=++O;
		if(L==R){tr[p].up=max(tr[p].up,v);return;}
		if(x<=mid)change1(pl,L,mid,x,v);
		else change1(pr,mid+1,R,x,v);
		pushup(p);
	}
	inline void change2(Re &p,Re L,Re R,Re x,Re v){
		if(!p)p=++O;
		if(L==R){tr[p].down=max(tr[p].down,v);return;}
		if(x<=mid)change2(pl,L,mid,x,v);
		else change2(pr,mid+1,R,x,v);
		pushup(p);
	}
	inline int ask1(Re p,Re L,Re R,Re l,Re r){
		if(!p)return 0;
		if(l<=L&&R<=r)return tr[p].up;
		Re ans=0;
		if(l<=mid)ans=max(ans,ask1(pl,L,mid,l,r));
		if(r>mid)ans=max(ans,ask1(pr,mid+1,R,l,r));
		return ans;
	}
	inline int ask2(Re p,Re L,Re R,Re l,Re r){
		if(!p)return 0;
		if(l<=L&&R<=r)return tr[p].down;
		Re ans=0;
		if(l<=mid)ans=max(ans,ask2(pl,L,mid,l,r));
		if(r>mid)ans=max(ans,ask2(pr,mid+1,R,l,r));
		return ans;
	}
	inline int merge(Re p,Re q,Re L,Re R){
		if(!p||!q)return p+q;
		if(L==R){tr[p].up=max(tr[p].up,tr[q].up),tr[p].down=max(tr[p].down,tr[q].down);return p;}
		Ans=max(Ans,max(tr[pl].up+tr[tr[q].rp].down,tr[pr].down+tr[tr[q].lp].up));
		pl=merge(pl,tr[q].lp,L,mid);
		pr=merge(pr,tr[q].rp,mid+1,R);
		pushup(p);return p;
	}
}TR;
inline void dfs(Re x,Re fa){
	Re up=0,down=0;
	for(Re i=head[x],to;i;i=a[i].next)
		if((to=a[i].to)!=fa){
			dfs(to,x);
			Re tmp1=TR.ask1(pt[to],1,t,1,A[x]-1),tmp2=TR.ask2(pt[to],1,t,A[x]+1,t);
			Ans=max(Ans,max(up+tmp2+1,down+tmp1+1));
			up=max(up,tmp1),down=max(down,tmp2);
			pt[x]=TR.merge(pt[x],pt[a[i].to],1,t);
		}
	TR.change1(pt[x],1,t,A[x],up+1),TR.change2(pt[x],1,t,A[x],down+1);
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),m=n-1;
	for(Re i=1;i<=n;++i)in(A[i]),b[i]=A[i];
	sort(b+1,b+n+1),t=unique(b+1,b+n+1)-b;
	for(Re i=1;i<=n;++i)A[i]=lower_bound(b+1,b+t+1,A[i])-b;
	while(m--)in(x),in(y),add(x,y),add(y,x);
	dfs(1,0),printf("%d\n",Ans);
}

```

**树套树-单修权值，区间权值和+垃圾回收** *(Intersection of Permutations)*

> 【树套树-单修权值，区间权值和+垃圾回收（Intersection of Permutations）】
线段树（Segment Tree）模板，支持区间操作的高效数据结构。

核心函数：
  void in(int &x) — 核心算法函数
  int New(无参数) — 核心算法函数
  void del(Re &p) — 核心算法函数
  void change(Re &p,Re L,Re R,Re w,Re v) — 核心算法函数
  int ask(Re p,Re L,Re R,Re l,Re r) — 核心算法函数
  int ask(Re L,Re R,Re l,Re r) — 核心算法函数
  void add(Re x,Re w,Re v) — 加法更新

核心结构体：Segment_Tree, QAQ

关键配置：
N=2e5+3

复杂度：建树 O(N)，单次操作 O(log N)

说明：freopen("123.txt","r",stdin);

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#define Re register int
using namespace std;
const int N=2e5+3;char opt[N];
int x,y,z,w,n,T,op,A[N],rk[N];
inline void in(int &x){
    Re fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
int pt[N<<1];
struct Segment_Tree{
	#define pl tr[p].lp
	#define pr tr[p].rp
	#define mid ((L+R)>>1)
	int O;queue<int>Q;
	struct QAQ{int S,lp,rp;}tr[N*200];
	inline int New(){// 新建节点
		if(Q.empty())return ++O;
		Re tmp=Q.front();Q.pop();
		return tmp;
	}
	inline void del(Re &p){pl=pr=0,Q.push(p),p=0;}// 删除节点(注意取地址，初始化为1)
	inline void change(Re &p,Re L,Re R,Re w,Re v){
	    if(!p)p=New();tr[p].S+=v;
	    if(L==R){if(!tr[p].S)del(p);return;}
	    if(w<=mid)change(pl,L,mid,w,v);
	    else change(pr,mid+1,R,w,v);
	    if(!tr[p].S)del(p);
	}
	inline int ask(Re p,Re L,Re R,Re l,Re r){
		if(!p)return 0;
		if(l<=L&&R<=r)return tr[p].S;
		Re ans=0;
		if(l<=mid)ans+=ask(pl,L,mid,l,r);
		if(r>mid)ans+=ask(pr,mid+1,R,l,r);
		return ans;
	}
}TR;
inline int ask(Re L,Re R,Re l,Re r){
    Re ans=0;
    for(Re i=R;i;i-=i&-i)ans+=TR.ask(pt[i],1,n,l,r);
    for(Re i=L-1;i;i-=i&-i)ans-=TR.ask(pt[i],1,n,l,r);
    return ans;
}
inline void add(Re x,Re w,Re v){
    for(Re i=x;i<=n;i+=i&-i)TR.change(pt[i],1,n,w,v);
}
int main(){
//	freopen("123.txt","r",stdin);
    in(n),in(T);
	for(Re i=1;i<=n;++i)in(x),rk[x]=i;
	for(Re i=1;i<=n;++i)in(A[i]),A[i]=rk[A[i]],add(i,A[i],1);
    while(T--){
    	in(op),in(x),in(y);
    	if(op>1)add(x,A[x],-1),add(y,A[y],-1),swap(A[x],A[y]),add(x,A[x],1),add(y,A[y],1);
    	else in(z),in(w),printf("%d\n",ask(z,w,x,y));
	}
}

```

**树套树-单修权值，区间第k小** *(pl)*

> 【树套树-单修权值，区间第k小】
线段树（Segment Tree）模板，支持区间操作的高效数据结构。

核心函数：
  void in(Re &x) — 核心算法函数
  void change(Re &p,Re L,Re R,Re x,Re v) — 核心算法函数
  int ask(Re p,Re L,Re R,Re K) — 核心算法函数
  void add(Re x,Re v) — 加法更新
  int ask(Re L,Re R,Re k) — 核心算法函数

核心结构体：QWQ, President_Tree, QAQ, BIT

关键配置：
N=1e5+3

复杂度：建树 O(N)，单次操作 O(log N)

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=1e5+3;
int n,m,T,b[N<<1],A[N];char op[N];
struct QWQ{int x,y,k;}Q[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
int t1,t2,pt[N],ptl[20],ptr[20];
struct President_Tree{
    #define pl (tr[p].lp)
    #define pr (tr[p].rp)
    #define mid ((L+R)>>1)
    int O;
    struct QAQ{int S,lp,rp;}tr[(N<<1)*200];
    inline void change(Re &p,Re L,Re R,Re x,Re v){
        if(!p)p=++O;tr[p].S+=v;
        if(L==R)return;
        if(x<=mid)change(pl,L,mid,x,v);
        else change(pr,mid+1,R,x,v);
    }
    inline int ask(Re p,Re L,Re R,Re K){
        if(L==R)return L;
        Re tmp=0;
        for(Re i=1;i<=t1;++i)tmp-=tr[tr[ptl[i]].lp].S;
        for(Re i=1;i<=t2;++i)tmp+=tr[tr[ptr[i]].lp].S;
        if(K<=tmp){
            for(Re i=1;i<=t1;++i)ptl[i]=tr[ptl[i]].lp;
            for(Re i=1;i<=t2;++i)ptr[i]=tr[ptr[i]].lp;
            return ask(pl,L,mid,K);
        }
        else{
            for(Re i=1;i<=t1;++i)ptl[i]=tr[ptl[i]].rp;
            for(Re i=1;i<=t2;++i)ptr[i]=tr[ptr[i]].rp;
            return ask(pr,mid+1,R,K-tmp);
        }
    }
}SG;
struct BIT{
    inline void add(Re x,Re v){
        for(Re i=x;i<=n;i+=i&-i)SG.change(pt[i],1,m,A[x],v);
    }
    inline int ask(Re L,Re R,Re k){
        t1=t2=0;
        for(Re i=L-1;i;i-=i&-i)ptl[++t1]=pt[i];
        for(Re i=R;i;i-=i&-i)ptr[++t2]=pt[i];
        return SG.ask(1,1,m,k);
    }
}TR;
int main(){
    in(n),in(T),m=n;
    for(Re i=1;i<=n;++i)in(A[i]),b[i]=A[i];
    for(Re i=1;i<=T;++i){
        scanf(" %c",&op[i]),in(Q[i].x),in(Q[i].y);
        if(op[i]=='Q')in(Q[i].k);
        else b[++m]=Q[i].y;
    }
    sort(b+1,b+m+1),m=unique(b+1,b+m+1)-b-1;
    for(Re i=1;i<=n;++i)A[i]=lower_bound(b+1,b+m+1,A[i])-b;
    for(Re i=1;i<=T;++i)if(op[i]=='C')Q[i].y=lower_bound(b+1,b+m+1,Q[i].y)-b;
    for(Re i=1;i<=n;++i)TR.add(i,1);
    for(Re i=1;i<=T;++i){
        if(op[i]=='Q')printf("%d\n",b[TR.ask(Q[i].x,Q[i].y,Q[i].k)]);
        else TR.add(Q[i].x,-1),A[Q[i].x]=Q[i].y,TR.add(Q[i].x,1);
    }
}

```

**线段树分治 (LCT维护MST) (城市建设)** *(时间分治)*

> 【线段树分治 (LCT维护MST) (城市建设)（时间分治）】
带懒标记的线段树模板，支持区间修改与区间查询。

核心函数：
  void in(int &x) — 核心算法函数
  void pushup(Re p) — 上推更新节点信息
  void updata(Re p) — 核心算法函数
  void pushdown(Re p) — 下传懒标记
  int which(Re p) — 核心算法函数
  int nort(Re p) — 核心算法函数
  void connect(Re p,Re fa,Re o) — 核心算法函数
  void rotate(Re p) — 旋转操作（平衡树）

核心结构体：QWQ, Link_Cut_Tree, QAQ, QAQ, Segment_Tree

关键配置：
N=2e4+3,M=5e4+3

复杂度：建树 O(N)，单次操作 O(log N)

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=2e4+3,M=5e4+3;
int n,m,x,y,z,T,op,X[N+M],Y[N+M],last[M];LL v[N+M],Ans[M];
inline void in(int &x){
    Re fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
struct QWQ{int id,op;QWQ(Re ID=0,Re OP=0){id=ID,op=OP;}};
struct Link_Cut_Tree{
	#define pl tr[p].ps[0]
	#define pr tr[p].ps[1]
	#define pf tr[p].fa
	int size,Q[N+M];QWQ QQ[M*32];LL MST;
	struct QAQ{int mx,fa,tag,ps[2];}tr[N+M];
	inline void pushup(Re p){
		tr[p].mx=p;
		if(pl&&v[tr[pl].mx]>v[tr[p].mx])tr[p].mx=tr[pl].mx;
		if(pr&&v[tr[pr].mx]>v[tr[p].mx])tr[p].mx=tr[pr].mx;
	}
	inline void updata(Re p){swap(pl,pr),tr[p].tag^=1;}
	inline void pushdown(Re p){
		if(tr[p].tag){
			if(pl)updata(pl);
			if(pr)updata(pr);
			tr[p].tag=0;
		}
	}
	inline int which(Re p){return tr[pf].ps[1]==p;}
	inline int nort(Re p){return tr[pf].ps[0]==p||tr[pf].ps[1]==p;}
	inline void connect(Re p,Re fa,Re o){tr[pf=fa].ps[o]=p;}
	inline void rotate(Re p){
		Re fa=pf,fas=which(p);
		Re pa=tr[fa].fa,pas=which(fa);
		Re x=tr[p].ps[fas^1];
		if(nort(fa))tr[pa].ps[pas]=p;pf=pa;
		connect(x,fa,fas),connect(fa,p,fas^1);
		pushup(fa),pushup(p); 
	}
	inline void splay(Re p){
		Re x=p,t=0;Q[++t]=x;
		while(nort(x))Q[++t]=x=tr[x].fa;
		while(t)pushdown(Q[t--]);
		for(Re fa;nort(p);rotate(p))
			if(nort(fa=pf))rotate(which(p)==which(fa)?fa:p);
	}
	inline void access(Re p){
		for(Re son=0;p;son=p,p=pf)
			splay(p),pr=son,pushup(p);
	}
	inline void makeroot(Re x){access(x),splay(x),updata(x);}
	inline int findroot(Re p){
		access(p),splay(p),pushdown(p);
		while(pl)pushdown(p=pl);
		return p;
	}
	inline void split(Re x,Re y){makeroot(x),access(y),splay(y);}
	inline void link(Re x,Re y){makeroot(x),tr[x].fa=y;}
	inline void cut(Re x,Re y){makeroot(x),access(y),splay(y),tr[x].fa=tr[y].ps[0]=0,pushup(y);}
	inline void cut_(Re id){
		makeroot(Y[id]),access(X[id]),splay(X[id]),tr[X[id]].ps[0]=tr[Y[id]].fa=tr[id].ps[0]=tr[id].fa=0,pushup(X[id]);
	}
	inline void link_(Re id){
		makeroot(X[id]),makeroot(Y[id]),tr[X[id]].fa=tr[Y[id]].fa=id;
	}
	inline void MST_link(Re id){
		Re x=X[id],y=Y[id];makeroot(x);
		if(findroot(y)!=x)link(x,id),link(id,y),QQ[++size]=QWQ(id,0),MST+=v[id];
		else{
			Re mx=tr[y].mx;
			if(v[id]<v[mx]){
//				cut(X[mx],mx),cut(mx,Y[mx]),QQ[++size]=QWQ(mx,1);
				cut_(mx),QQ[++size]=QWQ(mx,1);
				link(x,id),link(id,y),QQ[++size]=QWQ(id,0);
//				link_(id),QQ[++size]=QWQ(id,0);
				MST+=v[id]-v[mx];
			}
		}
	}
	inline void back(Re to){
		while(size>to){
			QWQ a=QQ[size--];Re id=a.id;
			if(a.op)link(id,Y[id]),link(X[id],id),MST+=v[id];
//			else cut(id,Y[id]),cut(X[id],id),MST-=v[id];
//			if(a.op)link_(id),MST+=v[id];
			else cut_(id),MST-=v[id];
		}
	}
	#undef pl
	#undef pr
}LCT;
int o,head[M<<2];
struct QAQ{int id,next;LL v;}a[M*32];
inline void add(Re x,Re id,LL v){a[++o].id=id,a[o].v=v,a[o].next=head[x],head[x]=o;}
struct Segment_Tree{
	#define pl (p<<1)
	#define pr (p<<1|1)
	#define mid ((L+R)>>1)
	inline void change(Re p,Re L,Re R,Re l,Re r,Re id,LL v){
		if(l>r)return;
		if(l<=L&&R<=r){add(p,id,v);return;}
		if(l<=mid)change(pl,L,mid,l,r,id,v);
		if(r>mid)change(pr,mid+1,R,l,r,id,v);
	}
	inline void dfs(Re p,Re L,Re R){
		Re tmp=LCT.size;
		for(Re i=head[p];i;i=a[i].next)v[a[i].id]=a[i].v,LCT.MST_link(a[i].id);
		if(L==R)Ans[L]=LCT.MST;
		else dfs(pl,L,mid),dfs(pr,mid+1,R);
		LCT.back(tmp);
	}
}T1;
int main(){
// 	freopen("123.txt","r",stdin);
// 	freopen("my.txt","w",stdout);
	in(n),in(m),in(T);
	for(Re i=1;i<=m;++i)in(X[i+n]),in(Y[i+n]),in(x),v[i+n]=x,last[i]=1;
	for(Re i=1;i<=T;++i){
		in(x),in(y);
		T1.change(1,1,T,last[x],i-1,x+n,v[x+n]);
		last[x]=i,v[x+n]=y;
	}
	for(Re i=1;i<=m;++i)T1.change(1,1,T,last[i],T,i+n,v[i+n]);
	T1.dfs(1,1,T);
	for(Re i=1;i<=T;++i)printf("%lld\n",Ans[i]);
}

```

**线段树分治 (冰茶姬 判断二分图)** *(时间分治)*

> 【线段树分治 (冰茶姬 判断二分图)（时间分治）】
线段树（Segment Tree）模板，支持区间操作的高效数据结构。

核心函数：
  void in(Re &x) — 核心算法函数
  int find(Re x) — 查找（并查集寻根/二分查找）
  void merge(Re x,Re y) — 合并操作
  void back(Re to) — 获取队尾元素
  void add(Re x,Re y1,Re y2) — 加法更新
  void change(Re p,Re L,Re R,Re l,Re r,Re x,Re y) — 核心算法函数
  void dfs(Re p,Re L,Re R) — 深度优先搜索遍历

核心结构体：Union, BK, QAQ, Segment_Tree

关键配置：
N=1e5+3,M=2e5+3

复杂度：建树 O(N)，单次操作 O(log N)

说明：freopen("123.txt","r",stdin);

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<stack>
#include<map>
#define LL long long
#define Re register int
#define mp make_pair
using namespace std;
const int N=1e5+3,M=2e5+3;
int x,y,l,r,n,m,T,Ans[N];char ch[20];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Union{// 冰茶姬（并查集）
	struct BK{int x,y,sizex,sizey;BK(Re X=0,Re S1=0,Re Y=0,Re S2=0){x=X,y=Y,sizex=S1,sizey=S2;}};
	int fa[N<<1],size[N<<1];stack<BK>Q;
	inline int find(Re x){return fa[x]==x?x:find(fa[x]);}
	inline void merge(Re x,Re y){// 启发式合并
		x=find(x),y=find(y);
		if(x==y)return;
		if(size[x]>size[y])swap(x,y);
		Q.push(BK(x,size[x],y,size[y]));
		fa[x]=y,size[y]+=size[x];
	}
	inline void back(Re to){// 撤销操作
		while(int(Q.size())>to){
			BK a=Q.top();Q.pop();
			fa[a.x]=a.x,size[a.x]=a.sizex;
			fa[a.y]=a.y,size[a.y]=a.sizey;
		}
	}
}TF;
int o,head[N<<2];
struct QAQ{int x,y,next;}a[M*20];
inline void add(Re x,Re y1,Re y2){a[++o].x=y1,a[o].y=y2,a[o].next=head[x],head[x]=o;}
struct Segment_Tree{
	#define pl (p<<1)
	#define pr (p<<1|1)
	#define mid ((L+R)>>1)
	inline void change(Re p,Re L,Re R,Re l,Re r,Re x,Re y){
		if(l>r)return;
		if(l<=L&&R<=r){add(p,x,y);return;}
		if(l<=mid)change(pl,L,mid,l,r,x,y);
		if(r>mid)change(pr,mid+1,R,l,r,x,y);
	}
	inline void dfs(Re p,Re L,Re R){
		Re tmp=TF.Q.size();
		for(Re i=head[p];i;i=a[i].next){
			if(TF.find(a[i].x)==TF.find(a[i].y)){
				for(Re j=L;j<=R;++j)Ans[j]=1;
				TF.back(tmp);return;
			}
			TF.merge(a[i].x,a[i].y+n),TF.merge(a[i].x+n,a[i].y);
		}
		if(L<R)dfs(pl,L,mid),dfs(pr,mid+1,R);
		TF.back(tmp);
	}
}T1;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(m),in(T);
	for(Re i=1;i<=(n<<1);++i)TF.fa[i]=i,TF.size[i]=1;
	for(Re i=1;i<=m;++i)in(x),in(y),in(l),in(r),T1.change(1,1,T,l+1,r+1-1,x,y);
	T1.dfs(1,1,T);
	for(Re i=1;i<=T;++i)puts(Ans[i]?"No":"Yes");
}

```

**线段树分治 (冰茶姬 查询图的连通性) (洞穴勘测)** *(时间分治)*

> 【线段树分治 (冰茶姬 查询图的连通性) (洞穴勘测)（时间分治）】
线段树（Segment Tree）模板，支持区间操作的高效数据结构。

核心函数：
  void in(Re &x) — 核心算法函数
  int find(Re x) — 查找（并查集寻根/二分查找）
  void merge(Re x,Re y) — 合并操作
  void back(Re to) — 获取队尾元素
  void add(Re x,Re y1,Re y2) — 加法更新
  void change(Re p,Re L,Re R,Re l,Re r,Re x,Re y) — 核心算法函数
  void dfs(Re p,Re L,Re R) — 深度优先搜索遍历

核心结构体：Query, Union, BK, QAQ, Segment_Tree

关键配置：
N=1e4+3,M=2e5+3

复杂度：建树 O(N)，单次操作 O(log N)

说明：freopen("123.txt","r",stdin);

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<stack>
#include<map>
#define LL long long
#define Re register int
#define mp(x,y) make_pair(x,y)
using namespace std;
const int N=1e4+3,M=2e5+3;
int x,y,n,T,Ans[M];char ch[20];
map<pair<int,int>,int>last;
struct Query{int x,y,op;}Q[M];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Union{// 冰茶姬（并查集）
	struct BK{int x,y,sizex,sizey;BK(Re X=0,Re S1=0,Re Y=0,Re S2=0){x=X,y=Y,sizex=S1,sizey=S2;}};
	int fa[N],size[N];stack<BK>Q;
	inline int find(Re x){return fa[x]==x?x:find(fa[x]);}
	inline void merge(Re x,Re y){// 启发式合并
		x=find(x),y=find(y);
		if(size[x]>size[y])swap(x,y);
		Q.push(BK(x,size[x],y,size[y]));
		fa[x]=y,size[y]+=size[x];
	}
	inline void back(Re to){// 撤销操作
		while(Q.size()>to){
			BK a=Q.top();Q.pop();
			fa[a.x]=a.x,size[a.x]=a.sizex;
			fa[a.y]=a.y,size[a.y]=a.sizey;
		}
	}
}TF;
int o,head[M<<2];
struct QAQ{int x,y,next;}a[M*20];
inline void add(Re x,Re y1,Re y2){a[++o].x=y1,a[o].y=y2,a[o].next=head[x],head[x]=o;}
struct Segment_Tree{
	#define pl (p<<1)
	#define pr (p<<1|1)
	#define mid (L+R>>1)
	inline void change(Re p,Re L,Re R,Re l,Re r,Re x,Re y){
		if(l<=L&&R<=r){add(p,x,y);return;}
		if(l<=mid)change(pl,L,mid,l,r,x,y);
		if(r>mid)change(pr,mid+1,R,l,r,x,y);
	}
	inline void dfs(Re p,Re L,Re R){
		Re tmp=TF.Q.size();
		for(Re i=head[p];i;i=a[i].next)TF.merge(a[i].x,a[i].y);
		if(L==R){if(Q[L].op)Ans[L]=(TF.find(Q[L].x)==TF.find(Q[L].y));}
		else dfs(pl,L,mid),dfs(pr,mid+1,R);
		TF.back(tmp);
	}
}T1;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T);
	for(Re i=1;i<=n;++i)TF.fa[i]=i,TF.size[i]=1;
	for(Re i=1;i<=T;++i){
		scanf("%s",ch),in(x),in(y);if(x>y)swap(x,y);
		if(ch[0]=='Q')Q[i].op=1,Q[i].x=x,Q[i].y=y;
		else if(ch[0]=='C')last[mp(x,y)]=i;
		else T1.change(1,1,T,last[mp(x,y)],i,x,y),last.erase(mp(x,y));
	}
	for(map<pair<int,int>,int>::iterator it=last.begin();it!=last.end();++it)
		T1.change(1,1,T,it->second,T,it->first.first,it->first.second);
	T1.dfs(1,1,T);
	for(Re i=1;i<=T;++i)if(Q[i].op)puts(Ans[i]?"Yes":"No");
}

```

**线段树分治 (线性基) (八纵八横)** *(时间分治)*

> 【线段树分治 (线性基) (八纵八横)（时间分治）】
线段树（Segment Tree）模板，支持区间操作的高效数据结构。

核心函数：
  void add(Re x,Re y,Int z) — 加法更新
  int find(Re x) — 查找（并查集寻根/二分查找）
  int getlen(Int &x) — 获取值
  void print(Int &x) — 核心算法函数
  void in(Int &x) — 核心算法函数
  void in(Re &x) — 核心算法函数
  void insert(Int x) — 插入元素
  Int ask(无参数) — 核心算法函数

核心结构体：QAQ, Line_JI, Segment_Tree, QAQ

关键配置：
N=550+5,M=1000+5

复杂度：建树 O(N)，单次操作 O(log N)

说明：freopen("123.txt","r",stdin);

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<bitset>
#include<stack>
#define LL long long
#define Re register int
#define Int bitset<M>
using namespace std;
const int N=550+5,M=1000+5;
int n,m,x,y,o,O,T,logN,X[N],Y[N],fa[N],last[N],head[N];Int z,Z[N],dis[N],Ans[M];char op[20];
struct QAQ{int to,next;Int w;}a[N<<1];
inline void add(Re x,Re y,Int z){a[++o].to=y,a[o].w=z,a[o].next=head[x],head[x]=o;}
inline int find(Re x){return x==fa[x]?x:fa[x]=find(fa[x]);}
inline int getlen(Int &x){Re n=1000;while(n>=1&&!x[n])--n;return n;}
inline void print(Int &x){for(Re i=getlen(x);i>=0;--i)putchar(x[i]+'0');puts("");}
inline void in(Int &x){cin>>x,logN=max(logN,getlen(x));}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Line_JI{
	Int p[M];bool pp[M];stack<int>Q;
	inline void insert(Int x){
		for(Re i=logN;i>=0;--i)
			if(x[i]){
				if(!pp[i]){Q.push(i),p[i]=x,pp[i]=1;break;}
				x^=p[i];
			}
	}
	inline Int ask(){
		Int ans;ans.reset();
		for(Re i=logN;i>=0;--i)if(pp[i]&&(!ans[i]))ans^=p[i];
		return ans;
	}
	inline void back(Re to){
		while(Q.size()>to)x=Q.top(),Q.pop(),p[x].reset(),pp[x]=0;
	}
}JI;
struct Segment_Tree{
	int o,head[M<<2];
	struct QAQ{int x,y,next;Int w;}a[(N+M)*10];
	inline void add(Re t,Re x,Re y,Int &z){a[++o].x=x,a[o].y=y,a[o].w=z,a[o].next=head[t],head[t]=o;}
	#define pl (p<<1)
	#define pr (p<<1|1)
	#define mid ((L+R)>>1)
	inline void change(Re p,Re L,Re R,Re l,Re r,Re x,Re y,Int &z){
		if(l<=L&&R<=r){add(p,x,y,z);return;}
		if(l<=mid)change(pl,L,mid,l,r,x,y,z);
		if(r>mid)change(pr,mid+1,R,l,r,x,y,z);
	}
	inline void dfs(Re p,Re L,Re R){
		Re tmp=JI.Q.size();
		for(Re i=head[p];i;i=a[i].next)JI.insert(dis[a[i].x]^dis[a[i].y]^a[i].w);
		if(L==R)Ans[L]=JI.ask();// 这里还没做back撤销操作,不能return!!!
		else dfs(pl,L,mid),dfs(pr,mid+1,R);
		JI.back(tmp);
	}
}TR;
inline void dfs(Re x,Re fa,Re w){
	dis[x]=dis[fa]^a[w].w;
	for(Re i=head[x];i;i=a[i].next)
		if(a[i].to!=fa)dfs(a[i].to,x,i);
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(m),in(T),++T;
	for(Re i=1;i<=n;++i)fa[i]=i;
	while(m--){
		in(x),in(y),in(z);
		if(find(x)!=find(y))add(x,y,z),add(y,x,z),fa[find(x)]=find(y);
		else TR.change(1,1,T,1,T,x,y,z);
	}
	for(Re i=2;i<=T;++i){
		scanf("%s",op);
		if(op[0]=='A')last[++O]=i,in(X[O]),in(Y[O]),in(Z[O]);
		else if(op[1]=='h'){
			in(x),in(z);
			TR.change(1,1,T,last[x],i-1,X[x],Y[x],Z[x]);
			last[x]=i,Z[x]=z;
		}
		else in(x),TR.change(1,1,T,last[x],i-1,X[x],Y[x],Z[x]),last[x]=0;
	}
	for(Re i=1;i<=O;++i)if(last[i])TR.change(1,1,T,last[i],T,X[i],Y[i],Z[i]);
	dfs(1,0,0),TR.dfs(1,1,T);
	for(Re i=1;i<=T;++i)print(Ans[i]);
}

```

**线段树分裂-分裂区间前后k个** *(区间排序 P2824)*

> 【线段树分裂-分裂区间前后k个（区间排序 P2824）】
线段树（Segment Tree）模板，支持区间操作的高效数据结构。

核心函数：
  void in(Re &x) — 核心算法函数
  void pushup(Re p) — 上推更新节点信息
  void change(Re &p,Re L,Re R,Re x) — 核心算法函数
  int merge(Re p,Re q,Re L,Re R) — 合并操作
  void split1(Re &p,Re q,Re L,Re R,Re k) — 分裂操作
  void split2(Re &p,Re q,Re L,Re R,Re k) — 分裂操作
  void dfs(Re p,Re L,Re R) — 深度优先搜索遍历
  IT split(Re w) — 分裂操作

核心结构体：QAQ, Segment_Tree, QAQ

关键配置：
N=1e5+3

复杂度：建树 O(N)，单次操作 O(log N)

说明：freopen("123.txt","r",stdin);

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<set>
#define LL long long
#define Re register int
#define IT set<QAQ>::iterator
using namespace std;
const int N=1e5+3;
int n,m,l,r,T,op,A[N],tmp[N],cnt[N],Ans[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct QAQ{
	int l,r;mutable int pt,op; 
	QAQ(Re L=0,Re R=0,Re OP=0,Re PT=0){l=L,r=R,op=OP,pt=PT;};
	inline bool operator<(const QAQ &O)const{return l<O.l;}
};
set<QAQ>s;
struct Segment_Tree{
	#define pl tr[p].lp
	#define pr tr[p].rp
	#define mid ((L+R)>>1)
	int O;
	struct QAQ{int S,lp,rp;}tr[N*60];
	inline void pushup(Re p){tr[p].S=tr[pl].S+tr[pr].S;}
	inline void change(Re &p,Re L,Re R,Re x){
		p=++O;
		if(L==R){tr[p].S=1;return;}
		if(x<=mid)change(pl,L,mid,x);
		else change(pr,mid+1,R,x);
		pushup(p);
	}
	inline int merge(Re p,Re q,Re L,Re R){
		if(!p||!q)return p+q;
		if(L==R){tr[p].S+=tr[q].S;return p;}
		pl=merge(pl,tr[q].lp,L,mid);
		pr=merge(pr,tr[q].rp,mid+1,R);
		pushup(p);return p;
	}
	inline void split1(Re &p,Re q,Re L,Re R,Re k){// 取q中的前k个,分到新节点p
		tr[p=++O].S=tr[q].S-k,tr[q].S=k;
		if(L==R)return;
		Re tmp=tr[tr[q].lp].S;
		if(k>tmp)split1(pr,tr[q].rp,mid+1,R,k-tmp);// q左子树全部分给p,只剩右子树
		else pr=tr[q].rp,tr[q].rp=0;// 右子树全部分给p
		if(k<tmp)split1(pl,tr[q].lp,L,mid,k);// q的右子树全部分给p,只剩左子树
	}
	inline void split2(Re &p,Re q,Re L,Re R,Re k){// 取q中的后k个,分到新节点p
		tr[p=++O].S=tr[q].S-k,tr[q].S=k;
		if(L==R)return;
		Re tmp=tr[tr[q].rp].S;
		if(k>tmp)split2(pl,tr[q].lp,L,mid,k-tmp);// q的右子树全部分给p,只剩左子树
		else pl=tr[q].lp,tr[q].lp=0;// 左子树全部分给p
		if(k<tmp)split2(pr,tr[q].rp,mid+1,R,k);// q左子树全部分给p,只剩右子树
	}
	inline void dfs(Re p,Re L,Re R){
		if(!p)return;
		if(L==R){cnt[tmp[++tmp[0]]=L]=tr[p].S;return;}
		dfs(pl,L,mid),dfs(pr,mid+1,R);
	}
}T1;
inline IT split(Re w){
	IT it=s.lower_bound(QAQ(w));
	if(it!=s.end()&&it->l==w)return it;
	--it;
	Re L=it->l,R=it->r,op=it->op,pt=it->pt,ptt=0;
	s.erase(it);
	if(op)T1.split1(ptt,pt,1,m,w-1-L+1);
	else T1.split2(ptt,pt,1,m,w-1-L+1);
	s.insert(QAQ(L,w-1,op,pt));
	return s.insert(QAQ(w,R,op,ptt)).first;
}
inline void assign(Re l,Re r,Re op){
	if(l==r)return;
	IT itr=split(r+1),itl=split(l),it=itl;
	Re pt=0;
	while(it!=itr)pt=T1.merge(pt,it->pt,1,m),it->pt=0,++it;
	s.erase(itl,itr),s.insert(QAQ(l,r,op,pt));
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T),m=n;
	for(Re i=1;i<=n;++i)in(A[i]);
	s.insert(QAQ(n+1,n+1));
	for(Re i=1;i<=n;++i){
		QAQ tmp(i,i,0,0);T1.change(tmp.pt,1,m,A[i]),s.insert(tmp);
	}
	while(T--)in(op),in(l),in(r),op^=1,assign(l,r,op);
	IT itl=s.lower_bound(QAQ(1)),itr=s.lower_bound(QAQ(n+1));
	while(itl!=itr){
		tmp[0]=0,T1.dfs(itl->pt,1,m);
		if(itl->op)for(Re i=1;i<=tmp[0];++i)
			for(Re j=1;j<=cnt[tmp[i]];++j)
				Ans[++Ans[0]]=tmp[i];
		else for(Re i=tmp[0];i>=1;--i)
			for(Re j=1;j<=cnt[tmp[i]];++j)
				Ans[++Ans[0]]=tmp[i];
		++itl;
	}
	in(op),printf("%d\n",Ans[op]);
}

```

**线段树分裂-分裂指定区间** *(mid)*

> 【线段树分裂-分裂指定区间】
线段树（Segment Tree）模板，支持区间操作的高效数据结构。

核心函数：
  void in(Re &x) — 核心算法函数
  void pushup(Re p) — 上推更新节点信息
  void build(Re &p,Re L,Re R) — 构建数据结构（建树/建图）
  void change(Re &p,Re L,Re R,Re x,Re v) — 核心算法函数
  LL ask(Re p,Re L,Re R,Re l,Re r) — 核心算法函数
  int ask(Re p,Re L,Re R,LL k) — 核心算法函数
  int merge(Re p,Re q,Re L,Re R) — 合并操作
  void split(Re &p,Re &q,Re L,Re R,Re l,Re r) — 分裂操作

核心结构体：Segment_Tree, QAQ

关键配置：
N=2e5+3

复杂度：建树 O(N)，单次操作 O(log N)

说明：freopen("123.txt","r",stdin);

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=2e5+3;
int n,m,x,y,p,T,op,A[N],pt[N];LL K;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Segment_Tree{
	#define pl tr[p].lp
	#define pr tr[p].rp
	#define mid ((L+R)>>1)
	int O;
	struct QAQ{int lp,rp;LL S;}tr[N*20];
	inline void pushup(Re p){tr[p].S=tr[pl].S+tr[pr].S;}
	inline void build(Re &p,Re L,Re R){
		p=++O;
		if(L==R){tr[p].S=A[L];return;}
		build(pl,L,mid),build(pr,mid+1,R);
		pushup(p);
	}
	inline void change(Re &p,Re L,Re R,Re x,Re v){
		if(!p)p=++O;
		if(L==R){tr[p].S+=v;return;}
		if(x<=mid)change(pl,L,mid,x,v);
		else change(pr,mid+1,R,x,v);
		pushup(p);
	}
	inline LL ask(Re p,Re L,Re R,Re l,Re r){
		if(!p)return 0;
		if(l<=L&&R<=r)return tr[p].S;
		LL ans=0;
		if(l<=mid)ans+=ask(pl,L,mid,l,r);
		if(r>mid)ans+=ask(pr,mid+1,R,l,r);
		return ans;
	}
	inline int ask(Re p,Re L,Re R,LL k){
		if(!p||k>tr[p].S)return -1;
		if(L==R)return L;
		LL tmp=tr[pl].S;
		if(tmp>=k)return ask(pl,L,mid,k);
		else return ask(pr,mid+1,R,k-tmp);
	}
	inline int merge(Re p,Re q,Re L,Re R){
		if(!p||!q)return p+q;
		if(L==R){tr[p].S+=tr[q].S;return p;}
		pl=merge(pl,tr[q].lp,L,mid);
		pr=merge(pr,tr[q].rp,mid+1,R);
		pushup(p);return p;
	}
	inline void split(Re &p,Re &q,Re L,Re R,Re l,Re r){
		if(!q)return;
		if(l<=L&&R<=r){p=q,q=0;return;}
		p=++O;
		if(l<=mid)split(pl,tr[q].lp,L,mid,l,r);
		if(r>mid)split(pr,tr[q].rp,mid+1,R,l,r);
		pushup(p),pushup(q);
	}
}T1;
int main(){
//	freopen("123.txt","r",stdin);
	in(m),in(T);
	for(Re i=1;i<=m;++i)in(A[i]);
	T1.build(pt[n=1],1,m);
	while(T--){
		in(op),in(p);
		if(op<1)in(x),in(y),T1.split(pt[++n],pt[p],1,m,x,y);
		else if(op<2)in(x),pt[p]=T1.merge(pt[p],pt[x],1,m),pt[x]=0;
		else if(op<3)in(x),in(y),T1.change(pt[p],1,m,y,x);
		else if(op<4)in(x),in(y),printf("%lld\n",T1.ask(pt[p],1,m,x,y));
		else scanf("%lld",&K),printf("%d\n",T1.ask(pt[p],1,m,K));
	}
}

```

**线段树合并** *(晋升者计数)*

> 【线段树合并（晋升者计数）】
线段树（Segment Tree）模板，支持区间操作的高效数据结构。

核心函数：
  void add(Re x,Re y) — 加法更新
  void in(Re &x) — 核心算法函数
  void pushup(Re p) — 上推更新节点信息
  void change(Re &p,Re L,Re R,Re x) — 核心算法函数
  int merge(Re p,Re q,Re L,Re R) — 合并操作
  int ask(Re &p,Re L,Re R,Re l,Re r) — 核心算法函数
  void dfs(Re x,Re fa) — 深度优先搜索遍历

核心结构体：QAQ, Segment_Tree, QAQ

关键配置：
N=1e5+3,logN=17

复杂度：建树 O(N)，单次操作 O(log N)

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#include<algorithm>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=1e5+3,logN=17;
int n,m,x,o,T,op,b[N],A[N],Ans[N],head[N];
struct QAQ{int to,next;}a[N];
inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
int pt[N];
struct Segment_Tree{
    #define pl (tr[p].lp)
    #define pr (tr[p].rp)
    #define mid ((L+R)>>1)
    int O;
    struct QAQ{int lp,rp,S;}tr[N*(logN+1)];
    inline void pushup(Re p){tr[p].S=tr[pl].S+tr[pr].S;}
    inline void change(Re &p,Re L,Re R,Re x){
        p=++O,++tr[p].S;
        if(L==R)return;
        if(x<=mid)change(pl,L,mid,x);
        else change(pr,mid+1,R,x);
    }
    inline int merge(Re p,Re q,Re L,Re R){
        if(!p||!q)return p+q;
        if(L==R){tr[p].S+=tr[q].S;return p;}
        pl=merge(pl,tr[q].lp,L,mid);
        pr=merge(pr,tr[q].rp,mid+1,R);
        pushup(p);return p;
    }
    inline int ask(Re &p,Re L,Re R,Re l,Re r){
        if(!p)return 0;
        if(l<=L&&R<=r)return tr[p].S;
        Re ans=0;
        if(l<=mid)ans+=ask(pl,L,mid,l,r);
        if(r>mid)ans+=ask(pr,mid+1,R,l,r);
        return ans;
    }
}TR;
inline void dfs(Re x,Re fa){
    TR.change(pt[x],1,m,A[x]);
    for(Re i=head[x],to;i;i=a[i].next)
        dfs(to=a[i].to,x),pt[x]=TR.merge(pt[x],pt[to],1,m);
    if(A[x]<m)Ans[x]=TR.ask(pt[x],1,m,A[x]+1,m);
}
int main(){
    in(n);
    for(Re i=1;i<=n;++i)in(A[i]),b[i]=A[i];
    sort(b+1,b+n+1),m=unique(b+1,b+n+1)-b-1;
    for(Re i=1;i<=n;++i)A[i]=lower_bound(b+1,b+m+1,A[i])-b;
    for(Re i=2;i<=n;++i)in(x),add(x,i);
    dfs(1,0);
    for(Re i=1;i<=n;++i)printf("%d\n",Ans[i]);
}

```

**超哥线段树** *(Blue Mary开公司)*

> 【超哥线段树（Blue Mary开公司）】
线段树（Segment Tree）模板，支持区间操作的高效数据结构。

核心函数：
  void in(Re &x) — 核心算法函数
  LD y(Re id,Re x) — 核心算法函数
  void change(Re p,Re L,Re R,Re id) — 核心算法函数
  LD ask(Re p,Re L,Re R,Re x) — 核心算法函数

核心结构体：Segment_Tree

关键配置：
N=1e5+3,M=5e4

复杂度：建树 O(N)，单次操作 O(log N)

说明：if(L==R){if(y(id,L)>y(tr[p],L))tr[p]=id;return;}；freopen("123.txt","r",stdin);

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LD double
#define LL long long
#define Re register int
using namespace std;
const int N=1e5+3,M=5e4;
int n,x,T;LD b[N],k[N];char s[20];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline LD y(Re id,Re x){return k[id]*x+b[id];}
struct Segment_Tree{
	#define pl (p<<1)
	#define pr (p<<1|1)
	#define mid ((L+R)>>1)
	int tr[N<<2];
	inline void change(Re p,Re L,Re R,Re id){
		if(y(id,L)>y(tr[p],L)&&y(id,R)>y(tr[p],R)){tr[p]=id;return;}
		if(y(id,L)<=y(tr[p],L)&&y(id,R)<=y(tr[p],R))return;
//		if(L==R){if(y(id,L)>y(tr[p],L))tr[p]=id;return;}
		if(k[tr[p]]<k[id]){
			if(y(id,mid+1)>y(tr[p],mid+1))change(pl,L,mid,tr[p]),tr[p]=id;
			else change(pr,mid+1,R,id);
		}
		else{
			if(y(id,mid)>y(tr[p],mid))change(pr,mid+1,R,tr[p]),tr[p]=id;
			else change(pl,L,mid,id);
		}
	}
	inline LD ask(Re p,Re L,Re R,Re x){
		if(L==R)return y(tr[p],x);
		LD ans=y(tr[p],x);
		if(x<=mid)return max(ans,ask(pl,L,mid,x));
		else return max(ans,ask(pr,mid+1,R,x));
	}
}TR;
int main(){
//	freopen("123.txt","r",stdin);
	in(T);
	while(T--){
		scanf("%s",s);
        if(s[0]=='P')++n,scanf("%lf%lf",&b[n],&k[n]),TR.change(1,1,M,n);
        else in(x),printf("%d\n",(int)(TR.ask(1,1,M,x-1)/100));
	}
}

```

**二逼平衡树** *(树套树(有注释)*

> 【二逼平衡树（树套树(有注释）】
线段树（Segment Tree）模板，支持区间操作的高效数据结构。

核心函数：
  void in(Re &x) — 核心算法函数
  int ask_kth(Re L,Re R,Re k) — 核心算法函数
  int ask_kth_pre(Re L,Re R,Re k) — 预处理函数
  void add(Re &p,Re L,Re R,Re w,Re v) — 加法更新
  void add_pre(Re x,Re v) — 加法更新
  int ask_level(Re p,Re L,Re R,Re x) — 核心算法函数
  int ask_level_pre(Re L,Re R,Re w) — 预处理函数
   F(i,1,T) — 核心算法函数

核心结构体：QAQ, O_O, T_T

关键配置：
N=1e5+3,inf=2147483647

复杂度：建树 O(N)，单次操作 O(log N)

说明：printf("%lf\n",(sizeof(tree))/1024.0/1024.0);；�������λ����ԭ����������һ�����������ֺ��ٰ�������һ�����ʹﵽ���滻��Ŀ��

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
#include<algorithm>
#include<cstring>
#include<cstdio>
#define mid (L+R>>1)
#define Re register int
#define pl tree[p].lp
#define pr tree[p].rp
#define F(i,a,b) for(Re i=a;i<=b;++i)
#define lo(o) lower_bound(b+1,b+m+1,o)-b
using namespace std;
const int N=1e5+3,inf=2147483647;
int x,y,z,n,m,T,t,fu,cnt,tl,tr,a[N],b[N],pt[N],C[N],opt[N],ptl[20],ptr[20]; 
struct QAQ{int g,lp,rp;}tree[N*250];
struct O_O{int l,r,k;}Q[N];
struct T_T{int i,x;}c[N];
inline void in(Re &x){
    x=fu=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
inline int ask_kth(Re L,Re R,Re k){
    if(L==R)return b[R];
    Re tmp=0;
    F(i,1,tl)tmp-=tree[tree[ptl[i]].lp].g;
    F(i,1,tr)tmp+=tree[tree[ptr[i]].lp].g;
    if(tmp>=k){
    	F(i,1,tl)ptl[i]=tree[ptl[i]].lp;
    	F(i,1,tr)ptr[i]=tree[ptr[i]].lp;
    	return ask_kth(L,mid,k);
    }
    else{
    	F(i,1,tl)ptl[i]=tree[ptl[i]].rp;
    	F(i,1,tr)ptr[i]=tree[ptr[i]].rp;
    	return ask_kth(mid+1,R,k-tmp);
    }
}
inline int ask_kth_pre(Re L,Re R,Re k){
    tl=tr=0;
    for(Re i=L-1;i;i-=i&-i)ptl[++tl]=pt[i];
    for(Re i=R;i;i-=i&-i)ptr[++tr]=pt[i];
    return ask_kth(1,m,k);
}
inline void add(Re &p,Re L,Re R,Re w,Re v){
    if(!p)p=++cnt;tree[p].g+=v;
    if(L==R)return;
    if(w<=mid)add(pl,L,mid,w,v);
    else add(pr,mid+1,R,w,v);
}
inline void add_pre(Re x,Re v){
    Re w=lo(a[x]);
    for(Re i=x;i<=n;i+=i&-i)add(pt[i],1,m,w,v);
}
inline int ask_level(Re p,Re L,Re R,Re x){
	if(L==R)return tree[p].g; 
	if(x<=mid)return ask_level(pl,L,mid,x);
	else return tree[pl].g+ask_level(pr,mid+1,R,x);
}
inline int ask_level_pre(Re L,Re R,Re w){
	Re ans=0;
    for(Re i=R;i;i-=i&-i)ans+=ask_level(pt[i],1,m,w);
    for(Re i=L-1;i;i-=i&-i)ans-=ask_level(pt[i],1,m,w);
    return ans;
}
int main(){
//	printf("%lf\n",(sizeof(tree))/1024.0/1024.0);
//	printf("%lf\n",(sizeof(tree)+sizeof(Q)+sizeof(c)+sizeof(a)+sizeof(b)+sizeof(pt)+sizeof(C))/1024.0/1024.0);
	in(n),in(T),m=n;
    F(i,1,n)in(a[i]),b[i]=a[i];
    F(i,1,T){
    	in(opt[i]);
    	if(opt[i]==3)in(c[i].i),in(c[i].x),b[++m]=c[i].x;
    	else{
    		in(Q[i].l),in(Q[i].r),in(Q[i].k);
    		if(opt[i]!=2)b[++m]=Q[i].k;
		}
    }
    sort(b+1,b+m+1);
    m=unique(b+1,b+m+1)-b-1;
    F(i,1,n)add_pre(i,1);
    F(i,1,T){
    	if(opt[i]==1)
    		Q[i].k=lo(Q[i].k),
			printf("%d\n",ask_level_pre(Q[i].l,Q[i].r,Q[i].k-1)+1);

    	if(opt[i]==2)
    		printf("%d\n",ask_kth_pre(Q[i].l,Q[i].r,Q[i].k));

		if(opt[i]==3)
			add_pre(c[i].i,-1),a[c[i].i]=c[i].x,add_pre(c[i].i,1);

		if(opt[i]==4){
		}

		if(opt[i]==5){
		}
    }
}

```

**二逼平衡树 (无注释)** *(树套树)*

> 【二逼平衡树 (无注释)（树套树）】
线段树（Segment Tree）模板，支持区间操作的高效数据结构。

核心函数：
  void in(Re &x) — 核心算法函数
  int ask_kth(Re L,Re R,Re k) — 核心算法函数
  int ask_kth_pre(Re L,Re R,Re k) — 预处理函数
  void add(Re &p,Re L,Re R,Re w,Re v) — 加法更新
  void add_pre(Re x,Re v) — 加法更新
  int ask_level(Re p,Re L,Re R,Re x) — 核心算法函数
  int ask_level_pre(Re L,Re R,Re w) — 预处理函数
   F(i,1,T) — 核心算法函数

核心结构体：QAQ, O_O, T_T

关键配置：
N=1e5+3,inf=2147483647

复杂度：建树 O(N)，单次操作 O(log N)

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
#include<algorithm>
#include<cstring>
#include<cstdio>
#define mid (L+R>>1)
#define Re register int
#define pl tree[p].lp
#define pr tree[p].rp
#define F(i,a,b) for(Re i=a;i<=b;++i)
#define lo(o) lower_bound(b+1,b+m+1,o)-b
using namespace std;
const int N=1e5+3,inf=2147483647;
int x,y,z,n,m,T,t,fu,cnt,tl,tr,a[N],b[N],pt[N],C[N],opt[N],ptl[20],ptr[20]; 
struct QAQ{int g,lp,rp;}tree[N*250];
struct O_O{int l,r,k;}Q[N];
struct T_T{int i,x;}c[N];
inline void in(Re &x){
    x=fu=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
inline int ask_kth(Re L,Re R,Re k){
    if(L==R)return b[R];
    Re tmp=0;
    F(i,1,tl)tmp-=tree[tree[ptl[i]].lp].g;
    F(i,1,tr)tmp+=tree[tree[ptr[i]].lp].g;
    if(tmp>=k){
    	F(i,1,tl)ptl[i]=tree[ptl[i]].lp;
    	F(i,1,tr)ptr[i]=tree[ptr[i]].lp;
    	return ask_kth(L,mid,k);
    }
    else{
    	F(i,1,tl)ptl[i]=tree[ptl[i]].rp;
    	F(i,1,tr)ptr[i]=tree[ptr[i]].rp;
    	return ask_kth(mid+1,R,k-tmp);
    }
}
inline int ask_kth_pre(Re L,Re R,Re k){
    tl=tr=0;
    for(Re i=L-1;i;i-=i&-i)ptl[++tl]=pt[i];
    for(Re i=R;i;i-=i&-i)ptr[++tr]=pt[i];
    return ask_kth(1,m,k);
}
inline void add(Re &p,Re L,Re R,Re w,Re v){
    if(!p)p=++cnt;tree[p].g+=v;
    if(L==R)return;
    if(w<=mid)add(pl,L,mid,w,v);
    else add(pr,mid+1,R,w,v);
}
inline void add_pre(Re x,Re v){
    Re w=lo(a[x]); 
    for(Re i=x;i<=n;i+=i&-i)add(pt[i],1,m,w,v);
}
inline int ask_level(Re p,Re L,Re R,Re x){
	if(L==R)return tree[p].g; 
	if(x<=mid)return ask_level(pl,L,mid,x);
	else return tree[pl].g+ask_level(pr,mid+1,R,x);
}
inline int ask_level_pre(Re L,Re R,Re w){
	Re ans=0;
    for(Re i=R;i;i-=i&-i)ans+=ask_level(pt[i],1,m,w);
    for(Re i=L-1;i;i-=i&-i)ans-=ask_level(pt[i],1,m,w);
    return ans;
}
int main(){
	in(n),in(T),m=n;
    F(i,1,n)in(a[i]),b[i]=a[i];
    F(i,1,T){
    	in(opt[i]);
    	if(opt[i]==3)in(c[i].i),in(c[i].x),b[++m]=c[i].x;
    	else{
    		in(Q[i].l),in(Q[i].r),in(Q[i].k);
    		if(opt[i]!=2)b[++m]=Q[i].k;
		}
    }
    sort(b+1,b+m+1),m=unique(b+1,b+m+1)-b-1;
    F(i,1,n)add_pre(i,1);
    F(i,1,T){
    	if(opt[i]==1)Q[i].k=lo(Q[i].k),printf("%d\n",ask_level_pre(Q[i].l,Q[i].r,Q[i].k-1)+1);
    	if(opt[i]==2)printf("%d\n",ask_kth_pre(Q[i].l,Q[i].r,Q[i].k));
		if(opt[i]==3)add_pre(c[i].i,-1),a[c[i].i]=c[i].x,add_pre(c[i].i,1);
		if(opt[i]==4){
			Re level=ask_level_pre(Q[i].l,Q[i].r,lo(Q[i].k)-1);
			if(!level)printf("%d\n",-inf);
			else printf("%d\n",ask_kth_pre(Q[i].l,Q[i].r,level));
		}
		if(opt[i]==5){
			Re level=ask_level_pre(Q[i].l,Q[i].r,lo(Q[i].k));
			if(level==Q[i].r-Q[i].l+1)printf("%d\n",inf);
			else printf("%d\n",ask_kth_pre(Q[i].l,Q[i].r,level+1));
		}
    }
}

```

**整体DP** *(Minimax)*

> 【整体DP（Minimax）】
带懒标记的线段树模板，支持区间修改与区间查询。

核心函数：
  void in(Re &x) — 核心算法函数
  int mi(Re x,Re k) — 核心算法函数
  int inv(Re x) — 求模逆元
  void pushup(Re p) — 上推更新节点信息
  void updata(Re p,Re v) — 核心算法函数
  void pushdown(Re p) — 下传懒标记
  void change(Re &p,Re L,Re R,Re x,Re v) — 核心算法函数
  int merge(Re p,Re q,Re pv,Re qv,Re v) — 合并操作

核心结构体：Segment_Tree, QAQ

关键配置：
N=3e5+3,P=998244353

复杂度：建树 O(N)，单次操作 O(log N)

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=3e5+3,P=998244353;
int n,m,x,ans,inv1e4,f[N],b[N],p[N],A[N],fa[N],ch[N][3];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline int mi(Re x,Re k){
	Re s=1;
	while(k){
		if(k&1)s=(LL)s*x%P;
		x=(LL)x*x%P,k>>=1;
	}
	return s;
}
inline int inv(Re x){return mi(x,P-2);}
int pt[N];
struct Segment_Tree{
	#define pl tr[p].lp
	#define pr tr[p].rp
	#define mid ((L+R)>>1)
	int O;
	struct QAQ{int S,lp,rp,mul;}tr[N*19];
	inline void pushup(Re p){
		tr[p].S=(tr[pl].S+tr[pr].S)%P;
	}
	inline void updata(Re p,Re v){
		tr[p].S=(LL)tr[p].S*v%P,tr[p].mul=(LL)tr[p].mul*v%P;
	}
	inline void pushdown(Re p){
		if(tr[p].mul!=1)updata(pl,tr[p].mul),updata(pr,tr[p].mul),tr[p].mul=1;
	}
	inline void change(Re &p,Re L,Re R,Re x,Re v){
		if(!p)p=++O;tr[p].mul=1;
		if(L==R){tr[p].S=v;return;}
		pushdown(p);
		if(x<=mid)change(pl,L,mid,x,v);
		else change(pr,mid+1,R,x,v);
		pushup(p);
	}
	inline int merge(Re p,Re q,Re pv,Re qv,Re v){
//		printf("pv=%d, qv=%d, v=%d\n",pv,qv,v);
		if(!p&&!q)return 0;
		if(!p){updata(q,qv);return q;}
		if(!q){updata(p,pv);return p;}
		pushdown(p),pushdown(q);
		Re plS=tr[pl].S,prS=tr[pr].S,qlS=tr[tr[q].lp].S,qrS=tr[tr[q].rp].S;
//		printf("p:%d,%d q:%d,%d\n",tr[pl].S,tr[pr].S,tr[tr[q].lp].S,tr[tr[q].rp].S);
		pl=merge(pl,tr[q].lp,(pv+(1-v+P)%P*1ll*qrS%P)%P,(qv+(1-v+P)%P*1ll*prS%P)%P,v);
		pr=merge(pr,tr[q].rp,(pv+(LL)v*qlS%P)%P,(qv+(LL)v*plS%P)%P,v);
		pushup(p);
		return p;
	}
	inline void dfs_(Re p,Re L,Re R){
		if(!p)return;
		if(L==R){f[L]=tr[p].S;return;}
		pushdown(p),dfs_(pl,L,mid),dfs_(pr,mid+1,R);
	}
	inline int ask(Re p,Re L,Re R,Re x){
		if(!p)return 0;
		if(L==R)return tr[p].S;
		pushdown(p);
		if(x<=mid)return ask(pl,L,mid,x);
		else return ask(pr,mid+1,R,x);
	}
}T1;
inline void dfs(Re x){
	if(!ch[x][0])T1.change(pt[x],1,m,A[x],1);
	else{
//		printf("x=%d:\n",x);
//		for(Re i=1;i<=m;++i)printf("%d ",T1.ask(pt[x],1,m,i));puts("");
		dfs(ch[x][1]);
		if(ch[x][0]<2)pt[x]=pt[ch[x][1]];
		else dfs(ch[x][2]),pt[x]=T1.merge(pt[ch[x][1]],pt[ch[x][2]],0,0,p[x]);
//		printf("x=%d:\n",x);
//		for(Re i=1;i<=m;++i)printf("%d ",T1.ask(pt[x],1,m,i));puts("");
	}
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),inv1e4=inv(10000);
	for(Re i=1;i<=n;++i)in(fa[i]),ch[fa[i]][++ch[fa[i]][0]]=i;
	for(Re i=1;i<=n;++i)
		if(ch[i][0])in(p[i]),p[i]=(LL)p[i]*inv1e4%P;
		else in(x),b[++m]=A[i]=x;
	sort(b+1,b+m+1);
	for(Re i=1;i<=n;++i)if(!ch[i][0])A[i]=lower_bound(b+1,b+m+1,A[i])-b;
//	for(Re i=1;i<=n;++i)if(!ch[i][0])printf("%d: %d\n",i,A[i]);
	dfs(1),T1.dfs_(1,1,m);
//	for(Re i=1;i<=m;++i)printf("%d ",f[i]);puts("");
	for(Re i=1;i<=m;++i)(ans+=(LL)i*b[i]%P*f[i]%P*f[i]%P)%=P;
	printf("%d\n",ans);
}

```

**普通平衡树** *(线段树)*

> 【普通平衡树（线段树）】
线段树（Segment Tree）模板，支持区间操作的高效数据结构。

核心函数：
  void in(Re &x) — 核心算法函数
  int ask_kth(Re p,Re L,Re R,Re k) — 核心算法函数
  void add(Re &p,Re L,Re R,Re w,Re v) — 加法更新
  int ask_level(Re p,Re L,Re R,Re x) — 核心算法函数
   F(i,1,T) — 核心算法函数
   F(i,1,T) — 核心算法函数

核心结构体：QAQ

关键配置：
N=1e5+3,inf=2147483647

复杂度：建树 O(N)，单次操作 O(log N)

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
#include<algorithm>
#include<cstring>
#include<cstdio>
#define mid (L+R>>1)
#define Re register int
#define pl tree[p].lp
#define pr tree[p].rp
#define F(i,a,b) for(Re i=a;i<=b;++i)
#define lo(o) lower_bound(b+1,b+m+1,o)-b
using namespace std;
const int N=1e5+3,inf=2147483647;
int m,T,t,fu,cnt,root,a[N],b[N],Q[N],opt[N]; 
struct QAQ{int g,lp,rp;}tree[N<<1];
inline void in(Re &x){
    x=fu=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
inline int ask_kth(Re p,Re L,Re R,Re k){
	if(L==R)return b[R];
    Re tmp=tree[pl].g;
    if(tmp>=k)return ask_kth(pl,L,mid,k);
    else return ask_kth(pr,mid+1,R,k-tmp);
}
inline void add(Re &p,Re L,Re R,Re w,Re v){
    if(!p)p=++cnt;tree[p].g+=v;
    if(L==R)return;
    if(w<=mid)add(pl,L,mid,w,v);
    else add(pr,mid+1,R,w,v);
}
inline int ask_level(Re p,Re L,Re R,Re x){
	if(!x)return 0;
	if(L==R)return tree[p].g;
	if(x<=mid)return ask_level(pl,L,mid,x);
	else return tree[pl].g+ask_level(pr,mid+1,R,x);
}
int main(){
	in(T); 
    F(i,1,T){
    	in(opt[i]),in(Q[i]);
    	if(opt[i]!=4)b[++m]=Q[i];
    }
    sort(b+1,b+m+1),m=unique(b+1,b+m+1)-b-1;
    F(i,1,T){
    	if(opt[i]==1)add(root,1,m,lo(Q[i]),1);
    	if(opt[i]==2)add(root,1,m,lo(Q[i]),-1);
		if(opt[i]==3)printf("%d\n",ask_level(root,1,m,lo(Q[i])-1)+1);
		if(opt[i]==4)printf("%d\n",ask_kth(root,1,m,Q[i]));
		if(opt[i]==5){
			Re level=ask_level(root,1,m,lo(Q[i])-1);
			printf("%d\n",ask_kth(root,1,m,level));
		}
		if(opt[i]==6){
			Re level=ask_level(root,1,m,lo(Q[i]));
			printf("%d\n",ask_kth(root,1,m,level+1));
		}
    }
}

```

**线段树分治 (冰茶姬+线性基 查询两点最短异或和路径) (Shortest Path Queries)** *(时间分治)*

> 【线段树分治 (冰茶姬+线性基 查询两点最短异或和路径) (Shortest Path Queries)（时间分治）】
线段树（Segment Tree）模板，支持区间操作的高效数据结构。

核心函数：
  void in(Re &x) — 核心算法函数
  int find(Re x) — 查找（并查集寻根/二分查找）
  int Dis(Re x) — 核心算法函数
  void merge(Re x,Re y,Re w) — 合并操作
  void back(Re to) — 获取队尾元素
  void insert(Re x) — 插入元素
  int ask(Re x) — 核心算法函数
  void back(Re to) — 获取队尾元素

核心结构体：Union, BK, Line_JI, QAQ, Segment_Tree

关键配置：
N=2e5+3,logN=30

复杂度：建树 O(N)，单次操作 O(log N)

说明：freopen("123.txt","r",stdin);

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<stack>
#include<map>
#define LL long long
#define Re register int
#define mp make_pair
using namespace std;
const int N=2e5+3,logN=30;
int x,y,n,m,T,op,X[N],Y[N],OP[N];LL Ans[N];map<pair<int,int>,int>last,z;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Union{// 冰茶姬（并查集）
	struct BK{int x,y,dx,dy,sx,sy;BK(Re X=0,Re d1=0,Re S1=0,Re Y=0,Re d2=0,Re S2=0){x=X,y=Y,sx=S1,sy=S2,dx=d1,dy=d2;}};
	int fa[N],dis[N],size[N];stack<BK>Q;
	inline int find(Re x){return fa[x]==x?x:find(fa[x]);}
	inline int Dis(Re x){return fa[x]==x?0:dis[x]^Dis(fa[x]);}
	inline void merge(Re x,Re y,Re w){// 启发式合并
		if(size[x]>size[y])swap(x,y);
		Q.push(BK(x,dis[x],size[x],y,dis[y],size[y]));
		fa[x]=y,dis[x]=w,size[y]+=size[x];
	}
	inline void back(Re to){// 撤销操作
		while(int(Q.size())>to){
			BK a=Q.top();Re x=a.x,y=a.y;Q.pop();
			fa[x]=x,dis[x]=a.dx,size[x]=a.sx;
			fa[y]=y,dis[y]=a.dy,size[y]=a.sy;
		}
	}
}TF;
struct Line_JI{
	int p[31];stack<int>Q;
	inline void insert(Re x){
		for(Re i=logN;i>=0;--i)
			if((x>>i)&1){
				if(!p[i]){p[i]=x,Q.push(i);break;}
				x^=p[i];
			}
	}
	inline int ask(Re x){for(Re i=logN;i>=0;--i)if(p[i])x=min(x,x^p[i]);return x;}
	inline void back(Re to){
		while(int(Q.size())>to)p[Q.top()]=0,Q.pop();
	}
}JI;
int o,head[N<<2];
struct QAQ{int x,y,w,next;}a[N*50];
inline void add(Re x,Re y1,Re y2,Re w){a[++o].w=w,a[o].x=y1,a[o].y=y2,a[o].next=head[x],head[x]=o;}
struct Segment_Tree{
	#define pl (p<<1)
	#define pr (p<<1|1)
	#define mid ((L+R)>>1)
	inline void change(Re p,Re L,Re R,Re l,Re r,Re x,Re y,Re v){
		if(l>r)return;
		if(l<=L&&R<=r){add(p,x,y,v);return;}
		if(l<=mid)change(pl,L,mid,l,r,x,y,v);
		if(r>mid)change(pr,mid+1,R,l,r,x,y,v);
	}
	inline void dfs(Re p,Re L,Re R){
		Re tmp1=TF.Q.size(),tmp2=JI.Q.size();
		for(Re i=head[p];i;i=a[i].next){
			Re x=TF.find(a[i].x),y=TF.find(a[i].y),w=TF.Dis(a[i].x)^TF.Dis(a[i].y)^a[i].w;
			if(x!=y)TF.merge(x,y,w);
			else JI.insert(w);
		}
		if(L==R){if(OP[L])Ans[L]=JI.ask(TF.Dis(X[L])^TF.Dis(Y[L]));}
		else dfs(pl,L,mid),dfs(pr,mid+1,R);
		TF.back(tmp1),JI.back(tmp2);
	}
}T1;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(m);
	for(Re i=1;i<=n;++i)TF.fa[i]=i,TF.size[i]=1;
	for(Re i=1;i<=m;++i){
		in(x),in(y);if(x>y)swap(x,y);
		in(z[mp(x,y)]),last[mp(x,y)]=1;
	}
	in(T);
	for(Re i=1;i<=T;++i){
		in(op),in(x),in(y);if(x>y)swap(x,y);
		if(op<2)in(z[mp(x,y)]),last[mp(x,y)]=i;
		else if(op<3)T1.change(1,1,T,last[mp(x,y)],i-1,x,y,z[mp(x,y)]),last.erase(last.find(mp(x,y)));
		else OP[i]=1,X[i]=x,Y[i]=y;
	}
	for(map<pair<int,int>,int>::iterator it=last.begin();it!=last.end();++it)
		T1.change(1,1,T,it->second,T,it->first.first,it->first.second,z[it->first]);
	T1.dfs(1,1,T);
	for(Re i=1;i<=T;++i)if(OP[i])printf("%lld\n",Ans[i]);
}

```

**线段树分治 (可持久化Trie+CDQ) (火星商店问题)** *(时间分治)*

> 【线段树分治 (可持久化Trie+CDQ) (火星商店问题)（时间分治）】
可持久化线段树（主席树）模板，通过动态开点维护历史版本。

核心函数：
  void in(Re &x) — 核心算法函数
  void insert(Re p,Re q,Re o,Re x) — 插入元素
  int ask(Re p,Re q,Re o,Re x) — 核心算法函数
  void change(Re p,Re L,Re R,Re l,Re r,Query &v) — 核心算法函数
  int find1(Re l,Re r,Re id) — 查找（并查集寻根/二分查找）
  int find2(Re l,Re r,Re id) — 查找（并查集寻根/二分查找）
  void CDQ(Re p,Re L,Re R,Re l,Re r) — 核心算法函数

核心结构体：Change, Query, Trie, Segment_Tree

关键配置：
N=1e5+3,logN=18

复杂度：建树 O(N)，单次操作 O(log N)

说明：freopen("123.txt","r",stdin);

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<vector>
#define LL long long
#define Re register int
using namespace std;
const int N=1e5+3,logN=18;
int n,x,y,z,w,op,m1,m2,T,A[N],t1[N],t2[N],Ans[N];
struct Change{int i,v,t;inline bool operator<(const Change &O)const{return i<O.i;}}C[N],tmp[N];
struct Query{int x,l,r,id;}Q[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
int pt[N];
struct Trie{
	int O,cnt[N*(logN+2)],tr[N*(logN+2)][2];
	inline void insert(Re p,Re q,Re o,Re x){
		if(o<0)return;Re i=(x>>o)&1;
		tr[p][i]=++O,tr[p][i^1]=tr[q][i^1];
		cnt[tr[p][i]]=cnt[tr[q][i]]+1;
		insert(tr[p][i],tr[q][i],o-1,x);
	}
	inline int ask(Re p,Re q,Re o,Re x){
		if(o<0)return 0;Re i=(x>>o)&1;
		if(cnt[tr[q][i^1]]>cnt[tr[p][i^1]])return (1<<o)+ask(tr[p][i^1],tr[q][i^1],o-1,x);
		else return ask(tr[p][i],tr[q][i],o-1,x);
	}
}T1;
struct Segment_Tree{
	#define pl (p<<1)
	#define pr (p<<1|1)
	#define mid ((L+R)>>1)
	vector<Query>tr[N<<2];
	inline void change(Re p,Re L,Re R,Re l,Re r,Query &v){
		if(l>r)return;
		if(l<=L&&R<=r){tr[p].push_back(v);return;}
		if(l<=mid)change(pl,L,mid,l,r,v);
		if(r>mid)change(pr,mid+1,R,l,r,v);
	}
	inline int find1(Re l,Re r,Re id){
		if(C[r].i<id)return r+1;
		while(l<r){
			Re Mid=l+r>>1;
			if(C[Mid].i>=id)r=Mid;
			else l=Mid+1;
		}
		return r;
	}
	inline int find2(Re l,Re r,Re id){
		if(C[r].i<=id)return r+1;
		while(l<r){
			Re Mid=l+r>>1;
			if(C[Mid].i>id)r=Mid;
			else l=Mid+1;
		}
		return r;
	}
	inline void CDQ(Re p,Re L,Re R,Re l,Re r){
		if(l>r)return;
		T1.O=pt[l-1]=0;
		for(Re i=l;i<=r;++i)T1.insert(pt[i]=++T1.O,pt[i-1],logN,C[i].v);
		for(vector<Query>::iterator it=tr[p].begin();it!=tr[p].end();++it){
			Re ll=find1(l,r,it->l)-1,rr=find2(l,r,it->r)-1;
			if(ll<rr)Ans[it->id]=max(Ans[it->id],T1.ask(pt[ll],pt[rr],logN,it->x));
		}
		if(L==R)return;
		Re p1=l-1;for(Re i=l;i<=r;++i)if(C[i].t<=mid)tmp[++p1]=C[i];
		Re p2=p1;for(Re i=l;i<=r;++i)if(C[i].t>mid)tmp[++p2]=C[i];
		for(Re i=l;i<=r;++i)C[i]=tmp[i];
		CDQ(pl,L,mid,l,p1),CDQ(pr,mid+1,R,p1+1,r);
	}
}TR;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T);
	for(Re i=1;i<=n;++i)in(A[i]),T1.insert(pt[i]=++T1.O,pt[i-1],logN,A[i]);
	for(Re i=1;i<=T;++i){
		in(op),in(x),in(y);
		if(!op)++m1,C[m1]=(Change){x,y,m1};
		else in(z),in(w),++m2,Q[m2]=(Query){z,x,y,m2},t1[m2]=max(1,m1-w+1),t2[m2]=m1;
	}
	for(Re i=1;i<=m2;++i)Ans[i]=T1.ask(pt[Q[i].l-1],pt[Q[i].r],logN,Q[i].x),TR.change(1,1,m1,t1[i],t2[i],Q[i]);
	sort(C+1,C+m1+1),TR.CDQ(1,1,m1,1,m1);
	for(Re i=1;i<=m2;++i)printf("%d\n",Ans[i]);
}

```

### 2.7 平衡树

**平衡树** *(BalancedBST)*

> 【平衡二叉搜索树（AVL 树）模板】
▪ TreeNode — 节点结构，维护 key（键值）、height（高度）、size（子树大小）、count（重复计数）
▪ getHeight(node) / getSize(node) — 获取节点高度/子树大小（空节点返回 0）
▪ updateNodeInfo(node) — 更新节点的高度和子树大小（插入/旋转后调用）
▪ getBalanceFactor(node) — 获取平衡因子（左高 - 右高），用于判断是否需要旋转
▪ rightRotate(y) / leftRotate(x) — 右旋/左旋操作，保持 AVL 平衡
▪ balanceNode(node) — 综合平衡调整（根据平衡因子选择 LL/LR/RR/RL 四种旋转）
所有操作（插入、删除、查找第 k 小/大、查询排名）均为 O(log N)。

```cpp
struct TreeNode {
    int key;
    TreeNode* left;
    TreeNode* right;
    int height; // 节点高度
    int size;   // 子树大小
    int count;  // 重复次数

    TreeNode(int value) 
        : key(value), height(1), size(1), count(1), left(nullptr), right(nullptr) {}
};

class BalancedBST {
private:
    TreeNode* root;

    // 获取节点高度
    int getHeight(TreeNode* node) const {
        return node ? node->height : 0;
    }

    // 获取节点子树大小
    int getSize(TreeNode* node) const {
        return node ? node->size : 0;
    }

    // 更新节点高度和大小
    void updateNodeInfo(TreeNode* node) const {
        if (node) {
            node->height = 1 + std::max(getHeight(node->left), getHeight(node->right));
            node->size = node->count + getSize(node->left) + getSize(node->right);
        }
    }

    // 获取平衡因子
    int getBalanceFactor(TreeNode* node) const {
        return node ? getHeight(node->left) - getHeight(node->right) : 0;
    }

    // 右旋
    TreeNode* rightRotate(TreeNode* y) const {
        TreeNode* x = y->left;
        TreeNode* T2 = x->right;

        x->right = y;
        y->left = T2;

        updateNodeInfo(y);
        updateNodeInfo(x);

        return x;
    }

    // 左旋
    TreeNode* leftRotate(TreeNode* x) const {
        TreeNode* y = x->right;
        TreeNode* T2 = y->left;

        y->left = x;
        x->right = T2;

        updateNodeInfo(x);
        updateNodeInfo(y);

        return y;
    }

    // 平衡节点
    TreeNode* balanceNode(TreeNode* node) const {
        if (!node) return nullptr;

        updateNodeInfo(node);
        int balance = getBalanceFactor(node);

        // Left Left Case
        if (balance > 1 && getBalanceFactor(node->left) >= 0)
            return rightRotate(node);

        // Right Right Case
        if (balance < -1 && getBalanceFactor(node->right) <= 0)
            return leftRotate(node);

        // Left Right Case
        if (balance > 1 && getBalanceFactor(node->left) < 0) {
            node->left = leftRotate(node->left);
            return rightRotate(node);
        }

        // Right Left Case
        if (balance < -1 && getBalanceFactor(node->right) > 0) {
            node->right = rightRotate(node->right);
            return leftRotate(node);
        }

        return node;
    }

    // 递归插入
    TreeNode* insertHelper(TreeNode* node, int value){
        if (!node) {
            return new TreeNode(value);
        }

        if (value < node->key) {
            node->left = insertHelper(node->left, value);
        } else if (value > node->key) {
            node->right = insertHelper(node->right, value);
        } else {
            node->count++;
            node->size++;
            return node;
        }

        return balanceNode(node);
    }

    // 查找最小节点
    TreeNode* findMinNode(TreeNode* node) const {
        while (node && node->left) {
            node = node->left;
        }
        return node;
    }

    // 递归删除
    TreeNode* removeHelper(TreeNode* node, int value){
        if (!node) return nullptr;

        if (value < node->key) {
            node->left = removeHelper(node->left, value);
        } else if (value > node->key) {
            node->right = removeHelper(node->right, value);
        } else {
            if (node->count > 1) {
                node->count--;
                node->size--;
                return node;
            }

            if (!node->left || !node->right) {
                TreeNode* temp = node->left ? node->left : node->right;
                if (!temp) {
                    delete node;
                    return nullptr;
                } else {
                    *node = *temp;
                    delete temp;
                }
            } else {
                TreeNode* successor = findMinNode(node->right);
                node->key = successor->key;
                node->count = successor->count;
                successor->count = 1;
                node->right = removeHelper(node->right, successor->key);
            }
        }

        return balanceNode(node);
    }

    // 递归查找
    bool searchHelper(TreeNode* node, int value) const {
        if (!node) return false;
        if (value == node->key) return true;
        if (value < node->key) return searchHelper(node->left, value);
        return searchHelper(node->right, value);
    }

    // 递归中序遍历
    void inorderHelper(TreeNode* node, std::vector<int>& result) const {
        if (!node) return;
        inorderHelper(node->left, result);
        for (int i = 0; i < node->count; ++i) {
            result.push_back(node->key);
        }
        inorderHelper(node->right, result);
    }

    // 递归查询排名
    int rankHelper(TreeNode* node, int value) const {
        if (!node) return 0;
        
        if (value < node->key) {
            return rankHelper(node->left, value);
        } else if (value > node->key) {
            return getSize(node->left) + node->count + rankHelper(node->right, value);
        } else {
            return getSize(node->left) + 1;
        }
    }

    // 递归按排名查找
    int selectHelper(TreeNode* node, int k) const {
        if (!node) return -1;
        
        int leftSize = getSize(node->left);
        
        if (k <= leftSize) {
            return selectHelper(node->left, k);
        } else if (k <= leftSize + node->count) {
            return node->key;
        } else {
            return selectHelper(node->right, k - leftSize - node->count);
        }
    }

    // 递归释放所有节点
    void clearHelper(TreeNode* node) {
        if (!node) return;
        clearHelper(node->left);
        clearHelper(node->right);
        delete node;
    }

public:
    BalancedBST() : root(nullptr) {}

    // 插入元素 - O(log n)
    void insert(int value) {
        root = insertHelper(root, value);
    }

    // 删除元素 - O(log n)
    void remove(int value) {
        root = removeHelper(root, value);
    }

    // 查找元素 - O(log n)
    bool search(int value) const {
        return searchHelper(root, value);
    }

    // 获取最小值 - O(log n)
    int min() const {
        TreeNode* node = findMinNode(root);
        return node ? node->key : -1;
    }

    // 获取最大值 - O(log n)
    int max() const {
        TreeNode* node = root;
        while (node && node->right) {
            node = node->right;
        }
        return node ? node->key : -1;
    }

    // 中序遍历 - O(n)
    std::vector<int> inorder() const {
        std::vector<int> result;
        inorderHelper(root, result);
        return result;
    }

    // 查询排名 - O(log n)
    int rank(int value) const {
        return rankHelper(root, value);
    }

    // 按排名查找 - O(log n)
    int select(int k) const {
        return selectHelper(root, k);
    }

    // 清空整棵树
    void clear() {
        clearHelper(root);
        root = nullptr;
    }

    // 获取树的大小 - O(1)
    int size() const {
        return getSize(root);
    }

    // 获取树的高度 - O(1)
    int height() const {
        return getHeight(root);
    }
};
```

**Splay (无注释)(文艺平衡树)** *(区间翻转)*

> 【Splay (无注释)(文艺平衡树)（区间翻转）】
Splay（伸展树）模板，通过伸展操作实现均摊高效访问。

核心函数：
  void in(Re &x) — 核心算法函数
  void pushup(Re p) — 上推更新节点信息
  void connect(Re p,Re f,Re o) — 核心算法函数
  int which(Re p) — 核心算法函数
  void pushdown(Re p) — 下传懒标记
  void rotate(Re p) — 旋转操作（平衡树）
  void Splay(Re p,Re to) — 伸展操作（Splay树）
  void New(Re x,Re fa) — 核心算法函数

核心结构体：Splay

关键配置：
N=1e5+5,inf=2e9

复杂度：所有操作 O(log N)

适用场景：有序集合维护、第K小查询、排名/前驱/后继查询

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)
#include<algorithm>
#include<cstdio>
#define Re register int
#define pl tr[p].ps[0]
#define pr tr[p].ps[1]
#define pf tr[p].fa
#define pv tr[p].v
using namespace std;
const int N=1e5+5,inf=2e9;
int T,x,y,n,o,root,a[N];
struct Splay{int v,fa,ps[2],tag,cnt,size;}tr[N];
inline void in(Re &x){
    int fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
inline void pushup(Re p){if(!p)return;tr[p].size=tr[p].cnt+tr[pl].size+tr[pr].size;}
inline void connect(Re p,Re f,Re o){tr[tr[p].fa=f].ps[o]=p;}
inline int which(Re p){return tr[pf].ps[1]==p;}
inline void pushdown(Re p){
	if(tr[p].tag)tr[p].tag=0,swap(pl,pr),tr[pl].tag^=1,tr[pr].tag^=1;
} 
inline void rotate(Re p){
	Re y=pf,ys=which(p);
	Re R=tr[y].fa,Rs=which(y);
	Re B=tr[p].ps[ys^1];
	connect(B,y,ys),connect(y,p,ys^1),connect(p,R,Rs);
	pushup(y),pushup(p);
}
inline void Splay(Re p,Re to){
	for(Re fa;(fa=pf)!=to;rotate(p))
		if(tr[fa].fa!=to)rotate(which(p)==which(fa)?fa:p);
	if(!to)root=p;
}
inline void New(Re x,Re fa){
	tr[++o].v=x,tr[o].fa=fa,tr[o].cnt=tr[o].size=1;
	if(fa)tr[fa].ps[tr[fa].v<x]=o;
}
inline int ask_w(Re p,Re x){
	pushdown(p);
	if(x<=tr[pl].size)return ask_w(pl,x);
	else{
		Re tmp=tr[pl].size+tr[p].cnt;
		return x<=tmp?p:ask_w(pr,x-tmp);
	}
}
inline void build(Re &p,Re L,Re R,Re fa){
	if(L>R)return;
	Re mid=L+R>>1;p=++o;
	pf=fa,pv=a[mid];
	tr[p].cnt=tr[p].size=1;
	build(pl,L,mid-1,p),build(pr,mid+1,R,p);
	pushup(p);
}
inline void reverse(Re l,Re r){
	l=ask_w(root,l-1),r=ask_w(root,r+1);
	Splay(l,0),Splay(r,l);
	tr[tr[r].ps[0]].tag^=1;
}
inline void print(Re p){
	pushdown(p);
	if(pl)print(pl);
	if(pv!=inf&&pv!=-inf)printf("%d ",pv);
	if(pr)print(pr);
}
int main(){
	in(n),in(T);
	a[1]=-inf,a[n+2]=inf;
	for(Re i=2;i<=n+1;++i)a[i]=i-1;
	build(root,1,n+2,0);
	while(T--)in(x),in(y),reverse(x+1,y+1);
	print(root);
}

```

**Splay (有注释)(文艺平衡树)** *(区间翻转)*

> 【Splay (有注释)(文艺平衡树)（区间翻转）】
Splay（伸展树）模板，通过伸展操作实现均摊高效访问。

核心函数：
  void in(Re &x) — 核心算法函数
  void pushup(Re p) — 上推更新节点信息
  void connect(Re p,Re f,Re o) — 核心算法函数
  int which(Re p) — 核心算法函数
  void pushdown(Re p) — 下传懒标记
  void rotate(Re p) — 旋转操作（平衡树）
  void Splay(Re p,Re to) — 伸展操作（Splay树）
  void New(Re x,Re fa) — 核心算法函数

核心结构体：Splay

关键配置：
N=1e5+5,inf=2e9

复杂度：所有操作 O(log N)

说明：��l~rȫ���Ƶ� ��(l-1)�� �����Ҷ���(r+1)�м䣬�������Ĳ���

适用场景：有序集合维护、第K小查询、排名/前驱/后继查询

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)
#include<algorithm>
#include<cstdio>
#define Re register int
#define pl tr[p].ps[0]
#define pr tr[p].ps[1]
#define pf tr[p].fa
#define pv tr[p].v
using namespace std;
const int N=1e5+5,inf=2e9;
int T,x,y,n,o,root,a[N];
struct Splay{int v,fa,ps[2],tag,cnt,size;}tr[N];
inline void in(Re &x){
    int fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
inline void pushup(Re p){if(!p)return;tr[p].size=tr[p].cnt+tr[pl].size+tr[pr].size;}
inline void connect(Re p,Re f,Re o){tr[tr[p].fa=f].ps[o]=p;}
inline int which(Re p){return tr[pf].ps[1]==p;}
inline void pushdown(Re p){
    if(tr[p].tag)tr[p].tag=0,swap(pl,pr),tr[pl].tag^=1,tr[pr].tag^=1;
} 
inline void rotate(Re p){
    Re y=pf,ys=which(p);
    Re R=tr[y].fa,Rs=which(y);
    Re B=tr[p].ps[ys^1];
    connect(B,y,ys),connect(y,p,ys^1),connect(p,R,Rs);
    pushup(y),pushup(p);
}
inline void Splay(Re p,Re to){
    for(Re fa;(fa=pf)!=to;rotate(p))
        if(tr[fa].fa!=to)rotate(which(p)==which(fa)?fa:p);
    if(!to)root=p;
}
inline void New(Re x,Re fa){
    tr[++o].v=x,tr[o].fa=fa,tr[o].cnt=tr[o].size=1;
    if(fa)tr[fa].ps[tr[fa].v<x]=o;
}
inline int ask_w(Re p,Re x){
    pushdown(p);
    if(x<=tr[pl].size)return ask_w(pl,x);
    else{
        Re tmp=tr[pl].size+tr[p].cnt;
        return x<=tmp?p:ask_w(pr,x-tmp);
    }
}
inline void build(Re &p,Re L,Re R,Re fa){
    if(L>R)return;
    Re mid=L+R>>1;p=++o;
    pf=fa,pv=a[mid];
    tr[p].cnt=tr[p].size=1;
    build(pl,L,mid-1,p),build(pr,mid+1,R,p);
    pushup(p);
}
inline void reverse(Re l,Re r){
    l=ask_w(root,l-1),r=ask_w(root,r+1);
    Splay(l,0),Splay(r,l);
    tr[tr[r].ps[0]].tag^=1;
}
inline void print(Re p){
    pushdown(p);
    if(pl)print(pl);
    if(pv!=inf&&pv!=-inf)printf("%d ",pv);
    if(pr)print(pr);
}
int main(){
    in(n),in(T);
    a[1]=-inf,a[n+2]=inf;
    for(Re i=2;i<=n+1;++i)a[i]=i-1;
    build(root,1,n+2,0);
    while(T--)in(x),in(y),reverse(x+1,y+1);
    print(root);
}

```

**Splay** *(数列P2710)*

> 【Splay（数列P2710）】
Splay（伸展树）模板，通过伸展操作实现均摊高效访问。

核心函数：
  void in(Re &x) — 核心算法函数
  void pushup(Re p) — 上推更新节点信息
  void updata(Re p) — 核心算法函数
  void updata(Re p,Re v) — 核心算法函数
  void pushdown(Re p) — 下传懒标记
  int which(Re p) — 核心算法函数
  void connect(Re p,Re fa,Re o) — 核心算法函数
  void rotate(Re p) — 旋转操作（平衡树）

核心结构体：Splay, QAQ

关键配置：
N=2e5+3,inf=1e9

复杂度：所有操作 O(log N)

说明：freopen("123.txt","r",stdin);

适用场景：有序集合维护、第K小查询、排名/前驱/后继查询

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#define LL long long
#define Re register int
using namespace std;
const int N=2e5+3,inf=1e9;
int n,x,y,z,T,A[N];char op[20];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Splay{
	#define pl (tr[p].ps[0])
	#define pr (tr[p].ps[1])
	#define pf (tr[p].fa)
	#define pv (tr[p].v)
	int O,root,Q[N];queue<int>D;
	struct QAQ{int v,S,fa,max,lmax,rmax,size,ps[2];bool tag,turn;}tr[N];
	inline void pushup(Re p){
		tr[p].S=tr[pl].S+tr[pr].S+pv;
		tr[p].size=tr[pl].size+tr[pr].size+1;
		tr[p].lmax=max(tr[pl].lmax,tr[pl].S+pv+tr[pr].lmax);
		tr[p].rmax=max(tr[pr].rmax,tr[pr].S+pv+tr[pl].rmax);
		tr[p].max=max(tr[pl].rmax+pv+tr[pr].lmax,max(tr[pl].max,tr[pr].max));
	}
	inline void updata(Re p){tr[p].turn^=1,swap(pl,pr),swap(tr[p].lmax,tr[p].rmax);}
	inline void updata(Re p,Re v){
		tr[p].tag=1,tr[p].S=(pv=v)*tr[p].size;
		if(v>0)tr[p].lmax=tr[p].rmax=tr[p].max=tr[p].S;
		else tr[p].lmax=tr[p].rmax=0,tr[p].max=v;
	}
	inline void pushdown(Re p){
		if(tr[p].tag){
			if(pl)updata(pl,pv);
			if(pr)updata(pr,pv);
			tr[p].tag=tr[p].turn=0;
		}
		if(tr[p].turn){
			if(pl)updata(pl);
			if(pr)updata(pr);
			tr[p].turn=0;
		}
	}
	inline int which(Re p){return tr[pf].ps[1]==p;}
	inline void connect(Re p,Re fa,Re o){tr[pf=fa].ps[o]=p;}
	inline void rotate(Re p){
		Re fa=pf,fas=which(p);
		Re pa=tr[fa].fa,pas=which(fa);
		Re x=tr[p].ps[fas^1];
		connect(x,fa,fas),connect(fa,p,fas^1),connect(p,pa,pas);
		pushup(fa),pushup(p);
	}
	inline void splay(Re p,Re to){
		Re x=p,t=0;Q[++t]=x;
		while(tr[x].fa)Q[++t]=x=tr[x].fa;
		while(t)pushdown(Q[t--]);
		for(Re fa;pf!=to;rotate(p))
			if(tr[fa=pf].fa!=to)rotate(which(p)==which(fa)?fa:p);
		if(!to)root=p;
	}
	inline void CL(Re p){
		tr[p].size=tr[p].turn=tr[p].tag=tr[p].lmax=tr[p].rmax=tr[p].S=pv=pf=pl=pr=0,tr[p].max=-inf;
	}
	inline int New(){
		Re p;
		if(D.empty())p=++O;
		else p=D.front(),D.pop();
		CL(p),tr[p].size=1;return p;
	}
	inline void build(Re &p,Re L,Re R,Re fa){
		if(L>R)return;Re mid=(L+R)>>1;p=New(),pv=A[mid],pf=fa;
		build(pl,L,mid-1,p),build(pr,mid+1,R,p);
		pushup(p);
	}
	inline void recycle(Re p){
		if(pl)recycle(pl);
		if(pr)recycle(pr);
		D.push(p),CL(p);
	}
	inline int find(Re p,Re K){
		pushdown(p);
		if(K<=tr[pl].size)return find(pl,K);
		return K<=tr[pl].size+1?p:find(pr,K-tr[pl].size-1);
	}
	inline int split(Re L,Re R){
		Re p=find(root,L-1),q=find(root,R+1);
		splay(p,0),splay(q,p);return tr[q].ps[0];
	}
	inline void insert(Re st,Re m){
		for(Re i=1;i<=m;++i)in(A[i]);
		Re rt=0;build(rt,1,m,0);
		Re p=find(root,st),q=find(root,st+1);
		splay(p,0),splay(q,p);
		connect(rt,q,0),pushup(q),pushup(p);
	}
	inline void erase(Re L,Re R){
		Re p=split(L,R),fa=pf;
		tr[fa].ps[0]=pf=0,recycle(p);
		pushup(fa),pushup(tr[fa].fa);
	}
	inline int ask(Re L,Re R){return tr[split(L,R)].S;}
	inline int ask_max(Re L,Re R){return tr[split(L,R)].max;}
	inline void change(Re L,Re R,Re v){
		Re p=split(L,R);updata(p,v),pushup(pf),pushup(tr[pf].fa);
	}
	inline void reverse(Re L,Re R){
		Re p=split(L,R);
		if(!tr[p].tag)updata(p),pushup(pf),pushup(tr[pf].fa);
	}
}TR;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T),TR.tr[0].max=A[1]=A[n+2]=-inf;
	for(Re i=2;i<=n+1;++i)in(A[i]);
	TR.build(TR.root,1,n+2,0);
	while(T--){
		scanf("%s",op);
        if(op[0]=='M'&&op[2]=='X')in(x),in(y),++x,printf("%d\n",TR.ask_max(x,x+y-1));
		else if(op[0]=='G'&&(int)strlen(op)==3)in(x),++x,printf("%d\n",TR.ask(x,x));
		else{
			in(x),in(y),++x;
	        if(op[0]=='I')TR.insert(x,y);
	        if(op[0]=='D')TR.erase(x,x+y-1);
	        if(op[0]=='M')in(z),TR.change(x,x+y-1,z);
	        if(op[0]=='R')TR.reverse(x,x+y-1);
	        if(op[0]=='G')printf("%d\n",TR.ask(x,x+y-1));
		}
	}
}

```

**Splay  (无注释)** *(普通平衡树)*

> 【Splay  (无注释)（普通平衡树）】
Splay（伸展树）模板，通过伸展操作实现均摊高效访问。

核心函数：
  void in(Re &x) — 核心算法函数
  void pushup(Re p) — 上推更新节点信息
  int which(Re p) — 核心算法函数
  void connect(Re p,Re fa,Re o) — 核心算法函数
  void rotate(Re p) — 旋转操作（平衡树）
  void splay(Re p) — 伸展操作（Splay树）
  int ask_level(Re p,Re x) — 核心算法函数
  int ask_v(Re p,Re k) — 核心算法函数

核心结构体：Splay, QAQ

关键配置：
N=1e5+5

复杂度：所有操作 O(log N)

说明：freopen("123.txt","r",stdin);

适用场景：有序集合维护、第K小查询、排名/前驱/后继查询

```cpp
#include<algorithm>
#include<cstdio>
#include<queue>
#define Re register int
#define LL long long
using namespace std;
const int N=1e5+5;
int x,T,op;
inline void in(Re &x){
    int fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
struct Splay{
	#define pl tr[p].ps[0]
	#define pr tr[p].ps[1]
	#define pf tr[p].fa
	#define pv tr[p].v
	int O,root;
	struct QAQ{int v,fa,cnt,size,ps[2];}tr[N];
	inline void pushup(Re p){
		if(p)tr[p].size=tr[p].cnt+tr[pl].size+tr[pr].size;
	}
	inline int which(Re p){return tr[pf].ps[1]==p;}
	inline void connect(Re p,Re fa,Re o){tr[pf=fa].ps[o]=p;}
	inline void rotate(Re p){
		Re fa=pf,fas=which(p);
		Re pa=tr[fa].fa,pas=which(fa);
		Re x=tr[p].ps[fas^1];
		connect(x,fa,fas),connect(fa,p,fas^1),connect(p,pa,pas);
		pushup(fa),pushup(p);
	}
	inline void splay(Re p){
		for(Re fa;fa=pf;rotate(p))
			if(tr[fa].fa)rotate(which(p)==which(fa)?fa:p);
		root=p;
	}
	inline int ask_level(Re p,Re x){
		if(x==pv){Re ans=tr[pl].size+1;splay(p);return ans;}
		return x<pv?ask_level(pl,x):tr[pl].size+tr[p].cnt+ask_level(pr,x);
	}
	inline int ask_v(Re p,Re k){
		if(!p)return 0;
		if(k<=tr[pl].size)return ask_v(pl,k);
		Re tmp=tr[pl].size+tr[p].cnt;
		return k<=tmp?pv:ask_v(pr,k-tmp);
	}
	inline int pre(Re p){p=pl;while(pr)p=pr;return p;}
	inline int nex(Re p){p=pr;while(pl)p=pl;return p;}
	inline void insert(Re x){
		Re p=root,fa=0;
		while(p&&pv!=x)fa=p,p=tr[p].ps[x>pv];
		if(p)++tr[p].cnt,pushup(p);
		else{
			tr[p=++O]=(QAQ){x,fa,1,1};
			if(fa)tr[fa].ps[x>tr[fa].v]=p;
		}
		splay(p);
	}
	inline void del(Re x){
		ask_level(root,x);Re p=root;
		if(tr[p].cnt>1){--tr[p].cnt,pushup(p);return;}
		if(!pl&&!pr){root=0;return;}
		if(!pl||!pr){tr[root=pl+pr].fa=0;return;}
		splay(pre(p));
		tr[root].ps[1]=pr,tr[pr].fa=root;
		pushup(root);
	}
	inline int ask_pre(Re x){insert(x);Re ans=tr[pre(root)].v;del(x);return ans;}
	inline int ask_nex(Re x){insert(x);Re ans=tr[nex(root)].v;del(x);return ans;}
}T1;
int main(){
//	freopen("123.txt","r",stdin);
	in(T);
	while(T--){
		in(op),in(x);
		if(op==1)T1.insert(x);
		if(op==2)T1.del(x);
		if(op==3)printf("%d\n",T1.ask_level(T1.root,x));
		if(op==4)printf("%d\n",T1.ask_v(T1.root,x));
		if(op==5)printf("%d\n",T1.ask_pre(x));
		if(op==6)printf("%d\n",T1.ask_nex(x));
	}
}

```

**Splay  (有注释)** *(普通平衡树)*

> #pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)

```cpp
//#pragma GCC optimize(3,"Ofast","inline")
//#pragma GCC optimize(2)
#include<algorithm>
#include<cstdio>
#define Re register int
#define pl tr[p].ps[0]
#define pr tr[p].ps[1]
#define pf tr[p].fa 
#define pv tr[p].v
using namespace std;
const int N=1e5+5,inf=2e9;
int T,a,b,n,o,root;
struct Splay{int v,fa,ps[2],cnt,size;}tr[N];
inline void in(Re &x){
    int fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
inline void pushup(Re p){if(!p)return;/*�������Ҫ���ж�return����������*/tr[p].size=tr[p].cnt+tr[pl].size+tr[pr].size;}
inline void connect(Re p,Re f,Re o){tr[tr[p].fa=f].ps[o]=p;}
inline int which(Re p){return tr[pf].ps[1]==p;}
inline void rotate(Re p){
	Re y=pf,ys=which(p);
	Re R=tr[y].fa,Rs=which(y);
	Re B=tr[p].ps[ys^1];
	connect(B,y,ys),connect(y,p,ys^1),connect(p,R,Rs);
	pushup(y),pushup(p);
}
inline void Splay(Re p){
	for(Re fa;fa=pf;rotate(p))
		if(tr[fa].fa)rotate(which(p)==which(fa)?fa:p);
	root=p;
}
inline void New(Re x,Re fa){
	tr[++o].v=x,tr[o].fa=fa,tr[o].cnt=tr[o].size=1;
	if(fa)tr[fa].ps[tr[fa].v<x]=o;
}
inline void insert(Re x){
	if(!root){New(x,0);root=o;return;}
	int p=root,fa=0;
	while(1){
		if(x==pv){++tr[p].cnt,pushup(p),pushup(fa),Splay(p);break;}
		fa=p,p=tr[p].ps[pv<x];
		if(!p){New(x,fa),pushup(fa),Splay(o);break;}
	}
}
inline int ask_level(Re p,Re x){
//printf("p: %d\n",p);exit(0);
	if(x==pv){Re ans=tr[pl].size+1;Splay(p);return ans;}
	else return x<pv?ask_level(pl,x):tr[p].cnt+tr[pl].size+ask_level(pr,x);
}
inline int ask_v(Re p,Re x){
	if(x<=tr[pl].size)return ask_v(pl,x);
	else{
		Re tmp=tr[pl].size+tr[p].cnt;
		return x<=tmp?pv:ask_v(pr,x-tmp);
	}
}
inline int ask_nex_p(Re p){p=pr;while(pl)p=pl;return p;}
inline int ask_pri_p(Re p){p=pl;while(pr)p=pr;return p;}
inline void del(Re x){
	ask_level(root,x);Re p=root;
	if(tr[p].cnt>1){--tr[p].cnt,--tr[p].size;return;}
	if(!pl&&!pr){root=0;return;}
	if(!pl||!pr){tr[root=pl+pr].fa=0;return;}
	Splay(ask_pri_p(root));
	tr[root].ps[1]=pr,tr[pr].fa=root;
	pushup(root);
}
int main(){
	in(T);
	while(T--){
		in(a),in(b);
		if(a==1)insert(b);
		if(a==2)del(b);
		if(a==3)printf("%d\n",ask_level(root,b));
		if(a==4)printf("%d\n",ask_v(root,b));
		if(a==5)insert(b),printf("%d\n",tr[ask_pri_p(root)].v),del(b);
		if(a==6)insert(b),printf("%d\n",tr[ask_nex_p(root)].v),del(b);
	}
}

```

**Treap  (无注释)** *(普通平衡树)*

> 【Treap  (无注释)（普通平衡树）】
FHQ Treap（无旋 Treap）模板，通过分裂/合并实现平衡。

核心函数：
  void in(Re &x) — 核心算法函数
  void pushup(Re p) — 上推更新节点信息
  void lturn(Re &p) — 核心算法函数
  void rturn(Re &p) — 核心算法函数
  void insert(Re &p,Re x) — 插入元素
  void del(Re &p,Re x) — 核心算法函数
  int ask_level(Re p,Re x) — 核心算法函数
  int ask_v(Re p,Re x) — 核心算法函数

核心结构体：Treap

关键配置：
N=1e5+5,inf=2e9

复杂度：所有操作 O(log N)

适用场景：有序集合维护、第K小查询、排名/前驱/后继查询

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)
#include<algorithm> 
#include<cstdlib> 
#include<cstdio>
#include<ctime>
#define Re register int
#define pl tr[p].lp
#define pr tr[p].rp
#define pv tr[p].v
using namespace std;
const int N=1e5+5,inf=2e9;
int a,b,o,T,root;
inline void in(Re &x){
    int fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
struct Treap{int v,rd,lp,rp,cnt,size;}tr[N];
inline void pushup(Re p){tr[p].size=tr[p].cnt+tr[pl].size+tr[pr].size;}
inline void lturn(Re &p){
	Re q=pr;pr=tr[q].lp,tr[q].lp=p;
	pushup(p),pushup(p=q);
}
inline void rturn(Re &p){
	Re q=pl;pl=tr[q].rp,tr[q].rp=p;
	pushup(p),pushup(p=q);
}
inline void insert(Re &p,Re x){
	if(!p){tr[p=++o].v=x,tr[p].cnt=tr[p].size=1,tr[p].rd=rand();return;}
	++tr[p].size;
	if(x==pv)++tr[p].cnt;
	else if(x<pv){
		insert(pl,x);
		if(tr[pl].rd<tr[p].rd)rturn(p);
	}
	else{
		insert(pr,x);
		if(tr[pr].rd<tr[p].rd)lturn(p);
	}
}
inline void del(Re &p,Re x){
	if(!p)return;
    if(x<pv)--tr[p].size,del(pl,x);
	else if(x>pv)--tr[p].size,del(pr,x);
	else{
		if(tr[p].cnt>1)--tr[p].cnt,--tr[p].size;
		else{
			if(pl*pr==0)p=pl+pr;
			else if(tr[pl].rd<tr[pr].rd)rturn(p),del(p,x);
			else lturn(p),del(p,x);
		}
	}
}
inline int ask_level(Re p,Re x){ 
	if(x==pv)return tr[pl].size+1;
	else return x<pv?ask_level(pl,x):tr[p].cnt+tr[pl].size+ask_level(pr,x);
}
inline int ask_v(Re p,Re x){
	if(x<=tr[pl].size)return ask_v(pl,x);
	else{
		Re tmp=tr[pl].size+tr[p].cnt;
		return x<=tmp?pv:ask_v(pr,x-tmp);
	}
}
inline int ask_pri(Re p,Re x){
	if(!p)return -inf;
	if(x<=pv)return ask_pri(pl,x);
	else return max(pv,ask_pri(pr,x));
}
inline int ask_nex(Re p,Re x){
	if(!p)return inf;
	if(x>=pv)return ask_nex(pr,x);
	else return min(pv,ask_nex(pl,x));
}
inline void write(int x){
	if(x<0) putchar('-'),x=-x;
	if(x>9) write(x/10);
	putchar(x%10+'0');
	return ;
}
int main(){
	srand((int)time(NULL));
	in(T);
	while(T--){
		in(a),in(b);
		if(a==1)insert(root,b);
		if(a==2)del(root,b);
		if(a==3)write(ask_level(root,b)),puts("");
		if(a==4)write(ask_v(root,b)),puts("");
		if(a==5)write(ask_pri(root,b)),puts(""); 
		if(a==6)write(ask_nex(root,b)),puts("");
	}
}

```

**Treap  (有注释)** *(普通平衡树)*

> 【Treap  (有注释)（普通平衡树）】
FHQ Treap（无旋 Treap）模板，通过分裂/合并实现平衡。

核心函数：
  void in(Re &x) — 核心算法函数
  void pushup(Re p) — 上推更新节点信息
  void lturn(Re &p) — 核心算法函数
  void rturn(Re &p) — 核心算法函数
  void insert(Re &p,Re x) — 插入元素
  void del(Re &p,Re x) — 核心算法函数
  int ask_level(Re p,Re x) — 核心算法函数
  int ask_v(Re p,Re x) — 核心算法函数

核心结构体：Treap

关键配置：
N=1e5+5,inf=2e9

复杂度：所有操作 O(log N)

适用场景：有序集合维护、第K小查询、排名/前驱/后继查询

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)
#include<algorithm> 
#include<cstdlib> 
#include<cstdio>
#include<ctime>
#define Re register int
#define pl tr[p].lp
#define pr tr[p].rp
#define pv tr[p].v
using namespace std;
const int N=1e5+5,inf=2e9;
int a,b,o,T,root;
inline void in(Re &x){
    int fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
struct Treap{int v,rd,lp,rp,cnt,size;}tr[N];
inline void pushup(Re p){tr[p].size=tr[p].cnt+tr[pl].size+tr[pr].size;}
inline void lturn(Re &p){
	Re q=pr;pr=tr[q].lp,tr[q].lp=p;
	pushup(p),pushup(p=q);
}
inline void rturn(Re &p){
	Re q=pl;pl=tr[q].rp,tr[q].rp=p;
	pushup(p),pushup(p=q);
}
inline void insert(Re &p,Re x){
	if(!p){tr[p=++o].v=x,tr[p].cnt=tr[p].size=1,tr[p].rd=rand();return;}
	++tr[p].size;
	if(x==pv)++tr[p].cnt;
	else if(x<pv){
		insert(pl,x);
		if(tr[pl].rd<tr[p].rd)rturn(p);
	}
	else{
		insert(pr,x);
		if(tr[pr].rd<tr[p].rd)lturn(p);
	}
}
inline void del(Re &p,Re x){
	if(!p)return;
    if(x<pv)--tr[p].size,del(pl,x);
	else if(x>pv)--tr[p].size,del(pr,x);
	else{
		if(tr[p].cnt>1)--tr[p].cnt,--tr[p].size;
		else{
			if(pl*pr==0)p=pl+pr;
			else if(tr[pl].rd<tr[pr].rd)rturn(p),del(p,x);
			else lturn(p),del(p,x);
		}
	}
}
inline int ask_level(Re p,Re x){
	if(x==pv)return tr[pl].size+1;
	else return x<pv?ask_level(pl,x):tr[p].cnt+tr[pl].size+ask_level(pr,x);
}
inline int ask_v(Re p,Re x){
	if(x<=tr[pl].size)return ask_v(pl,x);
	else{
		Re tmp=tr[pl].size+tr[p].cnt;
		return x<=tmp?pv:ask_v(pr,x-tmp);
	}
}
inline int ask_pri(Re p,Re x){
	if(!p)return -inf;
	if(x<=pv)return ask_pri(pl,x);
	else return max(pv,ask_pri(pr,x));
}
inline int ask_nex(Re p,Re x){
	if(!p)return inf;
	if(x>=pv)return ask_nex(pr,x);
	else return min(pv,ask_nex(pl,x));
}
int main(){
	srand((int)time(NULL));
	in(T);
	while(T--){
		in(a),in(b);
		if(a==1)insert(root,b);
		if(a==2)del(root,b);
		if(a==3)printf("%d\n",ask_level(root,b));
		if(a==4)printf("%d\n",ask_v(root,b));
		if(a==5)printf("%d\n",ask_pri(root,b)); 
		if(a==6)printf("%d\n",ask_nex(root,b));
	}
}

```

**二逼平衡树 (无注释)** *(树套树)*

> 【二逼平衡树 (无注释)（树套树）】
平衡二叉搜索树模板，保证插入/删除/查找均为对数复杂度。

核心函数：
  void in(Re &x) — 核心算法函数
  int ask_kth(Re L,Re R,Re k) — 核心算法函数
  int ask_kth_pre(Re L,Re R,Re k) — 预处理函数
  void add(Re &p,Re L,Re R,Re w,Re v) — 加法更新
  void add_pre(Re x,Re v) — 加法更新
  int ask_level(Re p,Re L,Re R,Re x) — 核心算法函数
  int ask_level_pre(Re L,Re R,Re w) — 预处理函数
   F(i,1,T) — 核心算法函数

核心结构体：QAQ, O_O, T_T

关键配置：
N=1e5+3,inf=2147483647

复杂度：所有操作 O(log N)

适用场景：有序集合维护、第K小查询、排名/前驱/后继查询

```cpp
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
#include<algorithm>
#include<cstring>
#include<cstdio>
#define mid (L+R>>1)
#define Re register int
#define pl tree[p].lp
#define pr tree[p].rp
#define F(i,a,b) for(Re i=a;i<=b;++i)
#define lo(o) lower_bound(b+1,b+m+1,o)-b
using namespace std;
const int N=1e5+3,inf=2147483647;
int x,y,z,n,m,T,t,fu,cnt,tl,tr,a[N],b[N],pt[N],C[N],opt[N],ptl[20],ptr[20]; 
struct QAQ{int g,lp,rp;}tree[N*250];
struct O_O{int l,r,k;}Q[N];
struct T_T{int i,x;}c[N];
inline void in(Re &x){
    x=fu=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
inline int ask_kth(Re L,Re R,Re k){
    if(L==R)return b[R];
    Re tmp=0;
    F(i,1,tl)tmp-=tree[tree[ptl[i]].lp].g;
    F(i,1,tr)tmp+=tree[tree[ptr[i]].lp].g;
    if(tmp>=k){
    	F(i,1,tl)ptl[i]=tree[ptl[i]].lp;
    	F(i,1,tr)ptr[i]=tree[ptr[i]].lp;
    	return ask_kth(L,mid,k);
    }
    else{
    	F(i,1,tl)ptl[i]=tree[ptl[i]].rp;
    	F(i,1,tr)ptr[i]=tree[ptr[i]].rp;
    	return ask_kth(mid+1,R,k-tmp);
    }
}
inline int ask_kth_pre(Re L,Re R,Re k){
    tl=tr=0;
    for(Re i=L-1;i;i-=i&-i)ptl[++tl]=pt[i];
    for(Re i=R;i;i-=i&-i)ptr[++tr]=pt[i];
    return ask_kth(1,m,k);
}
inline void add(Re &p,Re L,Re R,Re w,Re v){
    if(!p)p=++cnt;tree[p].g+=v;
    if(L==R)return;
    if(w<=mid)add(pl,L,mid,w,v);
    else add(pr,mid+1,R,w,v);
}
inline void add_pre(Re x,Re v){
    Re w=lo(a[x]); 
    for(Re i=x;i<=n;i+=i&-i)add(pt[i],1,m,w,v);
}
inline int ask_level(Re p,Re L,Re R,Re x){
	if(L==R)return tree[p].g; 
	if(x<=mid)return ask_level(pl,L,mid,x);
	else return tree[pl].g+ask_level(pr,mid+1,R,x);
}
inline int ask_level_pre(Re L,Re R,Re w){
	Re ans=0;
    for(Re i=R;i;i-=i&-i)ans+=ask_level(pt[i],1,m,w);
    for(Re i=L-1;i;i-=i&-i)ans-=ask_level(pt[i],1,m,w);
    return ans;
}
int main(){
	in(n),in(T),m=n;
    F(i,1,n)in(a[i]),b[i]=a[i];
    F(i,1,T){
    	in(opt[i]);
    	if(opt[i]==3)in(c[i].i),in(c[i].x),b[++m]=c[i].x;
    	else{
    		in(Q[i].l),in(Q[i].r),in(Q[i].k);
    		if(opt[i]!=2)b[++m]=Q[i].k;
		}
    }
    sort(b+1,b+m+1),m=unique(b+1,b+m+1)-b-1;
    F(i,1,n)add_pre(i,1);
    F(i,1,T){
    	if(opt[i]==1)Q[i].k=lo(Q[i].k),printf("%d\n",ask_level_pre(Q[i].l,Q[i].r,Q[i].k-1)+1);
    	if(opt[i]==2)printf("%d\n",ask_kth_pre(Q[i].l,Q[i].r,Q[i].k));
		if(opt[i]==3)add_pre(c[i].i,-1),a[c[i].i]=c[i].x,add_pre(c[i].i,1);
		if(opt[i]==4){
			Re level=ask_level_pre(Q[i].l,Q[i].r,lo(Q[i].k)-1);
			if(!level)printf("%d\n",-inf);
			else printf("%d\n",ask_kth_pre(Q[i].l,Q[i].r,level));
		}
		if(opt[i]==5){
			Re level=ask_level_pre(Q[i].l,Q[i].r,lo(Q[i].k));
			if(level==Q[i].r-Q[i].l+1)printf("%d\n",inf);
			else printf("%d\n",ask_kth_pre(Q[i].l,Q[i].r,level+1));
		}
    }
}

```

**二逼平衡树 (有注释)** *(树套树)*

> 【二逼平衡树 (有注释)（树套树）】
平衡二叉搜索树模板，保证插入/删除/查找均为对数复杂度。

核心函数：
  void in(Re &x) — 核心算法函数
  int ask_kth(Re L,Re R,Re k) — 核心算法函数
  int ask_kth_pre(Re L,Re R,Re k) — 预处理函数
  void add(Re &p,Re L,Re R,Re w,Re v) — 加法更新
  void add_pre(Re x,Re v) — 加法更新
  int ask_level(Re p,Re L,Re R,Re x) — 核心算法函数
  int ask_level_pre(Re L,Re R,Re w) — 预处理函数
   F(i,1,T) — 核心算法函数

核心结构体：QAQ, O_O, T_T

关键配置：
N=1e5+3,inf=2147483647

复杂度：所有操作 O(log N)

说明：printf("%lf\n",(sizeof(tree))/1024.0/1024.0);；�������λ����ԭ����������һ�����������ֺ��ٰ�������һ�����ʹﵽ���滻��Ŀ��

适用场景：有序集合维护、第K小查询、排名/前驱/后继查询

```cpp
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
#include<algorithm>
#include<cstring>
#include<cstdio>
#define mid (L+R>>1)
#define Re register int
#define pl tree[p].lp
#define pr tree[p].rp
#define F(i,a,b) for(Re i=a;i<=b;++i)
#define lo(o) lower_bound(b+1,b+m+1,o)-b
using namespace std;
const int N=1e5+3,inf=2147483647;
int x,y,z,n,m,T,t,fu,cnt,tl,tr,a[N],b[N],pt[N],C[N],opt[N],ptl[20],ptr[20]; 
struct QAQ{int g,lp,rp;}tree[N*250];
struct O_O{int l,r,k;}Q[N];
struct T_T{int i,x;}c[N];
inline void in(Re &x){
    x=fu=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
inline int ask_kth(Re L,Re R,Re k){
    if(L==R)return b[R];
    Re tmp=0;
    F(i,1,tl)tmp-=tree[tree[ptl[i]].lp].g;
    F(i,1,tr)tmp+=tree[tree[ptr[i]].lp].g;
    if(tmp>=k){
    	F(i,1,tl)ptl[i]=tree[ptl[i]].lp;
    	F(i,1,tr)ptr[i]=tree[ptr[i]].lp;
    	return ask_kth(L,mid,k);
    }
    else{
    	F(i,1,tl)ptl[i]=tree[ptl[i]].rp;
    	F(i,1,tr)ptr[i]=tree[ptr[i]].rp;
    	return ask_kth(mid+1,R,k-tmp);
    }
}
inline int ask_kth_pre(Re L,Re R,Re k){
    tl=tr=0;
    for(Re i=L-1;i;i-=i&-i)ptl[++tl]=pt[i];
    for(Re i=R;i;i-=i&-i)ptr[++tr]=pt[i];
    return ask_kth(1,m,k);
}
inline void add(Re &p,Re L,Re R,Re w,Re v){
    if(!p)p=++cnt;tree[p].g+=v;
    if(L==R)return;
    if(w<=mid)add(pl,L,mid,w,v);
    else add(pr,mid+1,R,w,v);
}
inline void add_pre(Re x,Re v){
    Re w=lo(a[x]);
    for(Re i=x;i<=n;i+=i&-i)add(pt[i],1,m,w,v);
}
inline int ask_level(Re p,Re L,Re R,Re x){
	if(L==R)return tree[p].g; 
	if(x<=mid)return ask_level(pl,L,mid,x);
	else return tree[pl].g+ask_level(pr,mid+1,R,x);
}
inline int ask_level_pre(Re L,Re R,Re w){
	Re ans=0;
    for(Re i=R;i;i-=i&-i)ans+=ask_level(pt[i],1,m,w);
    for(Re i=L-1;i;i-=i&-i)ans-=ask_level(pt[i],1,m,w);
    return ans;
}
int main(){
//	printf("%lf\n",(sizeof(tree))/1024.0/1024.0);
//	printf("%lf\n",(sizeof(tree)+sizeof(Q)+sizeof(c)+sizeof(a)+sizeof(b)+sizeof(pt)+sizeof(C))/1024.0/1024.0);
	in(n),in(T),m=n;
    F(i,1,n)in(a[i]),b[i]=a[i];
    F(i,1,T){
    	in(opt[i]);
    	if(opt[i]==3)in(c[i].i),in(c[i].x),b[++m]=c[i].x;
    	else{
    		in(Q[i].l),in(Q[i].r),in(Q[i].k);
    		if(opt[i]!=2)b[++m]=Q[i].k;
		}
    }
    sort(b+1,b+m+1);
    m=unique(b+1,b+m+1)-b-1;
    F(i,1,n)add_pre(i,1);
    F(i,1,T){
    	if(opt[i]==1)
    		Q[i].k=lo(Q[i].k),
			printf("%d\n",ask_level_pre(Q[i].l,Q[i].r,Q[i].k-1)+1);

    	if(opt[i]==2)
    		printf("%d\n",ask_kth_pre(Q[i].l,Q[i].r,Q[i].k));

		if(opt[i]==3)
			add_pre(c[i].i,-1),a[c[i].i]=c[i].x,add_pre(c[i].i,1);

		if(opt[i]==4){
		}

		if(opt[i]==5){
		}
    }
}

```

**普通平衡树** *(树状数组)*

> 【普通平衡树（树状数组）】
平衡二叉搜索树模板，保证插入/删除/查找均为对数复杂度。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re v) — 加法更新
  int ask(Re x) — 核心算法函数
  int ask_kth(Re k) — 核心算法函数
   F(i,1,T) — 核心算法函数
   F(i,1,T) — 核心算法函数

关键配置：
N=1e5+3,inf=2147483647

复杂度：所有操作 O(log N)

适用场景：有序集合维护、第K小查询、排名/前驱/后继查询

```cpp
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
#include<algorithm>
#include<cstdio>
#define Re register int
#define F(i,a,b) for(Re i=a;i<=b;++i)
#define lo(o) lower_bound(b+1,b+m+1,o)-b
#define P(x) if(op[i]==x)
using namespace std;
const int N=1e5+3,inf=2147483647;
int m,T,fu,C[N],a[N],b[N],Q[N],op[N]; 
inline void in(Re &x){
    x=fu=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
inline void add(Re x,Re v){while(x<=m)C[x]+=v,x+=x&-x;}
inline int ask(Re x){
	Re ans=0;
	while(x>0)ans+=C[x],x-=x&-x;
	return ans;
}
inline int ask_kth(Re k){
	Re l=0,r=m;
	while(l<r){
		Re mid=l+r>>1;
		if(ask(mid)>=k)r=mid;
		else l=mid+1;
	}
	return b[l];
}
int main(){
	in(T); 
    F(i,1,T){
    	in(op[i]),in(Q[i]);
    	if(op[i]!=4)b[++m]=Q[i];
    }
    sort(b+1,b+m+1),m=unique(b+1,b+m+1)-b-1;
    F(i,1,T){
    	P(1)add(lo(Q[i]),1);
    	P(2)add(lo(Q[i]),-1);
		P(3)printf("%d\n",ask(lo(Q[i])-1)+1);
		P(4)printf("%d\n",ask_kth(Q[i]));
		P(5)printf("%d\n",ask_kth(ask(lo(Q[i])-1)));
		P(6)printf("%d\n",ask_kth(ask(lo(Q[i]))+1));
    }
}

```

**普通平衡树** *(线段树)*

> 【普通平衡树（线段树）】
平衡二叉搜索树模板，保证插入/删除/查找均为对数复杂度。

核心函数：
  void in(Re &x) — 核心算法函数
  int ask_kth(Re p,Re L,Re R,Re k) — 核心算法函数
  void add(Re &p,Re L,Re R,Re w,Re v) — 加法更新
  int ask_level(Re p,Re L,Re R,Re x) — 核心算法函数
   F(i,1,T) — 核心算法函数
   F(i,1,T) — 核心算法函数

核心结构体：QAQ

关键配置：
N=1e5+3,inf=2147483647

复杂度：所有操作 O(log N)

适用场景：有序集合维护、第K小查询、排名/前驱/后继查询

```cpp
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
#include<algorithm>
#include<cstring>
#include<cstdio>
#define mid (L+R>>1)
#define Re register int
#define pl tree[p].lp
#define pr tree[p].rp
#define F(i,a,b) for(Re i=a;i<=b;++i)
#define lo(o) lower_bound(b+1,b+m+1,o)-b
using namespace std;
const int N=1e5+3,inf=2147483647;
int m,T,t,fu,cnt,root,a[N],b[N],Q[N],opt[N]; 
struct QAQ{int g,lp,rp;}tree[N<<1];
inline void in(Re &x){
    x=fu=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
inline int ask_kth(Re p,Re L,Re R,Re k){
	if(L==R)return b[R];
    Re tmp=tree[pl].g;
    if(tmp>=k)return ask_kth(pl,L,mid,k);
    else return ask_kth(pr,mid+1,R,k-tmp);
}
inline void add(Re &p,Re L,Re R,Re w,Re v){
    if(!p)p=++cnt;tree[p].g+=v;
    if(L==R)return;
    if(w<=mid)add(pl,L,mid,w,v);
    else add(pr,mid+1,R,w,v);
}
inline int ask_level(Re p,Re L,Re R,Re x){
	if(!x)return 0;
	if(L==R)return tree[p].g;
	if(x<=mid)return ask_level(pl,L,mid,x);
	else return tree[pl].g+ask_level(pr,mid+1,R,x);
}
int main(){
	in(T); 
    F(i,1,T){
    	in(opt[i]),in(Q[i]);
    	if(opt[i]!=4)b[++m]=Q[i];
    }
    sort(b+1,b+m+1),m=unique(b+1,b+m+1)-b-1;
    F(i,1,T){
    	if(opt[i]==1)add(root,1,m,lo(Q[i]),1);
    	if(opt[i]==2)add(root,1,m,lo(Q[i]),-1);
		if(opt[i]==3)printf("%d\n",ask_level(root,1,m,lo(Q[i])-1)+1);
		if(opt[i]==4)printf("%d\n",ask_kth(root,1,m,Q[i]));
		if(opt[i]==5){
			Re level=ask_level(root,1,m,lo(Q[i])-1);
			printf("%d\n",ask_kth(root,1,m,level));
		}
		if(opt[i]==6){
			Re level=ask_level(root,1,m,lo(Q[i]));
			printf("%d\n",ask_kth(root,1,m,level+1));
		}
    }
}

```

**营业额统计** *(Treap)*

> 【营业额统计（Treap）】
平衡二叉搜索树模板，保证插入/删除/查找均为对数复杂度。

核心函数：
  void in(Re &x) — 核心算法函数
  void pushup(Re p) — 上推更新节点信息
  void lturn(Re &p) — 核心算法函数
  void rturn(Re &p) — 核心算法函数
  void insert(Re &p,Re x) — 插入元素
  int ask_pri(Re p,Re x) — 核心算法函数
  int ask_nex(Re p,Re x) — 核心算法函数

核心结构体：Treap

关键配置：
N=32780,inf=2e9

复杂度：所有操作 O(log N)

适用场景：有序集合维护、第K小查询、排名/前驱/后继查询

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)
#include<algorithm> 
#include<cstdlib> 
#include<cstdio>
#include<ctime>
#define Re register int
#define pl tr[p].lp
#define pr tr[p].rp
#define pv tr[p].v
using namespace std;
const int N=32780,inf=2e9;
int a,o,T,ans,root;
inline void in(Re &x){
    int fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
struct Treap{int v,rd,lp,rp,cnt,size;}tr[N];
inline void pushup(Re p){tr[p].size=tr[p].cnt+tr[pl].size+tr[pr].size;}
inline void lturn(Re &p){
	Re q=pr;pr=tr[q].lp,tr[q].lp=p;
	pushup(p),pushup(p=q);
}
inline void rturn(Re &p){
	Re q=pl;pl=tr[q].rp,tr[q].rp=p;
	pushup(p),pushup(p=q);
}
inline void insert(Re &p,Re x){
	if(!p){tr[p=++o].v=x,tr[p].cnt=tr[p].size=1,tr[p].rd=rand();return;}
	++tr[p].size;
	if(x==pv)++tr[p].cnt;
	else if(x<pv){
		insert(pl,x);
		if(tr[pl].rd<tr[p].rd)rturn(p);
	}
	else{
		insert(pr,x);
		if(tr[pr].rd<tr[p].rd)lturn(p);
	}
}
inline int ask_pri(Re p,Re x){
	if(!p)return -inf;
	if(x==pv)return x;
	else if(x<pv)return ask_pri(pl,x);
	else return max(pv,ask_pri(pr,x));
}
inline int ask_nex(Re p,Re x){
	if(!p)return inf;
	if(x==pv)return x;
	else if(x>pv)return ask_nex(pr,x);
	else return min(pv,ask_nex(pl,x));
}
int main(){
	srand((int)time(NULL));
	in(T);--T;in(a);ans=a;insert(root,a);
	while(T--){
		in(a);
		ans+=min(abs(a-ask_pri(root,a)),abs(a-ask_nex(root,a)));
		insert(root,a);
	}
	printf("%d",ans);
}

```

### 2.8 主席树与可持久化

**区间第k小** *(seg)*

> 【区间第k小（seg）】
代码包含 update, query, solve 等核心函数，实现了 区间第k小 的算法逻辑。

核心函数：
  int update(int lu, int l, int r, int x) — 单点/区间更新操作
  int query(int u1, int u2, int l, int r, int k) — 区间/路径查询操作
  void solve(无参数) — 主解题函数

关键配置：
N=2e5 + 5

说明：核心变化：前缀和相减，二分找第 K 小

```cpp
#pragma GCC optimize("O3,unroll-loops")
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
const int N = 2e5 + 5; 
int n, m, cnt, root[N], a[N];
int ls[N << 5], rs[N << 5], w[N << 5];
vector<int> b;
int update(int lu, int l, int r, int x) {
    int u = ++cnt;
    ls[u] = ls[lu]; rs[u] = rs[lu]; w[u] = w[lu] + 1;
    if (l == r) return u;
    int mid = (l + r) >> 1;
    if (x <= mid) ls[u] = update(ls[lu], l, mid, x);
    else rs[u] = update(rs[lu], mid + 1, r, x);
    return u;
}
// 核心变化：前缀和相减，二分找第 K 小
int query(int u1, int u2, int l, int r, int k) {
    if (l == r) return l;
    int d = w[ls[u2]] - w[ls[u1]]; 
    int mid = (l + r) >> 1;
    if (k <= d) return query(ls[u1], ls[u2], l, mid, k); 
    else return query(rs[u1], rs[u2], mid + 1, r, k - d); 
}
void solve() {
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
        b.push_back(a[i]);
    }
    sort(b.begin(), b.end());
    b.erase(unique(b.begin(), b.end()), b.end());
    int max_val = b.size();
    for (int i = 1; i <= n; i++) {
        int x = lower_bound(b.begin(), b.end(), a[i]) - b.begin() + 1;
        root[i] = update(root[i - 1], 1, max_val, x);
    }
    
    while (m--) {
        int l, r, k;
        cin >> l >> r >> k;
        int ans_rk = query(root[l - 1], root[r], 1, max_val, k);
        cout << b[ans_rk - 1] << '\n'; 
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    solve();
    return 0;
}
```

**区间元素数** *(seg)*

> 【区间元素数（seg）】
代码包含 update, query, solve 等核心函数，实现了 区间元素数 的算法逻辑。

核心函数：
  int update(int lu,int l,int r,int x) — 单点/区间更新操作
  int query(int u1,int u2,int l,int r,int x) — 区间/路径查询操作
  void solve(无参数) — 主解题函数

关键配置：
N=1e6+5

说明：#define int long long

```cpp
#include<iostream>
#include<stack>
#include<string>
#include<set>
#include<algorithm>
#include<queue>
#include<map>
#include<vector>
#include<cmath>
using namespace std;
//#define int long long
const int N=1e6+5;
int n,m,cnt,root[N],last[N];
int ls[N<<5],rs[N<<5],w[N<<5];
int update(int lu,int l,int r,int x){
	int u=++cnt;
	ls[u]=ls[lu],rs[u]=rs[lu],w[u]=w[lu];w[u]++;
	if(l==r)return u;
	int mid=(l+r)>>1;
	if(x<=mid)ls[u]=update(ls[lu],l,mid,x);
	else rs[u]=update(rs[lu],mid+1,r,x);
	return u;
}
int query(int u1,int u2,int l,int r,int x){
	if(l>=x)return 0;
	if(r<x)return w[u2]-w[u1];
	int mid=(l+r)>>1;
	return query(ls[u1],ls[u2],l,mid,x)+query(rs[u1],rs[u2],mid+1,r,x);
}
void solve(){
	cin>>n;
	for(int i=1;i<=n;i++){
		int x;
		cin>>x;
		if(last[x])root[i]=update(root[i-1],0,n,last[x]);
		else root[i]=update(root[i-1],0,n,0);	
		last[x]=i;	
	}
	cin>>m;
	while(m--){
		int l,r;
		cin>>l>>r;
		cout<<query(root[l-1],root[r],0,n,l)<<'\n';
	}
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    int T=1;
    while(T--)solve();
}
/*
*/
```

**区间MEX** *(seg)*

> 【区间MEX（seg）】
代码包含 update, query, solve 等核心函数，实现了 区间MEX 的算法逻辑。

核心函数：
  int update(int pre, int l, int r, int x, int pos) — 单点/区间更新操作
  int query(int u, int l, int r, int limit_L) — 区间/路径查询操作
  void solve(无参数) — 主解题函数

关键配置：
N=2e5 + 5

```cpp
#pragma GCC optimize("O3,unroll-loops")
#include <iostream>
using namespace std;
const int N = 2e5 + 5; 
int n, q, cnt, root[N];
int ls[N * 40], rs[N * 40], min_pos[N * 40]; 
int update(int pre, int l, int r, int x, int pos) {
    int u = ++cnt;
    ls[u] = ls[pre]; rs[u] = rs[pre]; 
    if (l == r) {
        min_pos[u] = pos;
        return u;
    }
    int mid = (l + r) >> 1;
    if (x <= mid) ls[u] = update(ls[pre], l, mid, x, pos);
    else rs[u] = update(rs[pre], mid + 1, r, x, pos);
    min_pos[u] = min(min_pos[ls[u]], min_pos[rs[u]]);
    return u;
}
int query(int u, int l, int r, int limit_L) {
    if (l == r) return l;
    int mid = (l + r) >> 1;
    if (min_pos[ls[u]] < limit_L) return query(ls[u], l, mid, limit_L);
    else return query(rs[u], mid + 1, r, limit_L);
}
void solve() {
    cin >> n >> q;
    for (int i = 1, x; i <= n; ++i) {
        cin >> x;
        if (x > n + 1) {
            root[i] = root[i - 1];
        } else {
            root[i] = update(root[i - 1], 0, n + 1, x, i);
        }
    }
    while (q--) {
        int l, r;
        cin >> l >> r;
        cout << query(root[r], 0, n + 1, l) << '\n';
    }
}
int main() {
    ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    solve();
    return 0;
}
```

### 2.9 分块与莫队

**1.区修,单查** *(optimize)*

> 【1.区修,单查】
分块（Sqrt Decomposition）模板，将序列分成 sqrt(N) 块进行批量处理。

核心函数：
  void in(Re &x) — 核心算法函数
  void change(Re l,Re r,Re x) — 核心算法函数
  LL ask(Re x) — 核心算法函数

关键配置：
N=5e4+3,T=230

复杂度：O((N+Q)·sqrt(N)) 或类似分块复杂度

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)
#include<cstdio>
#include<cmath>
#define LL long long
#define Re register int
#define F(x,a,b) for(Re x=a;x<=b;++x)
const int N=5e4+3,T=230;
int n,t,x,l,r,Q,fu,pt[N],L[T],R[T];LL a[N],S[T],add[T];
inline void in(Re &x){
    x=fu=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
inline void change(Re l,Re r,Re x){
	Re p=pt[l],q=pt[r];
	if(p==q){F(i,l,r)a[i]+=x;S[p]+=x*(r-l+1);}
	else{
		F(i,p+1,q-1)add[i]+=x;
		F(i,l,R[p])a[i]+=x;S[p]+=x*(R[p]-l+1);
		F(i,L[q],r)a[i]+=x;S[q]+=x*(r-L[q]+1);
	}
}
inline LL ask(Re x){return a[x]+add[pt[x]];}
int main(){
	in(n),t=sqrt(Q=n);
	F(i,1,t)L[i]=(i-1)*t+1,R[i]=i*t;
	if(R[t]<n)R[++t]=n,L[t]=R[t-1]+1;
	F(i,1,n)in(x),a[i]=x;
	F(i,1,t)F(j,L[i],R[i])pt[j]=i,S[i]+=a[j];
	while(Q--){
		in(n),in(l),in(r),in(x);
		if(n)printf("%lld\n",ask(r));
		else change(l,r,x);
	}
}

```

**2.区修,区查** *(小于c2的个数)*

> 【2.区修,区查（小于c2的个数）】
分块（Sqrt Decomposition）模板，将序列分成 sqrt(N) 块进行批量处理。

核心函数：
  void in(Re &x) — 核心算法函数
  void sak(Re l,Re r,Re p,Re x) — 后缀数组
  void change(Re l,Re r,Re x) — 核心算法函数
  LL ask(Re l,Re r,LL x) — 核心算法函数

关键配置：
N=5e4+3,T=230

复杂度：O((N+Q)·sqrt(N)) 或类似分块复杂度

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)
#include<algorithm>
#include<cstdio>
#include<cmath>
#define LL long long
#define Re register int
#define F(x,a,b) for(Re x=a;x<=b;++x)
#define lo(l,r,x) (lower_bound(b+l,b+r+1,x)-b)
using namespace std;
const int N=5e4+3,T=230;
int n,t,x,l,r,o,Q,fu,pt[N],L[T],R[T];LL a[N],b[N],add[T];
inline void in(Re &x){
    x=fu=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
inline void sak(Re l,Re r,Re p,Re x){F(i,l,r)a[i]+=x;F(i,L[p],R[p])b[i]=a[i];sort(b+L[p],b+R[p]+1);}
inline void change(Re l,Re r,Re x){
	Re p=pt[l],q=pt[r];
	if(p==q)sak(l,r,p,x);
	else{
		F(i,p+1,q-1)add[i]+=x;
		sak(l,R[p],p,x),sak(L[q],r,q,x);
	}
}
inline LL ask(Re l,Re r,LL x){
	Re p=pt[l],q=pt[r];LL ans=0;
	if(p==q){F(i,l,r)ans+=a[i]+add[p]<x;return ans;}
	else{
		F(i,p+1,q-1)ans+=lo(L[i],R[i],x-add[i])-L[i];
		F(i,l,R[p])ans+=a[i]+add[p]<x;
		F(i,L[q],r)ans+=a[i]+add[q]<x;
	}
	return ans;
}
int main(){
	in(n),t=sqrt(Q=n);
	F(i,1,t)L[i]=(i-1)*t+1,R[i]=i*t;
	if(R[t]<n)R[++t]=n,L[t]=R[t-1]+1;
	F(i,1,n)in(x),a[i]=b[i]=x;
	F(i,1,t)F(j,L[i],R[i])pt[j]=i;
	F(i,1,t)sort(b+L[i],b+R[i]+1);
	while(Q--){
		in(o),in(l),in(r),in(x);
		if(o)printf("%lld\n",ask(l,r,(LL)x*x));
		else change(l,r,x);
	}
}

```

**3.区修,区查** *(x的前驱)*

> 【3.区修,区查（x的前驱）】
分块（Sqrt Decomposition）模板，将序列分成 sqrt(N) 块进行批量处理。

核心函数：
  void in(Re &x) — 核心算法函数
  void sak(Re l,Re r,Re p,Re x) — 后缀数组
  void change(Re l,Re r,Re x) — 核心算法函数
  int ask(Re l,Re r,Re x) — 核心算法函数

关键配置：
N=1e5+3,T=330

复杂度：O((N+Q)·sqrt(N)) 或类似分块复杂度

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)
#include<algorithm>
#include<cstdio>
#include<cmath>
#define inf -2147483647
#define Re register int
#define F(x,a,b) for(Re x=a;x<=b;++x)
using namespace std;
const int N=1e5+3,T=330;
int n,t,x,l,r,o,Q,fu,pt[N],L[T],R[T],a[N],b[N],add[T];
inline void in(Re &x){
    x=fu=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
inline void sak(Re l,Re r,Re p,Re x){F(i,l,r)a[i]+=x;F(i,L[p],R[p])b[i]=a[i];sort(b+L[p],b+R[p]+1);}
inline void change(Re l,Re r,Re x){
    Re p=pt[l],q=pt[r];
    if(p==q)sak(l,r,p,x);
    else{
        F(i,p+1,q-1)add[i]+=x;
        sak(l,R[p],p,x),sak(L[q],r,q,x);
    }
}
inline int ask(Re l,Re r,Re x){
    Re p=pt[l],q=pt[r],ans=inf,w;
    if(p==q){F(i,l,r)if(a[i]+add[p]<x)ans=max(ans,a[i]+add[p]);}
    else{
        F(i,p+1,q-1)w=lower_bound(b+L[i],b+R[i]+1,x-add[i])-(b+1),ans=w>=L[i]?max(ans,b[w]+add[i]):ans;
        F(i,l,R[p])if(a[i]+add[p]<x)ans=max(ans,a[i]+add[p]);
        F(i,L[q],r)if(a[i]+add[q]<x)ans=max(ans,a[i]+add[q]);
    }
    return ans==inf?-1:ans;
}
int main(){
    in(n),t=sqrt(Q=n);
    F(i,1,t)L[i]=(i-1)*t+1,R[i]=i*t;
    if(R[t]<n)R[++t]=n,L[t]=R[t-1]+1;
    F(i,1,n)in(x),a[i]=b[i]=x;
    F(i,1,t)F(j,L[i],R[i])pt[j]=i;
    F(i,1,t)sort(b+L[i],b+R[i]+1);
    while(Q--){
        in(o),in(l),in(r),in(x);
        if(o)printf("%d\n",ask(l,r,x));
        else change(l,r,x);
    }
}

```

**4.区修,区查** *(Sum)*

> 【4.区修,区查（Sum）】
分块（Sqrt Decomposition）模板，将序列分成 sqrt(N) 块进行批量处理。

核心函数：
  void in(Re &x) — 核心算法函数
  void change(Re l,Re r,Re x) — 核心算法函数
  LL ask(Re l,Re r) — 核心算法函数

关键配置：
N=5e4+3,T=230

复杂度：O((N+Q)·sqrt(N)) 或类似分块复杂度

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)
#include<cstdio>
#include<cmath>
#define LL long long
#define Re register int
#define F(x,a,b) for(Re x=a;x<=b;++x)
const int N=5e4+3,T=230;
int n,t,x,l,r,Q,fu,pt[N],L[T],R[T];LL a[N],S[T],add[T];
inline void in(Re &x){
    x=fu=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
inline void change(Re l,Re r,Re x){
	Re p=pt[l],q=pt[r];
	if(p==q){F(i,l,r)a[i]+=x;S[p]+=(LL)x*(r-l+1);}
	else{
		F(i,p+1,q-1)add[i]+=x;
		F(i,l,R[p])a[i]+=x;S[p]+=(LL)x*(R[p]-l+1);
		F(i,L[q],r)a[i]+=x;S[q]+=(LL)x*(r-L[q]+1);
	}
}
inline LL ask(Re l,Re r){
	Re p=pt[l],q=pt[r];LL ans=0;
	if(p==q){F(i,l,r)ans+=a[i];ans+=add[p]*(r-l+1);}
	else{
		F(i,p+1,q-1)ans+=S[i]+add[i]*(LL)(R[i]-L[i]+1);
		F(i,l,R[p])ans+=a[i];ans+=add[p]*(LL)(R[p]-l+1);
		F(i,L[q],r)ans+=a[i];ans+=add[q]*(LL)(r-L[q]+1);
	}
	return ans;
}
int main(){
	in(n),t=sqrt(Q=n);
	F(i,1,t)L[i]=(i-1)*t+1,R[i]=i*t;
	if(R[t]<n)R[++t]=n,L[t]=R[t-1]+1;
	F(i,1,n)in(x),a[i]=x;
	F(i,1,t)F(j,L[i],R[i])pt[j]=i,S[i]+=a[j];
	while(Q--){
		in(n),in(l),in(r),in(x);
		if(n)printf("%lld\n",ask(l,r)%(x+1));
		else change(l,r,x);
	}
}

```

**5.区修,区查(Sum)** *(Sqrt)*

> 【5.区修,区查(Sum)（Sqrt）】
分块（Sqrt Decomposition）模板，将序列分成 sqrt(N) 块进行批量处理。

核心函数：
  void in(Re &x) — 核心算法函数
  void sakura(Re p) — 后缀数组
  void change(Re l,Re r) — 核心算法函数
  LL ask(Re l,Re r) — 核心算法函数

关键配置：
N=5e4+3,T=230

复杂度：O((N+Q)·sqrt(N)) 或类似分块复杂度

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)
#include<cstdio>
#include<cmath>
#define LL long long
#define Re register int
#define F(x,a,b) for(Re x=a;x<=b;++x)
const int N=5e4+3,T=230;
int n,t,x,l,r,Q,fu,pt[N],L[T],R[T],pan[T];LL a[N],S[T];
inline void in(Re &x){
    x=fu=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
inline void sakura(Re p){
	if(pan[p])return;pan[p]=1,S[p]=0;
	F(i,L[p],R[p])S[p]+=(a[i]=sqrt(a[i])),pan[p]&=(a[i]<=1);
}
inline void change(Re l,Re r){
	Re p=pt[l],q=pt[r];
	if(p==q){F(i,l,r)S[p]-=a[i],a[i]=sqrt(a[i]),S[p]+=a[i];}
	else{
		F(i,p+1,q-1)sakura(i);
		F(i,l,R[p])S[p]-=a[i],a[i]=sqrt(a[i]),S[p]+=a[i];
		F(i,L[q],r)S[q]-=a[i],a[i]=sqrt(a[i]),S[q]+=a[i];
	}
}
inline LL ask(Re l,Re r){
	Re p=pt[l],q=pt[r];LL ans=0;
	if(p==q){F(i,l,r)ans+=a[i];}
	else{
		F(i,p+1,q-1)ans+=S[i];
		F(i,l,R[p])ans+=a[i];
		F(i,L[q],r)ans+=a[i];
	}
	return ans;
}
int main(){
	in(n),t=sqrt(Q=n);
	F(i,1,t)L[i]=(i-1)*t+1,R[i]=i*t;
	if(R[t]<n)R[++t]=n,L[t]=R[t-1]+1;
	F(i,1,n)in(x),a[i]=x;
	F(i,1,t)F(j,L[i],R[i])pt[j]=i,S[i]+=a[j];
	while(Q--){
		in(n),in(l),in(r),in(x);
		if(n)printf("%lld\n",ask(l,r));
		else change(l,r);
	}
}

```

**6.单插,单查** *(w前面插入x)*

> 【6.单插,单查（w前面插入x）】
分块（Sqrt Decomposition）模板，将序列分成 sqrt(N) 块进行批量处理。

核心函数：
  void in(Re &x) — 核心算法函数
  void change(Re w,Re x) — 核心算法函数
  int ask(Re w) — 核心算法函数
   F(i,1,t) — 核心算法函数

关键配置：
N=1e5+3,T=330

复杂度：O((N+Q)·sqrt(N)) 或类似分块复杂度

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)
#include<vector>
#include<cstdio>
#include<cmath>
#define Re register int
#define F(x,a,b) for(Re x=a;x<=b;++x)
using namespace std;
const int N=1e5+3,T=330;
int n,o,t,x,l,r,Q,fu,pt[N],pw[N],L[T],R[T];
vector<int>a[T];
inline void in(Re &x){
    x=fu=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
inline void change(Re w,Re x){
    F(i,1,t)
        if(w>a[i].size())w-=a[i].size();
        else{a[i].insert(a[i].begin()+w-1,x);return;}
}
inline int ask(Re w){
    F(i,1,t)
        if(w>a[i].size())w-=a[i].size();
        else return a[i][w-1];
}
int main(){
    in(n),t=sqrt(Q=n);
    F(i,1,t)L[i]=(i-1)*t+1,R[i]=i*t;
    if(R[t]<n)R[++t]=n,L[t]=R[t-1]+1;
    F(i,1,t){F(j,L[i],R[i])in(x),a[i].push_back(x),pt[j]=i;}
    while(Q--){
        in(o),in(l),in(r),in(x);
        if(o)printf("%d\n",ask(r));
        else change(l,r);
    }
}

```

**7.区修,单查** *(+,×)*

> 【7.区修,单查（+,×）】
分块（Sqrt Decomposition）模板，将序列分成 sqrt(N) 块进行批量处理。

核心函数：
  void in(Re &x) — 核心算法函数
  void spread(Re p) — 预处理函数
  void change(Re l,Re r,Re x) — 核心算法函数
  void change2(Re l,Re r,Re x) — 核心算法函数
  int ask(Re x) — 核心算法函数

关键配置：
N=1e5+3,T=320

复杂度：O((N+Q)·sqrt(N)) 或类似分块复杂度

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)
#include<cstdio>
#include<cmath>
#define Re register int
#define F(x,a,b) for(Re x=a;x<=b;++x)
const int N=1e5+3,T=320;
int n,t,x,l,r,Q,fu,P=10007,pt[N],L[T],R[T],a[N],add[T],mul[T];
inline void in(Re &x){
    x=fu=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
inline void spread(Re p){
	F(i,L[p],R[p])(((a[i]*=mul[p])%=P)+=add[p])%=P;
	add[p]=0,mul[p]=1;
}
inline void change(Re l,Re r,Re x){
	Re p=pt[l],q=pt[r];spread(p);
	if(p==q)F(i,l,r)(a[i]+=x)%=P;
	else{
		spread(q);
		F(i,p+1,q-1)(add[i]+=x)%P;
		F(i,l,R[p])(a[i]+=x)%=P;
		F(i,L[q],r)(a[i]+=x)%=P;
	}
}
inline void change2(Re l,Re r,Re x){
	Re p=pt[l],q=pt[r];spread(p);
	if(p==q)F(i,l,r)(a[i]*=x)%=P;
	else{
		spread(q);
		F(i,p+1,q-1)(add[i]*=x)%=P,(mul[i]*=x)%=P;
		F(i,l,R[p])(a[i]*=x)%=P;
		F(i,L[q],r)(a[i]*=x)%=P;
	}
}
inline int ask(Re x){return (a[x]*mul[pt[x]]%P+add[pt[x]])%P;}
int main(){
	in(n),t=sqrt(Q=n);
	F(i,1,t)L[i]=(i-1)*t+1,R[i]=i*t,mul[i]=1;
	if(R[t]<n)R[++t]=n,L[t]=R[t-1]+1,mul[t]=1;
	F(i,1,n)in(a[i]);
	F(i,1,t)F(j,L[i],R[i])pt[j]=i;
	while(Q--){
		in(n),in(l),in(r),in(x);
		if(n>1)printf("%d\n",ask(r));
		else n?change2(l,r,x%P):change(l,r,x%P);
	}
}

```

**8.区修,区查(c的个数)** *(推平)*

> 【8.区修,区查(c的个数)（推平）】
分块（Sqrt Decomposition）模板，将序列分成 sqrt(N) 块进行批量处理。

核心函数：
  void in(Re &x) — 核心算法函数
  int sak(Re l,Re r,Re p,Re x) — 后缀数组
  int fuck(Re p,Re x) — 核心算法函数
  int sovle(Re l,Re r,Re x) — 核心算法函数
   F(i,1,t) — 核心算法函数

关键配置：
N=1e5+3,T=330

复杂度：O((N+Q)·sqrt(N)) 或类似分块复杂度

```cpp
#pragma GCC diagnostic error "-std=c++11"
#pragma GCC target("avx")
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#include<cstdio>
#include<cmath>
#define Re register int
#define F(x,a,b) for(Re x=a;x<=b;++x)
const int N=1e5+3,T=330;
int n,t,x,l,r,Q,fu,pt[N],L[T],R[T],a[N],tag[T];
inline void in(Re &x){
    x=fu=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
inline int sak(Re l,Re r,Re p,Re x){
    Re tmp=0;
    if(tag[p]!=-1){F(i,L[p],R[p])a[i]=tag[p];tmp+=(r-l+1)*(tag[p]==x);}
    else F(i,l,r)tmp+=a[i]==x;
    tag[p]=-1;F(i,l,r)a[i]=x;
    return tmp;
}
inline int fuck(Re p,Re x){
    Re tmp=0;
    if(tag[p]!=-1){F(j,L[p],R[p])a[j]=tag[p];tmp+=(R[p]-L[p]+1)*(tag[p]==x);}
    else F(j,L[p],R[p])tmp+=a[j]==x;
    tag[p]=x;
    return tmp;
}
inline int sovle(Re l,Re r,Re x){
    Re p=pt[l],q=pt[r],ans=0;
    if(p==q)return l==r?fuck(p,x):sak(l,r,p,x);
    else{
        F(i,p+1,q-1)ans+=fuck(i,x);
        ans+=sak(l,R[p],p,x)+sak(L[q],r,q,x);
    }
    return ans;
}
int main(){
    in(n),t=sqrt(Q=n);
    F(i,1,t)L[i]=(i-1)*t+1,R[i]=i*t;
    if(R[t]<n)R[++t]=n,L[t]=R[t-1]+1;
    F(i,1,n)in(x),a[i]=x;
    F(i,1,t){tag[i]=-1;F(j,L[i],R[i])pt[j]=i;}
    while(Q--){
        in(l),in(r),in(x);
        printf("%d\n",sovle(l,r,x));
    }
}

```

**回滚莫队** *(歴史の研究)*

> 【回滚莫队（歴史の研究）】
莫队算法（Mo's Algorithm）模板，通过离线排序优化区间查询。

核心函数：
  void in(Re &x) — 核心算法函数

核心结构体：Query

关键配置：
N=1e5+3,M=1e5+3

复杂度：O((N+Q)·sqrt(N)) 或类似分块复杂度

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#define LL long long
#define Re register int
using namespace std;
const int N=1e5+3,M=1e5+3;
int n,m,T,BL,BLN,A[N],b[N],Li[325],Ri[325],cnt[N],cnt_[N],belong[N];LL Ans[M];
struct Query{
	int l,r,id;
	inline bool operator<(const Query &O)const{
		Re B1=belong[l],B2=belong[O.l];
		return B1!=B2?B1<B2:r<O.r;
	}
}Q[M];
inline void in(Re &x){
    Re fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T),BL=sqrt(n)+1,BLN=n/BL+1;
	for(Re i=1;i<=BLN;++i){
		Li[i]=(i-1)*BL+1,Ri[i]=min(i*BL,n);
		for(Re j=Li[i];j<=Ri[i];++j)belong[j]=i;
	}
	for(Re i=1;i<=n;++i)in(A[i]),b[i]=A[i];
	sort(b+1,b+n+1),m=unique(b+1,b+n+1)-b-1;
	for(Re i=1;i<=n;++i)A[i]=lower_bound(b+1,b+m+1,A[i])-b;
	for(Re i=1;i<=T;++i)in(Q[i].l),in(Q[i].r),Q[i].id=i;
	sort(Q+1,Q+T+1);Re i=1;
	for(Re p=1;p<=BLN;++p){
		Re nowL=Ri[p]+1,nowR=Ri[p];LL ans=0;
		memset(cnt,0,sizeof(cnt));
		while(belong[Q[i].l]==p){
			Re L=Q[i].l,R=Q[i].r;
			if(belong[L]==belong[R]){
				LL tmp=0;
				for(Re j=L;j<=R;++j)cnt_[A[j]]=0;
				for(Re j=L;j<=R;++j)++cnt_[A[j]],tmp=max(tmp,(LL)b[A[j]]*cnt_[A[j]]);
				Ans[Q[i].id]=tmp;
			}
			else{
				while(nowR<R)cnt[A[++nowR]]++,ans=max(ans,(LL)b[A[nowR]]*cnt[A[nowR]]);
				LL tmp=ans;
				while(nowL>L)cnt[A[--nowL]]++,tmp=max(tmp,(LL)b[A[nowL]]*cnt[A[nowL]]);
				Ans[Q[i].id]=tmp;
				while(nowL<Ri[p]+1)--cnt[A[nowL++]];
			}
			++i;
		}
	}
	for(Re i=1;i<=T;++i)printf("%lld\n",Ans[i]);
}

```

**带修莫队** *(数颜色／维护队列)*

> 【带修莫队（数颜色／维护队列）】
莫队算法（Mo's Algorithm）模板，通过离线排序优化区间查询。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x) — 加法更新
  void del(Re x) — 核心算法函数

核心结构体：Query, Change

关键配置：
N=2e5+3,M=2e5+3,INF=1e6+3

复杂度：O((N+Q)·sqrt(N)) 或类似分块复杂度

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#define Re register int
using namespace std;
const int N=2e5+3,M=2e5+3,INF=1e6+3;
int n,x,y,T,TQ,TC,BL,ans,a[N],Ans[M],cnt[INF];char op;
struct Query{
    int l,r,id,time;
    inline bool operator<(const Query &O)const{
        Re B1=l/BL,B2=O.l/BL,B3=r/BL,B4=O.r/BL;
        return B1!=B2?B1<B2:(B3!=B4?B3<B4:time<O.time);
    }
}Q[N];
struct Change{int w,co;}C[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void add(Re x){ans+=!cnt[x]++;}
inline void del(Re x){ans-=!--cnt[x];}
int main(){
//    freopen("123.txt","r",stdin);
    in(n),in(T),BL=pow(n,2.0/3.0);
    for(Re i=1;i<=n;++i)in(a[i]);
    for(Re i=1;i<=T;++i){
    	scanf(" %c",&op);
    	in(x),in(y);
    	if(op=='Q')++TQ,Q[TQ]=(Query){x,y,TQ,TC};
    	else C[++TC]=(Change){x,y};
	}
    sort(Q+1,Q+TQ+1);
    Re nowL=1,nowR=0,nowT=0;
    for(Re i=1;i<=TQ;++i){
        while(nowL<Q[i].l)del(a[nowL++]);
        while(nowL>Q[i].l)add(a[--nowL]);
        while(nowR>Q[i].r)del(a[nowR--]);
        while(nowR<Q[i].r)add(a[++nowR]);
        while(nowT<Q[i].time){
        	Re w=C[++nowT].w;
        	if(nowL<=w&&w<=nowR)del(a[w]),add(C[nowT].co);
        	swap(a[w],C[nowT].co);
		}
		while(nowT>Q[i].time){
			Re w=C[nowT].w;
        	if(nowL<=w&&w<=nowR)del(a[w]),add(C[nowT].co);
        	swap(a[w],C[nowT--].co);
		}
        Ans[Q[i].id]=ans;
    }
    for(Re i=1;i<=TQ;++i)printf("%d\n",Ans[i]);
}

```

**树上带修莫队** *(糖果公园)*

> 【树上带修莫队（糖果公园）】
莫队算法（Mo's Algorithm）模板，通过离线排序优化区间查询。

核心函数：
  void add(Re x,Re y) — 加法更新
  void in(Re &x) — 核心算法函数
  void dfs(Re x,Re fa) — 深度优先搜索遍历
  int lca(Re x,Re y) — 查询最近公共祖先
  void change(Re x) — 核心算法函数

核心结构体：QAQ, LCA, Query, Change

关键配置：
N=1e5+3,M=1e5+3,logN=17

复杂度：O((N+Q)·sqrt(N)) 或类似分块复杂度

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#define LL long long
#define Re register int
using namespace std;
const int N=1e5+3,M=1e5+3,logN=17;
int n,m,x,y,o,T,op,id_O,A[N],V[N],W[N],B[N],head[N],last[N],first[N];
struct QAQ{int to,next;}a[N<<1];
inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    Re fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
struct LCA{
	int deep[N],ant[N][20];
	inline void dfs(Re x,Re fa){
		first[B[++B[0]]=x]=++id_O;
		deep[x]=deep[ant[x][0]=fa]+1;
		for(Re i=1;(1<<i)<=deep[x];++i)ant[x][i]=ant[ant[x][i-1]][i-1];
		for(Re i=head[x];i;i=a[i].next)if(a[i].to!=fa)dfs(a[i].to,x);
		last[B[++B[0]]=x]=++id_O;
	}
	inline int lca(Re x,Re y){
		if(deep[x]<deep[y])swap(x,y);
		for(Re i=logN;i>=0;--i)if(deep[ant[x][i]]>=deep[y])x=ant[x][i];
		if(x==y)return x;
		for(Re i=logN;i>=0;--i)if(ant[x][i]!=ant[y][i])x=ant[x][i],y=ant[y][i];
		return ant[x][0];
	}
}T1;
int BL,TQ,TC,vis[N],cnt[N];LL ans,Ans[M];
struct Query{
	int l,r,id,lca,time;
	inline bool operator<(const Query &O)const{
		Re B1=l/BL,B2=O.l/BL,B3=r/BL,B4=O.r/BL;
		return B1!=B2?B1<B2:(B3!=B4?B3<B4:time<O.time);
	}
}Q[M];
struct Change{int w,co;}C[M];
inline void change(Re x){
	vis[x]?ans-=(LL)V[A[x]]*W[cnt[A[x]]--]:ans+=(LL)V[A[x]]*W[++cnt[A[x]]],vis[x]^=1;
}
int main(){
	freopen("123.txt","r",stdin);
	in(n),in(m),in(T),BL=pow(n<<1,2.0/3.0);
	for(Re i=1;i<=m;++i)in(V[i]);
	for(Re i=1;i<=n;++i)in(W[i]);
	for(Re i=1;i<n;++i)in(x),in(y),add(x,y),add(y,x);
	for(Re i=1;i<=n;++i)in(A[i]);
	T1.dfs(1,0);
	for(Re i=1;i<=T;++i){
		in(op),in(x),in(y);
		if(op){
			Re lca=T1.lca(x,y);
			if(first[x]>first[y])swap(x,y);
			if(lca==x)++TQ,Q[TQ]=(Query){first[x],first[y],TQ,0,TC};
			else ++TQ,Q[TQ]=(Query){last[x],first[y],TQ,lca,TC};
		}
		else C[++TC]=(Change){x,y};
	}
	sort(Q+1,Q+TQ+1);
	Re nowL=1,nowR=0,nowT=0;
	for(Re i=1;i<=TQ;++i){
		Re L=Q[i].l,R=Q[i].r,T=Q[i].time,lca=Q[i].lca;
		while(nowL<L)change(B[nowL++]);
		while(nowL>L)change(B[--nowL]);
		while(nowR>R)change(B[nowR--]);
		while(nowR<R)change(B[++nowR]);
		while(nowT<T){
			Re w=C[++nowT].w;
			if(vis[w])change(w),swap(A[w],C[nowT].co),change(w);
			else swap(A[w],C[nowT].co);
		}
		while(nowT>T){
			Re w=C[nowT].w;
			if(vis[w])change(w),swap(A[w],C[nowT].co),change(w);
			else swap(A[w],C[nowT].co);
			--nowT;
		}
		if(lca)change(lca);
		Ans[Q[i].id]=ans;
		if(lca)change(lca);
	}
	for(Re i=1;i<=TQ;++i)printf("%lld\n",Ans[i]);
}

```

**树上静态莫队** *(Count on a tree II)*

> 【树上静态莫队（Count on a tree II）】
莫队算法（Mo's Algorithm）模板，通过离线排序优化区间查询。

核心函数：
  void add(Re x,Re y) — 加法更新
  void in(Re &x) — 核心算法函数
  void dfs(Re x,Re fa) — 深度优先搜索遍历
  int lca(Re x,Re y) — 查询最近公共祖先
  void change(Re x) — 核心算法函数

核心结构体：QAQ, LCA, Query

关键配置：
N=4e4+3,M=1e5+3,INF=1e6+3,logN=16

复杂度：O((N+Q)·sqrt(N)) 或类似分块复杂度

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#define LL long long
#define Re register int
using namespace std;
const int N=4e4+3,M=1e5+3,INF=1e6+3,logN=16;
int n,m,o,x,y,T,BL,id_O,b[N],A[N],B[N<<1],head[N],last[N],first[N];
struct QAQ{int to,next;}a[N<<1];
inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    Re fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
struct LCA{
	int deep[N],ant[N][20];
	inline void dfs(Re x,Re fa){
		first[B[++B[0]]=x]=++id_O;
		deep[x]=deep[ant[x][0]=fa]+1;
		for(Re i=1;(1<<i)<=deep[x];++i)ant[x][i]=ant[ant[x][i-1]][i-1];
		for(Re i=head[x];i;i=a[i].next)if(a[i].to!=fa)dfs(a[i].to,x);
		last[B[++B[0]]=x]=++id_O;
	}
	inline int lca(Re x,Re y){
		if(deep[x]<deep[y])swap(x,y);
		for(Re i=logN;i>=0;--i)if(deep[ant[x][i]]>=deep[y])x=ant[x][i];
		if(x==y)return x;
		for(Re i=logN;i>=0;--i)if(ant[x][i]!=ant[y][i])x=ant[x][i],y=ant[y][i];
		return ant[x][0];
	}
}T1;
struct Query{
	int l,r,id,lca;
	inline bool operator<(const Query &O)const{
		Re B1=l/BL,B2=O.l/BL;
		return B1!=B2?B1<B2:((B1&1)?r<O.r:r>O.r);
	}
}Q[M];
int ans,vis[N<<1],Ans[M],cnt[INF];
inline void change(Re x){
	vis[x]?ans-=!--cnt[A[x]]:ans+=!cnt[A[x]]++,vis[x]^=1;
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T),BL=sqrt(n<<1);
	for(Re i=1;i<=n;++i)in(A[i]),b[i]=A[i];
	sort(b+1,b+n+1),m=unique(b+1,b+n+1)-b-1;
	for(Re i=1;i<=n;++i)A[i]=lower_bound(b+1,b+m+1,A[i])-b;
	m=n-1;while(m--)in(x),in(y),add(x,y),add(y,x);
	T1.dfs(1,0);
	for(Re i=1;i<=T;++i){
		in(x),in(y);Re lca=T1.lca(x,y);
		if(first[x]>first[y])swap(x,y);
		if(lca==x)Q[i]=(Query){first[x],first[y],i,0};
		else Q[i]=(Query){last[x],first[y],i,lca};
	}
	sort(Q+1,Q+T+1);
	Re nowL=1,nowR=0;
	for(Re i=1;i<=T;++i){
		Re L=Q[i].l,R=Q[i].r,lca=Q[i].lca;
		while(nowL<L)change(B[nowL++]);
		while(nowL>L)change(B[--nowL]);
		while(nowR>R)change(B[nowR--]);
		while(nowR<R)change(B[++nowR]);
		if(lca)change(lca);
		Ans[Q[i].id]=ans;
		if(lca)change(lca);
	}
	for(Re i=1;i<=T;++i)printf("%d\n",Ans[i]);
}

```

**静态莫队** *(D-query)*

> 【静态莫队（D-query）】
莫队算法（Mo's Algorithm）模板，通过离线排序优化区间查询。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x) — 加法更新
  void del(Re x) — 核心算法函数

核心结构体：Query

关键配置：
N=3e4+3,M=2e5+3

复杂度：O((N+Q)·sqrt(N)) 或类似分块复杂度

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#define LL long long
#define Re register int
using namespace std;
const int N=3e4+3,M=2e5+3;
int n,T,BL,ans,A[N],cnt[1000003],Ans[M];
struct Query{
    int l,r,id;
    inline bool operator<(const Query &O)const{
        Re B1=l/BL,B2=O.l/BL;
        return B1!=B2?B1<B2:((B1&1)?r<O.r:r>O.r);
    }
}Q[M];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void add(Re x){ans+=!cnt[x]++;}
inline void del(Re x){ans-=!--cnt[x];}
int main(){
    in(n),BL=sqrt(n)+1;
    for(Re i=1;i<=n;++i)in(A[i]);
    in(T);
    for(Re i=1;i<=T;++i)in(Q[i].l),in(Q[i].r),Q[i].id=i;
    sort(Q+1,Q+T+1);Re nowL=1,nowR=0;
    for(Re i=1;i<=T;++i){
        while(nowR<Q[i].r)add(A[++nowR]);
        while(nowR>Q[i].r)del(A[nowR--]);
        while(nowL>Q[i].l)add(A[--nowL]);
        while(nowL<Q[i].l)del(A[nowL++]);
        Ans[Q[i].id]=ans;
    }
    for(Re i=1;i<=T;++i)printf("%d\n",Ans[i]);
}

```

**小Z的袜子** *(optimize)*

> 【小Z的袜子】
分块（Sqrt Decomposition）模板，将序列分成 sqrt(N) 块进行批量处理。

核心函数：
  void in(Re &x) — 核心算法函数
  void sakura(Re p,Re x) — 后缀数组
  bool cmp(QAQ a,QAQ b) — 核心算法函数
  LL gcd_(LL a,LL b) — 最大公约数

核心结构体：QAQ

关键配置：
N=5e4+3

复杂度：O((N+Q)·sqrt(N)) 或类似分块复杂度

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)
#include<algorithm>
#include<cstdio>
#include<cmath>
#define Re register int
#define F(x,a,b) for(Re x=a;x<=b;++x)
#define LL long long
using std::sort;
const int N=5e4+3;
int n,q,t,L,R,ip,fu,len,gs[N],pt[N],co[N];LL ans,gcd,fz[N],fm[N];
struct QAQ{int l,r,id;}Q[N];
inline void in(Re &x){
    x=fu=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
inline void sakura(Re p,Re x){ans-=(LL)gs[fu=co[p]]*gs[fu],gs[fu]+=x,ans+=(LL)gs[fu]*gs[fu];} 
inline bool cmp(QAQ a,QAQ b){return pt[a.l]==pt[b.l]?a.r<b.r:a.l<b.l;}
inline LL gcd_(LL a,LL b){while(b^=a^=b^=a%=b);return a;}
int main(){
	in(n),in(q),t=sqrt(n);
	F(i,1,n)in(co[i]),pt[i]=i/t+1;
	F(i,1,q)in(Q[i].l),in(Q[i].r),Q[i].id=i;
	sort(Q+1,Q+q+1,cmp);
	L=1,R=0;
	F(i,1,q){
		while(L<Q[i].l)sakura(L++,-1);
		while(L>Q[i].l)sakura(--L,1);
		while(R<Q[i].r)sakura(++R,1);
		while(R>Q[i].r)sakura(R--,-1);
		ip=Q[i].id;
		if(Q[i].l==Q[i].r){fz[ip]=0,fm[ip]=1;continue;}
		fz[ip]=ans-(len=Q[i].r-Q[i].l+1);
		fm[ip]=(LL)len*(len-1);
		gcd=gcd_(fz[ip],fm[ip]),fz[ip]/=gcd,fm[ip]/=gcd;
	}
	F(i,1,q)printf("%lld/%lld\n",fz[i],fm[i]);
}

```

**蒲公英参考程序** *(区间众数)*

> 【蒲公英参考程序（区间众数）】
分块（Sqrt Decomposition）模板，将序列分成 sqrt(N) 块进行批量处理。

核心函数：
  void prework(无参数) — 预处理函数
  void update(int i) — 单点/区间更新操作
  int solve(int x,int y) — 主解题函数

复杂度：O((N+Q)·sqrt(N)) 或类似分块复杂度

```cpp
#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<cstring>
using namespace std;
const int u=40010;
int c[40][40][u],f[40][40],d[40][40],a[u],b[u],fa[u],fb[u],st[40],ed[40];
int n,m,t,l,tot,i,j,k,x,y,ans,L,R,cnt,num;

void prework()
{
	t=(int)pow(n*1.0,1.0/3);
	if(t) l=n/t;
	for(i=1;i<=t;i++) st[i]=(i-1)*l+1,ed[i]=i*l;
	if(ed[t]<n) st[t+1]=ed[t]+1,ed[++t]=n;
	memcpy(fa,a,sizeof(a));
	sort(fa+1,fa+n+1);
	for(i=1;i<=n;i++)
		if(i==1||fa[i]!=fa[i-1]) fb[++tot]=fa[i];
	for(i=1;i<=n;i++) b[i]=lower_bound(fb+1,fb+tot+1,a[i])-fb;
	for(i=1;i<=t;i++)
		for(j=i;j<=t;j++)
		{
			for(k=st[i];k<=ed[j];k++) c[i][j][b[k]]++;
			for(k=1;k<=tot;k++)
				if(c[i][j][k]>f[i][j]||c[i][j][k]==f[i][j]&&k<d[i][j])
					f[i][j]=c[i][j][k],d[i][j]=k;
		}
}

inline void update(int i)
{
	c[L][R][b[i]]++;
	if(c[L][R][b[i]]>cnt||c[L][R][b[i]]==cnt&&b[i]<num) cnt=c[L][R][b[i]],num=b[i];
}

int solve(int x,int y)
{
	int i,l,r;
	if(x>y) swap(x,y);
	for(i=1;i<=t;i++) if(x<=ed[i]) {l=i; break;}
	for(i=t;i;i--) if(y>=st[i]) {r=i; break;}
	if(l+1<=r-1) L=l+1,R=r-1; else L=R=0;
	cnt=f[L][R],num=d[L][R];
	if(l==r)
	{
		for(i=x;i<=y;i++) update(i);
		for(i=x;i<=y;i++) c[L][R][b[i]]--;
	}
	else{
		for(i=x;i<=ed[l];i++) update(i);
		for(i=st[r];i<=y;i++) update(i);
		for(i=x;i<=ed[l];i++) c[L][R][b[i]]--;
		for(i=st[r];i<=y;i++) c[L][R][b[i]]--;
	}
	return fb[num];
}

int main()
{
	cin>>n>>m;
	for(i=1;i<=n;i++) scanf("%d",&a[i]);
	prework();
	for(i=1;i<=m;i++)
	{
		scanf("%d%d",&x,&y);
		ans=solve((x+ans-1)%n+1,(y+ans-1)%n+1);
		printf("%d\n",ans);
	}
	return 0;
}

```

### 2.10 珂朵莉树

**珂朵莉树** *(optimize)*

> 【珂朵莉树】
代码包含 rnd, mi, split, assign, add 等核心函数，实现了 珂朵莉树 的算法逻辑。

核心函数：
  int rnd(无参数) — 核心算法函数
  LL mi(LL a,LL k,LL P) — 核心算法函数
  IT split(Re w) — 分裂操作
  void assign(Re l,Re r,LL v) — 核心算法函数
  void add(Re l,Re r,LL v) — 加法更新
  LL mi_sum(Re l,Re r,Re k,Re P) — 核心算法函数
  LL ask_k(Re l,Re r,Re k) — 核心算法函数

核心结构体：QAQ

关键配置：
N=1e5+5

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)
#include<algorithm>
#include<cstdio>
#include<vector>
#include<set>
#define LL long long
#define Re register int
#define IT set<QAQ>::iterator
using namespace std;
const int N=1e5+5;
struct QAQ{
	int l,r;mutable LL v;
	QAQ(int L,int R=-1,LL V=0):l(L),r(R),v(V){}
	bool operator<(QAQ o)const{return l<o.l;}
};
int l,r,x,y,n,m,fu,op,seed,vmax,a[N];set<QAQ>s;
inline int rnd(){
    Re tmp=seed;
    seed=((LL)seed*7+13)%1000000007;
    return tmp;
}
inline LL mi(LL a,LL k,LL P){
	LL ans=1;a%=P;
	while(k){
		if(k&1)(ans*=a)%=P;
		(a*=a)%=P,k>>=1;
	}
	return ans;
}
inline IT split(Re w){
	IT it=s.lower_bound(QAQ(w));
	if(it!=s.end()&&it->l==w)return it;
	--it;
	Re L=it->l,R=it->r;LL V=it->v;
	s.erase(it);
	s.insert(QAQ(L,w-1,V));
	return s.insert(QAQ(w,R,V)).first;
}
inline void assign(Re l,Re r,LL v){
	IT itr=split(r+1),itl=split(l);
	s.erase(itl,itr),s.insert(QAQ(l,r,v));
}
inline void add(Re l,Re r,LL v){
	IT itr=split(r+1),itl=split(l);
	while(itl!=itr)itl->v+=v,++itl;
}
inline LL mi_sum(Re l,Re r,Re k,Re P){
	IT itr=split(r+1),itl=split(l);LL ans=0;
	while(itl!=itr)(ans+=(LL)(itl->r-itl->l+1)%P*mi(itl->v,(LL)k,(LL)P)%P)%=P,++itl;
	return ans;
}
inline LL ask_k(Re l,Re r,Re k){
	IT itr=split(r+1),itl=split(l);
	vector<pair<LL,int> >Q;
	Q.clear();
	while(itl!=itr)Q.push_back(pair<LL,int>(itl->v,itl->r-itl->l+1)),++itl;
	sort(Q.begin(),Q.end());
	for(vector<pair<LL,int> >::iterator it=Q.begin();it!=Q.end();++it){
		k-=it->second;
		if(k<=0)return it->first;
	}
}
int main(){
	scanf("%d%d%d%d",&n,&m,&seed,&vmax);
	for(Re i=1;i<=n;++i)a[i]=(rnd()%vmax)+1,s.insert(QAQ(i,i,a[i]));
	s.insert(QAQ(n+1,n+1,0));
	while(m--){
	    op=(rnd()%4)+1,l=(rnd()%n)+1,r=(rnd()%n)+1;
	    if(l>r)swap(l,r);
	    if(op==3)x=(rnd()%(r-l+1))+1;
	    else x=(rnd()%vmax)+1;
	    if(op==4)y=(rnd()%vmax)+1;
	    
	    if(op<2)add(l,r,(LL)x);
		else if(op<3)assign(l,r,(LL)x);
		else if(op<4)printf("%lld\n",ask_k(l,r,x));
		else printf("%lld\n",mi_sum(l,r,x,y));
	}
}

```

**序列操作** *(P2572)*

> 【序列操作（P2572）】
代码包含 in, split, assign, count1, ask1 等核心函数，实现了 序列操作 的算法逻辑。

核心函数：
  void in(Re &x) — 核心算法函数
  IT split(Re w) — 分裂操作
  void assign(Re l,Re r,Re v) — 核心算法函数
  int count1(Re l,Re r) — 核心算法函数
  int ask1(Re l,Re r) — 核心算法函数
  void inverse(Re l,Re r) — 求模逆元

核心结构体：QAQ

关键配置：
N=1e5+5

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)
#include<algorithm>
#include<cstdio>
#include<vector>
#include<set>
#define Re register int
#define IT set<QAQ>::iterator
using namespace std;
const int N=1e5+5;
struct QAQ{
    int l,r;mutable int v;
    QAQ(Re L,Re R=-1,Re V=0):l(L),r(R),v(V){}
    bool operator<(QAQ o)const{return l<o.l;}
};
int x,y,n,m,fu,op;set<QAQ>s;
inline void in(Re &x){
    x=fu=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    if(fu)x=-x;
}
inline IT split(Re w){
    IT it=s.lower_bound(QAQ(w));
    if(it!=s.end()&&it->l==w)return it;
    --it;
    Re L=it->l,R=it->r,V=it->v;
    s.erase(it);
    s.insert(QAQ(L,w-1,V));
    return s.insert(QAQ(w,R,V)).first;
}
inline void assign(Re l,Re r,Re v){
    IT itr=split(r+1),itl=split(l);
    s.erase(itl,itr),s.insert(QAQ(l,r,v));
}
inline int count1(Re l,Re r){
	IT itr=split(r+1),itl=split(l);Re ans=0;
	while(itl!=itr)ans+=itl->v*(itl->r-itl->l+1),++itl;
	return ans;
}
inline int ask1(Re l,Re r){
	IT itr=split(r+1),itl=split(l);Re tmp=0,ans=0;
	while(itl!=itr){
		if(itl->v)tmp+=itl->r-itl->l+1;
		else ans=max(ans,tmp),tmp=0;
		++itl;
	}
	return max(ans,tmp);
}
inline void inverse(Re l,Re r){
	IT itr=split(r+1),itl=split(l);
	while(itl!=itr)itl->v^=1,++itl;
}
int main(){
    in(n),in(m);
    for(Re i=1;i<=n;++i)in(x),s.insert(QAQ(i,i,x));
    s.insert(QAQ(n+1,n+1,-1));
    while(m--){
        in(op),in(x),in(y);++x,++y;
        if(!op)assign(x,y,0);
        else if(op<2)assign(x,y,1);
        else if(op<3)inverse(x,y);
        else if(op<4)printf("%d\n",count1(x,y));
        else printf("%d\n",ask1(x,y));
    }
}

```

**脑洞治疗仪** *(optimize)*

> 【脑洞治疗仪】
代码包含 in, split, assign, ask1, scure 等核心函数，实现了 脑洞治疗仪 的算法逻辑。

核心函数：
  void in(Re &x) — 核心算法函数
  IT split(Re w) — 分裂操作
  void assign(Re l,Re r,Re v) — 核心算法函数
  int ask1(Re l,Re r) — 核心算法函数
  void scure(Re l,Re r,Re a,Re b) — 核心算法函数

核心结构体：QAQ

关键配置：
N=2e5+5

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)
#include<algorithm>
#include<cstdio>
#include<vector>
#include<set>
#define Re register int
#define IT set<QAQ>::iterator
using namespace std;
const int N=2e5+5;
struct QAQ{
    int l,r;mutable int v;
    QAQ(Re L,Re R=-1,Re V=0):l(L),r(R),v(V){}
    bool operator<(QAQ o)const{return l<o.l;}
};
int x,y,xx,yy,n,m,fu,op;set<QAQ>s;
inline void in(Re &x){
    x=fu=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    if(fu)x=-x;
}
inline IT split(Re w){
    IT it=s.lower_bound(QAQ(w));
    if(it!=s.end()&&it->l==w)return it;
    --it;
    Re L=it->l,R=it->r,V=it->v;
    s.erase(it);
    s.insert(QAQ(L,w-1,V));
    return s.insert(QAQ(w,R,V)).first;
}
inline void assign(Re l,Re r,Re v){
    IT itr=split(r+1),itl=split(l);
    s.erase(itl,itr),s.insert(QAQ(l,r,v));
}
inline int ask1(Re l,Re r){
	IT itr=split(r+1),itl=split(l);Re tmp=0,ans=0;
	while(itl!=itr){
		if(!itl->v)tmp+=itl->r-itl->l+1;
		else ans=max(ans,tmp),tmp=0;
		++itl;
	}
	return max(ans,tmp);
}
inline void scure(Re l,Re r,Re a,Re b){
	IT itr=split(r+1),itl=split(l),it=itl;Re t=0;
	while(it!=itr)t+=it->v*(it->r-it->l+1),++it;
	s.erase(itl,itr),s.insert(QAQ(l,r,0));
	if(!t)return;
	itr=split(b+1),itl=split(a);
	if(t>=b-a+1){s.erase(itl,itr),s.insert(QAQ(a,b,1));return;}
	for(;itl!=itr;++itl)
		if(!itl->v){
			t-=itl->r-itl->l+1;
			if(t<0){assign(itl->l,itl->r+t,1);break;}
			else itl->v=1;
		}
}
int main(){
    in(n),in(m);
    s.insert(QAQ(1,n,1));
    while(m--){
        in(op),in(x),in(y);
        if(!op)assign(x,y,0);
        else if(op<2)in(xx),in(yy),scure(x,y,xx,yy);
        else printf("%d\n",ask1(x,y));
    }
}

```

### 2.11 可并堆

**左偏树** *(可并堆)*

> 【左偏树（可并堆）】
代码包含 in, merge, top, pop 等核心函数，实现了 左偏树 的算法逻辑。

核心函数：
  void in(Re &x) — 核心算法函数
  int merge(Re x,Re y) — 合并操作
  int top(Re x) — 获取栈顶/堆顶元素
  void pop(Re x) — 弹出元素

核心结构体：Leftist_Tree

关键配置：
N=1e5+5

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#define LL long long
#define Re register int
using namespace std;
const int N=1e5+5;
int n,x,y,T,op,A[N];
inline void in(Re &x){
	Re fu=0;x=0;char ch=getchar();
	while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=fu?-x:x;
}
struct Leftist_Tree{
	int fa[N],pl[N],pr[N],dis[N];
	inline int merge(Re x,Re y){
		if(!x||!y)return x+y;
		if(A[x]>A[y]||(A[x]==A[y]&&x>y))swap(x,y);
		pr[x]=merge(pr[x],y);
		if(dis[pl[x]]<dis[pr[x]])swap(pl[x],pr[x]);
		dis[x]=dis[pr[x]]+1;
		if(pl[x])fa[pl[x]]=x;
		if(pr[x])fa[pr[x]]=x;
		return x;
	}
	inline int top(Re x){return fa[x]==x?x:fa[x]=top(fa[x]);}
	inline void pop(Re x){
		A[x]=-1,fa[pl[x]]=pl[x],fa[pr[x]]=pr[x];
		fa[x]=merge(pl[x],pr[x]),pl[x]=pr[x]=0;
	}
}T1;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T);
	for(Re i=1;i<=n;++i)in(A[i]),T1.fa[i]=i;
	while(T--){
		in(op),in(x);
		if(op&1){
			in(y);
			if(A[x]!=-1&&A[y]!=-1){
				x=T1.top(x),y=T1.top(y);
				if(x!=y)T1.merge(x,y);
			}
		}
		else if(A[x]==-1)puts("-1");
		else printf("%d\n",A[T1.top(x)]),T1.pop(T1.top(x));
	}
}

```

### 2.12 CDQ分治与整体二分

**CDQ分治** *(三维偏序)*

> #pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)

```cpp
//#pragma GCC optimize(3,"Ofast","inline")
//#pragma GCC optimize(2)
#include<algorithm>
#include<cstdio>
#define Re register int
using std::sort;
const int N=1e5+5,K=2e5+5;
int n,m,k,C[K],ans[N];
struct QAQ{int a,b,c,cnt,ans;}a[N],Q[N];
inline void in(Re &x){
    int fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
inline bool cmp1(QAQ p,QAQ o){return p.a!=o.a?p.a<o.a:(p.b!=o.b?p.b<o.b:p.c<o.c);}
inline bool cmp2(QAQ p,QAQ o){return p.b<o.b;}
inline void add(Re x,Re v){while(x<=k)C[x]+=v,x+=x&-x;}
inline int ask(Re x){
	Re ans=0;
	while(x)ans+=C[x],x-=x&-x;
	return ans;
}
inline void CDQ(Re L,Re R){
	if(L==R)return;
	Re mid=L+R>>1;
	CDQ(L,mid),CDQ(mid+1,R);
	sort(Q+L,Q+mid+1,cmp2),sort(Q+mid+1,Q+R+1,cmp2);
	Re j=L;
	for(Re i=mid+1;i<=R;++i){
		while(j<=mid&&Q[j].b<=Q[i].b)add(Q[j].c,Q[j].cnt),++j;
		Q[i].ans+=ask(Q[i].c);
	}
	for(Re i=L;i<j;++i)add(Q[i].c,-Q[i].cnt);
}
int main(){
	in(n),in(k);
	for(Re i=1;i<=n;++i)in(a[i].a),in(a[i].b),in(a[i].c);
	sort(a+1,a+n+1,cmp1);
	for(Re i=1;i<=n;++i){
		if(i>2&&a[i].a==a[i-1].a&&a[i].b==a[i-1].b&&a[i].c==a[i-1].c)++Q[m].cnt;
		else Q[++m]=a[i],Q[m].cnt=1;
	}
	CDQ(1,m);
	for(Re i=1;i<=m;++i)ans[Q[i].ans+Q[i].cnt-1]+=Q[i].cnt;
	for(Re i=0;i<n;++i)printf("%d\n",ans[i]);
}

```

**整体二分** *(P3332 K大数查询)*

> 【整体二分（P3332 K大数查询）】
代码包含 in, pushup, updata, updata_, pushdown 等核心函数，实现了 整体二分 的算法逻辑。

核心函数：
  void in(Re &x) — 核心算法函数
  void pushup(Re p) — 上推更新节点信息
  void updata(Re p,Re L,Re R,Re v) — 核心算法函数
  void updata_(Re p) — 核心算法函数
  void pushdown(Re p,Re L,Re R) — 下传懒标记
  void change(Re p,Re L,Re R,Re l,Re r,Re v) — 核心算法函数
  LL ask(Re p,Re L,Re R,Re l,Re r) — 核心算法函数
  void sakura(Re l,Re r,Re L,Re R) — 后缀数组

核心结构体：QAQ, Segment_Tree, QAQ

关键配置：
N=5e4+3,M=5e4+3,inf=1e9

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define Re register int
#define LL long long
using namespace std;
const int N=5e4+3,M=5e4+3,inf=1e9;
int n,x,T,Ans[M];
struct QAQ{int l,r,op,id;LL k;}Q[N+M],Q1[N+M],Q2[N+M];
inline void in(Re &x){
    int fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
struct Segment_Tree{
	#define pl p<<1
	#define pr p<<1|1
	#define Mid (L+R>>1)
	struct QAQ{int CL,add;LL S;}tr[N<<2];
	inline void pushup(Re p){tr[p].S=tr[pl].S+tr[pr].S;}
	inline void updata(Re p,Re L,Re R,Re v){tr[p].S+=v*(R-L+1),tr[p].add+=v;}
	inline void updata_(Re p){tr[p].add=tr[p].S=0,tr[p].CL=1;}
	inline void pushdown(Re p,Re L,Re R){
		if(tr[p].CL)updata_(pl),updata_(pr),tr[p].CL=0;
		if(tr[p].add)updata(pl,L,Mid,tr[p].add),updata(pr,Mid+1,R,tr[p].add),tr[p].add=0;
	}
	inline void change(Re p,Re L,Re R,Re l,Re r,Re v){
		if(l<=L&&R<=r){updata(p,L,R,v);return;}
		pushdown(p,L,R);
		if(l<=Mid)change(pl,L,Mid,l,r,v);
		if(r>Mid)change(pr,Mid+1,R,l,r,v);
		pushup(p);
	}
	inline LL ask(Re p,Re L,Re R,Re l,Re r){
		if(l<=L&&R<=r)return tr[p].S;
		LL ans=0;pushdown(p,L,R);
		if(l<=Mid)ans+=ask(pl,L,Mid,l,r);
		if(r>Mid)ans+=ask(pr,Mid+1,R,l,r);
		return ans;
	}
}T1;
inline void sakura(Re l,Re r,Re L,Re R){
	if(L>R)return;
	if(l==r){
		for(Re i=L;i<=R;++i)if(Q[i].op>1)Ans[Q[i].id]=l;
		return;
	}
	Re mid=l+r>>1,m1=0,m2=0;
	for(Re i=L;i<=R;++i)
		if(Q[i].op&1){
			if(Q[i].k<=mid)Q1[++m1]=Q[i];
			else Q2[++m2]=Q[i],T1.change(1,1,n,Q[i].l,Q[i].r,1);
		}
		else{
			LL tmp=T1.ask(1,1,n,Q[i].l,Q[i].r);
			if(Q[i].k<=tmp)Q2[++m2]=Q[i];
			else Q[i].k-=tmp,Q1[++m1]=Q[i];
		}
	T1.updata_(1);
	for(Re i=1;i<=m1;++i)Q[L+i-1]=Q1[i];
	for(Re i=1;i<=m2;++i)Q[L+m1+i-1]=Q2[i];
	sakura(l,mid,L,L+m1-1);
	sakura(mid+1,r,L+m1,R);
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T);
	for(Re i=1;i<=T;++i){
		in(Q[i].op),in(Q[i].l),in(Q[i].r),in(x),Q[i].k=x;
		if(Q[i].op>1)Q[i].id=++Ans[0];
	}
	sakura(-n,n,1,T);
	for(Re i=1;i<=Ans[0];++i)printf("%d\n",Ans[i]);
}

```

**整体二分** *(动态区间第K小)*

> 【整体二分（动态区间第K小）】
代码包含 in, add, ask_, ask, sakura 等核心函数，实现了 整体二分 的算法逻辑。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re v) — 加法更新
  int ask_(Re x) — 核心算法函数
  int ask(Re l,Re r) — 核心算法函数
  void sakura(Re l,Re r,Re L,Re R) — 后缀数组

核心结构体：QAQ, BIT

关键配置：
N=1e5+3,M=1e5+3,inf=1e9

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define Re register int
#define LL long long
using namespace std;
const int N=1e5+3,M=1e5+3,inf=1e9;
int n,x,y,z,T,cnt,a[N],Ans[M];char op;
struct QAQ{int l,r,k,op,id;}Q[N+M*2],Q1[N+M*2],Q2[N+M*2];
inline void in(Re &x){
    int fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
struct BIT{
	int C[N];
	inline void add(Re x,Re v){while(x<=n)C[x]+=v,x+=x&-x;}
	inline int ask_(Re x){Re ans=0;while(x)ans+=C[x],x-=x&-x;return ans;}
	inline int ask(Re l,Re r){return ask_(r)-ask_(l-1);}
}T1;
inline void sakura(Re l,Re r,Re L,Re R){
	if(L>R)return;
	if(l==r){
		for(Re i=L;i<=R;++i)if(Q[i].op>1)Ans[Q[i].id]=l;
		return;
	}
	Re mid=l+r>>1,m1=0,m2=0;
	for(Re i=L;i<=R;++i)
		if(Q[i].op&1){
			if(Q[i].l<=mid)Q1[++m1]=Q[i],T1.add(Q[i].id,Q[i].r);
			else Q2[++m2]=Q[i];
		}
		else{
			Re tmp=T1.ask(Q[i].l,Q[i].r);
			if(Q[i].k<=tmp)Q1[++m1]=Q[i];
			else Q[i].k-=tmp,Q2[++m2]=Q[i];
		}
	for(Re i=1;i<=m1;++i)if(Q1[i].op&1)T1.add(Q1[i].id,-Q1[i].r);
	for(Re i=1;i<=m1;++i)Q[L+i-1]=Q1[i];
	for(Re i=1;i<=m2;++i)Q[L+m1+i-1]=Q2[i];
	sakura(l,mid,L,L+m1-1);
	sakura(mid+1,r,L+m1,R);
}
int main(){
	freopen("123.txt","r",stdin);
	in(n),in(T);
	for(Re i=1;i<=n;++i)in(a[i]),Q[++cnt]=(QAQ){a[i],1,0,1,i};
	while(T--){
		scanf(" %c",&op),in(x),in(y);
		if(op=='C')Q[++cnt]=(QAQ){a[x],-1,0,1,x},Q[++cnt]=(QAQ){a[x]=y,1,0,1,x};
		else in(z),Q[++cnt]=(QAQ){x,y,z,2,++Ans[0]};
	}
	sakura(-inf,inf,1,cnt);
	for(Re i=1;i<=Ans[0];++i)printf("%d\n",Ans[i]);
}

```

**整体二分** *(静态区间第K小)*

> 【整体二分（静态区间第K小）】
代码包含 in, add, ask_, ask, sakura 等核心函数，实现了 整体二分 的算法逻辑。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re v) — 加法更新
  int ask_(Re x) — 核心算法函数
  int ask(Re l,Re r) — 核心算法函数
  void sakura(Re l,Re r,Re L,Re R) — 后缀数组

核心结构体：QAQ, BIT

关键配置：
N=2e5+3,M=2e5+3,inf=1e9

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define Re register int
#define LL long long
using namespace std;
const int N=2e5+3,M=2e5+3,inf=1e9;
int n,x,y,z,T,cnt,Ans[M];char op;
struct QAQ{int l,r,k,op,id;}Q[N+M],Q1[N+M],Q2[N+M];
inline void in(Re &x){
    int fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
struct BIT{
	int C[N];
	inline void add(Re x,Re v){while(x<=n)C[x]+=v,x+=x&-x;}
	inline int ask_(Re x){Re ans=0;while(x)ans+=C[x],x-=x&-x;return ans;}
	inline int ask(Re l,Re r){return ask_(r)-ask_(l-1);}
}T1;
inline void sakura(Re l,Re r,Re L,Re R){
	if(L>R)return;
	if(l==r){
		for(Re i=L;i<=R;++i)if(Q[i].op>1)Ans[Q[i].id]=l;
		return;
	}
	Re mid=l+r>>1,m1=0,m2=0;
	for(Re i=L;i<=R;++i)
		if(Q[i].op&1){
			if(Q[i].k<=mid)Q1[++m1]=Q[i],T1.add(Q[i].id,1);
			else Q2[++m2]=Q[i];
		}
		else{
			Re tmp=T1.ask(Q[i].l,Q[i].r);
			if(Q[i].k<=tmp)Q1[++m1]=Q[i];
			else Q[i].k-=tmp,Q2[++m2]=Q[i];
		}
	for(Re i=1;i<=m1;++i)if(Q1[i].op&1)T1.add(Q1[i].id,-1);
	for(Re i=1;i<=m1;++i)Q[L+i-1]=Q1[i];
	for(Re i=1;i<=m2;++i)Q[L+m1+i-1]=Q2[i];
	sakura(l,mid,L,L+m1-1);
	sakura(mid+1,r,L+m1,R);
}
int main(){
	freopen("123.txt","r",stdin);
	in(n),in(T);
	for(Re i=1;i<=n;++i)in(x),Q[++cnt]=(QAQ){0,0,x,1,i};
	for(Re i=1;i<=T;++i)in(x),in(y),in(z),Q[++cnt]=(QAQ){x,y,z,2,i};
	sakura(-inf,inf,1,cnt);
	for(Re i=1;i<=T;++i)printf("%d\n",Ans[i]);
}

```

### 2.13 可并堆

**左偏树（可并堆）模板** *(LeftistTree)*

```cpp
// 左偏树（可并堆）模板
struct LeftistTree {
    struct Node {
        int value;   // 节点值
        int left;    // 左子节点
        int right;   // 右子节点
        int dist;    // 距离（npl，空节点为0，叶节点为1）
    };
    
    vector<Node> heap;  // 堆节点数组，0号节点为空节点
    
    // 构造函数，初始化空节点
    LeftistTree(int reserveSize = 0) {
        heap.reserve(reserveSize + 1);
        heap.push_back({0, 0, 0, 0});  // 0号节点作为空节点
    }
    
    // 创建新节点
    int newNode(int value) {
        heap.push_back({value, 0, 0, 1});
        return (int)heap.size() - 1;
    }
    
    // 比较优先级，返回a是否优先于b
    // 可根据需要重写（此处为示例：值大的优先）
    bool higherPriority(int a, int b) {
        if (b == 0) return true;   // b为空
        if (a == 0) return false;  // a为空
        return heap[a].value > heap[b].value;  // 大根堆
    }
    
    // 合并两个堆，返回合并后的根节点
    int merge(int a, int b) {
        if (a == 0) return b;
        if (b == 0) return a;
        
        // 确保a的优先级更高
        if (!higherPriority(a, b)) swap(a, b);
        
        // 递归合并右子树
        heap[a].right = merge(heap[a].right, b);
        
        // 维护左偏性质：左子树dist >= 右子树dist
        if (heap[heap[a].left].dist < heap[heap[a].right].dist) {
            swap(heap[a].left, heap[a].right);
        }
        
        // 更新dist
        heap[a].dist = heap[heap[a].right].dist + 1;
        return a;
    }
    
    // 弹出堆顶（删除根节点）
    int pop(int root) {
        return merge(heap[root].left, heap[root].right);
    }
    
    // 获取堆顶值
    int top(int root) {
        return heap[root].value;
    }
    
    // 判断堆是否为空
    bool empty(int root) {
        return root == 0;
    }
};
```

**左偏树-P3377** *(luogu-p3377)*

```cpp
typedef pair<int,int> P;  // 存储键值对，通常用于比较优先级
struct Node {
    int l, r, d;  // l:左孩子, r:右孩子, d:距离（null路径长度）
    P v;          // 存储的值（键值对）
    Node(){}
    Node(int _l,int _r,int _d,P _v){l=_l,r=_r,d=_d,v=_v;}
} T[N];  // 数组存储所有节点
int merge(int a,int b){
    if(!a) return b;
    if(!b) return a;
    if(T[a].v < T[b].v)swap(a,b);
    T[a].r = merge(T[a].r,b);
    if(T[T[a].l].d < T[T[a].r].d)swap(T[a].l,T[a].r);
    T[a].d=T[a].r ? T[T[a].r].d+1:0;
    return a;
}
int pop(int a){
    int l = T[a].l,r=T[a].r;
    T[a].l=T[a].r=T[a].d=0;
    return merge(l,r);
}
```

## 3. 图论

### 3.1 最短路

**dijkstra  (信使)** *(n^2)*

> 【dijkstra  (信使)（n^2）】
Dijkstra 最短路算法模板，适用于非负权图。

复杂度：时间复杂度取决于具体算法

适用场景：图中最短路径计算、网格寻路、分层图最短路

```cpp
#include<bits/stdc++.h>
using namespace std;
int i,j,ans,a,b,z,n,m,pan[110],w,mi,f[110][110],dis[110];
int main(){
    scanf("%d%d",&n,&m);
    for(i=1;i<=n;i++)
        for(j=1;j<=n;j++)
            f[i][j]=0xfffffff;
    for(i=1;i<=n;i++)dis[i]=0xfffffff;
    for(i=1;i<=m;i++){
        scanf("%d%d%d",&a,&b,&z);
        f[a][b]=f[b][a]=z;
    }
    for(i=1;i<=n;i++)dis[i]=f[1][i];
    dis[1]=0;pan[1]=1;
    for(i=1;i<=n;i++){
        w=0;mi=0xfffffff;
        for(j=1;j<=n;j++)if(!pan[j]&&dis[j]<mi)mi=dis[w=j];
        if(!w)break;pan[w]=1;
        for(j=1;j<=n;j++)dis[j]=min(dis[j],dis[w]+f[w][j]);
    }
    for(i=1;i<=n;i++)ans=max(ans,dis[i]);
    if(ans==0xfffffff)printf("-1");
    else printf("%d",ans);
    return 0;
}

```

**最小环  (Sightseeing Trip)** *(Floyed)*

> 【最小环  (Sightseeing Trip)（Floyed）】
最短路算法模板，求解图中两点间的最短路径。

核心函数：
  void in(Re &x) — 核心算法函数
  void get(Re i,Re j) — 获取值

关键配置：
N=103,inf=1e8

复杂度：时间复杂度取决于具体算法

说明：freopen("123.txt","r",stdin);

适用场景：图中最短路径计算、网格寻路、分层图最短路

```cpp
#include<algorithm>
#include<cstdio>
#define Re register int
using namespace std;
const int N=103,inf=1e8;
int n,m,x,y,z,ans,Ans[N],a[N][N],g[N][N],dis[N][N];
inline void in(Re &x){
	Re fu=0;x=0;char ch=getchar();
	while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=fu?-x:x;
}
inline void get(Re i,Re j){
	Re k=g[i][j];if(!k)return;
	get(i,k),Ans[++Ans[0]]=k,get(k,j);
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(m);
	for(Re i=1;i<=n;++i)
		for(Re j=1;j<=n;++j)
			dis[i][j]=a[i][j]=inf;
	for(Re i=1;i<=n;++i)dis[i][i]=a[i][i]=0;
	while(m--)in(x),in(y),in(z),dis[x][y]=dis[y][x]=a[x][y]=a[y][x]=min(a[x][y],z);
	ans=inf;
	for(Re k=1;k<=n;++k){
		for(Re i=1;i<k;++i)
			for(Re j=i+1,tmp;j<k;++j)	
				if((tmp=dis[i][j]+a[j][k]+a[k][i])<ans){
					ans=tmp,Ans[0]=0;
					Ans[++Ans[0]]=i;
					get(i,j);
					Ans[++Ans[0]]=j;
					Ans[++Ans[0]]=k;
				}
		for(Re i=1;i<=n;++i)
			for(Re j=1,tmp;j<=n;++j)
				if((tmp=dis[i][k]+dis[k][j])<dis[i][j])	
					dis[i][j]=tmp,g[i][j]=k;
	}
	if(ans==inf)puts("No solution.");
	else for(Re i=1;i<=Ans[0];++i)printf("%d ",Ans[i]); 
}

```

**最短路** *(dijkstra)*

> 【最短路（dijkstra）】
Dijkstra 最短路算法模板，适用于非负权图。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re y,Re z) — 加法更新
  void dijkstra(Re st) — Dijkstra最短路

核心结构体：QAQ, QWQ

关键配置：
N=1e5+5,M=1e5+5,inf=2e9

复杂度：时间复杂度取决于具体算法

适用场景：图中最短路径计算、网格寻路、分层图最短路

```cpp
#include<cstring>
#include<cstdio>
#include<queue>
#define Re register int
using namespace std;
const int N=1e5+5,M=1e5+5,inf=2e9;
int x,y,z,n,m,o,to,st,dis[N],pan[N],head[N];
struct QAQ{int w,to,next;}a[M<<1];
struct QWQ{int x,d;inline bool operator<(QWQ O)const{return d>O.d;}};
priority_queue<QWQ>Q;
inline void in(Re &x){
	Re fu=0;x=0;char ch=getchar();
	while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=fu?-x:x;
}
inline void add(Re x,Re y,Re z){a[++o].to=y,a[o].w=z,a[o].next=head[x],head[x]=o;}
inline void dijkstra(Re st){
	for(Re i=0;i<=n;++i)dis[i]=inf;
	dis[st]=0,Q.push((QWQ){st,0});
	while(!Q.empty()){
		x=Q.top().x,Q.pop();
		if(pan[x])continue;
		pan[x]=1;
		for(Re i=head[x];i;i=a[i].next)
			if(dis[to=a[i].to]>dis[x]+a[i].w){
				dis[to]=dis[x]+a[i].w;
				Q.push((QWQ){to,dis[to]});
			}
	}
}
int main(){
	in(n),in(m),in(st);
	while(m--)in(x),in(y),in(z),add(x,y,z);
	dijkstra(st);
	for(Re i=1;i<=n;++i)printf("%d ",dis[i]);
}

```

**最短路** *(SPFA)*

> 【最短路（SPFA）】
SPFA 最短路算法模板，队列优化的 Bellman-Ford。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re y,Re z) — 加法更新
  void SPFA(Re st) — SPFA最短路

核心结构体：QAQ

关键配置：
N=1e4+5,M=5e5+5,inf=2147483647

复杂度：时间复杂度取决于具体算法

适用场景：图中最短路径计算、网格寻路、分层图最短路

```cpp
#include<cstring>
#include<cstdio>
#include<queue>
#define Re register int
using namespace std;
const int N=1e4+5,M=5e5+5,inf=2147483647;
int x,y,z,n,m,o,to,st,dis[N],pan[N],head[N];
struct QAQ{int w,to,next;}a[M<<1];
queue<int>Q;
inline void in(Re &x){
	Re fu=0;x=0;char ch=getchar();
	while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=fu?-x:x;
}
inline void add(Re x,Re y,Re z){a[++o].to=y,a[o].w=z,a[o].next=head[x],head[x]=o;}
inline void SPFA(Re st){
	for(Re i=0;i<=n;++i)dis[i]=inf;
	dis[st]=0,pan[st]=1,Q.push(st);
	while(!Q.empty()){
		x=Q.front(),Q.pop();
		pan[x]=0;
		for(Re i=head[x];i;i=a[i].next)
			if(dis[to=a[i].to]>dis[x]+a[i].w){
				dis[to]=dis[x]+a[i].w;
				if(!pan[to])pan[to]=1,Q.push(to);
			}
	}
}
int main(){
	in(n),in(m),in(st);
	while(m--)in(x),in(y),in(z),add(x,y,z);
	SPFA(st);
	for(Re i=1;i<=n;++i)printf("%d ",dis[i]);
}

```

**次短路** *(SPFA)*

> 【次短路（SPFA）】
SPFA 最短路算法模板，队列优化的 Bellman-Ford。

核心函数：
  void add(Re x,Re y,Re z) — 加法更新
  void in(Re &x) — 核心算法函数
  void SPFA(Re st) — SPFA最短路

核心结构体：QAQ

关键配置：
N=5003,M=1e5+3,inf=1e9

复杂度：时间复杂度取决于具体算法

适用场景：图中最短路径计算、网格寻路、分层图最短路

```cpp
#include<algorithm>
#include<cstdio>
#include<queue>
#define Re register int
using namespace std;
const int N=5003,M=1e5+3,inf=1e9;
int n,m,x,y,z,o,pan[N],head[N],dis[N][2];
struct QAQ{int w,to,next;}a[M<<1];queue<int>Q;
inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    Re fu=0;x=0;char ch=getchar();
    while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
    while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
    x=fu?-x:x;
}
inline void SPFA(Re st){
    for(Re i=0;i<=n;++i)dis[i][0]=dis[i][1]=inf;
    dis[st][0]=0,pan[st]=1,Q.push(st);
    while(!Q.empty()){
        Re x=Q.front();Q.pop();pan[x]=0;
        for(Re i=head[x],to,tmp;i;i=a[i].next){
            if(dis[to=a[i].to][0]>(tmp=dis[x][0]+a[i].w)){
                dis[to][1]=dis[to][0];
                dis[to][0]=tmp;
                if(!pan[to])pan[to]=1,Q.push(to);
            }
            if(dis[to][1]>(tmp=dis[x][0]+a[i].w)&&tmp>dis[to][0]){
                dis[to][1]=tmp;
                if(!pan[to])pan[to]=1,Q.push(to);
            }
            if(dis[to][1]>(tmp=dis[x][1]+a[i].w)){
                dis[to][1]=tmp;
                if(!pan[to])pan[to]=1,Q.push(to);
            }
        }
    }
}
int main(){
    in(n),in(m);
    while(m--)in(x),in(y),in(z),add(x,y,z),add(y,x,z);
    SPFA(1);
    printf("%d\n",dis[n][1]);
}

```

### 3.2 最小生成树

**严格次小生成树** *(add)*

> 【严格次小生成树】
最小生成树（MST）算法模板，使用 Kruskal/Prim 算法。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re y,Re z) — 加法更新
  void dfs(Re x,Re fa) — 深度优先搜索遍历
  int lca(Re x,Re y) — 查询最近公共祖先
  int ask_max(Re x,Re Ant,Re w) — 核心算法函数
  int find(Re x) — 查找（并查集寻根/二分查找）
  void kruscal(无参数) — 计算函数

核心结构体：QAQ, QWQ, LCA

关键配置：
N=5e5+3,M=5e5+3,logN=19,inf=2e9

复杂度：O(E log E)（Kruskal），O(V² / E log V)（Prim）

适用场景：连通图的最小代价连接、瓶颈路问题

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=5e5+3,M=5e5+3,logN=19,inf=2e9;
int T,n,m,o,root,fa[N],head[N],Tree[M],M1[N][23],M2[N][23];LL MinTree;
struct QAQ{int w,to,next;}a[M<<1];
struct QWQ{int x,y,w;inline bool operator<(QWQ O)const{return w<O.w;}}A[M];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}
struct LCA{
	int deep[N],ant[N][23];
	inline void dfs(Re x,Re fa){
		deep[x]=deep[fa]+1,ant[x][0]=fa;
		for(Re i=1;(1<<i)<=deep[x];++i){
			ant[x][i]=ant[ant[x][i-1]][i-1];
			M1[x][i]=max(M1[x][i-1],M1[ant[x][i-1]][i-1]);
			M2[x][i]=max(M2[x][i-1],M2[ant[x][i-1]][i-1]);
			if(M1[x][i-1]!=M1[ant[x][i-1]][i-1])
				M2[x][i]=max(M2[x][i],min(M1[x][i-1],M1[ant[x][i-1]][i-1]));
		}
		for(Re i=head[x],to;i;i=a[i].next)
			if((to=a[i].to)!=fa)M1[to][0]=a[i].w,M2[to][0]=-inf,dfs(to,x);
	}
	inline int lca(Re x,Re y){
		if(deep[x]>deep[y])swap(x,y);
		for(Re i=logN;i>=0;--i)if(deep[x]<=deep[y]-(1<<i))y=ant[y][i];
		if(x==y)return y;
		for(Re i=logN;i>=0;--i)
			if(ant[x][i]^ant[y][i])x=ant[x][i],y=ant[y][i];
		return ant[x][0];
	}
	inline int ask_max(Re x,Re Ant,Re w){
		Re ans=-inf;
		for(Re i=logN;i>=0;--i)
			if(deep[ant[x][i]]>=deep[Ant]){
				if(w!=M1[x][i])ans=max(ans,M1[x][i]);
				else ans=max(ans,M2[x][i]);
				x=ant[x][i];
			}
		return ans;
	}
}T1;
inline int find(Re x){return x==fa[x]?x:fa[x]=find(fa[x]);}
inline void kruscal(){
	sort(A+1,A+m+1);
	for(Re i=1;i<=n;++i)fa[i]=i;
	for(Re i=1;i<=m;++i){
		Re x=A[i].x,y=A[i].y,w=A[i].w;
		if(find(x)!=find(y)){
			MinTree+=w,Tree[i]=1;
			add(x,y,w),add(y,x,w);
			fa[find(x)]=find(y);
		}
	}
}
int main(){
	in(n),in(m),root=1;
	for(Re i=1;i<=m;++i)in(A[i].x),in(A[i].y),in(A[i].w);
	kruscal();
	M1[root][0]=0,M2[root][0]=-inf,T1.dfs(root,0);
	LL ans=1e17;
	for(Re i=1;i<=m;++i)
		if(!Tree[i]){
			Re x=A[i].x,y=A[i].y,w=A[i].w;
			Re lca=T1.lca(x,y);
			ans=min(ans,MinTree+w-max(T1.ask_max(x,lca,w),T1.ask_max(y,lca,w)));
		}
	printf("%lld",ans);
}

```

**曼哈顿距离最小生成树** *(Object Clustering)*

> 【曼哈顿距离最小生成树（Object Clustering）】
最小生成树（MST）算法模板，使用 Kruskal/Prim 算法。

核心函数：
  void in(Re &x) — 核心算法函数
  LL Abs(LL a) — 核心算法函数
  LL Dis(Re x,Re y) — 核心算法函数
  void CL(无参数) — 核心算法函数
  void add(Re x,Re v,Re ID) — 加法更新
  LL ask(Re x) — 核心算法函数
  LL find_(Re x) — 查找（并查集寻根/二分查找）
  LL find(Re x) — 查找（并查集寻根/二分查找）

核心结构体：QAQ, Point, BIT

复杂度：O(E log E)（Kruskal），O(V² / E log V)（Prim）

说明：freopen("123.txt","r",stdin);

适用场景：连通图的最小代价连接、瓶颈路问题

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register LL
using namespace std;
const LL N=1e4+3;
inline void in(Re &x){
	int f=0;x=0;char ch=getchar();
	while(ch<'0'||ch>'9')f|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=f?-x:x;
}
LL n,m,x,y,t,K,Ans,b[N];
struct QAQ{LL x,y,v;inline bool operator<(const QAQ &O)const{return v<O.v;}}a[N<<3];
struct Point{LL x,y,id;inline bool operator<(const Point &O)const{return x!=O.x?x<O.x:y<O.y;}}P[N];
inline LL Abs(LL a){return a<0?-a:a;}
inline LL Dis(Re x,Re y){return Abs(P[x].x-P[y].x)+Abs(P[x].y-P[y].y);}
struct BIT{
	LL n,C[N],id[N];
	inline void CL(){memset(C,127,sizeof(C));}
	inline void add(Re x,Re v,Re ID){while(x){if(v<C[x])C[x]=v,id[x]=ID;x-=x&-x;}}
	inline LL ask(Re x){Re Min=1e18,ID=0;while(x<=n){if(C[x]<Min)Min=C[x],ID=id[x];x+=x&-x;}return ID;}
}TR;
inline LL find_(Re x){
	Re l=1,r=t;
	while(l<r){
		Re mid=(l+r+1)>>1;
		if(b[mid]<=x)l=mid;
		else r=mid-1;
	}
	return l;
}
LL fa[N];
inline LL find(Re x){return fa[x]==x?x:fa[x]=find(fa[x]);}
inline void kruscal(){
	for(Re O=1;O<=4;++O){
		if(!(O&1))for(Re i=1;i<=n;++i)swap(P[i].x,P[i].y);
		else if(O==3)for(Re i=1;i<=n;++i)P[i].x*=-1;
		sort(P+1,P+n+1);
		for(Re i=1;i<=n;++i)b[i]=P[i].y-P[i].x;
		sort(b+1,b+n+1),t=unique(b+1,b+n+1)-b-1;
		TR.n=t,TR.CL();
		for(Re i=n;i>=1;--i){
			Re I=find_(P[i].y-P[i].x),j=TR.ask(I);
			if(j)a[++m]=(QAQ){P[i].id,P[j].id,Dis(i,j)};
			TR.add(I,P[i].x+P[i].y,i);
		}
	}
	sort(a+1,a+m+1);
	for(Re i=1;i<=n;++i)fa[i]=i;
	for(Re i=1,t=0;i<=m&&t<n-1;++i)if((x=find(a[i].x))!=(y=find(a[i].y))){
		fa[x]=y,Ans+=a[i].v;
		if(++t==K)printf("%lld\n",a[i].v);
	}
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(K),K=n-1-K+1;
	for(Re i=1;i<=n;++i)in(P[i].x),in(P[i].y),P[i].id=i;
	kruscal();
}

```

**最小生成树** *(Kruscal)*

> 【最小生成树（Kruscal）】
最小生成树（MST）算法模板，使用 Kruskal/Prim 算法。

核心函数：
  void in(Re &x) — 核心算法函数
  int find(Re x) — 查找（并查集寻根/二分查找）

核心结构体：QAQ

关键配置：
N=5003,M=2e5+3

复杂度：O(E log E)（Kruskal），O(V² / E log V)（Prim）

适用场景：连通图的最小代价连接、瓶颈路问题

```cpp
#include<algorithm>
#include<cstdio>
#define Re register int
using namespace std;
const int N=5003,M=2e5+3;
int n,m,ans,fa[N];
struct QAQ{int x,y,w;inline bool operator<(const QAQ &O)const{return w<O.w;};}A[M];
inline void in(Re &x){
	Re fu=0;x=0;char ch=getchar();
	while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=fu?-x:x;
}
inline int find(Re x){return x==fa[x]?x:fa[x]=find(fa[x]);}
int main(){
	in(n),in(m);
	for(Re i=1;i<=n;++i)fa[i]=i;
	for(Re i=1;i<=m;++i)in(A[i].x),in(A[i].y),in(A[i].w);
	sort(A+1,A+m+1);
	for(Re i=1,t=0;i<=m&&t<n-1;++i){
		Re x=find(A[i].x),y=find(A[i].y);
		if(x!=y)++t,ans+=A[i].w,fa[x]=y;
	}
	printf("%d",ans);
}

```

**最小生成树** *(LCT)*

> 【最小生成树（LCT）】
最小生成树（MST）算法模板，使用 Kruskal/Prim 算法。

核心函数：
  void in(Re &x) — 核心算法函数
  void pushup(Re p) — 上推更新节点信息
  void updata(Re p) — 核心算法函数
  void pushdown(Re p) — 下传懒标记
  int nort(Re p) — 核心算法函数
  int which(Re p) — 核心算法函数
  void connect(Re p,Re fa,Re o) — 核心算法函数
  void rotate(Re p) — 旋转操作（平衡树）

核心结构体：Link_Cut_Tree, QAQ

关键配置：
N=205003

复杂度：O(E log E)（Kruskal），O(V² / E log V)（Prim）

说明：freopen("123.txt","r",stdin);

适用场景：连通图的最小代价连接、瓶颈路问题

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define Re register int
#define LL long long
using namespace std;
const int N=205003;
int n,m,x,y,z,id,ans,id_O,v[N];
inline void in(Re &x){
    int fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
struct Link_Cut_Tree{
	#define pl tr[p].ps[0]
	#define pr tr[p].ps[1]
	#define pf tr[p].fa
	int Q[N];
	struct QAQ{int fa,mx,mxw,tag,ps[2];}tr[N];
	inline void pushup(Re p){
		tr[p].mx=v[p],tr[p].mxw=p;
		if(pl&&tr[pl].mx>tr[p].mx)tr[p].mx=tr[pl].mx,tr[p].mxw=tr[pl].mxw;
		if(pr&&tr[pr].mx>tr[p].mx)tr[p].mx=tr[pr].mx,tr[p].mxw=tr[pr].mxw;
	}
	inline void updata(Re p){swap(pl,pr),tr[p].tag^=1;}
	inline void pushdown(Re p){
		if(tr[p].tag){
			if(pl)updata(pl);
			if(pr)updata(pr);
			tr[p].tag=0;
		}
	}
	inline int nort(Re p){return tr[pf].ps[0]==p||tr[pf].ps[1]==p;}
	inline int which(Re p){return tr[pf].ps[1]==p;}
	inline void connect(Re p,Re fa,Re o){tr[pf=fa].ps[o]=p;}
	inline void rotate(Re p){
		Re fa=pf,fas=which(p);
		Re pa=tr[fa].fa,pas=which(fa);
		Re x=tr[p].ps[fas^1];
		if(nort(fa))tr[pa].ps[pas]=p;pf=pa;
		connect(x,fa,fas),connect(fa,p,fas^1);
		pushup(fa),pushup(p);
	}
	inline void splay(Re p){
		Re x=p,t=0;Q[++t]=x;
		while(nort(x))Q[++t]=x=tr[x].fa;
		while(t)pushdown(Q[t--]);
		for(Re fa;nort(p);rotate(p))
			if(nort(fa=pf))rotate(which(p)==which(fa)?fa:p);
	}
	inline void access(Re p){
		for(Re son=0;p;son=p,p=pf)
			splay(p),pr=son,pushup(p);
	}
	inline void makeroot(Re p){access(p),splay(p),updata(p);}
	inline int findroot(Re p){
		access(p),splay(p),pushdown(p);
		while(pl)pushdown(p=pl);
		return p;
	}
	inline void split(Re x,Re y){makeroot(x),access(y),splay(y);}
	inline void link(Re x,Re y){makeroot(x);if(findroot(y)!=x)tr[x].fa=y;}
	inline void cut(Re x,Re y){
		makeroot(x);
		if(findroot(y)==x&&tr[x].fa==y&&!tr[x].ps[1])
			tr[x].fa=tr[y].ps[0]=0,pushup(y);
	}
	inline int judge(Re x,Re y){makeroot(x);return findroot(y)==x;}
	inline void sakura(Re x,Re y,Re z,Re id){
		if(!judge(x,y))link(x,id),link(id,y),ans+=z;
		else{
			split(x,y);Re mx=tr[y].mx,mxw=tr[y].mxw;
			if(z<mx){
				ans+=z-mx,splay(mxw);
				tr[tr[mxw].ps[0]].fa=tr[tr[mxw].ps[1]].fa=0;
				link(x,id),link(id,y);
			}
		}
	}
}LCT;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(m);
	while(m--)in(x),in(y),in(z),v[id=++id_O+n]=z,LCT.sakura(x,y,z,id);
	printf("%d\n",ans);
}

```

**最小生成树** *(Prim n^2)*

> 【最小生成树（Prim n^2）】
最小生成树（MST）算法模板，使用 Kruskal/Prim 算法。

核心函数：
  void in(Re &x) — 核心算法函数
  void Prim(无参数) — Prim最小生成树

关键配置：
N=5003,M=2e5+3,inf=2e9

复杂度：O(E log E)（Kruskal），O(V² / E log V)（Prim）

适用场景：连通图的最小代价连接、瓶颈路问题

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define Re register int
using namespace std;
const int N=5003,M=2e5+3,inf=2e9;
int n,x,y,z,T,ans,pan[N],dis[N],a[N][N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void Prim(){
	for(Re i=0;i<=n;++i)dis[i]=inf;
	Re t=0;dis[1]=0;
	for(Re i=1;i<=n&&t<n;++i){
		Re w=0;
		for(Re j=1;j<=n;++j)if(!pan[j]&&dis[j]<dis[w])w=j;
		pan[w]=1,ans+=dis[w],++t;
		for(Re j=1;j<=n;++j)if(!pan[j])dis[j]=min(dis[j],a[w][j]);
	}
}
int main(){
	in(n),in(T);
	memset(a,127,sizeof(a));
	while(T--)in(x),in(y),in(z),a[x][y]=a[y][x]=min(a[x][y],z);
	Prim();
	printf("%d\n",ans);
}

```

**最小生成树** *(Prim)*

> 【最小生成树（Prim）】
最小生成树（MST）算法模板，使用 Kruskal/Prim 算法。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re y,Re z) — 加法更新
  void Prim(无参数) — Prim最小生成树

核心结构体：QAQ, QWQ

关键配置：
N=5003,M=2e5+3,inf=2e9

复杂度：O(E log E)（Kruskal），O(V² / E log V)（Prim）

适用场景：连通图的最小代价连接、瓶颈路问题

```cpp
#include<algorithm>
#include<cstdio>
#include<queue>
#define Re register int
using namespace std;
const int N=5003,M=2e5+3,inf=2e9;
int x,y,z,n,m,o,ans,pan[N],dis[N],head[N];
struct QAQ{int w,to,next;}a[M<<1];
struct QWQ{int x,d;inline bool operator<(QWQ o)const{return d>o.d;};};
priority_queue<QWQ>Q;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline void Prim(){
	for(Re i=0;i<=n;++i)pan[i]=0,dis[i]=inf;
	Re t=0;Q.push((QWQ){1,dis[1]=0});
	while(!Q.empty()&t<n){
		Re x=Q.top().x;Q.pop();
		if(pan[x])continue;
		pan[x]=1,++t,ans+=dis[x];
		for(Re i=head[x],to;i;i=a[i].next)
			if(dis[to=a[i].to]>a[i].w)Q.push((QWQ){to,dis[to]=a[i].w});
	}
}
int main(){
	in(n),in(m);
	while(m--)in(x),in(y),in(z),add(x,y,z),add(y,x,z);
	Prim();
	printf("%d",ans);
}

```

### 3.3 图的连通性

**拓扑排序** *(add)*

> 【拓扑排序】
拓扑排序模板，基于 Kahn 算法或 DFS。

核心函数：
  void add(Re x,Re y) — 加法更新
  void in(Re &x) — 核心算法函数

核心结构体：QAQ

关键配置：
N=5003,M=5e5+3,inf=2e9,P=80112002

适用场景：SCC缩点、2-SAT建图、割点/桥识别

```cpp
#include<cstring>
#include<cstdio>
#include<queue>
#define Re register int
using namespace std;
const int N=5003,M=5e5+3,inf=2e9,P=80112002;
int n,m,x,y,o,ans,dp[N],ru[N],chu[N],head[N];
struct QAQ{int to,next;}a[M];queue<int>Q;
inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
	Re fu=0;x=0;char ch=getchar();
	while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=fu?-x:x;
}

int main(){
	in(n),in(m);
	while(m--)in(x),in(y),add(x,y),++ru[y],++chu[x];
	for(Re i=1;i<=n;++i)if(!ru[i])dp[i]=1,Q.push(i);
	while(!Q.empty()){
		Re x=Q.front();Q.pop();
		for(Re i=head[x],to;i;i=a[i].next){
			(dp[to=a[i].to]+=dp[x])%=P;
			if(!--ru[to])Q.push(to);
		}
	}
	for(Re i=1;i<=n;++i)if(!chu[i])(ans+=dp[i])%=P;
	printf("%d\n",ans%P);
}

```

**2-SAT** *(kosaraju)*

> 【2-SAT（kosaraju）】
图的连通性相关算法模板。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re y) — 加法更新
  void dfs1(Re x) — 深度优先搜索遍历
  void dfs2(Re x) — 深度优先搜索遍历
  void kosaraju(无参数) — 后缀数组

核心结构体：Kosaraju, QAQ

关键配置：
N=2e6+3,M=2e6+3

适用场景：SCC缩点、2-SAT建图、割点/桥识别

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define Re register int
const int N=2e6+3,M=2e6+3;
int n,m,mm,p1,p2,x1,x2,Q_o,X[M],Y[M],ip[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Kosaraju{
	int o,ndfn_o,nQ[N],pan[N],head[N];
	struct QAQ{int x,to,next;}a[M];
	inline void add(Re x,Re y){a[++o].x=x,a[o].to=y,a[o].next=head[x],head[x]=o;}
	inline void dfs1(Re x){
		pan[x]=1;
		for(Re i=head[x];i;i=a[i].next)if(!pan[a[i].to])dfs1(a[i].to);
		nQ[++ndfn_o]=x;
	}
	inline void dfs2(Re x){
		ip[x]=Q_o;
		for(Re i=head[x];i;i=a[i].next)if(!ip[a[i].to])dfs2(a[i].to);
	}
	inline void kosaraju(){
		for(Re i=1;i<=m;++i)add(X[i],Y[i]);
		for(Re i=1;i<=2*n;++i)if(!pan[i])dfs1(i);
		memset(head,0,sizeof(head));
		memset(pan,0,sizeof(pan));
		memset(a,0,sizeof(a));o=0;
		for(Re i=1;i<=m;++i)add(Y[i],X[i]);
		for(Re i=ndfn_o;i;--i)if(!ip[nQ[i]])++Q_o,dfs2(nQ[i]);
	}
}T1;
int main(){
	in(n),in(mm);
	while(mm--)in(p1),in(x1),in(p2),in(x2),X[++m]=p1+(x1^1)*n,Y[m]=p2+x2*n,X[++m]=p2+(x2^1)*n,Y[m]=p1+x1*n;
	T1.kosaraju();
	for(Re i=1;i<=n;++i)if(ip[i]==ip[i+n])return !printf("IMPOSSIBLE");
	puts("POSSIBLE");
	for(Re i=1;i<=n;++i)printf("%d ",ip[i]<ip[i+n]);
}

```

**2-SAT** *(tarjan)*

> 【2-SAT（tarjan）】
图的连通性相关算法模板。

核心函数：
  void in(Re &x) — 核心算法函数
  int min(Re a,Re b) — 核心算法函数
  void add(Re x,Re y) — 加法更新
  void tarjan(Re x) — Tarjan算法（求SCC/LCA/割点桥）
  void SuoPoint(无参数) — 核心算法函数

核心结构体：Tarjan, QAQ

关键配置：
N=2e6+3,M=2e6+3

适用场景：SCC缩点、2-SAT建图、割点/桥识别

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define Re register int
const int N=2e6+3,M=2e6+3;
int n,m,p1,p2,x1,x2,Q_o,ip[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Tarjan{
	int o,t,dfn_o,Q[N],low[N],dfn[N],pan[N],head[N];
	struct QAQ{int to,next;}a[M];
	inline int min(Re a,Re b){return a<b?a:b;}
	inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
	inline void tarjan(Re x){
		low[x]=dfn[x]=++dfn_o,Q[++t]=x,pan[x]=1;
		for(Re i=head[x],to;i;i=a[i].next)
			if(!dfn[to=a[i].to])tarjan(to),low[x]=min(low[x],low[to]);
			else if(pan[to])low[x]=min(low[x],dfn[to]);
		if(low[x]==dfn[x]){
			++Q_o;
			while(1){
				ip[Q[t]]=Q_o,pan[Q[t]]=0;
				if(x==Q[t--])break;
			}
		}
	}
	inline void SuoPoint(){for(Re i=1;i<=2*n;++i)if(!dfn[i])tarjan(i);}
}T1;
int main(){
	in(n),in(m);
	while(m--)in(p1),in(x1),in(p2),in(x2),T1.add(p1+(x1^1)*n,p2+x2*n),T1.add(p2+(x2^1)*n,p1+x1*n);
	T1.SuoPoint();
	for(Re i=1;i<=n;++i)if(ip[i]==ip[i+n])return !printf("IMPOSSIBLE");
	puts("POSSIBLE");
	for(Re i=1;i<=n;++i)printf("%d ",ip[i]>ip[i+n]);
}
```

**割点 tanjan** *(min)*

> 【割点 tanjan】
无向图的割点/桥与双连通分量模板。

核心函数：
  void in(Re &x) — 核心算法函数
  int min(Re a,Re b) — 核心算法函数
  void add(Re x,Re y) — 加法更新
  void tarjan(Re x,Re root) — Tarjan算法（求SCC/LCA/割点桥）
  void cut_point(无参数) — 核心算法函数

核心结构体：Cut_Point, QAQ

关键配置：
N=2e4+3,M=2e5+3

适用场景：SCC缩点、2-SAT建图、割点/桥识别

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define Re register int
const int N=2e4+3,M=2e5+3;
int n,m,x,y,ans,cut[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Cut_Point{
	int o,dfn_o,low[N],dfn[N],head[N];
	struct QAQ{int to,next;}a[M];
	inline int min(Re a,Re b){return a<b?a:b;}
	inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
	inline void tarjan(Re x,Re root){
		Re son=0;dfn[x]=low[x]=++dfn_o;
		for(Re i=head[x],to;i;i=a[i].next)
			if(!dfn[to=a[i].to]){
				tarjan(to,root),++son;
				low[x]=min(low[x],low[to]);
				cut[x]|=(x!=root&&low[to]>=dfn[x]);
			}
			else low[x]=min(low[x],dfn[to]);
		cut[x]|=(x==root&&son>1),ans+=cut[x];
	}
	inline void cut_point(){
		for(Re i=1;i<=n;++i)if(!dfn[i])tarjan(i,i);
	}
}T1;
int main(){
	in(n),in(m);
	while(m--)in(x),in(y),T1.add(x,y),T1.add(y,x);
	T1.cut_point();
	printf("%d\n",ans);
	for(Re i=1;i<=n;++i)if(cut[i])printf("%d ",i);
}
```

**割边,桥** *(旅游航道)*

> 【割边,桥（旅游航道）】
无向图的割点/桥与双连通分量模板。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re y) — 加法更新
  void CL(无参数) — 核心算法函数
  void tarjan(Re x,Re p) — Tarjan算法（求SCC/LCA/割点桥）
  void get_bridg(无参数) — 获取值

核心结构体：Tarjan, QAQ

关键配置：
N=3e4+3,M=3e4+3

适用场景：SCC缩点、2-SAT建图、割点/桥识别

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define Re register int
using namespace std;
const int N=3e4+3,M=3e4+3;
int n,m,x,y,ans;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Tarjan{
	int o,dfn_o,dfn[N],low[N],head[N],bridge[M<<1];
	struct QAQ{int to,next;}a[M<<1];
	inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
	inline void CL(){
		memset(bridge,0,sizeof(bridge));
		memset(head,0,sizeof(head));
		memset(low,0,sizeof(low));
		memset(dfn,0,sizeof(dfn));
		dfn_o=ans=0,o=1;
	}
	inline void tarjan(Re x,Re p){
		dfn[x]=low[x]=++dfn_o;
		for(Re i=head[x],to;i;i=a[i].next)
			if(!dfn[to=a[i].to]){
				tarjan(to,i);
				low[x]=min(low[x],low[to]);
				if(low[to]>dfn[x])bridge[i]=bridge[i^1]=1,++ans;
			}
			else if(i!=(p^1))low[x]=min(low[x],dfn[to]);
	}
	inline void get_bridg(){for(Re i=1;i<=n;++i)if(!dfn[i])tarjan(i,-1);}
}T1;
int main(){
    while(scanf("%d%d",&n,&m)&&n&&m){
	    T1.CL();
	    while(m--)in(x),in(y),T1.add(x,y),T1.add(y,x);
	    T1.get_bridg();
	    printf("%d\n",ans);
    }
}

```

**欧拉回路  (Hierholzer)** *(无向+有向)*

> 【欧拉回路  (Hierholzer)（无向+有向）】
图的连通性相关算法模板。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re y) — 加法更新
  void dfs(Re x) — 深度优先搜索遍历
  void sakura(无参数) — 后缀数组
  void add(Re x,Re y) — 加法更新
  void dfs(Re x) — 深度优先搜索遍历
  void sakura(无参数) — 后缀数组

核心结构体：Euler_Circle__Undirected_Graph, QAQ, Euler_Circle__Directed_Graph, QAQ

关键配置：
N=1e5+3,M=2e5+3

适用场景：SCC缩点、2-SAT建图、割点/桥识别

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define Re register int
const int N=1e5+3,M=2e5+3;
int n,m,x,y,m_,op;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Euler_Circle__Undirected_Graph{// 无向图欧拉路
	int o,du[N],cur[N],ans[M],pan[M<<1],head[N];
	struct QAQ{int to,next;}a[M<<1];
	inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
	inline void dfs(Re x){
		for(Re i=head[x];i;i=head[x]){
			head[x]=a[i].next;// 当前弧优化
			if(!pan[i]){
				pan[i]=pan[i^1]=1;
				dfs(a[i].to);
				ans[++ans[0]]=(i&1)?-i/2:i/2;
			}
		}
	}
	inline void sakura(){
		in(n),in(m),m_=m,o=1;
		while(m_--)in(x),in(y),add(x,y),add(y,x),++du[x],++du[y];
		for(Re i=1;i<=n;cur[i]=head[i],++i)if(du[i]&1){puts("NO");return;}
		for(Re i=1;i<=n;++i)if(du[i]){dfs(i);break;}
		if(ans[0]!=m){puts("NO");return;}
		puts("YES");
		for(Re i=ans[0];i>=1;--i)printf("%d ",ans[i]);
	}
}T1;
struct Euler_Circle__Directed_Graph{// 无向图欧拉路
	int o,ru[N],chu[N],cur[N],ans[M],head[N];
	struct QAQ{int to,next;}a[M<<1];
	inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
	inline void dfs(Re x){
		for(Re i=head[x];i;i=head[x]){
			head[x]=a[i].next;// 当前弧优化
			dfs(a[i].to);
			ans[++ans[0]]=i;
		}
	}
	inline void sakura(){
		in(n),in(m),m_=m;
		while(m_--)in(x),in(y),add(x,y),++ru[y],++chu[x];
		for(Re i=1;i<=n;cur[i]=head[i],++i)if(ru[i]!=chu[i]){puts("NO");return;}
		for(Re i=1;i<=n;++i)if(chu[i]){dfs(i);break;}
		if(ans[0]!=m){puts("NO");return;}
		puts("YES");
		for(Re i=ans[0];i>=1;--i)printf("%d ",ans[i]);
	}
}T2;
int main(){
	in(op);
	if(op==1)T1.sakura();
	if(op==2)T2.sakura();
}

```

**欧拉路,欧拉回路** *(骑马修栅栏)*

> 【欧拉路,欧拉回路（骑马修栅栏）】
图的连通性相关算法模板。

核心函数：
  void in(Re &x) — 核心算法函数
  void dfs(Re x) — 深度优先搜索遍历

关键配置：
N=1030

适用场景：SCC缩点、2-SAT建图、割点/桥识别

```cpp
#include<algorithm>
#include<cstdio>
#define Re register int
using namespace std;
const int N=1030;
int n,x,y,mi=2e9,st=2e9,as,du[N],ans[N],r[N][N];
inline void in(Re &x){
	Re fu=0;x=0;char ch=getchar();
	while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=fu?-x:x;
}
inline void dfs(Re x){
	for(Re i=1;i<=500;++i)
		if(r[x][i]){
			--r[x][i],--r[i][x];
			dfs(i);
		}
	ans[++as]=x;
}
int main(){
	in(n);
	for(Re i=1;i<=n;++i)in(x),in(y),++r[x][y],++r[y][x],++du[x],++du[y],mi=min(mi,min(x,y));
	for(Re i=1;i<=500;++i)if(du[i]&1)st=min(st,i);
	if(st==2e9)st=mi;
	dfs(st);
	for(Re i=as;i;--i)printf("%d\n",ans[i]);
}

```

**缩点—强联通分量** *(Kosaraju)*

> 【缩点—强联通分量（Kosaraju）】
图的连通性相关算法模板。

核心函数：
  void in(Re &x) — 核心算法函数
  int max(Re a,Re b) — 核心算法函数
  void add(Re x,Re y) — 加法更新
  void dfs1(Re x) — 深度优先搜索遍历
  void dfs2(Re x) — 深度优先搜索遍历
  void kosaraju(无参数) — 后缀数组
  void add(Re x,Re y) — 加法更新
  void creat(无参数) — 核心算法函数

核心结构体：Kosaraju, QAQ, Tuopu, QAQ

关键配置：
N=1e6+3,M=1e6+3

适用场景：SCC缩点、2-SAT建图、割点/桥识别

```cpp
#include<cstring>
#include<cstdio>
#include<queue>
#define Re register int
const int N=1e6+3,M=1e6+3;
int n,m,Q_o,ans,X[M],Y[M],A[N],ip[N],gs[N],dp[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline int max(Re a,Re b){return a>b?a:b;}
struct Kosaraju{
	int o,ndfn_o,nQ[N],pan[N],head[N];
	struct QAQ{int x,to,next;}a[M<<1];
	inline void add(Re x,Re y){a[++o].x=x,a[o].to=y,a[o].next=head[x],head[x]=o;}
	inline void dfs1(Re x){
		pan[x]=1;
		for(Re i=head[x];i;i=a[i].next)if(!pan[a[i].to])dfs1(a[i].to);
		nQ[++ndfn_o]=x;
	}
	inline void dfs2(Re x){
		ip[x]=Q_o,gs[Q_o]+=A[x];
		for(Re i=head[x];i;i=a[i].next)if(!ip[a[i].to])dfs2(a[i].to);
	}
	inline void kosaraju(){
		for(Re i=1;i<=m;++i)add(X[i],Y[i]);
		for(Re i=1;i<=n;++i)if(!pan[i])dfs1(i);
		memset(head,0,sizeof(head));
		memset(pan,0,sizeof(pan));
		memset(a,0,sizeof(a));o=0;
		for(Re i=1;i<=m;++i)add(Y[i],X[i]);
		for(Re i=ndfn_o;i;--i)if(!ip[nQ[i]])++Q_o,dfs2(nQ[i]);
	}
}T1;
struct Tuopu{
	int o,x,y,ru[N],pan[N],head[N];std::queue<int>Q;
	struct QAQ{int to,next;}a[M<<1];
	inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
	inline void creat(){
		for(Re i=1;i<=T1.o;++i)
			if((x=ip[T1.a[i].x])!=(y=ip[T1.a[i].to]))
				++ru[y],add(x,y);
	}
	inline void tuopu(){
		creat();
		for(Re i=1;i<=Q_o;++i)if(!ru[i])dp[i]=gs[i],Q.push(i);
		while(!Q.empty()){
			Re x=Q.front();Q.pop();
			for(Re i=head[x],to;i;i=a[i].next){
				to=a[i].to;
				dp[to]=max(dp[to],dp[x]+gs[to]);
				if(!(--ru[to]))Q.push(to);
			}
		}
	}
}T2;
int main(){
	in(n),in(m);
	for(Re i=1;i<=n;++i)in(A[i]);
	for(Re i=1;i<=m;++i)in(X[i]),in(Y[i]);
	T1.kosaraju(),T2.tuopu();
	for(Re i=1;i<=Q_o;++i)ans=max(ans,dp[i]);
	printf("%d",ans);
}

```

**缩点—强联通分量** *(Tarjan)*

> 【缩点—强联通分量（Tarjan）】
图的连通性相关算法模板。

核心函数：
  void in(Re &x) — 核心算法函数
  int min(Re a,Re b) — 核心算法函数
  int max(Re a,Re b) — 核心算法函数
  void add(Re x,Re y) — 加法更新
  void tarjan(Re x) — Tarjan算法（求SCC/LCA/割点桥）
  void SuoPoint(无参数) — 核心算法函数
  void add(Re x,Re y) — 加法更新
  void creat(无参数) — 核心算法函数

核心结构体：Tarjan, QAQ, Tuopu, QAQ

关键配置：
N=1e4+3,M=1e5+3

适用场景：SCC缩点、2-SAT建图、割点/桥识别

```cpp
#include<cstring>
#include<cstdio>
#include<queue>
#define Re register int
const int N=1e4+3,M=1e5+3;
int n,m,x,y,Q_o,ans,A[N],ru[N],gs[N],ip[N],dp[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline int min(Re a,Re b){return a<b?a:b;}
inline int max(Re a,Re b){return a>b?a:b;}
struct Tarjan{
	int o,t,dfn_o,Q[N],low[N],dfn[N],pan[N],head[N];
	struct QAQ{int x,to,next;}a[M];
	inline void add(Re x,Re y){a[++o].x=x,a[o].to=y,a[o].next=head[x],head[x]=o;}
	inline void tarjan(Re x){
		dfn[x]=low[x]=++dfn_o,Q[++t]=x,pan[x]=1;
		for(Re i=head[x],to;i;i=a[i].next)
			if(!dfn[to=a[i].to])tarjan(to),low[x]=min(low[x],low[to]);
			else if(pan[to])low[x]=min(low[x],dfn[to]);
		if(low[x]==dfn[x]){
			++Q_o;
			while(1){
				ip[Q[t]]=Q_o,gs[Q_o]+=A[Q[t]],pan[Q[t]]=0;
				if(x==Q[t--])break;
			}
		}
	}
	inline void SuoPoint(){for(Re i=1;i<=n;++i)if(!dfn[i])tarjan(i);}
}T1;
struct Tuopu{
	int o,ru[N],pan[N],head[N];std::queue<int>Q;
	struct QAQ{int to,next;}a[M<<1];
	inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
	inline void creat(){
		for(Re i=1;i<=T1.o;++i)
			if((x=ip[T1.a[i].x])!=(y=ip[T1.a[i].to]))
				++ru[y],add(x,y);
	}
	inline void tuopu(){
		for(Re i=1;i<=Q_o;++i)if(!ru[i])dp[i]=gs[i],Q.push(i);
		while(!Q.empty()){
			Re x=Q.front();Q.pop();
			for(Re i=head[x],to;i;i=a[i].next){
				to=a[i].to;
				dp[to]=max(dp[to],dp[x]+gs[to]);
				if(!(--ru[to]))Q.push(to);
			}
		}
	}
}T2;
int main(){
	in(n),in(m);
	for(Re i=1;i<=n;++i)in(A[i]);
	while(m--)in(x),in(y),T1.add(x,y);
	T1.SuoPoint(),T2.creat(),T2.tuopu();
	for(Re i=1;i<=Q_o;++i)ans=max(ans,dp[i]);
	printf("%d",ans);
}

```

**缩点—点双连通分量** *(矿场搭建)*

> 【缩点—点双连通分量（矿场搭建）】
无向图的割点/桥与双连通分量模板。

核心函数：
  void in(Re &x) — 核心算法函数
  int max(Re a,Re b) — 核心算法函数
  void add(Re x,Re y) — 加法更新
  void CL(无参数) — 核心算法函数
  void tarjan(Re x,Re rt) — Tarjan算法（求SCC/LCA/割点桥）
  void SuoPoint(无参数) — 核心算法函数

核心结构体：Tarjan, QAQ

关键配置：
N=1003,M=503

适用场景：SCC缩点、2-SAT建图、割点/桥识别

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<vector>
#define LL long long
#define Re register int
using namespace std;
const int N=1003,M=503;
int n,m,x,y,T,Q_o,tmp,ans1,cut[N];LL ans2;
std::vector<int>dcc[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline int max(Re a,Re b){return a>b?a:b;}
struct Tarjan{
	int o,t,dfn_o,Q[N],dfn[N],low[N],head[N];
	struct QAQ{int to,next;}a[M<<1];
	inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
	inline void CL(){
		memset(head,0,sizeof(head));
		memset(low,0,sizeof(low));
		memset(dfn,0,sizeof(dfn));
		memset(cut,0,sizeof(cut));
		dfn_o=t=o=0;
	}
	inline void tarjan(Re x,Re rt){
		Re son=0;Q[++t]=x,dfn[x]=low[x]=++dfn_o;
		for(Re i=head[x],to;i;i=a[i].next)
			if(!dfn[to=a[i].to]){
				tarjan(to,rt),++son;
				low[x]=min(low[x],low[to]);
				if(low[to]>=dfn[x]){
					if(x!=rt)cut[x]=1;
					else cut[x]|=son>1;
					++Q_o;
					while(1){
						dcc[Q_o].push_back(Q[t]);
						if(to==Q[t--])break;
					}
					dcc[Q_o].push_back(x);
				}
			}
			else low[x]=min(low[x],dfn[to]);
	}
	inline void SuoPoint(){for(Re i=1;i<=n;++i)if(!dfn[i])tarjan(i,i);}
}T1;
int main(){
    while(scanf("%d",&m)&&m){
	    for(Re i=1;i<=Q_o;++i)dcc[i].clear();
	    T1.CL(),Q_o=ans1=n=0,ans2=1;
	    while(m--)in(x),in(y),T1.add(x,y),T1.add(y,x),n=max(n,max(x,y));
	    T1.SuoPoint();
	    for(Re i=1;i<=Q_o;++i){
	    	tmp=0,n=dcc[i].size();
	    	for(Re j=0;j<n;++j)tmp+=cut[dcc[i][j]];
	    	if(!tmp)ans1+=2,ans2*=(n-1)*n/2;
	    	else if(tmp<2)ans1+=1,ans2*=(n-1);
	    }
	    printf("Case %d: %d %lld\n",++T,ans1,ans2);
    }
}

```

**缩点—边双连通分量** *(Redundant Paths)*

> 【缩点—边双连通分量（Redundant Paths）】
无向图的割点/桥与双连通分量模板。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re y) — 加法更新
  void tarjan(Re x,Re p) — Tarjan算法（求SCC/LCA/割点桥）
  void dfs(Re x) — 深度优先搜索遍历
  void SuoPoint(无参数) — 核心算法函数

核心结构体：Tarjan, QAQ

关键配置：
N=5003,M=10003

适用场景：SCC缩点、2-SAT建图、割点/桥识别

```cpp
#include<algorithm>
#include<cstdio>
#define Re register int
using namespace std;
const int N=5003,M=10003;
int n,m,x,y,Q_o,leaf,ip[N],du[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Tarjan{
	int o,dfn_o,dfn[N],low[N],head[N],bridge[M<<1];
	struct QAQ{int to,next;}a[M<<1];
	inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
	inline void tarjan(Re x,Re p){
		dfn[x]=low[x]=++dfn_o;
		for(Re i=head[x],to;i;i=a[i].next)
			if(!dfn[to=a[i].to]){
				tarjan(to,i);
				low[x]=min(low[x],low[to]);
				if(low[to]>dfn[x])bridge[i]=bridge[i^1]=1;
			}
			else if(i!=(p^1))low[x]=min(low[x],dfn[to]);
	}
	inline void dfs(Re x){
		ip[x]=Q_o;
		for(Re i=head[x];i;i=a[i].next)
			if(!ip[a[i].to]&&!bridge[i])dfs(a[i].to);
	}
	inline void SuoPoint(){
		for(Re i=1;i<=n;++i)if(!dfn[i])tarjan(i,-1);
		for(Re i=1;i<=n;++i)if(!ip[i])++Q_o,dfs(i);
	}
}T1;
int main(){
    in(n),in(m),T1.o=1;
    while(m--)in(x),in(y),T1.add(x,y),T1.add(y,x);
    T1.SuoPoint();
    for(Re i=2;i<=T1.o;i+=2)
    	if((x=ip[T1.a[i].to])!=(y=ip[T1.a[i^1].to]))++du[x],++du[y];
    for(Re i=1;i<=Q_o;++i)leaf+=(du[i]==1);
    printf("%d",leaf+1>>1);
}

```

### 3.4 二分图与最大匹配

**二分图最大匹配-匈牙利算法** *(erfentu)*

> 【二分图最大匹配——匈牙利算法（Hungarian Algorithm）】
▪ main() — 读入左右部节点数 n1,n2 和边数 m，用 lambda 递归 DFS 寻找增广路
▪ dfs(self, x) — 嵌套 DFS：对左部节点 x 尝试匹配，遍历其所有邻接右部节点 y：若 y 未被访问且（y 未匹配 或 y 的当前匹配者可换人），则 match[y]=x 并返回 true
▪ vis[] — 每轮 DFS 的访问标记数组，防止重复访问右部节点
▪ match[] — 右部节点当前的匹配对象（0 表示未匹配）
时间复杂度 O(VE)。适用于任务分配、人员配对、棋盘多米诺覆盖等二分图匹配模型。

```cpp
signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);
    int n1,n2,m;
    cin >> n1 >> n2 >> m;
    vector<vector<int>>ver(n1+1);
    for(int i = 1;i <= m;i++){
        int x,y;
        cin >> x >> y;
        ver[x].push_back(y);
    }

    int ans = 0;
    vector<int>match(n2+1);
    for(int i = 1;i <= n1;i++){
        vector<int>vis(n2+1);
        auto dfs = [&](auto self,int x) -> bool {
            for(auto y : ver[x]){
                if(vis[y])continue;
                vis[y] = 1;
                if(!match[y] || self(self,match[y])){
                    match[y] = x;
                    return true;
                }
            }
            return false;
        };
        if(dfs(dfs,i)){
            ans++;
        }
    }
    cout << ans << '\n';
    return 0;
}
```

**二分图—最大匹配** *(add)*

> 【二分图—最大匹配】
二分图匹配算法模板（匈牙利算法 / Hopcroft-Karp）。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re y) — 加法更新
  int dfs(Re x) — 深度优先搜索遍历

核心结构体：QAQ

关键配置：
N=1003

适用场景：二分图判定与匹配、棋盘覆盖模型、最小点覆盖

```cpp
#include<cstring>
#include<cstdio>
#define Re register int
const int N=1003;
int o,n,m,e,x,y,ans,pan[N],head[N],match[N];
struct QAQ{int to,next;}a[N*N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
inline int dfs(Re x){
	for(Re i=head[x],to;i;i=a[i].next)
		if(!pan[to=a[i].to]){
			pan[to]=1;
			if(!match[to]||dfs(match[to])){
				match[to]=x;return 1;
			}
		}
	return 0;
}
int main(){
	in(n),in(m),in(e);
	while(e--){
		in(x),in(y);
		if(x<=n&&y<=m)add(x,y);
	}
	for(Re i=1;i<=n;++i){
		memset(pan,0,sizeof(pan));
		ans+=dfs(i);
	}
	printf("%d",ans);
}

```

**二分图判定** *(染色法)*

> 【二分图判定（染色法）】
二分图匹配算法模板（匈牙利算法 / Hopcroft-Karp）。

核心函数：
  void add(Re x,Re y) — 加法更新
  void in(Re &x) — 核心算法函数
  int judge(无参数) — 判定函数

核心结构体：QAQ

关键配置：
N=2003,M=1e6+3

适用场景：二分图判定与匹配、棋盘覆盖模型、最小点覆盖

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define Re register int
using namespace std;
const int N=2003,M=1e6+3;
int n,m,x,y,h,t,o,T,O,Q[N],head[N],color[N];
struct QAQ{int to,next;}a[M<<1];
inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline int judge(){
	for(Re i=1;i<=n;++i)
		if(!color[i]){
			h=1,t=0,Q[++t]=i,color[i]=1;
			while(h<=t){
				Re x=Q[h++];
				for(Re j=head[x],to;j;j=a[j].next)
					if(!color[to=a[j].to])color[to]=3-color[x],Q[++t]=to;
					else if(color[to]==color[x])return 0;
			}
		}
	return 1;
}
int main(){
	in(T);
	while(T--){
		memset(color,0,sizeof(color));
		memset(head,0,sizeof(head));
		in(n),in(m),o=0;
		while(m--)in(x),in(y),add(x,y),add(y,x);
		printf("Scenario #%d:\n",++O);
		puts(judge()?"No suspicious bugs found!\n":"Suspicious bugs found!\n");
	}
}

```

### 3.5 网络流

**网络流-最大流与最小割** *(wangluoliu)*

> 【网络流——最大流与最小割（Dinic 算法）】
▪ addEdge(from, to, cap) — 添加有向边及其反向边（cap=0），记录 rev 索引用于残量更新
▪ bfs(s, t) — BFS 构建层次图（level 数组）：从源点 s 出发，沿 cap>0 的边走，标记各节点层次
▪ dfs(v, t, upTo) — DFS 多路增广：在层次图上从 v 向 t 推进，最多增广 upTo 流量；使用 iter[] 当前弧优化避免重复走死路
▪ maxFlow(s, t) — Dinic 主函数：反复 bfs()+dfs() 直到无法到达汇点，累计流量
▪ getMinCutEdges(s) — 从源点 BFS（只走 cap>0 边），可达节点与不可达节点间的边即为最小割边集
一般图 O(V²E)，二分图匹配 O(E√V)。含割边标记 is_cut。适用于最大流、最小割、二分图匹配。

```cpp
struct Edge {
    int to, rev;
    int cap;
    bool is_cut; // 标记是否为割边
};

class MinCut {
private:
    std::vector<Edge> G[MAXN];
    int level[MAXN];
    int iter[MAXN];

public:
    // 添加一条从from到to，容量为cap的边
    void addEdge(int from, int to, int cap) {
        G[from].push_back({to, (int)G[to].size(), cap, false});
        G[to].push_back({from, (int)G[from].size() - 1, 0, false});
    }

    // 构建层次图
    bool bfs(int s, int t) {
        memset(level, -1, sizeof(level));
        std::queue<int> q;
        level[s] = 0;
        q.push(s);
        while (!q.empty()) {
            int v = q.front(); q.pop();
            for (const auto& e : G[v]) {
                if (e.cap > 0 && level[e.to] < 0) {
                    level[e.to] = level[v] + 1;
                    q.push(e.to);
                }
            }
        }
        return level[t] != -1;
    }

    // 在层次图上寻找增广路
    int dfs(int v, int t, int upTo) {
        if (v == t) return upTo;
        for (int &i = iter[v]; i < G[v].size(); ++i) {
            Edge &e = G[v][i];
            if (e.cap > 0 && level[v] < level[e.to]) {
                int d = dfs(e.to, t, std::min(upTo, e.cap));
                if (d > 0) {
                    e.cap -= d;
                    G[e.to][e.rev].cap += d;
                    return d;
                }
            }
        }
        return 0;
    }

    // 求最大流
    int maxFlow(int s, int t) {
        int flow = 0;
        while (bfs(s, t)) {
            memset(iter, 0, sizeof(iter));
            int f;
            while ((f = dfs(s, t, INF)) > 0) {
                flow += f;
            }
        }
        return flow;
    }

    // 获取最小割的割边集合
    std::vector<std::pair<int, int>> getMinCutEdges(int s) {
        std::vector<std::pair<int, int>> cutEdges;
        bool vis[MAXN] = {0};
        std::queue<int> q;
        q.push(s);
        vis[s] = true;
        while (!q.empty()) {
            int v = q.front(); q.pop();
            for (const auto& e : G[v]) {
                if (e.cap > 0 && !vis[e.to]) {
                    vis[e.to] = true;
                    q.push(e.to);
                }
            }
        }
        // 割边：从S集合到T集合的满流边
        for (int u = 0; u < MAXN; ++u) {
            if (vis[u]) {
                for (const auto& e : G[u]) {
                    if (!vis[e.to] && G[e.to][e.rev].cap > 0) {
                        cutEdges.emplace_back(u, e.to);
                    }
                }
            }
        }
        return cutEdges;
    }

    // 清空图
    void clear(int n) {
        for (int i = 0; i <= n; ++i) G[i].clear();
    }
};
```

**最大流  (m n^2)** *(Dinic+多路增广+当前弧)*

> 【最大流  (m n^2)（Dinic+多路增广+当前弧）】
最大流（Dinic）模板，含当前弧优化与多路增广。

核心函数：
  void in(Re &x) — 核心算法函数
  void add_(Re x,Re y,Re flow) — 加法更新
  void add(Re x,Re y,Re flow) — 加法更新
  int bfs(Re st,Re ed) — 广度优先搜索遍历
  int dfs(Re x,Re flow) — 深度优先搜索遍历
  void dinic(Re st,Re ed) — 核心算法函数

核心结构体：Dinic, QAQ

关键配置：
N=1e4+5,M=1e5+5,inf=2147483647

复杂度：一般图 O(V²E)，二分图 O(E√V)

适用场景：最大流/最小割建模、二分图匹配、任务分配问题

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#define LL long long
#define Re register int
using namespace std;
const int N=1e4+5,M=1e5+5,inf=2147483647;
int x,y,z,n,m,s,t,st,ed;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Dinic{
	int o,h,t,Q[N],dis[N],cur[N],head[N];LL maxflow;
	Dinic(){o=1;}
	struct QAQ{int to,next,flow;}a[M<<1];
	inline void add_(Re x,Re y,Re flow){a[++o].to=y,a[o].flow=flow,a[o].next=head[x],head[x]=o;}
	inline void add(Re x,Re y,Re flow){add_(x,y,flow),add_(y,x,0);}
	inline int bfs(Re st,Re ed){
		for(Re i=0;i<=ed;++i)dis[i]=0,cur[i]=head[i];
		h=1,t=0,Q[++t]=st,dis[st]=1;
		while(h<=t){
			Re x=Q[h++];
			for(Re i=head[x],to;i;i=a[i].next)
				if(a[i].flow&&!dis[to=a[i].to]){
					dis[to]=dis[x]+1,Q[++t]=to;
					if(to==ed)return 1;
				}
		}
		return 0;
	}
	inline int dfs(Re x,Re flow){
		if(x==ed||!flow)return flow;
		Re tmp=0,to,f;
		for(Re i=cur[x];i;i=a[i].next){
			cur[x]=i;
			if(dis[to=a[i].to]==dis[x]+1&&(f=dfs(to,min(flow-tmp,a[i].flow)))){
				a[i].flow-=f,a[i^1].flow+=f,tmp+=f;
				if(flow==tmp)break;
			}
		}
		return tmp;
	}
	inline void dinic(Re st,Re ed){while(bfs(st,ed))maxflow+=dfs(st,inf);}
}T1;
int main(){
    in(n),in(m),in(s),in(t),st=n+1,ed=st+1;
    while(m--)in(x),in(y),in(z),T1.add(x,y,z);
    T1.add(st,s,inf),T1.add(t,ed,inf),T1.dinic(st,ed);
    printf("%lld",T1.maxflow);
}

```

**最大流  (n m^2)** *(EK)*

> 【最大流  (n m^2)（EK）】
最大流（Dinic）模板，含当前弧优化与多路增广。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re y,Re z) — 加法更新
  int bfs(Re st,Re ed) — 广度优先搜索遍历
  void EK(Re st,Re ed) — 核心算法函数

核心结构体：QAQ

关键配置：
N=1e4+3,M=1e5+3,inf=2e9

复杂度：一般图 O(V²E)，二分图 O(E√V)

适用场景：最大流/最小割建模、二分图匹配、任务分配问题

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#define Re register int
using namespace std;
const int N=1e4+3,M=1e5+3,inf=2e9;
int x,y,z,o=1,n,m,h,t,st,ed,Q[N],cyf[N],pan[N],pre[N],head[N];long long maxflow; 
struct QAQ{int to,next,flow;}a[M<<1];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void add(Re x,Re y,Re z){a[++o].flow=z,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline int bfs(Re st,Re ed){
	for(Re i=0;i<=n;++i)pan[i]=0;
	h=1,t=0,pan[st]=1,Q[++t]=st,cyf[st]=inf;
	while(h<=t){
		Re x=Q[h++];
		for(Re i=head[x],to;i;i=a[i].next)
			if(a[i].flow&&!pan[to=a[i].to]){
				cyf[to]=min(cyf[x],a[i].flow);
				Q[++t]=to,pre[to]=i,pan[to]=1;
				if(to==ed)return 1;
			}
	}
	return 0;
}
inline void EK(Re st,Re ed){
	while(bfs(st,ed)==1){
		Re x=ed;maxflow+=cyf[ed];
		while(x!=st){
			Re i=pre[x];
			a[i].flow-=cyf[ed];
			a[i^1].flow+=cyf[ed];
			x=a[i^1].to;
		}
	}
}
int main(){
	in(n),in(m),in(st),in(ed);
	while(m--)in(x),in(y),in(z),add(x,y,z),add(y,x,0);
	EK(st,ed);
	printf("%lld",maxflow);
}

```

**最小割可行边、必须边** *(add_)*

> 【最小割可行边、必须边】
最大流（Dinic）模板，含当前弧优化与多路增广。

核心函数：
  void in(Re &x) — 核心算法函数
  void add_(Re x,Re y,Re flow) — 加法更新
  void add(Re x,Re y,Re flow) — 加法更新
  int bfs(Re st,Re ed) — 广度优先搜索遍历
  int dfs(Re x,Re flow) — 深度优先搜索遍历
  void tarjan(Re x) — Tarjan算法（求SCC/LCA/割点桥）
  void sakura(无参数) — 后缀数组

核心结构体：Dinic, QAQ

关键配置：
N=4003,M=6e4+3,inf=2e9

复杂度：一般图 O(V²E)，二分图 O(E√V)

说明：freopen("123.txt","r",stdin);

适用场景：最大流/最小割建模、二分图匹配、任务分配问题

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=4003,M=6e4+3,inf=2e9;
int n,m,x,y,z,st,ed;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Dinic{
	int o,h,t,Q[N],dis[N],cur[N],head[N];
	struct QAQ{int to,next,flow;}a[M<<1];
	inline void add_(Re x,Re y,Re flow){a[++o].to=y,a[o].flow=flow,a[o].next=head[x],head[x]=o;}
	inline void add(Re x,Re y,Re flow){add_(x,y,flow),add_(y,x,0);}
	inline int bfs(Re st,Re ed){
		for(Re i=0;i<=n;++i)dis[i]=0,cur[i]=head[i];
		h=1,t=0,dis[st]=1,Q[++t]=st;
		while(h<=t){
			Re x=Q[h++];
			for(Re i=head[x],to;i;i=a[i].next)
				if(a[i].flow&&!dis[to=a[i].to]){
					dis[to]=dis[x]+1,Q[++t]=to;
					if(to==ed)return 1;
				}
		}
		return 0;
	}
	inline int dfs(Re x,Re flow){
		if(x==ed||!flow)return flow;
		Re tmp=0,to,f;
		for(Re i=cur[x];i;i=a[i].next){
			cur[x]=i;
			if(dis[to=a[i].to]==dis[x]+1&&(f=dfs(to,min(flow-tmp,a[i].flow)))){
				a[i].flow-=f,a[i^1].flow+=f,tmp+=f;
				if(flow==tmp)break;
			}
		}
		return tmp;
	}
	int Q_o,dfn_O,ip[N],dfn[N],low[N],pan[N];
	inline void tarjan(Re x){
		dfn[x]=low[x]=++dfn_O,Q[++t]=x,pan[x]=1;
		for(Re i=head[x],to;i;i=a[i].next)
			if(a[i].flow){
				if(!dfn[to=a[i].to])tarjan(to),low[x]=min(low[x],low[to]);
				else if(pan[to])low[x]=min(low[x],dfn[to]);
			}
		if(dfn[x]==low[x]){
			++Q_o;
			while(1){
				ip[Q[t]]=Q_o,pan[Q[t]]=0;
				if(x==Q[t--])break;
			}
		}
	}
	inline void sakura(){
		while(bfs(st,ed))dfs(st,inf);
		for(Re i=1;i<=n;++i)if(!dfn[i])tarjan(i);
		for(Re i=2;i<=o;i+=2)printf("%d %d\n",
			(!a[i].flow&&ip[a[i^1].to]!=ip[a[i].to]),
			(!a[i].flow&&ip[st]==ip[a[i^1].to]&&ip[a[i].to]==ip[ed]));
	}
}T1;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(m),in(st),in(ed),T1.o=1;
	while(m--)in(x),in(y),in(z),T1.add(x,y,z);
	T1.sakura();
}

```

**最小费用最大流** *(EK+SPFA)*

> 【最小费用最大流（EK+SPFA）】
最大流（Dinic）模板，含当前弧优化与多路增广。

核心函数：
  void in(Re &x) — 核心算法函数
  void add_(Re x,Re y,Re flow,Re w) — 加法更新
  void add(Re a,Re b,Re flow,Re w) — 加法更新
  int SPFA(Re st,Re ed) — SPFA最短路
  void EK(Re st,Re ed) — 核心算法函数

核心结构体：MCMF, QAQ

关键配置：
N=5005,M=5e4+5,inf=2e9

复杂度：一般图 O(V²E)，二分图 O(E√V)

说明：freopen("123.txt","r",stdin);

适用场景：最大流/最小割建模、二分图匹配、任务分配问题

```cpp
#include<algorithm>
#include<cstdio>
#include<queue>
#define LL long long
#define Re register int
using namespace std;
const int N=5005,M=5e4+5,inf=2e9;
int x,y,z,w,n,m,s,t,st,ed;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct MCMF{
	int o,h,t,cyf[N],pan[N],pre[N],dis[N],head[N];LL mincost,maxflow;
	MCMF(){o=1;}
	struct QAQ{int w,to,next,flow;}a[M<<1];queue<int>Q;
	inline void add_(Re x,Re y,Re flow,Re w){a[++o].w=w,a[o].to=y,a[o].flow=flow,a[o].next=head[x],head[x]=o;}
	inline void add(Re a,Re b,Re flow,Re w){add_(a,b,flow,w),add_(b,a,0,-w);}
	inline int SPFA(Re st,Re ed){
		for(Re i=0;i<=ed;++i)dis[i]=inf,pan[i]=0;
		Q.push(st),pan[st]=1,dis[st]=0,cyf[st]=inf;
		while(!Q.empty()){
			Re x=Q.front();Q.pop();pan[x]=0;
			for(Re i=head[x],to;i;i=a[i].next)
				if(a[i].flow&&dis[to=a[i].to]>dis[x]+a[i].w){
					dis[to]=dis[x]+a[i].w,pre[to]=i;
					cyf[to]=min(cyf[x],a[i].flow);
					if(!pan[to])pan[to]=1,Q.push(to);
				}
		}
		return dis[ed]!=inf;
	}
	inline void EK(Re st,Re ed){
		while(SPFA(st,ed)){
			Re x=ed;maxflow+=cyf[ed],mincost+=(LL)cyf[ed]*dis[ed];
			while(x!=st){
				Re i=pre[x];
				a[i].flow-=cyf[ed];
				a[i^1].flow+=cyf[ed];
				x=a[i^1].to;
			}
		}
	}
}T1;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(m),in(s),in(t),st=n+1,ed=st+1;
	while(m--)in(x),in(y),in(z),in(w),T1.add(x,y,z,w);
	T1.add(st,s,inf,0),T1.add(t,ed,inf,0),T1.EK(st,ed);
	printf("%lld %lld\n",T1.maxflow,T1.mincost);
}

```

**孤岛营救问题  (EK)** *(MCMF)*

> 【孤岛营救问题  (EK)（MCMF）】
最大流（Dinic）模板，含当前弧优化与多路增广。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re y,Re z,Re w) — 加法更新
  void add_(Re a,Re b,Re flow,Re w) — 加法更新
  int SPFA(Re st,Re ed) — SPFA最短路
  void EK(Re st,Re ed) — 核心算法函数
  int P(Re x,Re y,Re k) — 核心算法函数

核心结构体：QAQ

关键配置：
N=2e5,M=2e6+5,inf=2e9

复杂度：一般图 O(V²E)，二分图 O(E√V)

适用场景：最大流/最小割建模、二分图匹配、任务分配问题

```cpp
#include<algorithm>
#include<cstdio>
#include<vector>
#include<queue>
#define LL long long
#define Re register int
using namespace std;
const int N=2e5,M=2e6+5,inf=2e9;
int T,x,y,z,w,G,o=1,p,n,m,h,t,st,ed,maxp,cyf[N],pan[N],pre[N],dis[N],head[N],Map[11][11][11][11];LL mincost,maxflow; 
struct QAQ{int w,to,next,flow;}a[M<<1];queue<int>Q;vector<int>key[11][11];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void add(Re x,Re y,Re z,Re w){a[++o].flow=z,a[o].w=w,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline void add_(Re a,Re b,Re flow,Re w){add(a,b,flow,w),add(b,a,0,-w);}
inline int SPFA(Re st,Re ed){
	for(Re i=0;i<=ed;++i)dis[i]=inf,pan[i]=0;
	Q.push(st),pan[st]=1,dis[st]=0,cyf[st]=inf;
	while(!Q.empty()){
		Re x=Q.front();Q.pop();pan[x]=0;
		for(Re i=head[x],to;i;i=a[i].next)
			if(a[i].flow&&dis[to=a[i].to]>dis[x]+a[i].w){
				dis[to]=dis[x]+a[i].w,pre[to]=i;
				cyf[to]=min(cyf[x],a[i].flow);
				if(!pan[to])pan[to]=1,Q.push(to);
			}
	}
	return dis[ed]!=inf;
}
inline void EK(Re st,Re ed){
	while(SPFA(st,ed)){
		Re x=ed;maxflow+=cyf[ed],mincost+=(LL)cyf[ed]*dis[ed];
		while(x!=st){
			Re i=pre[x];
			a[i].flow-=cyf[ed];
			a[i^1].flow+=cyf[ed];
			x=a[i^1].to;
		}
	}
}
inline int P(Re x,Re y,Re k){return (x-1)*m+y+k*n*m;}
int main(){
	in(n),in(m),in(p),maxp=(1<<p)-1;st=(maxp+1)*n*m+1,ed=st+1;
	in(T);while(T--)in(x),in(y),in(z),in(w),in(G),Map[x][y][z][w]=Map[z][w][x][y]=G?G:-1;
	in(T);while(T--)in(x),in(y),in(G),key[x][y].push_back(G);
	add_(st,P(1,1,0),1,0);
	for(Re k=0;k<=maxp;++k)add_(P(n,m,k),ed,1,0);
	for(Re i=1;i<=n;++i)
		for(Re j=1;j<=m;++j)
			if(!key[i][j].empty())
				for(Re O=0;O<key[i][j].size();++O){
					Re KEY=key[i][j][O];
					for(Re k=0;k<=maxp;++k){
						if(!((k>>KEY-1)&1))add_(P(i,j,k),P(i,j,k|(1<<KEY-1)),inf,0);
						else{
							if(i<n&&Map[i][j][i+1][j]!=-1){
								if(!Map[i][j][i+1][j])add_(P(i,j,k),P(i+1,j,k),inf,1);
								else if((k>>Map[i][j][i+1][j]-1)&1)add_(P(i,j,k),P(i+1,j,k),inf,1);
							}
							if(j<m&&Map[i][j][i][j+1]!=-1){
								if(!Map[i][j][i][j+1])add_(P(i,j,k),P(i,j+1,k),inf,1);
								else if((k>>Map[i][j][i][j+1]-1)&1)add_(P(i,j,k),P(i,j+1,k),inf,1);
							}
							if(i>1&&Map[i][j][i-1][j]!=-1){
								if(!Map[i][j][i-1][j])add_(P(i,j,k),P(i-1,j,k),inf,1);
								else if((k>>Map[i][j][i-1][j]-1)&1)add_(P(i,j,k),P(i-1,j,k),inf,1);
							}
							if(j>1&&Map[i][j][i][j-1]!=-1){
								if(!Map[i][j][i][j-1])add_(P(i,j,k),P(i,j-1,k),inf,1);
								else if((k>>Map[i][j][i][j-1]-1)&1)add_(P(i,j,k),P(i,j-1,k),inf,1);
							}
						}
					}
				}
			else
				for(Re k=0;k<=maxp;++k){
					if(i<n&&Map[i][j][i+1][j]!=-1){
						if(!Map[i][j][i+1][j])add_(P(i,j,k),P(i+1,j,k),inf,1);
						else if((k>>Map[i][j][i+1][j]-1)&1)add_(P(i,j,k),P(i+1,j,k),inf,1);
					}
					if(j<m&&Map[i][j][i][j+1]!=-1){
						if(!Map[i][j][i][j+1])add_(P(i,j,k),P(i,j+1,k),inf,1);
						else if((k>>Map[i][j][i][j+1]-1)&1)add_(P(i,j,k),P(i,j+1,k),inf,1);
					}
					if(i>1&&Map[i][j][i-1][j]!=-1){
						if(!Map[i][j][i-1][j])add_(P(i,j,k),P(i-1,j,k),inf,1);
						else if((k>>Map[i][j][i-1][j]-1)&1)add_(P(i,j,k),P(i-1,j,k),inf,1);
					}
					if(j>1&&Map[i][j][i][j-1]!=-1){
						if(!Map[i][j][i][j-1])add_(P(i,j,k),P(i,j-1,k),inf,1);
						else if((k>>Map[i][j][i][j-1]-1)&1)add_(P(i,j,k),P(i,j-1,k),inf,1);
					}
				}
	EK(st,ed);
	if(maxflow)printf("%lld",mincost);
	else printf("-1");
}

```

**数字梯形问题  (EK)** *(MCMF)*

> 【数字梯形问题  (EK)（MCMF）】
最大流（Dinic）模板，含当前弧优化与多路增广。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re y,Re z,Re w) — 加法更新
  void add_(Re a,Re b,Re flow,Re w) — 加法更新
  int SPFA(Re st,Re ed) — SPFA最短路
  void EK(Re st,Re ed) — 核心算法函数
  void TAT1(无参数) — 核心算法函数
  void TAT2(无参数) — 核心算法函数
  void TAT3(无参数) — 核心算法函数

核心结构体：QAQ

关键配置：
N=1200,M=1865,inf=2e9

复杂度：一般图 O(V²E)，二分图 O(E√V)

适用场景：最大流/最小割建模、二分图匹配、任务分配问题

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#define LL long long
#define Re register int
using namespace std;
const int N=1200,M=1865,inf=2e9;
int o=1,n,m,h,t,st,ed,O,Poi[23][43],A[23][43],cyf[N],pan[N],pre[N],dis[N],head[N];LL maxcost,maxflow; 
struct QAQ{int w,to,next,flow;}a[M<<1];queue<int>Q;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void add(Re x,Re y,Re z,Re w){a[++o].flow=z,a[o].w=w,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline void add_(Re a,Re b,Re flow,Re w){add(a,b,flow,w),add(b,a,0,-w);}
inline int SPFA(Re st,Re ed){
    for(Re i=0;i<=ed;++i)dis[i]=-inf,pan[i]=0;
    Q.push(st),pan[st]=1,dis[st]=0,cyf[st]=inf;
    while(!Q.empty()){
    	Re x=Q.front();Q.pop();pan[x]=0;
    	for(Re i=head[x],to;i;i=a[i].next)
    		if(a[i].flow&&dis[to=a[i].to]<dis[x]+a[i].w){
    			dis[to]=dis[x]+a[i].w,pre[to]=i;
    			cyf[to]=min(cyf[x],a[i].flow);
    			if(!pan[to])pan[to]=1,Q.push(to);
    		}
    }
    return dis[ed]!=-inf;
}
inline void EK(Re st,Re ed){
    while(SPFA(st,ed)){
    	Re x=ed;maxflow+=cyf[ed],maxcost+=(LL)cyf[ed]*dis[ed];
    	while(x!=st){
    		Re i=pre[x];
    		a[i].flow-=cyf[ed];
    		a[i^1].flow+=cyf[ed];
    		x=a[i^1].to;
    	}
    }
}
inline void TAT1(){
    for(Re i=1;i<=m;++i)add_(st,Poi[1][i],1,0);
    for(Re i=1;i<=m+n-1;++i)add_(Poi[n][i]+O,ed,1,0);
    for(Re i=1;i<=n;++i)
    	for(Re j=1;j<=m+i-1;++j){
    		add_(Poi[i][j],Poi[i][j]+O,1,A[i][j]);
    		if(i<n)add_(Poi[i][j]+O,Poi[i+1][j],1,0),add_(Poi[i][j]+O,Poi[i+1][j+1],1,0);
    	}
    EK(st,ed);
    printf("%lld\n",maxcost);
}
inline void TAT2(){
    for(Re i=1;i<=m;++i)add_(st,Poi[1][i],1,0);
    for(Re i=1;i<=m+n-1;++i)add_(Poi[n][i]+O,ed,inf,0);
    for(Re i=1;i<=n;++i)
    	for(Re j=1;j<=m+i-1;++j){
    		add_(Poi[i][j],Poi[i][j]+O,inf,A[i][j]);
    		if(i<n)add_(Poi[i][j]+O,Poi[i+1][j],1,0),add_(Poi[i][j]+O,Poi[i+1][j+1],1,0);
    	}
    EK(st,ed);
    printf("%lld\n",maxcost);
}
inline void TAT3(){
    for(Re i=1;i<=m;++i)add_(st,Poi[1][i],1,0);
    for(Re i=1;i<=m+n-1;++i)add_(Poi[n][i]+O,ed,inf,0);
    for(Re i=1;i<=n;++i)
    	for(Re j=1;j<=m+i-1;++j){
            add_(Poi[i][j],Poi[i][j]+O,inf,A[i][j]);
            if(i<n)add_(Poi[i][j]+O,Poi[i+1][j],inf,0),add_(Poi[i][j]+O,Poi[i+1][j+1],inf,0);
    	}
    EK(st,ed);
    printf("%lld\n",maxcost);
}
inline void CL(){
    memset(head,0,sizeof(head));
    memset(cyf,0,sizeof(cyf));
    memset(pre,0,sizeof(pre));
    memset(a,0,sizeof(a));
    maxflow=maxcost=0,o=1;
}
int main(){
    in(m),in(n);
    for(Re i=1;i<=n;++i)
    	for(Re j=1;j<=m+i-1;++j)
            in(A[i][j]),Poi[i][j]=++O;
    st=O<<1|1,ed=st+1;
    TAT1(),CL(),TAT2(),CL(),TAT3();
}

```

**方格取数问题** *(Dinic)*

> 【方格取数问题（Dinic）】
最大流（Dinic）模板，含当前弧优化与多路增广。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re y,Re z) — 加法更新
  void add_(Re x,Re y,Re z) — 加法更新
  int bfs(Re st,Re ed) — 广度优先搜索遍历
  int dfs(Re x,Re flow) — 深度优先搜索遍历
  void Dinic(Re st,Re ed) — 核心算法函数
  int Poi(Re i,Re j) — 核心算法函数

核心结构体：QAQ

关键配置：
N=1e4+5,M=3e4+5,inf=2e9

复杂度：一般图 O(V²E)，二分图 O(E√V)

说明：若边权为0，不满足增广路性质，此时dfs返回值f为0，不必执行下面了

适用场景：最大流/最小割建模、二分图匹配、任务分配问题

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#define Re register int
using namespace std;
const int N=1e4+5,M=3e4+5,inf=2e9;
int x,n,m,h,t,o=1,T,st,ed,ans,maxflow,Q[N],cur[N],dis[N],head[N],wi[4]={0,0,1,-1},wj[4]={1,-1,0,0};
struct QAQ{int to,next,flow;}a[M<<1];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void add(Re x,Re y,Re z){a[++o].flow=z,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline void add_(Re x,Re y,Re z){add(x,y,z),add(y,x,0);}
inline int bfs(Re st,Re ed){//bfs求源点到所有点的最短路 
    for(Re i=0;i<=ed;++i)cur[i]=head[i],dis[i]=0;//当前弧优化cur=head
    h=1,t=0,dis[st]=1,Q[++t]=st;
    while(h<=t){
        Re x=Q[h++],to;
        for(Re i=head[x];i;i=a[i].next)
            if(a[i].flow&&!dis[to=a[i].to]){
            	dis[to]=dis[x]+1,Q[++t]=to;
            	if(to==ed)return 1;
            }
    }
    return 0;
}
inline int dfs(Re x,Re flow){//flow为源点到x的路径上的最小边权 
    if(!flow||x==ed)return flow;//发现没有流了或者到达终点即可返回 
    Re tmp=0,to,f;
    for(Re i=cur[x];i;i=a[i].next){
    	cur[x]=i;//当前弧优化cur=i
    	if(dis[to=a[i].to]==dis[x]+1&&(f=dfs(to,min(flow-tmp,a[i].flow)))){
    	//若边权为0，不满足增广路性质，此时dfs返回值f为0，不必执行下面了 
            a[i].flow-=f,a[i^1].flow+=f;
            tmp+=f;//记录终点已经有了多少流 
            if(!(flow-tmp))break;//前面那些儿子都是最短路，这些最优路径已经榨干了从x出来的所有流，后面的都不用管了 
    	}
    }
    return tmp;
}
inline void Dinic(Re st,Re ed){
    Re flow=0;maxflow=0;
    while(bfs(st,ed))maxflow+=dfs(st,inf);
}
inline int Poi(Re i,Re j){return (i-1)*m+j;}
int main(){
	in(n),in(m),st=n*m+1,ed=st+1;
	for(Re i=1;i<=n;++i)
		for(Re j=1;j<=m;++j){
			in(x),ans+=x;
			if((i+j)%2)add_(st,Poi(i,j),x);
			else add_(Poi(i,j),ed,x);
		}
	for(Re i=1;i<=n;++i)
		for(Re j=1;j<=m;++j)
			if((i+j)%2)for(Re k=0;k<4;++k){
				Re ni=i+wi[k],nj=j+wj[k];
				if(ni>=1&&ni<=n&&nj>=1&&nj<=m)add_(Poi(i,j),Poi(ni,nj),inf);
			}
	Dinic(st,ed);
	printf("%d\n",ans-maxflow);
}
```

**汽车加油行驶问题  (EK)** *(MCMF)*

> 【汽车加油行驶问题  (EK)（MCMF）】
最大流（Dinic）模板，含当前弧优化与多路增广。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re y,Re z,Re w) — 加法更新
  void add_(Re a,Re b,Re flow,Re w) — 加法更新
  int SPFA(Re st,Re ed) — SPFA最短路
  void EK(Re st,Re ed) — 核心算法函数
  int P(Re x,Re y,Re k) — 核心算法函数

核心结构体：QAQ

关键配置：
N=11e4+5,M=6e5+5,inf=2e9

复杂度：一般图 O(V²E)，二分图 O(E√V)

说明：��ÿһ���(n,n)����������㣬����n>=2��������㲻���ܵ����յ㣬��˲��������͵��յ㣬���Ե�0�㲻��；����״̬�����뻨��A���ͼӵ����������ڲ��������͵���ĳһ�㣬�������͵ĵ�0����Բ��ӣ�����；������֮��״̬����������״̬����K-1�͵����������ĸ�����

适用场景：最大流/最小割建模、二分图匹配、任务分配问题

```cpp
#include<algorithm>
#include<cstdio>
#include<queue>
#define LL long long
#define Re register int
using namespace std;
const int N=11e4+5,M=6e5+5,inf=2e9;
int x,y,z,w,o=1,n,m,h,t,A,B,C,K,st,ed,cyf[N],pan[N],pre[N],dis[N],head[N];LL mincost,maxflow; 
struct QAQ{int w,to,next,flow;}a[M<<1];queue<int>Q;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void add(Re x,Re y,Re z,Re w){a[++o].flow=z,a[o].w=w,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline void add_(Re a,Re b,Re flow,Re w){add(a,b,flow,w),add(b,a,0,-w);}
inline int SPFA(Re st,Re ed){
	for(Re i=0;i<=ed;++i)dis[i]=inf,pan[i]=0;
	Q.push(st),pan[st]=1,dis[st]=0,cyf[st]=inf;
	while(!Q.empty()){
		Re x=Q.front();Q.pop();pan[x]=0;
		for(Re i=head[x],to;i;i=a[i].next)
			if(a[i].flow&&dis[to=a[i].to]>dis[x]+a[i].w){
				dis[to]=dis[x]+a[i].w,pre[to]=i;
				cyf[to]=min(cyf[x],a[i].flow);
				if(!pan[to])pan[to]=1,Q.push(to);
			}
	}
	return dis[ed]!=inf;
}
inline void EK(Re st,Re ed){
	while(SPFA(st,ed)){
		Re x=ed;maxflow+=cyf[ed],mincost+=(LL)cyf[ed]*dis[ed];
		while(x!=st){
			Re i=pre[x];
			a[i].flow-=cyf[ed];
			a[i^1].flow+=cyf[ed];
			x=a[i^1].to;
		}
	}
}
inline int P(Re x,Re y,Re k){return (x-1)*n+y+k*n*n;}
int main(){
	in(n),in(K),in(A),in(B),in(C),st=(K+1)*n*n+1,ed=st+1;
	add_(st,P(1,1,0),1,0);
	for(Re k=1;k<=K;++k)add_(P(n,n,k),ed,1,0);
	for(Re i=1;i<=n;++i)
		for(Re j=1;j<=n;++j){
			in(x);
			if(x){
				for(Re k=1;k<=K;++k)add_(P(i,j,k),P(i,j,0),inf,A);
				if(i<n)add_(P(i,j,0),P(i+1,j,1),inf,0);
				if(j<n)add_(P(i,j,0),P(i,j+1,1),inf,0);
				if(i>1)add_(P(i,j,0),P(i-1,j,1),inf,B);
				if(j>1)add_(P(i,j,0),P(i,j-1,1),inf,B);
			}
			else{
				for(Re k=0;k<K;++k){
					if(i<n)add_(P(i,j,k),P(i+1,j,k+1),inf,0);
					if(j<n)add_(P(i,j,k),P(i,j+1,k+1),inf,0);
					if(i>1)add_(P(i,j,k),P(i-1,j,k+1),inf,B);
					if(j>1)add_(P(i,j,k),P(i,j-1,k+1),inf,B);
				}
				add_(P(i,j,K),P(i,j,0),1,A+C);
			}
		}
	EK(st,ed);
	printf("%lld",mincost);
}

```

**深海机器人问题  (EK)** *(MCMF)*

> 【深海机器人问题  (EK)（MCMF）】
最大流（Dinic）模板，含当前弧优化与多路增广。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re y,Re z,Re w) — 加法更新
  void add_(Re a,Re b,Re flow,Re w) — 加法更新
  int SPFA(Re st,Re ed) — SPFA最短路
  void EK(Re st,Re ed) — 核心算法函数
  int Poi(Re x,Re y) — 核心算法函数

核心结构体：QAQ

关键配置：
N=260,M=1540,inf=2e9

复杂度：一般图 O(V²E)，二分图 O(E√V)

适用场景：最大流/最小割建模、二分图匹配、任务分配问题

```cpp
#include<algorithm>
#include<cstdio>
#include<queue>
#define LL long long
#define Re register int
using namespace std;
const int N=260,M=1540,inf=2e9;
int x,y,z,o=1,n,m,h,t,Q1,Q2,st,ed,cyf[N],pan[N],pre[N],dis[N],head[N];LL maxcost,maxflow; 
struct QAQ{int w,to,next,flow;}a[M<<1];queue<int>Q;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void add(Re x,Re y,Re z,Re w){a[++o].flow=z,a[o].w=w,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline void add_(Re a,Re b,Re flow,Re w){add(a,b,flow,w),add(b,a,0,-w);}
inline int SPFA(Re st,Re ed){
	for(Re i=0;i<=ed;++i)dis[i]=-inf,pan[i]=0;
	Q.push(st),pan[st]=1,dis[st]=0,cyf[st]=inf;
	while(!Q.empty()){
		Re x=Q.front();Q.pop();pan[x]=0;
		for(Re i=head[x],to;i;i=a[i].next)
			if(a[i].flow&&dis[to=a[i].to]<dis[x]+a[i].w){
				dis[to]=dis[x]+a[i].w,pre[to]=i;
				cyf[to]=min(cyf[x],a[i].flow);
				if(!pan[to])pan[to]=1,Q.push(to);
			}
	}
	return dis[ed]!=-inf;
}
inline void EK(Re st,Re ed){
	while(SPFA(st,ed)){
		Re x=ed;maxflow+=cyf[ed],maxcost+=(LL)cyf[ed]*dis[ed];
		while(x!=st){
			Re i=pre[x];
			a[i].flow-=cyf[ed];
			a[i^1].flow+=cyf[ed];
			x=a[i^1].to;
		}
	}
}
inline int Poi(Re x,Re y){return (x-1)*m+y;}
int main(){
	in(Q1),in(Q2),in(n),in(m),++n,++m,st=n*m+1,ed=st+1;
	for(Re i=1;i<=n;++i)
		for(Re j=1;j<m;++j)
			in(x),add_(Poi(i,j),Poi(i,j+1),1,x),add_(Poi(i,j),Poi(i,j+1),inf,0);
	for(Re j=1;j<=m;++j)
		for(Re i=1;i<n;++i)
			in(x),add_(Poi(i,j),Poi(i+1,j),1,x),add_(Poi(i,j),Poi(i+1,j),inf,0);
	while(Q1--)in(z),in(x),in(y),add_(st,Poi(x+1,y+1),z,0);
	while(Q2--)in(z),in(x),in(y),add_(Poi(x+1,y+1),ed,z,0);
	EK(st,ed);
	printf("%lld",maxcost);
}

```

**航空路线问题  (EK)** *(MCMF)*

> 【航空路线问题  (EK)（MCMF）】
最大流（Dinic）模板，含当前弧优化与多路增广。

核心函数：
  void add(Re x,Re y,Re z,Re w) — 加法更新
  void add_(Re a,Re b,Re flow,Re w) — 加法更新
  int SPFA(Re st,Re ed) — SPFA最短路
  void EK(Re st,Re ed) — 核心算法函数
  void dfs1(Re x) — 深度优先搜索遍历
  void dfs2(Re x) — 深度优先搜索遍历

核心结构体：QAQ

关键配置：
N=103,M=40000,inf=2e9

复杂度：一般图 O(V²E)，二分图 O(E√V)

适用场景：最大流/最小割建模、二分图匹配、任务分配问题

```cpp
#include<algorithm>
#include<iostream>
#include<string>
#include<cstdio>
#include<queue>
#include<map>
#define LL long long
#define Re register int
using namespace std;
const int N=103,M=40000,inf=2e9;
int x,y,o=1,n,m,h,t,st,ed,flag,cyf[N],pan[N],pre[N],dis[N],head[N];LL maxcost,maxflow;
struct QAQ{int w,to,next,flow;}a[M<<1];queue<int>Q;string CH,ch[N];map<string,int>ip;
inline void add(Re x,Re y,Re z,Re w){a[++o].flow=z,a[o].w=w,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline void add_(Re a,Re b,Re flow,Re w){add(a,b,flow,w),add(b,a,0,-w);}
inline int SPFA(Re st,Re ed){
	for(Re i=0;i<=ed;++i)dis[i]=-inf,pan[i]=0;
	Q.push(st),pan[st]=1,dis[st]=0,cyf[st]=inf;
	while(!Q.empty()){
		Re x=Q.front();Q.pop();pan[x]=0;
		for(Re i=head[x],to;i;i=a[i].next)
			if(a[i].flow&&dis[to=a[i].to]<dis[x]+a[i].w){//�· 
				dis[to]=dis[x]+a[i].w,pre[to]=i;
				cyf[to]=min(cyf[x],a[i].flow);
				if(!pan[to])pan[to]=1,Q.push(to);
			}
	}
	return dis[ed]!=-inf;
}
inline void EK(Re st,Re ed){
	while(SPFA(st,ed)){
		Re x=ed;maxflow+=cyf[ed],maxcost+=(LL)cyf[ed]*dis[ed];
		while(x!=st){
			Re i=pre[x];
			a[i].flow-=cyf[ed];
			a[i^1].flow+=cyf[ed];
			x=a[i^1].to;
		}
	}
}
inline void dfs1(Re x){
	pan[x]=1;
	cout<<ch[x-n]<<endl;
	for(Re i=head[x],to;i;i=a[i].next)
		if((to=a[i].to)<=n&&!a[i].flow){dfs1(to+n);break;}
}
inline void dfs2(Re x){
	for(Re i=head[x],to;i;i=a[i].next)
		if((to=a[i].to)<=n&&!a[i].flow&&!pan[to+n])dfs2(to+n);
	cout<<ch[x-n]<<endl;
}
int main(){
	cin>>n>>m;st=1,ed=n<<1;
	for(Re i=1;i<=n;++i)cin>>ch[i],ip[ch[i]]=i;
	for(Re i=2;i<n;++i)add_(i,n+i,1,1);
	add_(1,1+n,2,1),add_(n,n+n,2,1);
	while(m--){
		cin>>CH;x=ip[CH];
		cin>>CH;y=ip[CH];
		if(x>y)swap(x,y);
		flag|=x==1&&y==n; 
		add_(x+n,y,1,0);
	}
	EK(st,ed);
	if(maxflow==2)printf("%d\n",maxcost-2);
	else if(maxflow==1&&flag){
		printf("2\n");
		cout<<ch[1]<<endl<<ch[n]<<endl<<ch[1]<<endl;
		return 0;
	}
	else return !printf("No Solution!\n");
	for(Re i=1;i<=n+2;++i)pan[i+n]=0;
	dfs1(1+n),dfs2(1+n);
}

```

**负载平衡问题  (EK)** *(MCMF)*

> 【负载平衡问题  (EK)（MCMF）】
最大流（Dinic）模板，含当前弧优化与多路增广。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re y,Re z,Re w) — 加法更新
  void add_(Re a,Re b,Re flow,Re w) — 加法更新
  int SPFA(Re st,Re ed) — SPFA最短路
  void EK(Re st,Re ed) — 核心算法函数

核心结构体：QAQ

关键配置：
N=103,inf=2e9

复杂度：一般图 O(V²E)，二分图 O(E√V)

适用场景：最大流/最小割建模、二分图匹配、任务分配问题

```cpp
#include<algorithm>
#include<cstdio>
#include<queue>
#define LL long long
#define Re register int
using namespace std;
const int N=103,inf=2e9;
int o=1,n,h,t,S,st,ed,A[N],cyf[N],pan[N],pre[N],dis[N],head[N];LL mincost; 
struct QAQ{int w,to,next,flow;}a[N<<3];queue<int>Q;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void add(Re x,Re y,Re z,Re w){a[++o].flow=z,a[o].w=w,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline void add_(Re a,Re b,Re flow,Re w){add(a,b,flow,w),add(b,a,0,-w);}
inline int SPFA(Re st,Re ed){
	for(Re i=0;i<=n;++i)dis[i]=inf,pan[i]=0;
	Q.push(st),pan[st]=1,dis[st]=0,cyf[st]=inf;
	while(!Q.empty()){
		Re x=Q.front();Q.pop();pan[x]=0;
		for(Re i=head[x],to;i;i=a[i].next)
			if(a[i].flow&&dis[to=a[i].to]>dis[x]+a[i].w){
				dis[to]=dis[x]+a[i].w,pre[to]=i;
				cyf[to]=min(cyf[x],a[i].flow);
				if(!pan[to])pan[to]=1,Q.push(to);
			}
	}
	return dis[ed]!=inf;
}
inline void EK(Re st,Re ed){
	while(SPFA(st,ed)){
		Re x=ed;mincost+=(LL)cyf[ed]*dis[ed];
		while(x!=st){
			Re i=pre[x];
			a[i].flow-=cyf[ed];
			a[i^1].flow+=cyf[ed];
			x=a[i^1].to;
		}
	}
}
int main(){
	in(n);st=n+1,ed=n+2;
	for(Re i=1;i<=n;++i)in(A[i]),S+=A[i];S/=n;
	for(Re i=1;i<=n;++i){
		if(i>1)add_(i,i-1,inf,1),add_(i-1,i,inf,1);
		if(A[i]>S)add_(st,i,A[i]-S,0);
		else if(A[i]<S)add_(i,ed,S-A[i],0);
	}
	add_(1,n,inf,1),add_(n,1,inf,1);
	n+=2;EK(st,ed);
	printf("%lld",mincost);
}

```

**运输问题  (EK)** *(MCMF)*

> 【运输问题  (EK)（MCMF）】
最大流（Dinic）模板，含当前弧优化与多路增广。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re y,Re z,Re w) — 加法更新
  void add_(Re a,Re b,Re flow,Re w) — 加法更新
  int SPFA(Re st,Re ed) — SPFA最短路
  void EK(Re st,Re ed) — 核心算法函数

核心结构体：QAQ

关键配置：
N=205,M=10205,inf=2e9

复杂度：一般图 O(V²E)，二分图 O(E√V)

适用场景：最大流/最小割建模、二分图匹配、任务分配问题

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#define LL long long
#define Re register int
using namespace std;
const int N=205,M=10205,inf=2e9;
int o=1,n,m,h,t,st,ed,cyf[N],pan[N],pre[N],dis[N],head[N],Flow[N][2],Cost[N][N];LL mincost,maxflow; 
struct QAQ{int w,to,next,flow;}a[M<<1];queue<int>Q;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void add(Re x,Re y,Re z,Re w){a[++o].flow=z,a[o].w=w,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline void add_(Re a,Re b,Re flow,Re w){add(a,b,flow,w),add(b,a,0,-w);}
inline int SPFA(Re st,Re ed){
	for(Re i=0;i<=ed;++i)dis[i]=inf,pan[i]=0;
	Q.push(st),pan[st]=1,dis[st]=0,cyf[st]=inf;
	while(!Q.empty()){
		Re x=Q.front();Q.pop();pan[x]=0;
		for(Re i=head[x],to;i;i=a[i].next)
			if(a[i].flow&&dis[to=a[i].to]>dis[x]+a[i].w){
				dis[to]=dis[x]+a[i].w,pre[to]=i;
				cyf[to]=min(cyf[x],a[i].flow);
				if(!pan[to])pan[to]=1,Q.push(to);
			}
	}
	return dis[ed]!=inf;
}
inline void EK(Re st,Re ed){
	while(SPFA(st,ed)){
		Re x=ed;maxflow+=cyf[ed],mincost+=(LL)cyf[ed]*dis[ed];
		while(x!=st){
			Re i=pre[x];
			a[i].flow-=cyf[ed];
			a[i^1].flow+=cyf[ed];
			x=a[i^1].to;
		}
	}
}
int main(){
	in(n),in(m),st=n+m+1,ed=st+1;
	for(Re i=1;i<=n;++i)in(Flow[i][0]),add_(st,i,Flow[i][0],0);
	for(Re i=1;i<=m;++i)in(Flow[i][1]),add_(n+i,ed,Flow[i][1],0);
	for(Re i=1;i<=n;++i)
		for(Re j=1;j<=m;++j)
			in(Cost[i][j]),add_(i,n+j,inf,Cost[i][j]);
	EK(st,ed);
	printf("%lld\n",mincost);
	memset(head,0,sizeof(head));
	memset(cyf,0,sizeof(cyf));
	memset(pre,0,sizeof(pre));
	memset(a,0,sizeof(a));
	o=1;maxflow=mincost=0;
	for(Re i=1;i<=n;++i)add_(st,i,Flow[i][0],0);
	for(Re i=1;i<=m;++i)add_(n+i,ed,Flow[i][1],0);
	for(Re i=1;i<=n;++i)
		for(Re j=1;j<=m;++j)
			add_(i,n+j,inf,-Cost[i][j]);
	EK(st,ed);
	printf("%lld\n",-mincost);
}

```

**飞行员配对方案问题** *(Dinic)*

> 【飞行员配对方案问题（Dinic）】
最大流（Dinic）模板，含当前弧优化与多路增广。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re y,Re z) — 加法更新
  int bfs(Re st,Re ed) — 广度优先搜索遍历
  int dfs(Re x,Re flow) — 深度优先搜索遍历
  void Dinic(Re st,Re ed) — 核心算法函数

核心结构体：QAQ

关键配置：
N=103,inf=2e9

复杂度：一般图 O(V²E)，二分图 O(E√V)

适用场景：最大流/最小割建模、二分图匹配、任务分配问题

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define Re register int
using namespace std;
const int N=103,inf=2e9;
int x,y,n,m,o=1,h,t,st,ed,ans,maxflow,Q[N],dis[N],head[N];
struct QAQ{int to,next,flow;}a[N*N*2+N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void add(Re x,Re y,Re z){a[++o].flow=z,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline int bfs(Re st,Re ed){
	for(Re i=0;i<=n+2;++i)dis[i]=0;
	h=1,t=0,dis[st]=1,Q[++t]=st;
	while(h<=t){
		Re to,x=Q[h++];
		for(Re i=head[x];i;i=a[i].next)
			if(a[i].flow&&!dis[to=a[i].to]){
				dis[to]=dis[x]+1,Q[++t]=to;
				if(to==ed)return 1;
			}
	}
	return 0;
}
inline int dfs(Re x,Re flow){
	if(!flow||x==ed)return flow;
	Re tmp=0,to,f;
	for(Re i=head[x];i;i=a[i].next)
		if(dis[to=a[i].to]==dis[x]+1&&(f=dfs(to,min(flow-tmp,a[i].flow)))){
			a[i].flow-=f,a[i^1].flow+=f,tmp+=f;
			if(flow==tmp)break;
		}
	return tmp;
}
inline void Dinic(Re st,Re ed){
	Re flow=0;while(bfs(st,ed))while(flow=dfs(st,inf))maxflow+=flow;
}
int main(){
	in(m),in(n),st=n+1,ed=n+2;
	while(1){
		in(x),in(y);
		if(x==-1)break;
		add(x,y,1),add(y,x,0);
	}
	for(Re i=1;i<=m;++i)add(st,i,1),add(i,st,0);
	for(Re i=m+1;i<=n;++i)add(i,ed,1),add(ed,i,0);
	Dinic(st,ed);
	printf("%d\n",maxflow);
	for(Re x=1;x<=m;++x)
		for(Re i=head[x];i;i=a[i].next)
			if(!(i&1)&&a[i].to!=st&&!a[i].flow)printf("%d %d\n",x,a[i].to);
}

```

**飞行员配对方案问题** *(EK)*

> 【飞行员配对方案问题（EK）】
最大流（Dinic）模板，含当前弧优化与多路增广。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re y,Re z) — 加法更新
  int bfs(Re st,Re ed) — 广度优先搜索遍历
  void EK(Re st,Re ed) — 核心算法函数

核心结构体：QAQ

关键配置：
N=103,inf=2e9

复杂度：一般图 O(V²E)，二分图 O(E√V)

适用场景：最大流/最小割建模、二分图匹配、任务分配问题

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define Re register int
using namespace std;
const int N=103,inf=2e9;
int x,y,n,m,o=1,h,t,st,ed,ans,maxflow,cyf[N],Q[N],pre[N],pan[N],head[N];
struct QAQ{int to,next,flow;}a[N*N*2+N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void add(Re x,Re y,Re z){a[++o].flow=z,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline int bfs(Re st,Re ed){
	for(Re i=0;i<=n+2;++i)pan[i]=0;
	h=1,t=0,pan[st]=1,cyf[st]=inf,Q[++t]=st;
	while(h<=t){
		Re to,x=Q[h++];
		for(Re i=head[x];i;i=a[i].next)
			if(a[i].flow&&!pan[to=a[i].to]){
				cyf[to]=min(cyf[x],a[i].flow);
				pan[to]=1,pre[to]=i,Q[++t]=to;
				if(to==ed)return 1;
			}
	}
	return 0;
}
inline void EK(Re st,Re ed){
	while(bfs(st,ed)){
		maxflow+=cyf[ed];
		Re x=ed;
		while(x!=st){
			Re i=pre[x];
			a[i].flow-=cyf[ed];
			a[i^1].flow+=cyf[ed];
			x=a[i^1].to;
		}
	}
}
int main(){
	in(m),in(n),st=n+1,ed=n+2;
	while(1){
		in(x),in(y);
		if(x==-1)break;
		add(x,y,1),add(y,x,0);
	}
	for(Re i=1;i<=m;++i)add(st,i,1),add(i,st,0);
	for(Re i=m+1;i<=n;++i)add(i,ed,1),add(ed,i,0);
	EK(st,ed);
	printf("%d\n",maxflow);
	for(Re x=1;x<=m;++x)
		for(Re i=head[x];i;i=a[i].next)
			if(!(i&1)&&a[i].to!=st&&!a[i].flow)printf("%d %d\n",x,a[i].to);
}

```

**魔术球问题** *(Dinic)*

> 【魔术球问题（Dinic）】
最大流（Dinic）模板，含当前弧优化与多路增广。

核心函数：
  void add(Re x,Re y,Re flow) — 加法更新
  void add_(Re x,Re y,Re flow) — 加法更新
  int bfs(Re st,Re ed) — 广度优先搜索遍历
  int dfs(Re x,Re flow) — 深度优先搜索遍历
  void Dinic(Re st,Re ed) — 核心算法函数

核心结构体：QAQ

关键配置：
N=1e5+5,inf=2e9

复杂度：一般图 O(V²E)，二分图 O(E√V)

说明：freopen("123.txt","r",stdin);

适用场景：最大流/最小割建模、二分图匹配、任务分配问题

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<vector>
#include<cmath>
#define Re register int
using namespace std;
const int N=1e5+5,inf=2e9;
int h,t,n,p,o=1,st,ed,cnt,maxflow,Q[N],zhu[N],ans[N],pan[N],pre[N],dis[N],head[N];
struct QAQ{int to,flow,next;}a[N<<1];vector<int>Ans[N];
inline void add(Re x,Re y,Re flow){a[++o].flow=flow,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline void add_(Re x,Re y,Re flow){add(x,y,flow),add(y,x,0);}
inline int bfs(Re st,Re ed){
	for(Re i=0;i<=ed;++i)dis[i]=0;
	h=1,t=0,dis[st]=1,Q[++t]=st;
	while(h<=t){
		Re x=Q[h++],to;
		for(Re i=head[x];i;i=a[i].next)
			if(a[i].flow&&!dis[to=a[i].to]){
				dis[to]=dis[x]+1,Q[++t]=to;
				if(to==ed)return 1;
			}
	}
	return 0;
}
inline int dfs(Re x,Re flow){
	if(!flow||x==ed)return flow;
	Re tmp=0,to,f;
	for(Re i=head[x];i;i=a[i].next)
		if(dis[to=a[i].to]==dis[x]+1&&(f=dfs(to,min(flow-tmp,a[i].flow)))){
			a[i].flow-=f,a[i^1].flow+=f;
			tmp+=f,pre[to]=i;
			if(!(flow-tmp))break;
		}
	return tmp;
}
inline void Dinic(Re st,Re ed){
	Re flow=0;maxflow=0;
	while(bfs(st,ed))while(flow=dfs(st,inf))maxflow+=flow;
}
int main(){
//	freopen("123.txt","r",stdin);
	scanf("%d",&n),st=1e5+1,ed=st+1;
	while(ans[0]<=n){
		++p;
		add_(st,p<<1,1),add_(p<<1|1,ed,1);
		for(Re j=sqrt(p)+1;j*j-p<=p-1;++j)add_((j*j-p)<<1,(p<<1)|1,1);
		Dinic(st,ed);
		if(!maxflow)ans[++ans[0]]=p,Ans[zhu[p]=ans[0]].push_back(p);
		else{
			Re x=p<<1|1;
			while(!zhu[x-1>>1])x=a[pre[x]^1].to+1;
			Ans[zhu[x-1>>1]].push_back(p);
		}
	}
	printf("%d\n",p-1);
	for(Re i=1;i<=n;puts(""),++i)
		for(Re j=0;j<Ans[i].size();++j)
			printf("%d ",Ans[i][j]);
}

```

**魔术球问题** *(EK)*

> 【魔术球问题（EK）】
最大流（Dinic）模板，含当前弧优化与多路增广。

核心函数：
  void add(Re x,Re y,Re flow) — 加法更新
  void add_(Re x,Re y,Re flow) — 加法更新
  int bfs(Re st,Re ed) — 广度优先搜索遍历
  void EK(Re st,Re ed) — 核心算法函数

核心结构体：QAQ

关键配置：
N=1e5+5,inf=2e9

复杂度：一般图 O(V²E)，二分图 O(E√V)

说明：freopen("123.txt","r",stdin);

适用场景：最大流/最小割建模、二分图匹配、任务分配问题

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<vector>
#include<cmath>
#define Re register int
using namespace std;
const int N=1e5+5,inf=2e9;
int h,t,n,p,o=1,st,ed,cnt,maxflow,Q[N],zhu[N],ans[N],pan[N],pre[N],cyf[N],head[N];
struct QAQ{int to,flow,next;}a[N<<1];vector<int>Ans[N];
inline void add(Re x,Re y,Re flow){a[++o].flow=flow,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline void add_(Re x,Re y,Re flow){add(x,y,flow),add(y,x,0);}
inline int bfs(Re st,Re ed){
	for(Re i=1;i<=ed;++i)pan[i]=0;
	h=1,t=0,pan[st]=1,Q[++t]=st,cyf[st]=inf;
	while(h<=t){
		Re x=Q[h++];
		for(Re i=head[x],to;i;i=a[i].next)
			if(a[i].flow&&!pan[to=a[i].to]){
				cyf[to]=min(cyf[x],a[i].flow);
				pan[Q[++t]=to]=1,pre[to]=i;
				if(to==ed)return 1;
			}
	}
	return 0;
}
inline void EK(Re st,Re ed){
	Re x,flow=0;maxflow=0;
	while(bfs(st,ed)){
		x=ed,maxflow+=cyf[ed];
		while(x!=st){
			Re i=pre[x];
			a[i].flow-=cyf[ed];
			a[i^1].flow+=cyf[ed];
			x=a[i^1].to;
		}
	}
}
int main(){
//	freopen("123.txt","r",stdin);
	scanf("%d",&n),st=1e5+1,ed=st+1;
	while(ans[0]<=n){
		++p;
		add_(st,p<<1,1),add_(p<<1|1,ed,1);
		for(Re j=sqrt(p)+1;j*j-p<=p-1;++j)add_((j*j-p)<<1,(p<<1)|1,1);
		EK(st,ed);
		if(!maxflow)ans[++ans[0]]=p,Ans[zhu[p]=ans[0]].push_back(p);
		else{
			Re x=p<<1|1;
			while(!zhu[x-1>>1])x=a[pre[x]^1].to+1;
			Ans[zhu[x-1>>1]].push_back(p);
		}
	}
	printf("%d\n",p-1);
	for(Re i=1;i<=n;puts(""),++i)
		for(Re j=0;j<Ans[i].size();++j)
			printf("%d ",Ans[i][j]);
}

```

**教辅的组成** *(Dinic)*

> 【教辅的组成（Dinic）】
最大流（Dinic）模板，含当前弧优化与多路增广。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re y,Re z) — 加法更新
  void add_(Re x,Re y,Re flow) — 加法更新
  int bfs(Re st,Re ed) — 广度优先搜索遍历
  int dfs(Re x,Re flow) — 深度优先搜索遍历
  void Dinic(Re st,Re ed) — 核心算法函数

核心结构体：QAQ

关键配置：
N=4e4+5,M=7e4+3,inf=2e9

复杂度：一般图 O(V²E)，二分图 O(E√V)

适用场景：最大流/最小割建模、二分图匹配、任务分配问题

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#define Re register int
using namespace std;
const int N=4e4+5,M=7e4+3,inf=2e9;
int x,y,z,o=1,n1,n2,n3,nn,m,h,t,st,ed,Q[N],dis[N],pan[N],pre[N],head[N];long long maxflow; 
struct QAQ{int to,next,flow;}a[M<<1];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void add(Re x,Re y,Re z){a[++o].flow=z,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline void add_(Re x,Re y,Re flow){add(x,y,flow),add(y,x,0);}
inline int bfs(Re st,Re ed){
	for(Re i=0;i<=ed;++i)dis[i]=0;
	h=1,t=0,dis[st]=1,Q[++t]=st;
	while(h<=t){
		Re x=Q[h++],to;
		for(Re i=head[x];i;i=a[i].next)
			if(a[i].flow&&!dis[to=a[i].to]){
				dis[to]=dis[x]+1,Q[++t]=to;
				if(to==ed)return 1;
			}
	}
	return 0;
}
inline int dfs(Re x,Re flow){
	if(!flow||x==ed)return flow;
	Re tmp=0,to,f;
	for(Re i=head[x];i;i=a[i].next)
		if(dis[to=a[i].to]==dis[x]+1&&(f=dfs(to,min(flow-tmp,a[i].flow)))){
			a[i].flow-=f,a[i^1].flow+=f,tmp+=f;
			if(!(flow-tmp))break;
		}
	return tmp;
}
inline void Dinic(Re st,Re ed){
	Re flow=0;
	while(bfs(st,ed))while(flow=dfs(st,inf))maxflow+=flow;
}
int main(){
	freopen("123.txt","r",stdin);
	in(n1),in(n2),in(n3);nn=n1+n2+n3,st=nn+n1+1,ed=st+1;
	for(Re i=1;i<=n1;++i)add_(i,i+nn,1);
	for(Re i=1;i<=n2;++i)add_(st,n1+i,1);
	for(Re i=1;i<=n3;++i)add_(n1+n2+i,ed,1);
	in(m);while(m--)in(x),in(y),add_(n1+y,x,1);
	in(m);while(m--)in(x),in(y),add_(x+nn,n1+n2+y,1);
	Dinic(st,ed);
	printf("%lld",maxflow);
}

```

### 3.6 负环与差分约束

**01分数规划** *(观光奶牛Sightseeing Cows)*

> 【01分数规划（观光奶牛Sightseeing Cows）】
负环检测与差分约束系统模板，基于 SPFA/Bellman-Ford。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re y,Re z) — 加法更新
  int SPFA(Re st,double mid) — SPFA最短路

核心结构体：QAQ

关键配置：
N=1e4+5,M=5e5+5,inf=2e9

```cpp
#include<cstring>
#include<cstdio>
#include<queue>
#define Re register int
using namespace std;
const int N=1e4+5,M=5e5+5,inf=2e9;
int x,y,z,n,m,o,T,to,A[N],cha[N],pan[N],head[N];double dis[N];
struct QAQ{int w,to,next;}a[M<<1];queue<int>Q;
inline void in(Re &x){
    Re fu=0;x=0;char ch=getchar();
    while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
    while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
    x=fu?-x:x;
}
inline void add(Re x,Re y,Re z){a[++o].to=y,a[o].w=z,a[o].next=head[x],head[x]=o;}
inline int SPFA(Re st,double mid){
    for(Re i=0;i<=n;++i)dis[i]=-inf,pan[i]=cha[i]=0;
    dis[st]=0,cha[st]=pan[st]=1,Q.push(st);
    while(!Q.empty()){
        x=Q.front(),Q.pop();
        pan[x]=0;
        for(Re i=head[x];i;i=a[i].next)
            if(dis[to=a[i].to]<dis[x]+A[x]-mid*a[i].w){
                dis[to]=dis[x]+A[x]-mid*a[i].w;
                if(++cha[to]>n)return 1;
                if(!pan[to])Q.push(to);
            }
    }
    return 0;
}
int main(){
    in(n),in(m);
    for(Re i=1;i<=n;++i)in(A[i]);
    while(m--)in(x),in(y),in(z),add(x,y,z);
    double l=0,r=1000000,mid;
    while(r-l>1e-4){
        mid=(l+r)/2;
        if(SPFA(1,mid))l=mid;
        else r=mid;
    }
    printf("%.2lf",l);
}

```

**判负环** *(SPFA)*

> 【判负环（SPFA）】
负环检测与差分约束系统模板，基于 SPFA/Bellman-Ford。

核心函数：
  void add(Re x,Re y,Re z) — 加法更新
  void in(Re &x) — 核心算法函数
  int SPFA(Re st) — SPFA最短路

核心结构体：QAQ

关键配置：
N=2003,M=3e5+3,inf=2e9

说明：if(++chu[to]>=n)return 1;

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#define LL long long
#define Re register int
using namespace std;
const int N=2003,M=3e5+3,inf=2e9;
int n,m,x,y,z,o,T,pan[N],chu[N],dis[N],head[N];queue<int>Q;
struct QAQ{int w,to,next;}a[M<<1];
inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline int SPFA(Re st){
    for(Re i=1;i<=n;++i)dis[i]=inf,chu[i]=pan[i]=0;
    while(!Q.empty())Q.pop();
    Q.push(st),dis[st]=0,chu[st]=0,pan[st]=1;
    while(!Q.empty()){
        Re x=Q.front();Q.pop();pan[x]=0;
        for(Re i=head[x],to;i;i=a[i].next)
            if(dis[to=a[i].to]>dis[x]+a[i].w){
                dis[to]=dis[x]+a[i].w;
                if((chu[to]=chu[x]+1)>=n)return 1;
//                if(++chu[to]>=n)return 1;
                if(!pan[to])pan[to]=1,Q.push(to);
            }
    }
    return 0;
}
int main(){
    in(T);
    while(T--){
        in(n),in(m),memset(head,0,sizeof(head)),o=0;
        while(m--){in(x),in(y),in(z),add(x,y,z);if(z>=0)add(y,x,z);}
        puts(SPFA(1)?"YES":"NO");
    }
}

```

**差分约束系统** *(糖果)*

> 【差分约束系统（糖果）】
负环检测与差分约束系统模板，基于 SPFA/Bellman-Ford。

核心函数：
  void add(Re x,Re y,Re z) — 加法更新
  void in(Re &x) — 核心算法函数
  int SPFA(Re st,Re ed) — SPFA最短路

核心结构体：QAQ

关键配置：
N=1e5+5,M=3e5+5,inf=2e9

```cpp
#include<cstring>
#include<cstdio>
#include<queue>
#define Re register int
using namespace std;
const int N=1e5+5,M=3e5+5,inf=2e9;
int x,y,n,m,o,op,chu[N],dis[N],pan[N],head[N];long long ans;
struct QAQ{int w,to,next;}a[M];queue<int>Q;
inline void add(Re x,Re y,Re z){a[++o].to=y,a[o].w=z,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
	Re fu=0;x=0;char ch=getchar();
	while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=fu?-x:x;
}
inline int SPFA(Re st,Re ed){
	for(Re i=0;i<=n;++i)dis[i]=-inf,chu[i]=0;
	dis[st]=0,chu[st]=pan[st]=1,Q.push(st);
	while(!Q.empty()){
		x=Q.front(),Q.pop();
		pan[x]=0;
		for(Re i=head[x],to;i;i=a[i].next)
			if(dis[to=a[i].to]<dis[x]+a[i].w){
				dis[to]=dis[x]+a[i].w;
				if((chu[to]=chu[x]+1)>n+1)return 1;
				if(!pan[to])pan[to]=1,Q.push(to);
			}
	}
	return 0;
}
int main(){
	in(n),in(m);
	for(Re i=n;i>=1;--i)add(0,i,1); //a[i]>=a[0]=1,a[i]-a[0]>=1
	while(m--){
		in(op),in(x),in(y);
		if(op<2)add(y,x,0),add(x,y,0);
		else if(op<3)add(x,y,1);//a[x]<a[y]: a[y]-a[x]>=1
		else if(op<4)add(y,x,0);//a[x]>=a[y]: a[x]-a[y]>=0
		else if(op<5)add(y,x,1);//a[x]>a[y]: a[x]-a[y]>=1
		else add(x,y,0);//a[x]<=a[y]: a[y]-a[x]>=0
		if(!(op%2)&&x==y){puts("-1");return 0;}
	}
	if(SPFA(0,n))puts("-1");
	else{
		for(Re i=1;i<=n;++i)ans+=dis[i];
		printf("%lld",ans);
	}
}

```

### 3.7 线段树优化建图

**线段树优化建边+Dijkstra最短路** *(Legacy)*

> 【线段树优化建边+Dijkstra最短路（Legacy）】
线段树（Segment Tree）模板，支持区间操作的高效数据结构。

核心函数：
  void add(Re x,Re y,Re z) — 加法更新
  void in(Re &x) — 核心算法函数
  void build(Re p,Re L,Re R) — 构建数据结构（建树/建图）
  void change(Re p,Re L,Re R,Re l,Re r,Re x,Re w,Re op) — 核心算法函数
  void dijkstra(Re st) — Dijkstra最短路

核心结构体：QAQ, Segment_Tree, QAQ, QWQ

关键配置：
N=1e5+3

复杂度：建树 O(N)，单次操作 O(log N)

说明：freopen("123.txt","r",stdin);

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#define LL long long
#define Re register int
using namespace std;
const int N=1e5+3;
const LL inf=1e18;
int n,m,x,y,w,l,r,o,op,st,head[N<<3];bool pan[N<<3];LL dis[N<<3];
struct QAQ{int w,to,next;}a[(N<<3)+(N<<2)+N*18*2];
inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Segment_Tree{
	#define pl (p<<1)
	#define pr (p<<1|1)
	#define mid ((L+R)>>1)
	int O;
	struct QAQ{int in,out;}tr[N<<2];
	inline void build(Re p,Re L,Re R){
		if(L==R){tr[p].in=tr[p].out=L;return;}
		tr[p].in=++O,tr[p].out=++O,add(tr[p].in,tr[p].out,0);
		build(pl,L,mid),build(pr,mid+1,R);
		add(tr[p].in,tr[pl].in,0),add(tr[p].in,tr[pr].in,0);
		add(tr[pl].out,tr[p].out,0),add(tr[pr].out,tr[p].out,0);
	}
	inline void change(Re p,Re L,Re R,Re l,Re r,Re x,Re w,Re op){
		if(l<=L&&R<=r){
			if(op)add(tr[p].out,x,w);
			else add(x,tr[p].in,w);
			return;
		}
		if(l<=mid)change(pl,L,mid,l,r,x,w,op);
		if(r>mid)change(pr,mid+1,R,l,r,x,w,op);
	}
}TR;
struct QWQ{int x;LL d;inline bool operator<(const QWQ &O)const{return d>O.d;}};
priority_queue<QWQ>Q;
inline void dijkstra(Re st){
	for(Re i=1;i<=TR.O;++i)dis[i]=inf;
	Q.push((QWQ){st,dis[st]=0});
	while(!Q.empty()){
		Re x=Q.top().x;Q.pop();
		if(pan[x])continue;
		pan[x]=0;
		for(Re i=head[x],to;i;i=a[i].next)
			if(dis[to=a[i].to]>dis[x]+a[i].w)
				Q.push((QWQ){to,dis[to]=dis[x]+a[i].w});
	}
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(m),in(st);
	TR.O=n,TR.build(1,1,n);
	while(m--){
		in(op),in(x);
		if(op<2)in(y),in(w),TR.change(1,1,n,y,y,x,w,0);
		else if(op<3)in(l),in(r),in(w),TR.change(1,1,n,l,r,x,w,0);
		else in(l),in(r),in(w),TR.change(1,1,n,l,r,x,w,1);
	}
	dijkstra(st);
	for(Re i=1;i<=n;++i)printf("%lld ",dis[i]==inf?-1:dis[i]);
}

```

**线段树优化建边+Dinic最大流** *(Last chance)*

> 【线段树优化建边+Dinic最大流（Last chance）】
线段树（Segment Tree）模板，支持区间操作的高效数据结构。

核心函数：
  void in(Re &x) — 核心算法函数
  void add_(Re x,Re y,Re flow) — 加法更新
  void add(Re x,Re y,Re flow) — 加法更新
  int bfs(Re st,Re ed) — 广度优先搜索遍历
  int dfs(Re x,Re flow) — 深度优先搜索遍历
  void dinic(Re st,Re ed) — 核心算法函数
  int find(Re x) — 查找（并查集寻根/二分查找）
  void build(Re p,Re L,Re R) — 构建数据结构（建树/建图）

核心结构体：Network_Flow, QAQ, Segment_Tree, QAQ

关键配置：
N=5003+3,M=25e4+3,inf=2e9

复杂度：建树 O(N)，单次操作 O(log N)

说明：freopen("123.txt","r",stdin);

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#define LL long long
#define Re register int
using namespace std;
const int N=5003+3,M=25e4+3,inf=2e9;
int n,m,x,y,z,O,op,st,ed,X[N],Y[N],Z[N],Ans[N],cnt[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Network_Flow{
	int o,h,t,maxflow,Q[N*3],dis[N*3],cur[N*3],head[N*3];
	struct QAQ{int to,next,flow;}a[M<<1];
	inline void add_(Re x,Re y,Re flow){a[++o].to=y,a[o].flow=flow,a[o].next=head[x],head[x]=o;}
	inline void add(Re x,Re y,Re flow){add_(x,y,flow),add_(y,x,0);}
	inline int bfs(Re st,Re ed){
		for(Re i=0;i<=ed;++i)dis[i]=0,cur[i]=head[i];
		h=1,t=0,dis[Q[++t]=st]=1;
		while(h<=t){
			Re x=Q[h++];
			for(Re i=head[x],to;i;i=a[i].next)
				if(a[i].flow&&!dis[to=a[i].to]){
					dis[Q[++t]=to]=dis[x]+1;
					if(to==ed)return 1;
				}
		}
		return 0;
	}
	inline int dfs(Re x,Re flow){
		if(x==ed||!flow)return flow;
		Re tmp=0,to,f;
		for(Re i=cur[x];i;i=a[i].next){
			cur[x]=i;
			if(dis[to=a[i].to]==dis[x]+1&&(f=dfs(to,min(a[i].flow,flow-tmp)))){
				a[i].flow-=f,a[i^1].flow+=f,tmp+=f;
				if(tmp==flow)break;
			}
		}
		return tmp;
	}
	inline void dinic(Re st,Re ed){while(bfs(st,ed))maxflow+=dfs(st,inf);}
	inline int find(Re x){
		Re last=ed;
		while(x<=O||x>O+n){
			for(Re i=head[x];i;i=a[i].next)
				if(a[i^1].to==x&&a[i].to!=last&&a[i].flow){
					--a[i].flow,last=x,x=a[i].to;break;
				}
		}
		return x-O;
	}
}T1;
struct Segment_Tree{
	#define pl (p<<1)
	#define pr (p<<1|1)
	#define mid ((L+R)>>1)
	struct QAQ{int in;}tr[N<<2];
	inline void build(Re p,Re L,Re R){
		if(L==R){tr[p].in=L;return;}
		tr[p].in=++O,build(pl,L,mid),build(pr,mid+1,R);
		T1.add(tr[p].in,tr[pl].in,inf),T1.add(tr[p].in,tr[pr].in,inf);
	}
	inline void change(Re p,Re L,Re R,Re l,Re r,Re x,Re w){
		if(l<=L&&R<=r){T1.add(x,tr[p].in,w);return;}
		if(l<=mid)change(pl,L,mid,l,r,x,w);
		if(r>mid)change(pr,mid+1,R,l,r,x,w);
	}
}TR;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(m),T1.o=1,O=m,TR.build(1,1,m),st=O+n+1,ed=st+1;
	for(Re i=1;i<=n;++i){
		in(op);
		if(op<1){
			in(x),T1.add(st,O+i,1);
			while(x--)in(y),T1.add(O+i,y,1);
		}
		else if(op<2)in(x),in(y),T1.add(st,O+i,1),TR.change(1,1,m,x,y,O+i,1);
		else{
			in(x),in(y),in(z),T1.add(st,O+i,2),X[i]=x,Y[i]=y,Z[i]=z;
			T1.add(O+i,x,1),T1.add(O+i,y,1),T1.add(O+i,z,1);
		}
	}
	for(Re j=1;j<=m;++j)T1.add(j,ed,1);
	T1.dinic(st,ed),printf("%d\n",T1.maxflow);
	for(Re i=T1.head[ed];i;i=T1.a[i].next)
		if(T1.a[i].flow)++cnt[Ans[T1.a[i].to]=T1.find(T1.a[i].to)];
	for(Re i=1;i<=n;++i)
		if(X[i]&&cnt[i]==1){
			if(Ans[X[i]]==i)Ans[Y[i]]=i;
			else Ans[X[i]]=i;
		}
	for(Re i=1;i<=m;++i)if(Ans[i])printf("%d %d\n",Ans[i],i);
}

```

**线段树优化建边+Tarjan缩点** *(炸弹)*

> 【线段树优化建边+Tarjan缩点（炸弹）】
线段树（Segment Tree）模板，支持区间操作的高效数据结构。

核心函数：
  void add(Re x,Re y) — 加法更新
  template<typename T>inline void in(T &x) — 核心算法函数
  void build(Re p,Re L,Re R) — 构建数据结构（建树/建图）
  void change(Re p,Re L,Re R,Re l,Re r,Re x) — 核心算法函数
  int find1(LL x,Re r) — 查找（并查集寻根/二分查找）
  int find2(LL x,Re l) — 查找（并查集寻根/二分查找）
  void add(Re x,Re y) — 加法更新
  void dfs(Re x) — 深度优先搜索遍历

核心结构体：QAQ, Segment_Tree, QAQ, Tuopu, QAQ

关键配置：
N=5e5+3,M=(N<<2)+N*18*2,P=1e9+7

复杂度：建树 O(N)，单次操作 O(log N)

说明：printf("(x=%d) -> (l=%d,r=%d) w=%d\n",x,l,r,w);return;；freopen("123.txt","r",stdin);

适用场景：区间最值/和查询、区间加/乘/赋值修改、区间合并统计等

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#include<map>
#define LL long long
#define Re register int
#define mp make_pair
using namespace std;
const int N=5e5+3,M=(N<<2)+N*18*2,P=1e9+7;
int o,n,Ans,head[N<<2];LL X[N],R[N];
struct QAQ{int x,to,next;}a[M];map<pair<int,int>,int>vis;
inline void add(Re x,Re y){a[++o].x=x,a[o].to=y,a[o].next=head[x],head[x]=o;}
template<typename T>inline void in(T &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Segment_Tree{
	#define pl (p<<1)
	#define pr (p<<1|1)
	#define mid ((L+R)>>1)
	int O;
	struct QAQ{int in;}tr[N<<2];
	inline void build(Re p,Re L,Re R){
		if(L==R){tr[p].in=L;return;}
		tr[p].in=++O;
		build(pl,L,mid),build(pr,mid+1,R);
		add(tr[p].in,tr[pl].in),add(tr[p].in,tr[pr].in);
	}
	inline void change(Re p,Re L,Re R,Re l,Re r,Re x){
//		printf("(x=%d) -> (l=%d,r=%d) w=%d\n",x,l,r,w);return;
		if(l<=L&&R<=r){add(x,tr[p].in);return;}
		if(l<=mid)change(pl,L,mid,l,r,x);
		if(r>mid)change(pr,mid+1,R,l,r,x);
	}
}TR;
inline int find1(LL x,Re r){
	Re l=1;
	while(l<r){
		Re Mid=l+r>>1;
		if(X[Mid]<x)l=Mid+1;
		else r=Mid;
	}
	return r;
}
inline int find2(LL x,Re l){
	Re r=n;
	while(l<r){
		Re Mid=l+r+1>>1;
		if(X[Mid]>x)r=Mid-1;
		else l=Mid;
	}
	return l;
}
struct Tuopu{
	int o,n,L[N<<2],R[N<<2],ru[N<<2],pan[N<<2],head[N<<2];queue<int>Q;
	struct QAQ{int to,next;}a[M];
	inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
	inline void dfs(Re x){
		if(pan[x])return;
		pan[x]=1;
		for(Re i=head[x],to;i;i=a[i].next)
			dfs(to=a[i].to),L[x]=min(L[x],L[to]),R[x]=max(R[x],R[to]);
	}
	inline void sakura(){for(Re i=1;i<=n;++i)if(!ru[i])dfs(i);}
}T2;
int Q_o,ip[N<<2];
struct Tarjan{
	int n,t,dfn_o,Q[N<<2],low[N<<2],dfn[N<<2],pan[N<<2];
	inline void tarjan(Re x){
		dfn[x]=low[x]=++dfn_o,Q[++t]=x,pan[x]=1;
		for(Re i=head[x],to;i;i=a[i].next)
			if(!dfn[to=a[i].to])tarjan(to),low[x]=min(low[x],low[to]);
			else if(pan[to])low[x]=min(low[x],dfn[to]);
		if(low[x]==dfn[x]){
			++Q_o,T2.L[Q_o]=n+1,T2.R[Q_o]=-1;
			while(1){
				ip[Q[t]]=Q_o,pan[Q[t]]=0;
				if(x==Q[t--])break;
			}
		}
	}
	inline void sakura(){
		for(Re i=1;i<=n;++i)if(!dfn[i])tarjan(i);
		for(Re i=1,x,y;i<=o;++i)
			if((x=ip[a[i].x])!=(y=ip[a[i].to])&&!vis[mp(x,y)])
				vis[mp(x,y)]=1,++T2.ru[y],T2.add(x,y);
	}
}T1;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),TR.O=n,TR.build(1,1,n);
	for(Re i=1;i<=n;++i)in(X[i]),in(R[i]);
	for(Re i=1;i<=n;++i)TR.change(1,1,n,find1(X[i]-R[i],i),find2(X[i]+R[i],i),i);
	T1.n=TR.O,T1.sakura();
	for(Re i=1;i<=n;++i)T2.L[ip[i]]=min(T2.L[ip[i]],i),T2.R[ip[i]]=max(T2.R[ip[i]],i);;
	T2.n=Q_o,T2.sakura();
	for(Re i=1;i<=n;++i)(Ans+=(LL)i*(T2.R[ip[i]]-T2.L[ip[i]]+1)%P)%=P;
	printf("%d\n",Ans);
}

```

## 4. 树上问题

### 4.1 最近公共祖先LCA

**最近公共祖先** *(lca)*

> 【最近公共祖先（LCA）——倍增法（Binary Lifting）】
▪ dfs(u, p) — 预处理 DFS：计算 depth[u]（深度），parent[u][0]=p（父节点），递推 parent[u][k] = parent[parent[u][k-1]][k-1]（2^k 级祖先），并建立子节点列表 ch[u]
▪ lca(u, v) — 查询 LCA：
  ① 将较深的 u 上提到与 v 同深度（从高到低枚举 k，若 depth[u]-(1<<k)≥depth[v] 则跳）
  ② 若 u==v 返回；否则从高到低同时上跳（parent[u][k]!=parent[v][k] 时跳）
  ③ 最终 parent[u][0] 即为 LCA
预处理 O(N log N)，单次查询 O(log N)。适用于树上距离、路径信息查询、树上差分。

```cpp
#include <iostream>
#include <vector>
#include <queue>
using namespace std;

const int MAXN = 1e5 + 5;
const int LOG = 20;  // 2^20 > 1e5

vector<int> adj[MAXN];
vector<int> ch[MAXN];
int depth[MAXN];
int parent[MAXN][LOG];
int n, m, root;

// 预处理：计算每个节点的深度和2^k级祖先
void dfs(int u, int p) {
    depth[u] = depth[p] + 1;
    parent[u][0] = p;
    for (int k = 1; k < LOG; ++k) {
        parent[u][k] = parent[parent[u][k-1]][k-1];
    }
    for (int v : adj[u]) {
        if (v != p) {
            ch[u].push_back(v);
            dfs(v, u);
        }
    }
}

// 查找u和v的最近公共祖先
int lca(int u, int v) {
    if (depth[u] < depth[v]) {
        swap(u, v);
    }
    // 将u提到与v同一深度
    for (int k = LOG - 1; k >= 0; --k) {
        if (depth[u] - (1 << k) >= depth[v]) {
            u = parent[u][k];
        }
    }
    if (u == v) {
        return u;
    }
    // 同时向上跳
    for (int k = LOG - 1; k >= 0; --k) {
        if (parent[u][k] != parent[v][k]) {
            u = parent[u][k];
            v = parent[v][k];
        }
    }
    return parent[u][0];
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    cin >> n >> m;
    root = 1;
    for (int i = 1; i < n; ++i) {
        int u, v;
        cin >> u >> v;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    // 预处理
    dfs(root, 0);

    // lca查询
    // cout << lca(u, v);
    return 0;
}
```

### 4.2 树链剖分

**树链剖分+MOD** *(shulianpoufenMOD)*

> 【树链剖分（Heavy-Light Decomposition）——带 MOD 版】
▪ dfs1(u, p) — 第一次 DFS：计算 parent、depth、sz（子树大小）、heavy（重儿子）
▪ dfs2(u, h) — 第二次 DFS：分配 pos（线段树位置/DFS 序）、top（重链顶部），优先遍历重儿子保证重链连续
▪ build(datas, tree, rt, l, r) — 线段树建树，O(N)
▪ pushDown(tree, rt, len) — 下传懒标记，O(1)
▪ query(tree, rt, l, r, ql, qr) — 线段树区间查询（含 MOD），O(log N)
▪ updateRange(tree, rt, l, r, ul, ur, val) — 线段树区间更新（含 MOD），O(log N)
▪ queryPath(u, v) — 查询树上路径 u↔v 的权值和：反复跳深度较深的 top，每次跳 O(log N)，总计 O(log² N)
▪ updatePath(u, v, val) — 更新树上路径 u↔v 的权值，同理 O(log² N)
剖分 O(N)，每次路径/子树操作 O(log² N)。适用于树上路径权值修改/查询（含取模）。

```cpp
const int MAXN = 1e5 + 5;  // 最大节点数
int N, M, R, P;  // 节点数、操作数、根节点、模数
vector<int> adj[MAXN];  // 邻接表存储树结构
int val[MAXN];  // 节点初始权值

// 树链剖分相关变量
int parent[MAXN];  // 父节点
int depth[MAXN];   // 节点深度
int sz[MAXN];      // 子树大小
int heavy[MAXN];   // 重儿子
int pos[MAXN];     // 节点在线段树中的位置
int top[MAXN];     // 所在重链的顶部节点
int current_pos;   // 当前DFS序位置

// 线段树节点结构
struct node {
    int data;  // 节点值
    int lazy;  // 懒标记
    node() : data(0), lazy(0) {}
};

vector<node> tree;  // 线段树

// 构建线段树
void build(const vector<int>& datas, vector<node>& tree, int rt, int left, int right) {
    if (left == right) {
        tree[rt].data = datas[left];
        return;
    }
    int mid = left + (right - left) / 2;
    build(datas, tree, 2 * rt, left, mid);
    build(datas, tree, 2 * rt + 1, mid + 1, right);
    tree[rt].data = (tree[2 * rt].data + tree[2 * rt + 1].data) % P;
}

// 下传懒标记
void pushDown(vector<node>& tree, int rt, int len) {
    if (tree[rt].lazy != 0) {
        tree[rt * 2].data = (tree[rt * 2].data + tree[rt].lazy * (len - len / 2)) % P;
        tree[rt * 2].lazy = (tree[rt * 2].lazy + tree[rt].lazy) % P;
        tree[rt * 2 + 1].data = (tree[rt * 2 + 1].data + tree[rt].lazy * (len / 2)) % P;
        tree[rt * 2 + 1].lazy = (tree[rt * 2 + 1].lazy + tree[rt].lazy) % P;
        tree[rt].lazy = 0;
    }
}

// 线段树区间查询
int query(vector<node>& tree, int rt, int left, int right, int ql, int qr) {
    if (ql > right || qr < left) {
        return 0;
    }
    if (ql <= left && qr >= right) {
        return tree[rt].data;
    }
    pushDown(tree, rt, right - left + 1);
    int mid = left + (right - left) / 2;
    int leftsum = query(tree, 2 * rt, left, mid, ql, qr);
    int rightsum = query(tree, 2 * rt + 1, mid + 1, right, ql, qr);
    return (leftsum + rightsum) % P;
}

// 线段树区间更新
void updateRange(vector<node>& tree, int rt, int left, int right, int ul, int ur, int value) {
    if (ul > right || ur < left) return;
    if (ul <= left && ur >= right) {
        tree[rt].data = (tree[rt].data + value * (right - left + 1)) % P;
        tree[rt].lazy = (tree[rt].lazy + value) % P;
        return;
    }
    pushDown(tree, rt, right - left + 1);
    int mid = left + (right - left) / 2;
    updateRange(tree, 2 * rt, left, mid, ul, ur, value);
    updateRange(tree, 2 * rt + 1, mid + 1, right, ul, ur, value);
    tree[rt].data = (tree[2 * rt].data + tree[2 * rt + 1].data) % P;
}

// 第一次DFS：计算父节点、深度、子树大小和重儿子
void dfs1(int u, int p) {
    parent[u] = p;
    depth[u] = depth[p] + 1;
    sz[u] = 1;
    heavy[u] = 0;
    for (int v : adj[u]) {
        if (v != p) {
            dfs1(v, u);
            sz[u] += sz[v];
            if (sz[v] > sz[heavy[u]]) {
                heavy[u] = v;
            }
        }
    }
}

// 第二次DFS：进行重链剖分，计算DFS序和重链顶部
void dfs2(int u, int p, int chain_top) {
    pos[u] = ++current_pos;
    top[u] = chain_top;
    if (heavy[u]) {
        dfs2(heavy[u], u, chain_top);
    }
    for (int v : adj[u]) {
        if (v != p && v != heavy[u]) {
            dfs2(v, u, v);
        }
    }
}

// 路径更新：将x到y路径上的节点值都加上z
void pathUpdate(int x, int y, int z) {
    while (top[x] != top[y]) {
        if (depth[top[x]] > depth[top[y]]) {
            swap(x, y);
        }
        updateRange(tree, 1, 1, N, pos[top[y]], pos[y], z);
        y = parent[top[y]];
    }
    if (depth[x] > depth[y]) {
        swap(x, y);
    }
    updateRange(tree, 1, 1, N, pos[x], pos[y], z);
}

// 路径查询：查询x到y路径上的节点值之和
int pathQuery(int x, int y) {
    int res = 0;
    while (top[x] != top[y]) {
        if (depth[top[x]] > depth[top[y]]) {
            swap(x, y);
        }
        res = (res + query(tree, 1, 1, N, pos[top[y]], pos[y])) % P;
        y = parent[top[y]];
    }
    if (depth[x] > depth[y]) {
        swap(x, y);
    }
    res = (res + query(tree, 1, 1, N, pos[x], pos[y])) % P;
    return res;
}

// 子树更新：将以x为根的子树所有节点值加上z
void subtreeUpdate(int x, int z) {
    int l = pos[x];
    int r = pos[x] + sz[x] - 1;
    updateRange(tree, 1, 1, N, l, r, z);
}

// 子树查询：查询以x为根的子树所有节点值之和
int subtreeQuery(int x) {
    int l = pos[x];
    int r = pos[x] + sz[x] - 1;
    return query(tree, 1, 1, N, l, r);
}

// 求两个节点的最近公共祖先（LCA）
int lca(int x, int y) {
    while (top[x] != top[y]) {
        if (depth[top[x]] < depth[top[y]]) {
            swap(x, y);
        }
        x = parent[top[x]];
    }
    return depth[x] < depth[y] ? x : y;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    cin >> N >> M >> R >> P;
    for (int i = 1; i <= N; ++i) {
        cin >> val[i];
    }
    for (int i = 1; i < N; ++i) {
        int x, y;
        cin >> x >> y;
        adj[x].push_back(y);
        adj[y].push_back(x);
    }

    // 第一次DFS预处理
    dfs1(R, 0);
    current_pos = 0;
    // 第二次DFS进行重链剖分
    dfs2(R, 0, R);

    // 构建线段树
    vector<int> datas(N + 1);
    for (int i = 1; i <= N; ++i) {
        datas[pos[i]] = val[i] % P;
    }

    tree.resize(4 * (N + 1));
    build(datas, tree, 1, 1, N);

    // 处理操作
    while (M--) {
        int cmd;
        cin >> cmd;
        if (cmd == 1) {  // 路径更新
            int x, y, z;
            cin >> x >> y >> z;
            pathUpdate(x, y, z);
        } else if (cmd == 2) {  // 路径查询
            int x, y;
            cin >> x >> y;
            cout << pathQuery(x, y) << '\n';
        } else if (cmd == 3) {  // 子树更新
            int x, z;
            cin >> x >> z;
            subtreeUpdate(x, z);
        } else if (cmd == 4) {  // 子树查询
            int x;
            cin >> x;
            cout << subtreeQuery(x) << '\n';
        }
    }

    return 0;
}
```

**树链剖分** *(shulianpoufen)*

> 【树链剖分（Heavy-Light Decomposition）——无 MOD 版】
▪ dfs1(u, p) — 第一次 DFS：计算 parent、depth、sz、heavy（重儿子）
▪ dfs2(u, h) — 第二次 DFS：分配 pos（DFS 序）、top（重链顶部），优先遍历重儿子
▪ build(datas, tree, rt, l, r) — 线段树建树，O(N)
▪ pushDown(tree, rt, len) — 下传懒标记，O(1)
▪ query(tree, rt, l, r, ql, qr) — 线段树区间查询（无 MOD），O(log N)
▪ updateRange(tree, rt, l, r, ul, ur, val) — 线段树区间更新（无 MOD），O(log N)
▪ queryPath(u, v) / updatePath(u, v, val) — 树上路径查询/更新，O(log² N)
与 ID=27 功能一致但不含模数，适用于不需要取模的树上路径/子树操作。

```cpp
const int MAXN = 1e5 + 5;  // 最大节点数
int N, M, R;  // 节点数、操作数、根节点
vector<int> adj[MAXN];  // 邻接表存储树结构
int val[MAXN];  // 节点初始权值

// 树链剖分相关变量
int parent[MAXN];  // 父节点
int depth[MAXN];   // 节点深度
int sz[MAXN];      // 子树大小
int heavy[MAXN];   // 重儿子
int pos[MAXN];     // 节点在线段树中的位置
int top[MAXN];     // 所在重链的顶部节点
int current_pos;   // 当前DFS序位置

// 线段树节点结构
struct node {
    int data;  // 节点值
    int lazy;  // 懒标记
    node() : data(0), lazy(0) {}
};

vector<node> tree;  // 线段树

// 构建线段树
void build(const vector<int>& datas, vector<node>& tree, int rt, int left, int right) {
    if (left == right) {
        tree[rt].data = datas[left];
        return;
    }
    int mid = left + (right - left) / 2;
    build(datas, tree, 2 * rt, left, mid);
    build(datas, tree, 2 * rt + 1, mid + 1, right);
    tree[rt].data = tree[2 * rt].data + tree[2 * rt + 1].data;
}

// 下传懒标记
void pushDown(vector<node>& tree, int rt, int len) {
    if (tree[rt].lazy != 0) {
        tree[rt * 2].data = tree[rt * 2].data + tree[rt].lazy * (len - len / 2);
        tree[rt * 2].lazy = tree[rt * 2].lazy + tree[rt].lazy;
        tree[rt * 2 + 1].data = tree[rt * 2 + 1].data + tree[rt].lazy * (len / 2);
        tree[rt * 2 + 1].lazy = tree[rt * 2 + 1].lazy + tree[rt].lazy;
        tree[rt].lazy = 0;
    }
}

// 线段树区间查询
int query(vector<node>& tree, int rt, int left, int right, int ql, int qr) {
    if (ql > right || qr < left) {
        return 0;
    }
    if (ql <= left && qr >= right) {
        return tree[rt].data;
    }
    pushDown(tree, rt, right - left + 1);
    int mid = left + (right - left) / 2;
    int leftsum = query(tree, 2 * rt, left, mid, ql, qr);
    int rightsum = query(tree, 2 * rt + 1, mid + 1, right, ql, qr);
    return leftsum + rightsum;
}

// 线段树区间更新
void updateRange(vector<node>& tree, int rt, int left, int right, int ul, int ur, int value) {
    if (ul > right || ur < left) return;
    if (ul <= left && ur >= right) {
        tree[rt].data = tree[rt].data + value * (right - left + 1);
        tree[rt].lazy = tree[rt].lazy + value;
        return;
    }
    pushDown(tree, rt, right - left + 1);
    int mid = left + (right - left) / 2;
    updateRange(tree, 2 * rt, left, mid, ul, ur, value);
    updateRange(tree, 2 * rt + 1, mid + 1, right, ul, ur, value);
    tree[rt].data = tree[2 * rt].data + tree[2 * rt + 1].data;
}

// 第一次DFS：计算父节点、深度、子树大小和重儿子
void dfs1(int u, int p) {
    parent[u] = p;
    depth[u] = depth[p] + 1;
    sz[u] = 1;
    heavy[u] = 0;
    for (int v : adj[u]) {
        if (v != p) {
            dfs1(v, u);
            sz[u] += sz[v];
            if (sz[v] > sz[heavy[u]]) {
                heavy[u] = v;
            }
        }
    }
}

// 第二次DFS：进行重链剖分，计算DFS序和重链顶部
void dfs2(int u, int p, int chain_top) {
    pos[u] = ++current_pos;
    top[u] = chain_top;
    if (heavy[u]) {
        dfs2(heavy[u], u, chain_top);
    }
    for (int v : adj[u]) {
        if (v != p && v != heavy[u]) {
            dfs2(v, u, v);
        }
    }
}

// 路径更新：将x到y路径上的节点值都加上z
void pathUpdate(int x, int y, int z) {
    while (top[x] != top[y]) {
        if (depth[top[x]] > depth[top[y]]) {
            swap(x, y);
        }
        updateRange(tree, 1, 1, N, pos[top[y]], pos[y], z);
        y = parent[top[y]];
    }
    if (depth[x] > depth[y]) {
        swap(x, y);
    }
    updateRange(tree, 1, 1, N, pos[x], pos[y], z);
}

// 路径查询：查询x到y路径上的节点值之和
int pathQuery(int x, int y) {
    int res = 0;
    while (top[x] != top[y]) {
        if (depth[top[x]] > depth[top[y]]) {
            swap(x, y);
        }
        res = res + query(tree, 1, 1, N, pos[top[y]], pos[y]);
        y = parent[top[y]];
    }
    if (depth[x] > depth[y]) {
        swap(x, y);
    }
    res = res + query(tree, 1, 1, N, pos[x], pos[y]);
    return res;
}

// 子树更新：将以x为根的子树所有节点值加上z
void subtreeUpdate(int x, int z) {
    int l = pos[x];
    int r = pos[x] + sz[x] - 1;
    updateRange(tree, 1, 1, N, l, r, z);
}

// 子树查询：查询以x为根的子树所有节点值之和
int subtreeQuery(int x) {
    int l = pos[x];
    int r = pos[x] + sz[x] - 1;
    return query(tree, 1, 1, N, l, r);
}

// 求两个节点的最近公共祖先（LCA）
int lca(int x, int y) {
    while (top[x] != top[y]) {
        if (depth[top[x]] < depth[top[y]]) {
            swap(x, y);
        }
        x = parent[top[x]];
    }
    return depth[x] < depth[y] ? x : y;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    cin >> N >> M >> R;
    for (int i = 1; i <= N; ++i) {
        cin >> val[i];
    }
    for (int i = 1; i < N; ++i) {
        int x, y;
        cin >> x >> y;
        adj[x].push_back(y);
        adj[y].push_back(x);
    }

    // 第一次DFS预处理
    dfs1(R, 0);
    current_pos = 0;
    // 第二次DFS进行重链剖分
    dfs2(R, 0, R);

    // 构建线段树
    vector<int> datas(N + 1);
    for (int i = 1; i <= N; ++i) {
        datas[pos[i]] = val[i];
    }

    tree.resize(4 * (N + 1));
    build(datas, tree, 1, 1, N);

    // 处理操作
    while (M--) {
        int cmd;
        cin >> cmd;
        if (cmd == 1) {  // 路径更新
            int x, y, z;
            cin >> x >> y >> z;
            pathUpdate(x, y, z);
        } else if (cmd == 2) {  // 路径查询
            int x, y;
            cin >> x >> y;
            cout << pathQuery(x, y) << '\n';
        } else if (cmd == 3) {  // 子树更新
            int x, z;
            cin >> x >> z;
            subtreeUpdate(x, z);
        } else if (cmd == 4) {  // 子树查询
            int x;
            cin >> x;
            cout << subtreeQuery(x) << '\n';
        }
    }

    return 0;
}
```

### 4.3 树论综合

**斯坦纳树  (游览计划)** *(方格图)*

> 【斯坦纳树  (游览计划)（方格图）】
斯坦纳树（Steiner Tree）模板，连接指定点集的最小树。

核心函数：
  void in(Re &x) — 核心算法函数
  void SPFA(Re s) — SPFA最短路
  void dfs(Re i,Re j,Re s) — 深度优先搜索遍历
  void sakura(无参数) — 后缀数组

核心结构体：Steiner_Tree, PRE, QAQ

关键配置：
N=12

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#define LL long long
#define Re register int
using namespace std;
const int N=12;
int n,m,ct,A[N][N],B[N][N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Steiner_Tree{
	struct PRE{int i,j,s;PRE(Re I=0,Re J=0,Re S=0){i=I,j=J,s=S;}}pre[N][N][1024+3];
	int vis[N][N],dp[N][N][1024+3],wx[4]={-1,0,1,0},wy[4]={0,1,0,-1};
	struct QAQ{int x,y;QAQ(Re X=0,Re Y=0){x=X,y=Y;}};
	queue<QAQ>Q;
	inline void SPFA(Re s){
		while(!Q.empty()){
			QAQ now=Q.front();Q.pop();
			Re x=now.x,y=now.y;vis[x][y]=0;
			for(Re o=0;o<4;++o){
				Re nx=x+wx[o],ny=y+wy[o];
				if(nx<1||nx>n||ny<1||ny>m)continue;
				if(dp[nx][ny][s]>dp[x][y][s]+B[nx][ny]){
					dp[nx][ny][s]=dp[x][y][s]+B[nx][ny],pre[nx][ny][s]=PRE(x,y,s);
					if(!vis[nx][ny])Q.push(QAQ(nx,ny)),vis[nx][ny]=1;
				}
			}
		}
	}
	int Ans[N][N];
	inline void dfs(Re i,Re j,Re s){
		Ans[i][j]=1;PRE to=pre[i][j][s];
		if(to.s){
			dfs(to.i,to.j,to.s);
			if(to.i==i&&to.j==j)dfs(to.i,to.j,s^to.s);
		}
	}
	inline void sakura(){
		memset(dp,63,sizeof(dp));
		Re V=(1<<ct)-1,inf=dp[0][0][0];
		for(Re i=1;i<=n;++i)
			for(Re j=1;j<=m;++j)
				if(A[i][j])dp[i][j][1<<A[i][j]-1]=0;
		for(Re s=0;s<=V;++s){
			for(Re i=1;i<=n;++i)
				for(Re j=1;j<=m;++j){
					for(Re t=(s-1)&s,tmp;t;t=(t-1)&s)
						if((tmp=dp[i][j][t]+dp[i][j][s^t]-B[i][j])<dp[i][j][s])
							dp[i][j][s]=tmp,pre[i][j][s]=PRE(i,j,t);
					if(dp[i][j][s]!=inf)Q.push(QAQ(i,j)),vis[i][j]=1;
				}
			SPFA(s);
		}
		Re ans=2e9,x,y;
		for(Re i=1;i<=n;++i)
			for(Re j=1;j<=m;++j)
				if(A[i][j])ans=dp[x=i][y=j][V];
		printf("%d\n",ans);
		dfs(x,y,V);
		for(Re i=1;i<=n;puts(""),++i)
			for(Re j=1;j<=m;++j)
				putchar(A[i][j]?'x':(Ans[i][j]?'o':'_'));
	}
}T1;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(m);
	for(Re i=1;i<=n;++i)
		for(Re j=1;j<=m;++j){
			in(B[i][j]);
			if(!B[i][j])A[i][j]=++ct;
		}
	T1.sakura();
}

```

**斯坦纳树** *(普通无向图)*

> 【斯坦纳树（普通无向图）】
斯坦纳树（Steiner Tree）模板，连接指定点集的最小树。

核心函数：
  void add(Re x,Re y,Re z) — 加法更新
  void in(Re &x) — 核心算法函数
  void SPFA(Re s) — SPFA最短路

核心结构体：QAQ

关键配置：
N=103,M=503

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#define LL long long
#define Re register int
using namespace std;
const int N=103,M=503;
int n,m,o,x,y,z,K,ans,pan[N],head[N],dp[N][1024+3];queue<int>Q;
struct QAQ{int w,to,next;}a[M<<1];
inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void SPFA(Re s){
	while(!Q.empty()){
		Re x=Q.front();Q.pop();pan[x]=0;
		for(Re i=head[x],to;i;i=a[i].next)
			if(dp[x][s]+a[i].w<dp[to=a[i].to][s]){
				dp[to][s]=dp[x][s]+a[i].w;
				if(!pan[to])Q.push(to),pan[to]=1;
			}
	}
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(m),in(K);
	while(m--)in(x),in(y),in(z),add(x,y,z),add(y,x,z);
	memset(dp,63,sizeof(dp));Re inf=dp[0][0];
	for(Re i=1;i<=K;++i)in(x),dp[x][1<<i-1]=0,ans=x;
	Re V=(1<<K)-1;
	for(Re s=0;s<=V;++s){
		for(Re i=1;i<=n;++i){
			for(Re t=(s-1)&s;t;t=(t-1)&s)
				dp[i][s]=min(dp[i][s],dp[i][t]+dp[i][s^t]);
			if(dp[i][s]!=inf)Q.push(i),pan[i]=1;
		}
		SPFA(s);
	}
	printf("%d ",dp[ans][V]);
}

```

**DFS序+分治** *(Lomsat gelral)*

> 【DFS序+分治（Lomsat gelral）】
树上问题算法模板。

核心函数：
  void add(Re x,Re y) — 加法更新
  void in(Re &x) — 核心算法函数
  void dfs(Re x,Re fa) — 深度优先搜索遍历
  void CL(无参数) — 核心算法函数
  void insert(Re x) — 插入元素
  void sakura(Re L,Re R) — 后缀数组

核心结构体：QAQ

关键配置：
N=1e5+3

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=1e5+3;
int o,n,m,x,y,t,tmp,dfn_O,A[N],Q[N],cnt[N],dfn[N],idx[N],size[N],head[N];LL ans,Ans[N];
struct QAQ{int to,next;}a[N<<1];
inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void dfs(Re x,Re fa){
    idx[dfn[x]=++dfn_O]=x,size[x]=1;
    for(Re i=head[x],to;i;i=a[i].next)
        if((to=a[i].to)!=fa)dfs(to,x),size[x]+=size[to];
}
inline void CL(){
    while(t)cnt[Q[t--]]=0;ans=tmp=0;
}
inline void insert(Re x){
    ++cnt[Q[++t]=A[x]];
    if(cnt[A[x]]>tmp)tmp=cnt[ans=A[x]];
    else if(cnt[A[x]]==tmp)ans+=A[x];
}
inline void sakura(Re L,Re R){
    if(L==R){if(size[idx[L]]==1)Ans[idx[L]]=A[idx[L]];return;}
    Re mid=L+R>>1;
    sakura(L,mid),sakura(mid+1,R);
    Re p=mid;CL();
    for(Re i=mid,j;i>=L&&(j=i+size[idx[i]]-1)<=R;--i){
        insert(idx[i]);
        if(j<=mid)continue;
        while(p<j)insert(idx[++p]);
        Ans[idx[i]]=ans;
    }
}
int main(){
//  freopen("123.txt","r",stdin);
    in(n),m=n-1;
    for(Re i=1;i<=n;++i)in(A[i]);
    while(m--)in(x),in(y),add(x,y),add(y,x);
    dfs(1,0),sakura(1,n);
    for(Re i=1;i<=n;++i)printf("%lld ",Ans[i]);
}

```

**Dsu on tree** *(Lomsat gelral)*

> 【Dsu on tree（Lomsat gelral）】
树上问题算法模板。

核心函数：
  void add(Re x,Re y) — 加法更新
  void in(Re &x) — 核心算法函数
  void dfs(Re x,Re fa) — 深度优先搜索遍历
  void CL(无参数) — 核心算法函数
  void insert(Re x) — 插入元素
  void addson(Re x,Re fa) — 加法更新
  void sakura(Re x,Re fa) — 后缀数组

核心结构体：QAQ

关键配置：
N=1e5+3

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=1e5+3;
int o,n,m,x,y,t,K,tmp,A[N],Q[N],cnt[N],son[N],size[N],head[N];LL ans,Ans[N];
struct QAQ{int to,next;}a[N<<1];
inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void dfs(Re x,Re fa){
	size[x]=1;
	for(Re i=head[x],to;i;i=a[i].next)
		if((to=a[i].to)!=fa){
			dfs(to,x),size[x]+=size[to];
			if(size[to]>size[son[x]])son[x]=to;
		}
}
inline void CL(){
	while(t)cnt[Q[t--]]=0;ans=tmp=0;
}
inline void insert(Re x){
	++cnt[Q[++t]=A[x]];
	if(cnt[A[x]]>tmp)tmp=cnt[ans=A[x]];
	else if(cnt[A[x]]==tmp)ans+=A[x];
}
inline void addson(Re x,Re fa){
	insert(x);
	for(Re i=head[x],to;i;i=a[i].next)
		if((to=a[i].to)!=fa)addson(to,x);
}
inline void sakura(Re x,Re fa){
	for(Re i=head[x],to;i;i=a[i].next)
		if((to=a[i].to)!=fa&&to!=son[x])sakura(to,x),CL();
	if(son[x])sakura(son[x],x);
	for(Re i=head[x],to;i;i=a[i].next)
		if((to=a[i].to)!=fa&&to!=son[x])addson(to,x);
	insert(x),Ans[x]=ans;
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),m=n-1;
	for(Re i=1;i<=n;++i)in(A[i]);
	while(m--)in(x),in(y),add(x,y),add(y,x);
	dfs(1,0),sakura(1,0);
	for(Re i=1;i<=n;++i)printf("%lld ",Ans[i]);
}

```

**Prufer序列** *(get_prufer)*

> 【Prufer序列】
Prufer 序列模板，n 个节点的有标号无根树计数。

核心函数：
  void in(Re &x) — 核心算法函数
  LL get_prufer(无参数) — 获取值
  LL get_fa(无参数) — 获取值

关键配置：
N=5e6+3

说明：printf("Prufer: ");for(Re i=1;i<=n-2;++i)printf("%d ",pf[i]);puts("");；printf("fa: ");for(Re i=1;i<=n-1;++i)printf("%d ",fa[i]);puts("");；freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=5e6+3;
int n,op,fa[N],pf[N],son[N];LL ans;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline LL get_prufer(){
	for(Re i=1;i<=n-1;++i)in(fa[i]),++son[fa[i]];
	for(Re i=1,j=1;i<=n-2;++i,++j){
		while(son[j])++j;pf[i]=fa[j];
		while(i<=n-2&&!--son[pf[i]]&&pf[i]<j)pf[i+1]=fa[pf[i]],++i;
	}
//	printf("Prufer: ");for(Re i=1;i<=n-2;++i)printf("%d ",pf[i]);puts("");
	for(Re i=1;i<=n-2;++i)ans^=(LL)i*pf[i];
	return ans;
}
inline LL get_fa(){
	for(Re i=1;i<=n-2;++i)in(pf[i]),++son[pf[i]];pf[n-1]=n;
	for(Re i=1,j=1;i<=n-1;++i,++j){
		while(son[j])++j;fa[j]=pf[i];
		while(i<=n-1&&!--son[pf[i]]&&pf[i]<j)fa[pf[i]]=pf[i+1],++i;
	}
//	printf("fa: ");for(Re i=1;i<=n-1;++i)printf("%d ",fa[i]);puts("");
	for(Re i=1;i<=n-1;++i)ans^=(LL)i*fa[i];
	return ans;
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(op),printf("%lld\n",op<2?get_prufer():get_fa());
}

```

**基环树** *(Island 求基环树森林直径之和)*

> 【基环树（Island 求基环树森林直径之和）】
基环树（Pseudo Tree）模板，含一个环的 n 节点 n 边连通图。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re y,Re z) — 加法更新
  LL max(LL a,LL b) — 核心算法函数
  int find_circle(Re x,Re p) — 查找（并查集寻根/二分查找）
  void Tree_dp(Re x) — 核心算法函数
  LL pp(Re j) — 核心算法函数
  LL sakura(Re root) — 后缀数组

核心结构体：QAQ

关键配置：
N=1e6+3

```cpp
#pragma comment(linker, "/STACK:102400000,102400000")
#include<cstdio>
#define Re register int
const int N=1e6+3;
#define LL long long
int n,m,x,y,o=1,h,t,st,cnt,In[N],cir[N],pan[N],head[N];LL ans,tmp,Q[N<<1],S[N<<1],dp[N<<1],dis[N];
struct QAQ{int w,to,next;}a[N<<1];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline LL max(LL a,LL b){return a>b?a:b;}
inline int find_circle(Re x,Re p){
	if(In[x]){st=x,cir[++cnt]=x,pan[x]=1;return 1;}
	In[x]=1;
	for(Re i=head[x];i;i=a[i].next)
		if(i!=(p^1)&&find_circle(a[i].to,i)){
			pan[x]=1;
			if(x==st){S[0]=S[1]-a[i].w;return 0;}
			cir[++cnt]=x,S[cnt]=S[cnt-1]+a[i].w;
			return 1;
		}
	return 0;
}
inline void Tree_dp(Re x){
	pan[x]=1;
	for(Re i=head[x],to;i;i=a[i].next)
		if(!pan[to=a[i].to]){
			Tree_dp(to);
			tmp=max(tmp,dis[x]+a[i].w+dis[to]);
			dis[x]=max(dis[x],dis[to]+a[i].w);
		}
}
inline LL pp(Re j){return dp[j]-S[j];}
inline LL sakura(Re root){
	S[0]=cnt=st=0;find_circle(root,0);
	LL ans1=0,ans2=0;tmp=0;
	for(Re i=1;i<=cnt;++i){
		tmp=0,Tree_dp(cir[i]),ans1=max(ans1,tmp);
		dp[i+cnt]=dp[i]=dis[cir[i]];
		S[i+cnt]=S[i+cnt-1]+S[i]-S[i-1];
	}
	h=1,t=0,Q[++t]=1;//ans=max(dp[i]+dp[j]+S[i]-S[j]) i-j+1<=cnt i-cnt+1<=j<i
	for(Re i=2;i<=(cnt<<1);++i){
		while(h<=t&&Q[h]<i-cnt+1)++h;
		if(h<=t)ans2=max(ans2,dp[i]+S[i]+pp(Q[h]));
		while(h<=t&&pp(Q[t])<=pp(i))--t;
		Q[++t]=i;
	}
	return max(ans1,ans2);
}
int main(){
	in(n);
	for(Re i=1;i<=n;++i)in(x),in(y),add(i,x,y),add(x,i,y);
	for(Re i=1;i<=n;++i)if(!pan[i])ans+=sakura(i);
	printf("%lld",ans);
}
```

**最近公共祖先LCA** *(LCT)*

> 【最近公共祖先LCA（LCT）】
最近公共祖先（LCA）模板（倍增法/树剖/Tarjan）。

核心函数：
  void in(Re &x) — 核心算法函数
  void pushup(Re p) — 上推更新节点信息
  void updata(Re p) — 核心算法函数
  void pushdown(Re p) — 下传懒标记
  int nort(Re p) — 核心算法函数
  int which(Re p) — 核心算法函数
  void connect(Re p,Re fa,Re o) — 核心算法函数
  void rotate(Re p) — 旋转操作（平衡树）

核心结构体：Link_Cut_Tree, QAQ

关键配置：
N=5e5+3

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define Re register int
#define LL long long
using namespace std;
const int N=5e5+3;
int n,m,x,y,T,root;
inline void in(Re &x){
    int fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
struct Link_Cut_Tree{
	#define pl tr[p].ps[0]
	#define pr tr[p].ps[1]
	#define pf tr[p].fa
	int Q[N];
	struct QAQ{int fa,tag,ps[2];}tr[N];
	inline void pushup(Re p){}
	inline void updata(Re p){swap(pl,pr),tr[p].tag^=1;}
	inline void pushdown(Re p){
		if(tr[p].tag){
			if(pl)updata(pl);
			if(pr)updata(pr);
			tr[p].tag=0;
		}
	}
	inline int nort(Re p){return tr[pf].ps[0]==p||tr[pf].ps[1]==p;}
	inline int which(Re p){return tr[pf].ps[1]==p;}
	inline void connect(Re p,Re fa,Re o){tr[pf=fa].ps[o]=p;}
	inline void rotate(Re p){
		Re fa=pf,fas=which(p);
		Re pa=tr[fa].fa,pas=which(fa);
		Re x=tr[p].ps[fas^1];
		if(nort(fa))tr[pa].ps[pas]=p;pf=pa;
		connect(x,fa,fas),connect(fa,p,fas^1);
		pushup(fa),pushup(p);
	}
	inline void splay(Re p){
		Re x=p,t=0;Q[++t]=x;
		while(nort(x))Q[++t]=x=tr[x].fa;
		while(t)pushdown(Q[t--]);
		for(Re fa;nort(p);rotate(p))
			if(nort(fa=pf))rotate(which(p)==which(fa)?fa:p);
	}
	inline int access(Re p){
		Re son=0;
		for(;p;son=p,p=pf)
			splay(p),pr=son,pushup(p);
		return son;
	}
	inline void makeroot(Re p){access(p),splay(p),updata(p);}
	inline int findroot(Re p){
		access(p),splay(p),pushdown(p);
		while(pl)pushdown(p=pl);
		return p;
	}
	inline void split(Re x,Re y){makeroot(x),access(y),splay(y);}
	inline void link(Re x,Re y){makeroot(x),tr[x].fa=y;}
	inline void cut(Re x,Re y){
		makeroot(x);
		if(findroot(y)==x&&tr[x].fa==y&&!tr[x].ps[1])
			tr[x].fa=tr[y].ps[0]=0,pushup(y);
	}
	inline int lca(Re x,Re y){access(x);return access(y);}
}LCT;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T),in(root),m=n-1;
	while(m--)in(x),in(y),LCT.link(x,y);LCT.makeroot(root);
	while(T--)in(x),in(y),printf("%d\n",LCT.lca(x,y));
}

```

**最近公共祖先LCA** *(RMQ)*

> 【最近公共祖先LCA（RMQ）】
最近公共祖先（LCA）模板（倍增法/树剖/Tarjan）。

核心函数：
  void add(Re x,Re y) — 加法更新
  void in(Re &x) — 核心算法函数
  void dfs(Re x,Re fa) — 深度优先搜索遍历
  void build(Re rt) — 构建数据结构（建树/建图）
  int lca(Re x,Re y) — 查询最近公共祖先

核心结构体：QAQ, LCA

关键配置：
N=5e5+3,logN=20

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=5e5+3,logN=20;
int n,m,o,x,y,T,rt,head[N];
struct QAQ{int to,next;}a[N<<1];
inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct LCA{
	int O,lg[N<<1],Qx[N<<1],Qd[N<<1],fir[N],deep[N],f[N<<1][23],ans[N<<1][23];
	inline void dfs(Re x,Re fa){
		Qx[fir[x]=++O]=x,Qd[O]=deep[x]=deep[fa]+1;
		for(Re i=head[x],to;i;i=a[i].next)
			if((to=a[i].to)!=fa)dfs(to,x),Qx[++O]=x,Qd[O]=deep[x];
	}
	inline void build(Re rt){
		dfs(rt,0),lg[0]=-1;
		for(Re i=1;i<=O;++i)f[i][0]=Qd[i],ans[i][0]=Qx[i],lg[i]=lg[i>>1]+1;
		for(Re j=1;j<=logN;++j)
			for(Re i=1;i+(1<<j)-1<=O;++i)
				if(f[i][j-1]<f[i+(1<<j-1)][j-1])f[i][j]=f[i][j-1],ans[i][j]=ans[i][j-1];
				else f[i][j]=f[i+(1<<j-1)][j-1],ans[i][j]=ans[i+(1<<j-1)][j-1];
	}
	inline int lca(Re x,Re y){
		Re L=fir[x],R=fir[y];
		if(L>R)swap(L,R);
		Re m=lg[R-L+1];
		return f[L][m]<f[R-(1<<m)+1][m]?ans[L][m]:ans[R-(1<<m)+1][m];
	}
}T1;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T),in(rt),m=n-1;
	while(m--)in(x),in(y),add(x,y),add(y,x);
	T1.build(rt);
	while(T--)in(x),in(y),printf("%d\n",T1.lca(x,y));
}

```

**最近公共祖先LCA** *(倍增)*

> 【最近公共祖先LCA（倍增）】
最近公共祖先（LCA）模板（倍增法/树剖/Tarjan）。

核心函数：
  void in(Re &x) — 核心算法函数
  void dfs(Re x,Re fa) — 深度优先搜索遍历
  int lca(Re x,Re y) — 查询最近公共祖先
  void add(Re x,Re y) — 加法更新

核心结构体：QAQ, LCA

关键配置：
N=5e5+3,M=5e5+3,logN=19

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define Re register int
using namespace std;
const int N=5e5+3,M=5e5+3,logN=19;
int T,Q,n,m,x,y,o,root,head[N];
struct QAQ{int to,next;}a[M<<1];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct LCA{
	int deep[N],ant[N][23];
	inline void dfs(Re x,Re fa){
		deep[x]=deep[ant[x][0]=fa]+1;
		for(Re i=1;(1<<i)<=deep[x];++i)ant[x][i]=ant[ant[x][i-1]][i-1];
		for(Re i=head[x];i;i=a[i].next)if(a[i].to!=fa)dfs(a[i].to,x);
	}
	inline int lca(Re x,Re y){
		if(deep[x]<deep[y])swap(x,y);
		for(Re i=logN;i>=0;--i)if(deep[ant[x][i]]>=deep[y])x=ant[x][i];
		if(x==y)return x;
		for(Re i=logN;i>=0;--i)if(ant[x][i]!=ant[y][i])x=ant[x][i],y=ant[y][i];
		return ant[x][0];
	}
}T1;
inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
int main(){
	in(n),in(Q),in(root),m=n-1;
	while(m--)in(x),in(y),add(x,y),add(y,x);
	T1.dfs(root,0);
	while(Q--)in(x),in(y),printf("%d\n",T1.lca(x,y));
}

```

**最近公共祖先LCA** *(树剖)*

> 【最近公共祖先LCA（树剖）】
最近公共祖先（LCA）模板（倍增法/树剖/Tarjan）。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re y) — 加法更新
  void dfs1(Re x,Re Fa) — 深度优先搜索遍历
  void dfs2(Re x,Re rt) — 深度优先搜索遍历
  void kill(Re rt) — 核心算法函数
  int lca(Re x,Re y) — 查询最近公共祖先

核心结构体：Killed_Tree, QAQ

关键配置：
N=5e5+3

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstdio>
#define Re register int
using namespace std;
const int N=5e5+3;
int n,m,x,y,T,root;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Killed_Tree{
	struct QAQ{int to,next;}a[N<<1];
	int o,head[N];
	inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
	int id_o,id[N],fa[N],son[N],top[N],deep[N],size[N];
	inline void dfs1(Re x,Re Fa){
		size[x]=1,deep[x]=deep[fa[x]=Fa]+1;
		for(Re i=head[x],to;i;i=a[i].next)
			if((to=a[i].to)!=Fa){
				dfs1(to,x);
				size[x]+=size[to];
				if(size[to]>size[son[x]])son[x]=to;
			}
	}
	inline void dfs2(Re x,Re rt){
		id[x]=++id_o,top[x]=rt;
		if(!son[x])return;
		dfs2(son[x],rt);
		for(Re i=head[x],to;i;i=a[i].next)
			if((to=a[i].to)!=fa[x]&&to!=son[x])dfs2(to,to);
	}
	inline void kill(Re rt){dfs1(rt,0),dfs2(rt,rt);}
	inline int lca(Re x,Re y){
		while(top[x]!=top[y]){
			if(deep[top[x]]<deep[top[y]])swap(x,y);
			x=fa[top[x]];
		}
		if(deep[x]>deep[y])swap(x,y);
		return x;
	}
}T1;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T),in(root),m=n-1;
	while(m--)in(x),in(y),T1.add(x,y),T1.add(y,x);
	T1.kill(root);
	while(T--)in(x),in(y),printf("%d\n",T1.lca(x,y));
}

```

**树的直径** *(dfs)*

> 【树的直径（dfs）】
树的直径算法模板（两次 BFS/DFS 或树形 DP）。

核心函数：
  void add(Re x,Re y,Re z) — 加法更新
  void in(Re &x) — 核心算法函数
  void dfs(Re x,Re fa) — 深度优先搜索遍历
  int sakura(无参数) — 后缀数组

核心结构体：QAQ, Tree_Diam_DFS

关键配置：
N=1e4+3,M=3e5+3

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define Re register int
using namespace std;
const int N=1e4+3,M=3e5+3;
int n,m,x,y,o,head[N];
struct QAQ{int w,to,next;}a[N<<1];
inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
	Re fu=0;x=0;char ch=getchar();
	while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=fu?-x:x;
}
struct Tree_Diam_DFS{
	int cur,dis[N];
	inline void dfs(Re x,Re fa){
		if(dis[x]>dis[cur])cur=x;
		for(Re i=head[x],to;i;i=a[i].next)
			if((to=a[i].to)!=fa)dis[to]=dis[x]+a[i].w,dfs(to,x);
	}
	inline int sakura(){
		dfs(1,0);
		memset(dis,0,sizeof(dis));
		dfs(cur,0);
		return dis[cur];
	}
}T1;
int main(){
	in(n),m=n-1;
    while(m--)in(x),in(y),add(x,y,1),add(y,x,1);
    printf("%d\n",T1.sakura());
}

```

**树的直径** *(dp)*

> 【树的直径（dp）】
树的直径算法模板（两次 BFS/DFS 或树形 DP）。

核心函数：
  void add(Re x,Re y,Re z) — 加法更新
  void in(Re &x) — 核心算法函数
  void dfs(Re x,Re fa) — 深度优先搜索遍历
  int sakura(无参数) — 后缀数组
  void dfs(Re x,Re fa) — 深度优先搜索遍历
  int sakura(无参数) — 后缀数组

核心结构体：QAQ, Tree_Diam_DP1, Tree_Diam_DP2

关键配置：
N=1e4+3,M=3e5+3

说明：printf("%d\n",T2.sakura());

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define Re register int
using namespace std;
const int N=1e4+3,M=3e5+3;
int n,m,x,y,o,head[N];
struct QAQ{int w,to,next;}a[N<<1];
inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
	Re fu=0;x=0;char ch=getchar();
	while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=fu?-x:x;
}
struct Tree_Diam_DP1{
	int ans,dis[N];
	inline void dfs(Re x,Re fa){
		for(Re i=head[x],to,tmp;i;i=a[i].next)
			if((to=a[i].to)!=fa){
				dfs(to,x);
				ans=max(ans,dis[x]+dis[to]+a[i].w);
				dis[x]=max(dis[x],dis[to]+a[i].w);
			}
	}
	inline int sakura(){dfs(1,0);return ans;}
}T1;
struct Tree_Diam_DP2{
	int ans,dis[N][2];
	inline void dfs(Re x,Re fa){
		for(Re i=head[x],to,tmp;i;i=a[i].next)
			if((to=a[i].to)!=fa){
				dfs(to,x);
				if(dis[x][0]<(tmp=dis[to][0]+a[i].w))dis[x][1]=dis[x][0],dis[x][0]=tmp;
				else dis[x][1]=max(dis[x][1],tmp);
			}
		ans=max(ans,dis[x][1]+dis[x][0]);
	}
	inline int sakura(){dfs(1,0);return ans;}
}T2;
int main(){
	in(n),m=n-1;
    while(m--)in(x),in(y),add(x,y,1),add(y,x,1);
    printf("%d\n",T1.sakura());
//    printf("%d\n",T2.sakura());
}

```

**树的重心** *(add)*

> 【树的重心】
树的重心算法模板（DFS 统计子树大小）。

核心函数：
  void add(Re x,Re y,Re z) — 加法更新
  void in(Re &x) — 核心算法函数
  void dfs(Re x,Re fa) — 深度优先搜索遍历
  void sakura(无参数) — 后缀数组

核心结构体：QAQ, Tree_Diam_DP1

关键配置：
N=2e4+3,inf=2e9

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define Re register int
using namespace std;
const int N=2e4+3,inf=2e9;
int n,m,x,y,o,T,head[N];
struct QAQ{int w,to,next;}a[N<<1];
inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
	Re fu=0;x=0;char ch=getchar();
	while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=fu?-x:x;
}
struct Tree_Diam_DP1{
	int ans,dp[N],size[N];
	inline void dfs(Re x,Re fa){
		size[x]=1,dp[x]=0;
		for(Re i=head[x],to,tmp;i;i=a[i].next)
			if((to=a[i].to)!=fa){
				dfs(to,x),size[x]+=size[to];
				dp[x]=max(dp[x],size[to]);
			}
		if(n-size[x])dp[x]=max(dp[x],n-size[x]);
	}
	inline void sakura(){
		dfs(1,0),dp[ans=0]=inf;
		for(Re i=1;i<=n;++i)if(dp[i]<dp[ans])ans=i;
	}
}T1;
int main(){
	in(T);
	while(T--){
		memset(head,0,sizeof(head));
		in(n),m=n-1,o=0;
	    while(m--)in(x),in(y),add(x,y,1),add(y,x,1);
	    T1.sakura();
		printf("%d %d\n",T1.ans,T1.dp[T1.ans]);
	}
}

```

**虚树** *(Kingdom and its Cities)*

> 【虚树（Kingdom and its Cities）】
虚树（Virtual Tree）模板，只保留关键点的压缩树。

核心函数：
  void add(Re x,Re y) — 加法更新
  void in(Re &x) — 核心算法函数
  void dfs(Re x,Re fa) — 深度优先搜索遍历
  int lca(Re x,Re y) — 查询最近公共祖先
  bool cmp(Re x,Re y) — 核心算法函数
  void add(Re x,Re y) — 加法更新
  void insert(Re x) — 插入元素
  void dfs(Re x) — 深度优先搜索遍历

核心结构体：QAQ, LCA, Virtual_Tree, QAQ

关键配置：
N=1e5+3,logN=17

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=1e5+3,logN=17;
int n,m,x,y,o,T,dfn_o,dfn[N],deep[N],head[N];
struct QAQ{int to,next;}a[N<<1];
inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct LCA{
	int ant[N][20];
	inline void dfs(Re x,Re fa){
		deep[x]=deep[ant[x][0]=fa]+1,dfn[x]=++dfn_o;
		for(Re j=1;(1<<j)<=deep[x];++j)ant[x][j]=ant[ant[x][j-1]][j-1];
		for(Re i=head[x];i;i=a[i].next)if(a[i].to!=fa)dfs(a[i].to,x);
	}
	inline int lca(Re x,Re y){
		if(deep[x]<deep[y])swap(x,y);
		for(Re j=logN;j>=0;--j)if(deep[ant[x][j]]>=deep[y])x=ant[x][j];
		if(x==y)return x;
		for(Re j=logN;j>=0;--j)if(ant[x][j]!=ant[y][j])x=ant[x][j],y=ant[y][j];
		return ant[x][0];
	}
}T1;
inline bool cmp(Re x,Re y){return dfn[x]<dfn[y];}
struct Virtual_Tree{
	int t,o,ans,A[N],Q[N],key[N],head[N];
	struct QAQ{int to,next;}a[N<<1];
	inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
	inline void insert(Re x){// 撤销操作
		Re lca=T1.lca(Q[t],x);
		while(t>1&&deep[Q[t-1]]>deep[lca])add(Q[t-1],Q[t]),--t;
		if(t&&deep[Q[t]]>deep[lca])add(lca,Q[t--]);
		if(!t||Q[t]!=lca)Q[++t]=lca;
		Q[++t]=x;
	}
	inline void dfs(Re x){// 撤销操作
		if(key[x])
			for(Re i=head[x],to;i;i=a[i].next){
				dfs(to=a[i].to);
				if(key[to])key[to]=0,++ans;
			}
		else{
			for(Re i=head[x],to;i;i=a[i].next)
				dfs(to=a[i].to),key[x]+=key[to],key[to]=0;
			if(key[x]>1)key[x]=0,++ans;
		}
		head[x]=0;
	}
	inline void sakura(){
		in(m);Re flag=1;ans=o=t=0;
		for(Re i=1;i<=m;++i)in(A[i]),key[A[i]]=1;
		for(Re i=1;i<=m&&flag;++i)flag&=(!key[T1.ant[A[i]][0]]);
		if(!flag){
			for(Re i=1;i<=m;++i)key[A[i]]=0;
			puts("-1");return;
		}
		sort(A+1,A+m+1,cmp),Q[++t]=1;
		for(Re i=1+(A[1]==1);i<=m;++i)insert(A[i]);
		while(t>1)add(Q[t-1],Q[t]),--t;
		dfs(1),key[1]=0;
		printf("%d\n",ans);
	}
}T2;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),m=n-1;
	while(m--)in(x),in(y),add(x,y),add(y,x);
	T1.dfs(1,0),in(T);
	while(T--)T2.sakura();
}

```

**天天爱跑步** *(mid)*

> 【天天爱跑步】
树上问题算法模板。

核心函数：
  void add(Re x,Re y) — 加法更新
  void in(Re &x) — 核心算法函数
  void change(Re &p,Re L,Re R,Re x,Re v) — 核心算法函数
  int merge(Re p,Re q) — 合并操作
  int ask(Re p,Re L,Re R,Re x) — 核心算法函数
  void dfs(Re x,Re fa) — 深度优先搜索遍历
  int lca(Re x,Re y) — 查询最近公共祖先
  void dfs(Re x,Re fa) — 深度优先搜索遍历

核心结构体：QWQ, Segmemt_Tree, QAQ, LCA

关键配置：
N=3e5+3,logN=19

```cpp
#include<algorithm>
#include<cstdio>
#define pl tr[p].lp 
#define pr tr[p].rp
#define mid (L+R>>1)
#define Re register int
const int N=3e5+3,logN=19;
int x,y,n,m,T,o,lca,w[N],pt[N],ans[N],head[N],deep[N];
struct QWQ{int to,next;}a[N<<1];
inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    x=0;char c=getchar();
    while(c<'0'||c>'9')c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
}
struct Segmemt_Tree{
	struct QAQ{int g,lp,rp;}tr[N*36];int cnt;
	inline void change(Re &p,Re L,Re R,Re x,Re v){
		if(!p)p=++cnt;
		if(L==R){tr[p].g+=v;return;}
		if(x<=mid)change(pl,L,mid,x,v);
	    else change(pr,mid+1,R,x,v);
	}
	inline int merge(Re p,Re q){
	    if(!p)return q;if(!q)return p;
	    tr[p].g+=tr[q].g;
	    pl=merge(pl,tr[q].lp);
		pr=merge(pr,tr[q].rp);
	    return p;
	}
	inline int ask(Re p,Re L,Re R,Re x){
	    if(!p)return 0;
	    if(L==R)return tr[p].g;
	    if(x<=mid)return ask(pl,L,mid,x);
	    else return ask(pr,mid+1,R,x);
	}
}T1;
struct LCA{
	int ant[N][23];
	inline void dfs(Re x,Re fa){
		deep[x]=deep[fa]+1,ant[x][0]=fa;
		for(Re i=1;(1<<i)<=deep[x];++i)ant[x][i]=ant[ant[x][i-1]][i-1];
		for(Re i=head[x];i;i=a[i].next)if(a[i].to!=fa)dfs(a[i].to,x);
	}
	inline int lca(Re x,Re y){
		if(deep[x]>deep[y])std::swap(x,y);
		for(Re i=logN;i>=0;--i)if(deep[x]<=deep[y]-(1<<i))y=ant[y][i];
		if(x==y)return y;
		for(Re i=logN;i>=0;--i)
			if(ant[x][i]==ant[y][i])continue;
			else x=ant[x][i],y=ant[y][i];
		return ant[x][0];
	}
}T2;
inline void dfs(Re x,Re fa){
    for(Re i=head[x],to;i;i=a[i].next)
    	if((to=a[i].to)!=fa)
        	dfs(to,x),pt[x]=T1.merge(pt[x],pt[to]);
	ans[x]+=T1.ask(pt[x],1,n<<1,n+deep[x]-w[x]);
    if(w[x]&&deep[x]+w[x]<=n)ans[x]+=T1.ask(pt[x],1,n<<1,n+deep[x]+w[x]);
}
int main(){
	in(n),in(T),m=n-1;
	while(m--)in(x),in(y),add(x,y),add(y,x);
	for(Re i=1;i<=n;++i)in(w[i]);
	T2.dfs(1,0);
	while(T--){
		in(x),in(y),lca=T2.lca(x,y);
		T1.change(pt[x],1,n<<1,n+deep[x],1);
        T1.change(pt[y],1,n<<1,n+deep[lca]*2-deep[x],1);
        T1.change(pt[lca],1,n<<1,n+deep[x],-1);
        T1.change(pt[T2.ant[lca][0]],1,n<<1,n+deep[lca]*2-deep[x],-1);
	}
	dfs(1,0);
	for(Re i=1;i<=n;++i)printf("%d ",ans[i]);
}

```

**树的直径升级版 每个点可到的最远距离computer** *(HDU)*

> 【树的直径升级版 每个点可到的最远距离computer（HDU）】
树的直径算法模板（两次 BFS/DFS 或树形 DP）。

核心函数：
  void add(int x,int y,int w) — 加法更新
  void dfs(int x,int pa) — 深度优先搜索遍历
  void dfsf(int x,int pa) — 深度优先搜索遍历
  int sakura(无参数) — 后缀数组

核心结构体：QAQ

说明：����ȹ�������ӵ�ͷ��һ���·����ô�ö��ӵķ�������������λ���׵Ĵδ���������ȡ���；����·û������ͷ����ô���ķ�������Ǹ��׵������������ȡ���

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define R register int
using namespace std;
int n,b,c,d,t,longson[10005],d1[10005],d2[10005],df[10005],head[10005];
struct QAQ{int to,next,w;}a[20005];
inline void add(int x,int y,int w){a[++t].to=y,a[t].w=w,a[t].next=head[x],head[x]=t;}
inline void dfs(int x,int pa){
	for(R i=head[x];i;i=a[i].next){
		R s,to=a[i].to;
		if(to==pa)continue;
		dfs(to,x);s=d1[to]+a[i].w;
		if(s>d1[x])d2[x]=d1[x],d1[x]=s,longson[x]=to;
		else d2[x]=max(d2[x],s);
	}
}
inline void dfsf(int x,int pa){
	for(R i=head[x];i;i=a[i].next){
		R to=a[i].to;
		if(to==pa)continue;
		if(longson[x]==to)df[to]=a[i].w+max(d2[x],df[x]);
		else df[to]=a[i].w+max(d1[x],df[x]);
		dfsf(to,x);
	}
}
inline int sakura(){
	while(~scanf("%d",&n)){
		memset(longson,0,sizeof(longson));
		memset(head,0,sizeof(head));
		memset(d1,0,sizeof(d1));
		memset(d2,0,sizeof(d2));
		memset(df,0,sizeof(df));
		memset(a,0,sizeof(a));t=0;
		for(R i=2;i<=n;i++){
			scanf("%d%d",&b,&c);
			add(i,b,c),add(b,i,c);
		}
		dfs(1,0);dfsf(1,0);
		for(R i=1;i<=n;i++)printf("%d\n",max(d1[i],df[i]));
	}
	return 0;
}
int QAQWQ=sakura();
int main(){}

```

**雪松果树** *(DFS序+分治)*

> 【雪松果树（DFS序+分治）】
树上问题算法模板。

核心函数：
  void add(Re x,Re y) — 加法更新
  void add(Re x,Re y,Re id) — 加法更新
  void in(Re &x) — 核心算法函数
  void dfs(Re x,Re fa) — 深度优先搜索遍历
  int kant(Re x,Re k) — 核心算法函数
  void dfs(Re x,Re fa) — 深度优先搜索遍历
  void CL(无参数) — 核心算法函数
  void insert(Re x) — 插入元素

核心结构体：QAQ, Query, QAQ, LCA

关键配置：
N=1e6+5,logN=14

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=1e6+5,logN=14;
int o,n,m,x,y,t,T,dfn_O,A[N],Q[N],dfn[N],idx[N],Ans[N],cnt[N],son[N],deep[N],size[N],head[N];
struct QAQ{int to,next;}a[N];
inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
struct Query{
	int o,head[N];
	struct QAQ{int to,id,next;}a[N];
	inline void add(Re x,Re y,Re id){a[++o].to=y,a[o].id=id,a[o].next=head[x],head[x]=o;}
}QT;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct LCA{
	int ant[N][15];
	inline void dfs(Re x,Re fa){
		deep[x]=deep[ant[x][0]=fa]+1;
		for(Re i=1;(1<<i)<=deep[x];++i)ant[x][i]=ant[ant[x][i-1]][i-1];
		for(Re i=head[x];i;i=a[i].next)if(a[i].to!=fa)dfs(a[i].to,x);
	}
	inline int kant(Re x,Re k){
		for(Re i=logN;i>=0;--i)
			if((1<<i)<=k)k-=(1<<i),x=ant[x][i];
		return x;
	}
}T1;
inline void dfs(Re x,Re fa){
	idx[dfn[x]=++dfn_O]=x,size[x]=1,deep[x]=deep[fa]+1;
    for(Re i=head[x],to;i;i=a[i].next)
        if((to=a[i].to)!=fa)dfs(to,x),size[x]+=size[to];
}
inline void CL(){
	while(t)cnt[Q[t--]]=0;
}
inline void insert(Re x){
	++cnt[Q[++t]=deep[x]];
}
inline void addson(Re x,Re fa){
	insert(x);
	for(Re i=head[x],to;i;i=a[i].next)
		if((to=a[i].to)!=fa)addson(to,x);
}
inline void getans(Re x){
	for(Re i=QT.head[x];i;i=QT.a[i].next)
		Ans[QT.a[i].id]=cnt[deep[x]+QT.a[i].to];
}
inline void sakura(Re L,Re R){
    if(L==R){if(size[idx[L]]==1)CL(),insert(idx[L]),getans(idx[L]);return;}
    Re mid=L+R>>1;
    sakura(L,mid),sakura(mid+1,R);
    Re p=mid;CL();
    for(Re i=mid,j;i>=L&&(j=i+size[idx[i]]-1)<=R;--i){
        insert(idx[i]);
        if(j<=mid)continue;
        while(p<j)insert(idx[++p]);
        getans(idx[i]);
    }
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T);
	for(Re i=2;i<=n;++i)in(x),add(x,i);
	T1.dfs(1,0);
	for(Re i=1;i<=T;++i)in(x),in(y),QT.add(T1.kant(x,y),y,i);
	dfs(1,0),sakura(1,n);
	for(Re i=1;i<=T;++i)printf("%d ",max(Ans[i]-1,0));
}

```

**雪松果树** *(Dsu on tree)*

> 【雪松果树（Dsu on tree）】
树上问题算法模板。

核心函数：
  void add(Re x,Re y) — 加法更新
  void add(Re x,Re y,Re id) — 加法更新
  void in(Re &x) — 核心算法函数
  void dfs(Re x,Re fa) — 深度优先搜索遍历
  int kant(Re x,Re k) — 核心算法函数
  void dfs(Re x,Re fa) — 深度优先搜索遍历
  void CL(无参数) — 核心算法函数
  void insert(Re x) — 插入元素

核心结构体：QAQ, Query, QAQ, LCA

关键配置：
N=1e6+5,logN=14

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=1e6+5,logN=14;
int o,n,m,x,y,t,T,A[N],Q[N],Ans[N],cnt[N],son[N],deep[N],size[N],head[N];
struct QAQ{int to,next;}a[N];
inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
struct Query{
	int o,head[N];
	struct QAQ{int to,id,next;}a[N];
	inline void add(Re x,Re y,Re id){a[++o].to=y,a[o].id=id,a[o].next=head[x],head[x]=o;}
}QT;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct LCA{
	int ant[N][15];
	inline void dfs(Re x,Re fa){
		deep[x]=deep[ant[x][0]=fa]+1;
		for(Re i=1;(1<<i)<=deep[x];++i)ant[x][i]=ant[ant[x][i-1]][i-1];
		for(Re i=head[x];i;i=a[i].next)if(a[i].to!=fa)dfs(a[i].to,x);
	}
	inline int kant(Re x,Re k){
		for(Re i=logN;i>=0;--i)
			if((1<<i)<=k)k-=(1<<i),x=ant[x][i];
		return x;
	}
}T1;
inline void dfs(Re x,Re fa){
	size[x]=1,deep[x]=deep[fa]+1;
	for(Re i=head[x],to;i;i=a[i].next)
		if((to=a[i].to)!=fa){
			dfs(to,x),size[x]+=size[to];
			if(size[to]>size[son[x]])son[x]=to;
		}
}
inline void CL(){
	while(t)cnt[Q[t--]]=0;
}
inline void insert(Re x){
	++cnt[Q[++t]=deep[x]];
}
inline void addson(Re x,Re fa){
	insert(x);
	for(Re i=head[x],to;i;i=a[i].next)
		if((to=a[i].to)!=fa)addson(to,x);
}
inline void sakura(Re x,Re fa){
	for(Re i=head[x],to;i;i=a[i].next)
		if((to=a[i].to)!=fa&&to!=son[x])sakura(to,x),CL();
	if(son[x])sakura(son[x],x);
	for(Re i=head[x],to;i;i=a[i].next)
		if((to=a[i].to)!=fa&&to!=son[x])addson(to,x);
	insert(x);
	for(Re i=QT.head[x];i;i=QT.a[i].next)
		Ans[QT.a[i].id]=cnt[deep[x]+QT.a[i].to];
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T);
	for(Re i=2;i<=n;++i)in(x),add(x,i);
	T1.dfs(1,0);
	for(Re i=1;i<=T;++i)in(x),in(y),QT.add(T1.kant(x,y),y,i);
	dfs(1,0),sakura(1,n);
	for(Re i=1;i<=T;++i)printf("%d ",max(Ans[i]-1,0));
}

```

**Qtree7** *(LCT维护同色连通块最大点权)*

> 【Qtree7（LCT维护同色连通块最大点权）】
树上问题算法模板。

核心函数：
  void add(Re x,Re y) — 加法更新
  void in(Re &x) — 核心算法函数
  void insert(Re x) — 插入元素
  void erase(Re x) — 删除元素
  int top(无参数) — 获取栈顶/堆顶元素
  void pushup(Re p) — 上推更新节点信息
  int which(Re p) — 核心算法函数
  int nort(Re p) — 核心算法函数

核心结构体：QAQ, Queue, Link_Cut_Tree, QAQ

关键配置：
N=1e5+3,inf=2e9

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#define LL long long
#define Re register int
using namespace std;
const int N=1e5+3,inf=2e9;
int n,m,x,y,o,T,op,A[N],co[N],fa[N],head[N];
struct QAQ{int to,next;}a[N<<1];
inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Queue{
	priority_queue<int>Q,D;
	inline void insert(Re x){Q.push(x);}
	inline void erase(Re x){if(Q.top()==x)Q.pop();else D.push(x);}
	inline int top(){
		while(!Q.empty()&&!D.empty()&&Q.top()==D.top())Q.pop(),D.pop();
		return Q.empty()?-inf:Q.top();
	}
};
struct Link_Cut_Tree{
	#define pl tr[p].ps[0]
	#define pr tr[p].ps[1]
	#define pf tr[p].fa
	struct QAQ{int fa,max,ps[2];}tr[N];Queue si[N];
	inline void pushup(Re p){
		tr[p].max=max(max(A[p],si[p].top()),max(tr[pl].max,tr[pr].max));
	}
	inline int which(Re p){return tr[pf].ps[1]==p;}
	inline int nort(Re p){return tr[pf].ps[0]==p||tr[pf].ps[1]==p;}
	inline void connect(Re p,Re fa,Re o){tr[pf=fa].ps[o]=p;}
	inline void rotate(Re p){
		Re fa=pf,fas=which(p);
		Re pa=tr[fa].fa,pas=which(fa);
		Re x=tr[p].ps[fas^1];
		if(nort(fa))tr[pa].ps[pas]=p;pf=pa;
		connect(x,fa,fas),connect(fa,p,fas^1);
		pushup(fa),pushup(p);
	}
	inline void splay(Re p){
		for(Re fa;nort(p);rotate(p))
			if(nort(fa=pf))rotate(which(p)==which(fa)?fa:p);
	}
	inline void access(Re p){
		for(Re son=0;p;son=p,p=pf)
			splay(p),si[p].insert(tr[pr].max),pr=son,si[p].erase(tr[pr].max),pushup(p);
	}
	inline void link(Re p,Re fa){
		access(p),splay(p),access(fa),splay(fa),si[pf=fa].insert(tr[p].max),pushup(fa);
	}
	inline void cut(Re p,Re fa){
		access(p),splay(p),splay(fa),pf=tr[fa].ps[1]=0,pushup(fa);
	}
	inline int ask(Re p){
		access(p),splay(p);while(pl)p=pl;splay(p);return tr[pr].max;
	}
	inline void change(Re p,Re v){
		access(p),splay(p),A[p]=v,pushup(p);
	}
}LCT[2];
inline void dfs(Re x,Re Fa){
	LCT[0].tr[x].max=LCT[1].tr[x].max=A[x];
	for(Re i=head[x],to;i;i=a[i].next)
		if((to=a[i].to)!=Fa)dfs(to,x);
	LCT[co[x]].link(x,fa[x]=Fa);
}
int main(){
//    freopen("123.txt","r",stdin);
    in(n),m=n-1,LCT[0].tr[0].max=LCT[1].tr[0].max=-inf;
    while(m--)in(x),in(y),add(x,y),add(y,x);
    for(Re i=1;i<=n;++i)in(co[i]);
    for(Re i=1;i<=n;++i)in(A[i]);
    in(T),dfs(1,n+1);
    while(T--){
    	in(op),in(x);
    	if(op<1)printf("%d\n",LCT[co[x]].ask(x));
    	else if(op<2)LCT[co[x]].cut(x,fa[x]),LCT[co[x]^=1].link(x,fa[x]);
    	else in(y),LCT[co[x]].change(x,y);
	}
}

```

**[RCOI] XOR  (LCT 计算原树信息)** *(TLE 30pt)*

> 【[RCOI] XOR  (LCT 计算原树信息)（TLE 30pt）】
树上问题算法模板。

核心函数：
  void in(Re &x) — 核心算法函数
  void pushup(Re p) — 上推更新节点信息
  void updata(Re p) — 核心算法函数
  void pushdown(Re p) — 下传懒标记
  int nort(Re p) — 核心算法函数
  int which(Re p) — 核心算法函数
  void connect(Re p,Re fa,Re o) — 核心算法函数
  void rotate(Re p) — 旋转操作（平衡树）

核心结构体：Link_Cut_Tree, QAQ

关键配置：
N=1e6+3,M=2e6+3

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#include<algorithm>
#include<cstring>
#include<cstdio>
#define Re register int
#define LL long long
using namespace std;
const int N=1e6+3,M=2e6+3;
int n,m,x,y,T,op,HYJ,Ans,root,A[N];
inline void in(Re &x){
    int fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
struct Link_Cut_Tree{
	#define pl tr[p].ps[0]
	#define pr tr[p].ps[1]
	#define pf tr[p].fa
	int Q[N];
	struct QAQ{int fa,si,ans,tag,shi,yuan,ps[2];}tr[N];
	inline void pushup(Re p){
		tr[p].shi=A[p]^tr[pl].shi^tr[pr].shi;
		tr[p].ans=A[p]^tr[p].si^tr[pl].ans^tr[pr].ans;
	}
	inline void updata(Re p){swap(pl,pr),tr[p].tag^=1;}
	inline void pushdown(Re p){
		if(tr[p].tag){
			if(pl)updata(pl);
			if(pr)updata(pr);
			tr[p].tag=0;
		}
	}
	inline int nort(Re p){return tr[pf].ps[0]==p||tr[pf].ps[1]==p;}
	inline int which(Re p){return tr[pf].ps[1]==p;}
	inline void connect(Re p,Re fa,Re o){tr[pf=fa].ps[o]=p;}
	inline void rotate(Re p){
		Re fa=pf,fas=which(p);
		Re pa=tr[fa].fa,pas=which(fa);
		Re x=tr[p].ps[fas^1];
		if(nort(fa))tr[pa].ps[pas]=p;pf=pa;
		connect(x,fa,fas),connect(fa,p,fas^1);
		pushup(fa),pushup(p);
	}
	inline void splay(Re p){
		Re x=p,t=0;Q[++t]=x;
		while(nort(x))Q[++t]=x=tr[x].fa;
		while(t)pushdown(Q[t--]);
		for(Re fa;nort(p);rotate(p))
			if(nort(fa=pf))rotate(which(p)==which(fa)?fa:p);
	}
	inline int access(Re p){
		Re son=0;
		for(;p;son=p,p=pf)
			splay(p),tr[p].si^=tr[pr].ans,tr[p].si^=tr[pr=son].ans,pushup(p);
		return son;
	}
	inline void makeroot(Re p){access(p),splay(p),updata(p);}
	inline int findroot(Re p){
		access(p),splay(p),pushdown(p);
		while(pl)pushdown(p=pl);
		return p;
	}
	inline void split(Re x,Re y){makeroot(x),access(y),splay(y);}
	inline void link(Re x,Re y){
		makeroot(x);
		if(findroot(y)!=x)tr[tr[x].fa=y].si^=tr[x].ans,pushup(y);
	}
	inline int lca(Re x,Re y){access(x);return access(y);}
	
	inline int ask_son(Re p){access(p);return tr[pr].ans^tr[p].si^A[p];}
}LCT;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(HYJ),in(T),m=n-1,T+=HYJ,root=1;
	for(Re i=1;i<=n;++i)in(A[i]);
	while(m--)in(x),in(y),LCT.link(x,y);
	LCT.makeroot(root);
//	Ans=0;for(Re i=1;i<=n;++i)Ans^=LCT.ask_son(i);
//	printf("%d\n",Ans);return 0;
	while(T--){
		in(op),in(x);
//		if(op<2)LCT.makeroot(root=x),printf("%d\n",Ans);
		if(op<2){
			LCT.makeroot(root=x);Ans=0;
			for(Re i=1;i<=n;++i)Ans^=LCT.ask_son(i);
			printf("%d\n",Ans);
		}
		else if(op<3)in(y),LCT.access(x),LCT.splay(x),A[x]=y,LCT.pushup(x);
		else if(op<4)in(y),printf("%d\n",LCT.lca(x,y));
		else if(op<5)in(y),LCT.split(x,y),printf("%d\n",LCT.tr[y].shi),LCT.makeroot(root);
		else printf("%d\n",LCT.ask_son(x));
		LCT.makeroot(root);
	}
}

```

**LCT 动态树** *(pushup)*

> 【LCT 动态树】
树上问题算法模板。

核心函数：
  void in(Re &x) — 核心算法函数
  void pushup(Re p) — 上推更新节点信息
  void updata(Re p) — 核心算法函数
  void pushdown(Re p) — 下传懒标记
  int nort(Re p) — 核心算法函数
  int which(Re p) — 核心算法函数
  void connect(Re p,Re fa,Re o) — 核心算法函数
  void rotate(Re p) — 旋转操作（平衡树）

核心结构体：Link_Cut_Tree, QAQ

关键配置：
N=1e5+3

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define Re register int
#define LL long long
using namespace std;
const int N=1e5+3;
int n,x,y,T,op,a[N];
inline void in(Re &x){
    int fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
struct Link_Cut_Tree{
	#define pl tr[p].ps[0]
	#define pr tr[p].ps[1]
	#define pf tr[p].fa
	int Q[N];
	struct QAQ{int fa,ans,tag,ps[2];}tr[N];
	inline void pushup(Re p){
		tr[p].ans=a[p]^tr[pl].ans^tr[pr].ans;
	}
	inline void updata(Re p){swap(pl,pr),tr[p].tag^=1;}
	inline void pushdown(Re p){
		if(tr[p].tag){
			if(pl)updata(pl);
			if(pr)updata(pr);
			tr[p].tag=0;
		}
	}
	inline int nort(Re p){return tr[pf].ps[0]==p||tr[pf].ps[1]==p;}
	inline int which(Re p){return tr[pf].ps[1]==p;}
	inline void connect(Re p,Re fa,Re o){tr[pf=fa].ps[o]=p;}
	inline void rotate(Re p){
		Re fa=pf,fas=which(p);
		Re pa=tr[fa].fa,pas=which(fa);
		Re x=tr[p].ps[fas^1];
		if(nort(fa))tr[pa].ps[pas]=p;pf=pa;
		connect(x,fa,fas),connect(fa,p,fas^1);
		pushup(fa),pushup(p);
	}
	inline void splay(Re p){
		Re x=p,t=0;Q[++t]=x;
		while(nort(x))Q[++t]=x=tr[x].fa;
		while(t)pushdown(Q[t--]);
		for(Re fa;nort(p);rotate(p))
			if(nort(fa=pf))rotate(which(p)==which(fa)?fa:p);
	}
	inline void access(Re p){
		for(Re son=0;p;son=p,p=pf)
			splay(p),pr=son,pushup(p);
	}
	inline void makeroot(Re p){access(p),splay(p),updata(p);}
	inline int findroot(Re p){
		access(p),splay(p),pushdown(p);
		while(pl)pushdown(p=pl);
		return p;
	}
	inline void split(Re x,Re y){makeroot(x),access(y),splay(y);}
	inline void link(Re x,Re y){makeroot(x);if(findroot(y)!=x)tr[x].fa=y;}
	inline void cut(Re x,Re y){
		makeroot(x);
		if(findroot(y)==x&&tr[x].fa==y&&!tr[x].ps[1])
			tr[x].fa=tr[y].ps[0]=0,pushup(y);
	}
}LCT;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T);
	for(Re i=1;i<=n;++i)in(a[i]);
	while(T--){
		in(op),in(x),in(y);
		if(!op)LCT.split(x,y),printf("%d\n",LCT.tr[y].ans);
		else if(op<2)LCT.link(x,y);
		else if(op<3)LCT.cut(x,y);
		else LCT.splay(x),a[x]=y,LCT.pushup(x);
	}
}

```

**动态DP  (带修树上最大点权独立集)** *(LCT)*

> 【动态DP  (带修树上最大点权独立集)（LCT）】
树上问题算法模板。

核心函数：
  void add(Re x,Re y) — 加法更新
  void in(Re &x) — 核心算法函数
  void pushup(Re p) — 上推更新节点信息
  int which(Re p) — 核心算法函数
  int nort(Re p) — 核心算法函数
  void connect(Re p,Re fa,Re o) — 核心算法函数
  void rotate(Re p) — 旋转操作（平衡树）
  void splay(Re p) — 伸展操作（Splay树）

核心结构体：QAQ, Matrix, Link_Cut_Tree, QAQ

关键配置：
N=1e5+3

说明：freopen("123.txt","r",stdin);

适用场景：树上的最优化问题（最大独立集、最小支配集、直径等）

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define Mat Matrix
#define LL long long
#define Re register int
using namespace std;
const int N=1e5+3;
const LL inf=1e18;
int n,m,o,x,y,T,A[N],head[N];
struct QAQ{int to,next;}a[N<<1];
inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Matrix{
	LL a[3][3];Mat(){a[1][1]=a[1][2]=a[2][1]=a[2][2]=-inf;}
	inline Mat operator*(const Mat &O)const{
		Mat A;
		for(Re i=1;i<=2;++i)
			for(Re j=1;j<=2;++j)
				for(Re k=1;k<=2;++k)
					A.a[i][j]=max(A.a[i][j],a[i][k]+O.a[k][j]);
		return A;
	}
}G[N];
struct Link_Cut_Tree{
	#define pl tr[p].ps[0]
	#define pr tr[p].ps[1]
	#define pf tr[p].fa
	struct QAQ{int fa,ps[2];}tr[N];Mat TR[N];
	inline void pushup(Re p){
		TR[p]=G[p];
		if(pl)TR[p]=TR[pl]*TR[p];
		if(pr)TR[p]=TR[p]*TR[pr];
	}
	inline int which(Re p){return tr[pf].ps[1]==p;}
	inline int nort(Re p){return tr[pf].ps[0]==p||tr[pf].ps[1]==p;}
	inline void connect(Re p,Re fa,Re o){tr[pf=fa].ps[o]=p;}
	inline void rotate(Re p){
		Re fa=pf,fas=which(p);
		Re pa=tr[fa].fa,pas=which(fa);
		Re x=tr[p].ps[fas^1];
		if(nort(fa))tr[pa].ps[pas]=p;pf=pa;
		connect(x,fa,fas),connect(fa,p,fas^1);
		pushup(fa),pushup(p);
	}
	inline void splay(Re p){
		for(Re fa;nort(p);rotate(p))
			if(nort(fa=pf))rotate(which(p)==which(fa)?fa:p);
	}
	inline void access(Re p){
		for(Re son=0;p;son=p,p=pf){
			splay(p);
			if(pr)G[p].a[1][1]+=max(TR[pr].a[1][1],TR[pr].a[2][1]),G[p].a[1][2]=G[p].a[1][1],G[p].a[2][1]+=TR[pr].a[1][1];
			pr=son;
			if(pr)G[p].a[1][1]-=max(TR[pr].a[1][1],TR[pr].a[2][1]),G[p].a[1][2]=G[p].a[1][1],G[p].a[2][1]-=TR[pr].a[1][1];
			pushup(p);
		}
	}
	inline void change(Re x,Re v){access(x),splay(x),G[x].a[2][1]+=v-A[x],A[x]=v,pushup(x);}//�޸�x�ĵ�Ȩ(G[x][1])
	inline LL ask(){splay(1);return max(TR[1].a[1][1],TR[1].a[2][1]);}
}T1;
LL g[N][2];
inline void dfs(Re x,Re fa){
	g[x][1]=A[x],T1.tr[x].fa=fa;
	for(Re i=head[x],to;i;i=a[i].next)if((to=a[i].to)!=fa)
		dfs(to,x),g[x][0]+=max(g[to][0],g[to][1]),g[x][1]+=g[to][0];
	G[x].a[1][1]=G[x].a[1][2]=g[x][0];
	G[x].a[2][1]=g[x][1],G[x].a[2][2]=-inf;
	T1.pushup(x);
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T),m=n-1;
	for(Re i=1;i<=n;++i)in(A[i]);
	while(m--)in(x),in(y),add(x,y),add(y,x);
	dfs(1,0);
	while(T--)in(x),in(y),T1.change(x,y),printf("%lld\n",T1.ask());
}

```

**动态DP  (带修树上最大点权独立集)** *(树剖)*

> 【动态DP  (带修树上最大点权独立集)（树剖）】
树上问题算法模板。

核心函数：
  void add(Re x,Re y) — 加法更新
  void in(Re &x) — 核心算法函数
  void pushup(Re p) — 上推更新节点信息
  void build(Re p,Re L,Re R) — 构建数据结构（建树/建图）
  void change(Re p,Re L,Re R,Re x,Mat &v) — 核心算法函数
  Mat ask(Re p,Re L,Re R,Re l,Re r) — 核心算法函数
  void dfs1(Re x,Re Fa) — 深度优先搜索遍历
  void dfs2(Re x,Re rt) — 深度优先搜索遍历

核心结构体：QAQ, Matrix, killed_Tree, Segment_Tree

关键配置：
N=1e5+3

说明：freopen("123.txt","r",stdin);

适用场景：树上的最优化问题（最大独立集、最小支配集、直径等）

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define Mat Matrix
#define LL long long
#define Re register int
using namespace std;
const int N=1e5+3;
const LL inf=1e18;
int n,m,o,x,y,T,A[N],head[N];
struct QAQ{int to,next;}a[N<<1];
inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Matrix{
	LL a[3][3];Mat(){a[1][1]=a[1][2]=a[2][1]=a[2][2]=-inf;}
	inline Mat operator*(const Mat &O)const{
		Mat A;
		for(Re i=1;i<=2;++i)
			for(Re j=1;j<=2;++j)
				for(Re k=1;k<=2;++k)
					A.a[i][j]=max(A.a[i][j],a[i][k]+O.a[k][j]);
		return A;
	}
}G[N];
int idx[N];
struct killed_Tree{
	struct Segment_Tree{
		#define pl (p<<1)
		#define pr (p<<1|1)
		#define mid ((L+R)>>1)
		Mat tr[N<<2];
		inline void pushup(Re p){tr[p]=tr[pl]*tr[pr];}
		inline void build(Re p,Re L,Re R){
			if(L==R){tr[p]=G[idx[L]];return;}
			build(pl,L,mid),build(pr,mid+1,R);
			pushup(p);
		}
		inline void change(Re p,Re L,Re R,Re x,Mat &v){
			if(L==R){tr[p]=v;return;}
			if(x<=mid)change(pl,L,mid,x,v);
			else change(pr,mid+1,R,x,v);
			pushup(p);
		}
		inline Mat ask(Re p,Re L,Re R,Re l,Re r){
			if(l<=L&&R<=r)return tr[p];
			if(r<=mid)return ask(pl,L,mid,l,r);
			else if(l>mid)return ask(pr,mid+1,R,l,r);
			else return ask(pl,L,mid,l,r)*ask(pr,mid+1,R,l,r);
		}
	}TR;
	int id_O,fa[N],st[N],ed[N],son[N],top[N],deep[N],size[N];LL f[N][2],g[N][2];
	inline void dfs1(Re x,Re Fa){
		deep[x]=deep[fa[x]=Fa]+1,size[x]=1;
		for(Re i=head[x],to;i;i=a[i].next)
			if((to=a[i].to)!=Fa){
				dfs1(to,x),size[x]+=size[to];
				if(size[to]>size[son[x]])son[x]=to;
			}
	}
	inline void dfs2(Re x,Re rt){
		idx[st[x]=++id_O]=x,ed[rt]=max(ed[rt],id_O),top[x]=rt;
		f[x][0]=g[x][0]=0,f[x][1]=g[x][1]=A[x];
		if(son[x])dfs2(son[x],rt),f[x][0]+=max(f[son[x]][0],f[son[x]][1]),f[x][1]+=f[son[x]][0];
		for(Re i=head[x],to;i;i=a[i].next)
			if((to=a[i].to)!=fa[x]&&to!=son[x]){
				dfs2(to,to);
				f[x][0]+=max(f[to][0],f[to][1]),f[x][1]+=f[to][0];
				g[x][0]+=max(f[to][0],f[to][1]),g[x][1]+=f[to][0];
			}
		G[x].a[1][1]=G[x].a[1][2]=g[x][0];
		G[x].a[2][1]=g[x][1],G[x].a[2][2]=-inf;
	}
	inline LL ask(){Mat F=TR.ask(1,1,n,st[1],ed[1]);return max(F.a[1][1],F.a[2][1]);}
	inline void change(Re x,Re v){//�޸�x�ĵ�Ȩ
		G[x].a[2][1]+=v-A[x],A[x]=v;//�޸�G[x][1]
		while(x){
			Mat F1=TR.ask(1,1,n,st[top[x]],ed[top[x]]);
			TR.change(1,1,n,st[x],G[x]);
			Mat F2=TR.ask(1,1,n,st[top[x]],ed[top[x]]);
			x=fa[top[x]];
			G[x].a[1][1]+=max(F2.a[1][1],F2.a[2][1])-max(F1.a[1][1],F1.a[2][1]),G[x].a[1][2]=G[x].a[1][1];
			G[x].a[2][1]+=F2.a[1][1]-F1.a[1][1];
		}
	}
}T1;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T),m=n-1;
	for(Re i=1;i<=n;++i)in(A[i]);
	while(m--)in(x),in(y),add(x,y),add(y,x);
	T1.dfs1(1,0),T1.dfs2(1,1),T1.TR.build(1,1,n);
	while(T--)in(x),in(y),T1.change(x,y),printf("%lld\n",T1.ask());
}

```

**大融合** *(LCT 计算虚子树信息)*

> 【大融合（LCT 计算虚子树信息）】
树上问题算法模板。

核心函数：
  void in(Re &x) — 核心算法函数
  void pushup(Re p) — 上推更新节点信息
  void updata(Re p) — 核心算法函数
  void pushdown(Re p) — 下传懒标记
  int nort(Re p) — 核心算法函数
  int which(Re p) — 核心算法函数
  void connect(Re p,Re fa,Re o) — 核心算法函数
  void rotate(Re p) — 旋转操作（平衡树）

核心结构体：Link_Cut_Tree, QAQ

关键配置：
N=1e5+3

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define Re register int
#define LL long long
using namespace std;
const int N=1e5+3;
int n,x,y,T;char op;
inline void in(Re &x){
    int fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
struct Link_Cut_Tree{
	#define pl tr[p].ps[0]
	#define pr tr[p].ps[1]
	#define pf tr[p].fa
	int Q[N];
	struct QAQ{int fa,si,ans,tag,ps[2];}tr[N];
	inline void pushup(Re p){
		tr[p].ans=1+tr[p].si+tr[pl].ans+tr[pr].ans;
	}
	inline void updata(Re p){swap(pl,pr),tr[p].tag^=1;}
	inline void pushdown(Re p){
		if(tr[p].tag){
			if(pl)updata(pl);
			if(pr)updata(pr);
			tr[p].tag=0;
		}
	}
	inline int nort(Re p){return tr[pf].ps[0]==p||tr[pf].ps[1]==p;}
	inline int which(Re p){return tr[pf].ps[1]==p;}
	inline void connect(Re p,Re fa,Re o){tr[pf=fa].ps[o]=p;}
	inline void rotate(Re p){
		Re fa=pf,fas=which(p);
		Re pa=tr[fa].fa,pas=which(fa);
		Re x=tr[p].ps[fas^1];
		if(nort(fa))tr[pa].ps[pas]=p;pf=pa;
		connect(x,fa,fas),connect(fa,p,fas^1);
		pushup(fa),pushup(p);
	}
	inline void splay(Re p){
		Re x=p,t=0;Q[++t]=x;
		while(nort(x))Q[++t]=x=tr[x].fa;
		while(t)pushdown(Q[t--]);
		for(Re fa;nort(p);rotate(p))
			if(nort(fa=pf))rotate(which(p)==which(fa)?fa:p);
	}
	inline void access(Re p){
		for(Re son=0;p;son=p,p=pf)
			splay(p),tr[p].si+=tr[pr].ans,tr[p].si-=tr[pr=son].ans,pushup(p);
	}
	inline void makeroot(Re p){access(p),splay(p),updata(p);}
	inline int findroot(Re p){
		access(p),splay(p),pushdown(p);
		while(pl)pushdown(p=pl);
		return p;
	}
	inline void split(Re x,Re y){makeroot(x),access(y),splay(y);}
	inline void link(Re x,Re y){
		makeroot(x);
		if(findroot(y)!=x)tr[tr[x].fa=y].si+=tr[x].ans,pushup(y);
	}
	inline void cut(Re x,Re y){
		makeroot(x);
		if(findroot(y)==x&&tr[x].fa==y&&!tr[x].ps[1])
			tr[x].fa=tr[y].ps[0]=0,pushup(y);
	}
	inline int ask(Re x,Re y){split(x,y);return (tr[x].si+1)*(tr[y].si+1);}
}LCT;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T);
	while(T--){
		scanf(" %c",&op),in(x),in(y);
		if(op=='A')LCT.link(x,y);
		if(op=='Q')printf("%d\n",LCT.ask(x,y));
	}
}

```

**树链剖分** *(重链剖分)*

> 【树链剖分（重链剖分）】
树上问题算法模板。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re y) — 加法更新
  void pushdown(Re p) — 下传懒标记
  void build(Re p,Re L,Re R) — 构建数据结构（建树/建图）
  void change(Re p,Re l,Re r,Re v) — 核心算法函数
  int ask(Re p,Re l,Re r) — 核心算法函数
  void dfs1(Re x,Re Fa) — 深度优先搜索遍历
  void dfs2(Re x,Re rt) — 深度优先搜索遍历

核心结构体：Killed_Tree, QAQ, Segment_Tree, QAQ

关键配置：
N=1e5+3

```cpp
#include<algorithm>
#include<cstdio>
#define Re register int
using namespace std;
const int N=1e5+3;
int n,m,x,y,z,T,P,op,root,A[N],AA[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Killed_Tree{
	struct QAQ{int to,next;}a[N<<1];
	int o,id_o,fa[N],id[N],idx[N],top[N],son[N],size[N],deep[N],head[N];
	inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
	struct Segment_Tree{
		#define pl (p<<1)
		#define pr (p<<1|1)
		#define mid (L+R>>1)
		struct QAQ{int S,l,r,add;}tr[N<<2];
		inline void pushdown(Re p){
			Re v=tr[p].add;
			if(v){
				(tr[pl].S+=v*(tr[pl].r-tr[pl].l+1)%P)%=P,(tr[pl].add+=v)%=P;
				(tr[pr].S+=v*(tr[pr].r-tr[pr].l+1)%P)%=P,(tr[pr].add+=v)%=P;
				tr[p].add=0;
			}
		}
		inline void build(Re p,Re L,Re R){
			tr[p].l=L,tr[p].r=R;
			if(L==R){tr[p].S=AA[L]%P;return;}
			build(pl,L,mid),build(pr,mid+1,R);
			tr[p].S=(tr[pl].S+tr[pr].S)%P;
		}
		inline void change(Re p,Re l,Re r,Re v){
			Re L=tr[p].l,R=tr[p].r;
			if(l<=L&&R<=r){(tr[p].S+=v*(R-L+1)%P)%=P,(tr[p].add+=v)%=P;return;}
			pushdown(p);
			if(l<=mid)change(pl,l,r,v);
			if(r>mid)change(pr,l,r,v);
			tr[p].S=(tr[pl].S+tr[pr].S)%P;
		}
		inline int ask(Re p,Re l,Re r){
			Re L=tr[p].l,R=tr[p].r;
			if(l<=L&&R<=r)return tr[p].S;
			Re ans=0;pushdown(p);
			if(l<=mid)(ans+=ask(pl,l,r))%=P;
			if(r>mid)(ans+=ask(pr,l,r))%=P;
			return ans;
		}
	}TR;
	inline void dfs1(Re x,Re Fa){
		size[x]=1,deep[x]=deep[fa[x]=Fa]+1;
		for(Re i=head[x],to;i;i=a[i].next)
			if((to=a[i].to)!=Fa){
				dfs1(to,x);
				size[x]+=size[to];
				if(size[to]>size[son[x]])son[x]=to;
			}
	}
	inline void dfs2(Re x,Re rt){
		id[x]=++id_o,idx[id_o]=x,AA[id_o]=A[x],top[x]=rt;
		if(!son[x])return;//Ҷ�ڵ�
		dfs2(son[x],rt);
		for(Re i=head[x],to;i;i=a[i].next)
			if((to=a[i].to)!=fa[x]&&to!=son[x])dfs2(to,to);
	}
	inline void kill(Re rt){dfs1(rt,0),dfs2(rt,rt),TR.build(1,1,n);}
	inline int ask_dis(Re x,Re y){
		Re ans=0;
		while(top[x]!=top[y]){
			if(deep[top[x]]<deep[top[y]])swap(x,y);
			(ans+=TR.ask(1,id[top[x]],id[x]))%=P;
			x=fa[top[x]];
		}
		if(deep[x]>deep[y])swap(x,y);
		(ans+=TR.ask(1,id[x],id[y]))%=P;
		return ans;
	}
	inline void change_dis(Re x,Re y,Re v){
		while(top[x]!=top[y]){
			if(deep[top[x]]<deep[top[y]])swap(x,y);
			TR.change(1,id[top[x]],id[x],v);
			x=fa[top[x]];
		}
		if(deep[x]>deep[y])swap(x,y);
		TR.change(1,id[x],id[y],v);
	}
	inline int ask_son(Re x){
		return TR.ask(1,id[x],id[x]+size[x]-1);
	}
	inline void change_son(Re x,Re v){
		TR.change(1,id[x],id[x]+size[x]-1,v);
	}
}T1;
int main(){
	in(n),in(T),in(root),in(P),m=n-1;
	for(Re i=1;i<=n;++i)in(A[i]);
	while(m--)in(x),in(y),T1.add(x,y),T1.add(y,x);
	T1.kill(root);
	while(T--){
		in(op);
		if(op<2)in(x),in(y),in(z),T1.change_dis(x,y,z%P);
		else if(op<3)in(x),in(y),printf("%d\n",T1.ask_dis(x,y));
		else if(op<4)in(x),in(z),T1.change_son(x,z%P);
		else in(x),printf("%d\n",T1.ask_son(x));
	}
}

```

**水管局长** *(LCT动态维护MST)*

> 【水管局长（LCT动态维护MST）】
树上问题算法模板。

核心函数：
  void in(int &x) — 核心算法函数
  void pushup(Re p) — 上推更新节点信息
  void updata(Re p) — 核心算法函数
  void pushdown(Re p) — 下传懒标记
  int which(Re p) — 核心算法函数
  int nort(Re p) — 核心算法函数
  void connect(Re p,Re fa,Re o) — 核心算法函数
  void rotate(Re p) — 旋转操作（平衡树）

核心结构体：Query, Link_Cut_Tree, QAQ, Kruscal, QAQ

关键配置：
N=1003,M=1e5+3

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=1003,M=1e5+3;
int n,m,x,y,z,T,op,id,id_O,v[N+M],vis[N+M],Ans[M],ID[N][N];
struct Query{int op,x,y;}Q[M];
inline void in(int &x){
    Re fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
struct Link_Cut_Tree{
	#define pl tr[p].ps[0]
	#define pr tr[p].ps[1]
	#define pf tr[p].fa
	int Q[N+M];
	struct QAQ{int mx,fa,tag,ps[2];}tr[N+M];
	inline void pushup(Re p){
		tr[p].mx=p;
		if(pl&&v[tr[pl].mx]>v[tr[p].mx])tr[p].mx=tr[pl].mx;
		if(pr&&v[tr[pr].mx]>v[tr[p].mx])tr[p].mx=tr[pr].mx;
	}
	inline void updata(Re p){swap(pl,pr),tr[p].tag^=1;}
	inline void pushdown(Re p){
		if(tr[p].tag){
			if(pl)updata(pl);
			if(pr)updata(pr);
			tr[p].tag=0;
		}
	}
	inline int which(Re p){return tr[pf].ps[1]==p;}
	inline int nort(Re p){return tr[pf].ps[0]==p||tr[pf].ps[1]==p;}
	inline void connect(Re p,Re fa,Re o){tr[pf=fa].ps[o]=p;}
	inline void rotate(Re p){
		Re fa=pf,fas=which(p);
		Re pa=tr[fa].fa,pas=which(fa);
		Re x=tr[p].ps[fas^1];
		if(nort(fa))tr[pa].ps[pas]=p;pf=pa;
		connect(x,fa,fas),connect(fa,p,fas^1);
		pushup(fa),pushup(p); 
	}
	inline void splay(Re p){
		Re x=p,t=0;Q[++t]=x;
		while(nort(x))Q[++t]=x=tr[x].fa;
		while(t)pushdown(Q[t--]);
		for(Re fa;nort(p);rotate(p))
			if(nort(fa=pf))rotate(which(p)==which(fa)?fa:p);
	}
	inline void access(Re p){
		for(Re son=0;p;son=p,p=pf)
			splay(p),pr=son,pushup(p);
	}
	inline void makeroot(Re x){access(x),splay(x),updata(x);}
	inline int findroot(Re p){
		access(p),splay(p),pushdown(p);
		while(pl)pushdown(p=pl);
		return p;
	}
	inline void split(Re x,Re y){makeroot(x),access(y),splay(y);}
	inline void link(Re x,Re y){makeroot(x);if(findroot(y)!=x)tr[x].fa=y;}
	inline void cut(Re x,Re y){
		makeroot(x);
		if(findroot(y)==x&&tr[x].fa==y&&!tr[x].ps[1])
			tr[x].fa=tr[y].ps[0]=0,pushup(y);
	}
	inline void MST_link(Re x,Re y,Re id){
		makeroot(x);
		if(findroot(y)!=x)link(x,id),link(id,y);
		else{
			split(x,y);Re mx=tr[y].mx;
			if(v[id]<v[mx]){
				splay(mx);
				tr[tr[mx].ps[0]].fa=tr[tr[mx].ps[1]].fa=0;
				tr[mx].ps[0]=tr[mx].ps[1]=tr[mx].fa=0;
				link(x,id),link(id,y);
			}
		}
	}
	inline int MST_path(Re x,Re y){split(x,y);return v[tr[y].mx];}
}LCT;
struct Kruscal{
	int fa[N];
	struct QAQ{int x,y,z;inline bool operator<(const QAQ &O)const{return z<O.z;}}a[M];
	inline int find(Re x){return x==fa[x]?x:fa[x]=find(fa[x]);}
	inline void sakura(){
		for(Re i=1;i<=n;++i)fa[i]=i;
		for(Re i=1;i<=m;++i)in(x),in(y),in(z),v[ID[x][y]=ID[y][x]=++id_O+n]=z,a[i]=(QAQ){x,y,z};
		for(Re i=1;i<=T;++i)in(op),in(x),in(y),vis[ID[x][y]]|=op>1,Q[i]=(Query){op,x,y};
		sort(a+1,a+m+1);
		for(Re i=1,t=0;t<n-1&&i<=m;++i)
			if(!vis[ID[x=a[i].x][y=a[i].y]]&&find(x)!=find(y))
				fa[find(x)]=find(y),++t,LCT.MST_link(x,y,ID[x][y]);
	}
}T1;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(m),in(T),T1.sakura();
	for(Re i=T;i>=1;--i){
		Re op=Q[i].op,x=Q[i].x,y=Q[i].y;
		if(op&1)Ans[++Ans[0]]=LCT.MST_path(x,y);
		else LCT.MST_link(x,y,ID[x][y]);
	}
	for(Re i=Ans[0];i>=1;--i)printf("%d\n",Ans[i]);
}

```

**遥远的国度** *(LCT维护原子树信息)*

> 【遥远的国度（LCT维护原子树信息）】
树上问题算法模板。

核心函数：
  void in(Re &x) — 核心算法函数
  void pushup(Re p) — 上推更新节点信息
  void updata(Re p) — 核心算法函数
  void updata(Re p,Re v) — 核心算法函数
  void pushdown(Re p) — 下传懒标记
  int which(Re p) — 核心算法函数
  int nort(Re p) — 核心算法函数
  void connect(Re p,Re fa,Re o) — 核心算法函数

核心结构体：Link_Cut_Tree, QAQ

关键配置：
N=1e5+3,inf=2e9

说明：shi: ����ʵ����(�ڸ����ϵ�v)；si: ���������������(���ڸ����ϵ�ans)；freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<set>
#define LL long long
#define Re register int
using namespace std;
const int N=1e5+3,inf=2e9;
int n,x,y,z,T,op,root,X[N],Y[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Link_Cut_Tree{
	#define pl tr[p].ps[0]
	#define pr tr[p].ps[1]
	#define pf tr[p].fa
	#define pv tr[p].v
	int Q[N];
	struct QAQ{int v,fa,si,shi,ans,add,tag,ans0,ps[2];multiset<int>SI;}tr[N];
	inline void pushup(Re p){
		tr[p].shi=min(pv,min(tr[pl].shi,tr[pr].shi));
		tr[p].si=min(*tr[p].SI.begin(),min(tr[pl].si,tr[pr].si));
		tr[p].ans=min(tr[p].shi,tr[p].si);
	}
	inline void updata(Re p){tr[p].tag^=1,swap(pl,pr);}
	inline void updata(Re p,Re v){tr[p].add=1,tr[p].shi=pv=v,tr[p].ans=min(tr[p].shi,tr[p].si);}
	inline void pushdown(Re p){
		if(tr[p].tag){
			if(pl)updata(pl);
			if(pr)updata(pr);
			tr[p].tag=0;
		}
		if(tr[p].add){
			if(pl)updata(pl,pv);
			if(pr)updata(pr,pv);
			tr[p].add=0;
		}
	}
	inline int which(Re p){return tr[pf].ps[1]==p;}
	inline int nort(Re p){return tr[pf].ps[0]==p||tr[pf].ps[1]==p;}
	inline void connect(Re p,Re fa,Re o){tr[pf=fa].ps[o]=p;}
	inline void rotate(Re p){
		Re fa=pf,fas=which(p);
		Re pa=tr[fa].fa,pas=which(fa);
		Re x=tr[p].ps[fas^1];
		if(nort(fa))tr[pa].ps[pas]=p;pf=pa;
		connect(x,fa,fas),connect(fa,p,fas^1);
		pushup(fa),pushup(p);
	}
	inline void splay(Re p){
		Re x=p,t=0;Q[++t]=x;
		while(nort(x))Q[++t]=x=tr[x].fa;
		while(t)pushdown(Q[t--]);
		for(Re fa;nort(p);rotate(p))
			if(nort(fa=pf))rotate(which(p)==which(fa)?fa:p);
	}
	inline void access(Re p){
		for(Re son=0;p;son=p,p=pf){
			splay(p);
			if(pr)tr[p].SI.insert(tr[pr].ans);
			pr=son;
			if(pr)tr[p].SI.erase(tr[p].SI.lower_bound(tr[pr].ans));
			pushup(p);
		}
	}
	inline void makeroot(Re p){access(p),splay(p),updata(p);}
	inline void link(Re x,Re y){makeroot(x),access(y),splay(y),tr[tr[x].fa=y].SI.insert(tr[x].ans);}
	inline void change(Re x,Re y,Re z){makeroot(x),access(y),splay(y),updata(y,z);}
	inline int ask_son(Re p){access(p),splay(p);return min(pv,*tr[p].SI.begin());}
}T1;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T),T1.tr[0].shi=T1.tr[0].si=inf;
	for(Re i=1;i<n;++i)in(X[i]),in(Y[i]);
	for(Re i=1;i<=n;++i)in(T1.tr[i].v),T1.tr[i].SI.insert(inf),T1.pushup(i);
	for(Re i=1;i<n;++i)T1.link(X[i],Y[i]);
	in(root),T1.makeroot(root);
	while(T--){
		in(op),in(x);
		if(op<2)T1.makeroot(root=x);
		else if(op<3)in(y),in(z),T1.change(x,y,z),T1.makeroot(root);
		else printf("%d\n",T1.ask_son(x));
	}
}

```

**长链剖分优化dp** *(Dominant Indices)*

> 【长链剖分优化dp（Dominant Indices）】
树上问题算法模板。

核心函数：
  void add(Re x,Re y) — 加法更新
  void in(Re &x) — 核心算法函数
  void dfs1(Re x,Re fa) — 深度优先搜索遍历
  void dfs2(Re x,Re fa) — 深度优先搜索遍历

核心结构体：QAQ

关键配置：
N=1e6+3

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=1e6+3;
int n,m,x,y,o,Sz[N],son[N],Ans[N],dep[N],head[N];int *SZ=Sz,*dp[N];
struct QAQ{int to,next;}a[N<<1];
inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void dfs1(Re x,Re fa){
	for(Re i=head[x],to;i;i=a[i].next)
		if((to=a[i].to)!=fa){
			dfs1(to,x);
			if(dep[to]>dep[son[x]])son[x]=to;
		}
	dep[x]=dep[son[x]]+1;
}
inline void dfs2(Re x,Re fa){
	dp[x][0]=1;
	if(son[x])dp[son[x]]=dp[x]+1,dfs2(son[x],x),Ans[x]=Ans[son[x]]+1;
	for(Re i=head[x],to;i;i=a[i].next)
		if((to=a[i].to)!=fa&&to!=son[x]){
			dp[to]=SZ,SZ+=dep[to],dfs2(to,x);
			for(Re j=1;j<=dep[to];++j){
				dp[x][j]+=dp[to][j-1];
				if(dp[x][j]>dp[x][Ans[x]])Ans[x]=j;
				else if(dp[x][j]==dp[x][Ans[x]])Ans[x]=min(Ans[x],j);
			}
		}
	if(dp[x][Ans[x]]==1)Ans[x]=0;
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),m=n-1;
	while(m--)in(x),in(y),add(x,y),add(y,x);
	dfs1(1,0),dp[1]=SZ,SZ+=dep[1],dfs2(1,0);
	for(Re i=1;i<=n;++i)printf("%d\n",Ans[i]);
}

```

**Distance in Tree** *(长度等于K的路径数)*

> 【Distance in Tree（长度等于K的路径数）】
树上问题算法模板。

核心函数：
  void add(Re x,Re y) — 加法更新
  void in(Re &x) — 核心算法函数
  void getrt(Re x,Re fa) — 获取值
  void getdis(Re x,Re fa) — 获取值
  int calc(Re x,Re d) — 计算函数
  void sakura(Re x) — 后缀数组

核心结构体：QAQ

关键配置：
N=5e4+3,inf=2e9

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=5e4+3,inf=2e9;
int n,m,o,x,y,K,head[N];LL Ans;
struct QAQ{int to,next;}a[N<<1];
inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
int rt,sum,cnt,tmp[N],dis[N],vis[N],maxp[N],size[N];
inline void getrt(Re x,Re fa){
	size[x]=1,maxp[x]=0;
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to]&&to!=fa)
			getrt(to,x),size[x]+=size[to],maxp[x]=max(maxp[x],size[to]);
	maxp[x]=max(maxp[x],sum-size[x]);
	if(maxp[x]<maxp[rt])rt=x;
}
inline void getdis(Re x,Re fa){
	if(dis[fa]+1>K)return;
	tmp[++cnt]=dis[x]=dis[fa]+1;
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to]&&to!=fa)getdis(to,x);
}
inline int calc(Re x,Re d){
	Re ans=0;cnt=0,tmp[++cnt]=dis[x]=d;
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to])getdis(to,x);
	sort(tmp+1,tmp+cnt+1);
	Re L=cnt+1,R=cnt;
	for(Re i=1;i<=cnt&&i<R;++i){
		while(tmp[i]+tmp[L-1]>=K)--L;
		while(R>=L&&tmp[i]+tmp[R]>K)--R;
		if(L<=R&&i<R&&tmp[i]+tmp[L]==K&&tmp[i]+tmp[R]==K)ans+=(R-max(L,i+1)+1);
	}
	return ans;
}
inline void sakura(Re x){
	Re now=sum;vis[x]=1,Ans+=calc(x,0);
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to])
			Ans-=calc(to,1),sum=size[to]>size[x]?now-size[x]:size[to],maxp[rt=0]=inf,getrt(to,x),sakura(rt);
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(K),m=n-1;
	while(m--)in(x),in(y),add(x,y),add(y,x);
	sum=n,maxp[rt=0]=inf,getrt(1,0),sakura(rt);
	printf("%lld\n",Ans);
}

```

**Qtree4** *(点分树+可删堆)*

> 【Qtree4（点分树+可删堆）】
树上问题算法模板。

核心函数：
  void add(Re x,Re y,Re z) — 加法更新
  void in(Re &x) — 核心算法函数
  void dfs(Re x,Re fa,Re w) — 深度优先搜索遍历
  void build(Re rt) — 构建数据结构（建树/建图）
  int lca(Re x,Re y) — 查询最近公共祖先
  int Dis(Re x,Re y) — 核心算法函数
  int top(无参数) — 获取栈顶/堆顶元素
  int sec(无参数) — 核心算法函数

核心结构体：QAQ, LCA, Queue

关键配置：
N=1e5+3,logN=18,inf=1e9

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#define LL long long
#define Re register int
using namespace std;
const int N=1e5+3,logN=18,inf=1e9;
int n,m,x,y,z,o,T,Cnt,A[N],ans[N],head[N];char op;
struct QAQ{int w,to,next;}a[N<<1];
inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct LCA{
	int O,lg[N<<1],fir[N],idx[N<<1],idd[N<<1],dis[N],deep[N],f[N<<1][20],ans[N<<1][20];
	inline void dfs(Re x,Re fa,Re w){
		idx[fir[x]=++O]=x,idd[O]=deep[x]=deep[fa]+1,dis[x]=dis[fa]+w;
		for(Re i=head[x],to;i;i=a[i].next)
			if((to=a[i].to)!=fa)dfs(to,x,a[i].w),idx[++O]=x,idd[O]=deep[x];
	}
	inline void build(Re rt){
		dfs(rt,0,0),lg[0]=-1;
		for(Re i=1;i<=O;++i)f[i][0]=idd[i],ans[i][0]=idx[i],lg[i]=lg[i>>1]+1;
		for(Re j=1;j<=logN;++j)
			for(Re i=1;i+(1<<j)-1<=O;++i)
				if(f[i][j-1]<f[i+(1<<j-1)][j-1])f[i][j]=f[i][j-1],ans[i][j]=ans[i][j-1];
				else f[i][j]=f[i+(1<<j-1)][j-1],ans[i][j]=ans[i+(1<<j-1)][j-1];
	}
	inline int lca(Re x,Re y){
		Re L=fir[x],R=fir[y];
		if(L>R)swap(L,R);
		Re m=lg[R-L+1];
		return f[L][m]<f[R-(1<<m)+1][m]?ans[L][m]:ans[R-(1<<m)+1][m];
	}
}T0;
inline int Dis(Re x,Re y){return T0.dis[x]+T0.dis[y]-(T0.dis[T0.lca(x,y)]<<1);}
struct Queue{
	priority_queue<int>Q,D;
	inline int top(){
		while(!Q.empty()&&!D.empty()&&Q.top()==D.top())Q.pop(),D.pop();
		return Q.empty()?-inf:Q.top();
	}
	inline int sec(){
		Re x=top();if(x==-inf)return x;
		Q.pop();Re ans=top();Q.push(x);
		return ans;
	}
	inline void erase(Re x){if(Q.top()==x)Q.pop();else D.push(x);}
	inline void insert(Re x){Q.push(x);}
	inline int empty(){
		while(!Q.empty()&&!D.empty()&&Q.top()==D.top())Q.pop(),D.pop();
		return Q.empty();
	}
}Ans,Q[N],dis[N];
int rt,sum,Fa[N],vis[N],size[N],maxp[N];
inline void getrt(Re x,Re fa){
	size[x]=1,maxp[x]=0;
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to]&&to!=fa)
			getrt(to,x),size[x]+=size[to],maxp[x]=max(maxp[x],size[to]);
	maxp[x]=max(maxp[x],sum-size[x]);
	if(maxp[x]<maxp[rt])rt=x;
}
inline void getdis(Re x,Re fa,Re rt){
	dis[rt].insert(Dis(x,Fa[rt]));
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to]&&to!=fa)getdis(to,x,rt);
}
inline void sakura(Re x){
	Re now=sum;vis[x]=1,getdis(x,0,x);
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to]){
			sum=size[to]>size[x]?now-size[x]:size[to],maxp[rt=0]=inf,getrt(to,0);
			Fa[to=rt]=x,sakura(rt),Q[x].insert(dis[to].top());
		}
	Q[x].insert(0),Ans.insert(ans[x]=max(0,Q[x].top()+Q[x].sec()));
}
inline void insert(Re x){
	Ans.erase(ans[x]),Q[x].insert(0),Ans.insert(ans[x]=max(0,Q[x].top()+Q[x].sec()));
	for(Re fa=x;Fa[fa];fa=Fa[fa]){
		Re pa=Fa[fa];
		Ans.erase(ans[pa]);
		if(!dis[fa].empty())Q[pa].erase(dis[fa].top());
		
		dis[fa].insert(Dis(x,pa));
		
		Q[pa].insert(dis[fa].top());
		Ans.insert(ans[pa]=max(0,Q[pa].top()+Q[pa].sec()));
	}
}
inline void erase(Re x){
	Ans.erase(ans[x]),Q[x].erase(0),Ans.insert(ans[x]=max(0,Q[x].top()+Q[x].sec()));
	for(Re fa=x;Fa[fa];fa=Fa[fa]){
		Re pa=Fa[fa];
		Ans.erase(ans[pa]);
		Q[pa].erase(dis[fa].top());
		
		dis[fa].erase(Dis(x,pa));
		
		if(!dis[fa].empty())Q[pa].insert(dis[fa].top());
		Ans.insert(ans[pa]=max(0,Q[pa].top()+Q[pa].sec()));
	}
}
inline void change(Re x){
	if(A[x])insert(x),A[x]=0,++Cnt;
	else erase(x),A[x]=1,--Cnt;
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),m=n-1,Cnt=n;
	while(m--)in(x),in(y),in(z),add(x,y,z),add(y,x,z);
	in(T),T0.build(1),sum=n,maxp[rt=0]=inf,getrt(1,0),sakura(rt);
	while(T--){
		scanf(" %c",&op);
		if(op=='C')in(x),change(x);
		else if(!Cnt)puts("They have disappeared.");
		else printf("%d\n",Cnt<2?0:Ans.top());
	}
}

```

**Race** *(长度等于K的路径最小边数)*

> 【Race（长度等于K的路径最小边数）】
树上问题算法模板。

核心函数：
  void add(Re x,Re y,Re z) — 加法更新
  void in(Re &x) — 核心算法函数
  void getrt(Re x,Re fa) — 获取值
  void getdis(Re x,Re fa,Re w) — 获取值
  void calc(Re x) — 计算函数
  void sakura(Re x) — 后缀数组

核心结构体：QAQ

关键配置：
N=2e5+3,INF=1e6+3,inf=2e9

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=2e5+3,INF=1e6+3,inf=2e9;
int n,m,o,x,y,z,K,Ans,head[N];
struct QAQ{int w,to,next;}a[N<<1];
inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
int rt,sum,dd[N],ddd[N],dep[N],Min[INF],tmp[N],dis[N],vis[N],maxp[N],size[N];
inline void getrt(Re x,Re fa){
	size[x]=1,maxp[x]=0;
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to]&&to!=fa)
			getrt(to,x),size[x]+=size[to],maxp[x]=max(maxp[x],size[to]);
	maxp[x]=max(maxp[x],sum-size[x]);
	if(maxp[x]<maxp[rt])rt=x;
}
inline void getdis(Re x,Re fa,Re w){
	if(dis[fa]+w>K)return;
	dd[++dd[0]]=dis[x]=dis[fa]+w,ddd[dd[0]]=dep[x]=dep[fa]+1;
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to]&&to!=fa)getdis(to,x,a[i].w);
}
inline void calc(Re x){
	dis[x]=dep[x]=tmp[0]=0,Min[tmp[++tmp[0]]=0]=0;
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to]){
			dd[0]=0,getdis(to,x,a[i].w);
			for(Re i=1;i<=dd[0];++i)Ans=min(Ans,ddd[i]+Min[K-dd[i]]);
			for(Re i=1;i<=dd[0];++i)Min[dd[i]]=min(Min[dd[i]],ddd[i]),tmp[++tmp[0]]=dd[i];
		}
	for(Re i=1;i<=tmp[0];++i)Min[tmp[i]]=inf;
}
inline void sakura(Re x){
	Re now=sum;vis[x]=1,calc(x);
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to])
			sum=size[to]>size[x]?now-size[x]:size[to],maxp[rt=0]=inf,getrt(to,x),sakura(rt);
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(K),m=n-1;
	for(Re i=0;i<=K;++i)Min[i]=inf;
	while(m--)in(x),in(y),in(z),++x,++y,add(x,y,z),add(y,x,z);
	Ans=inf,sum=n,maxp[rt=0]=inf,getrt(1,0),sakura(rt);
	printf("%d\n",(Ans==inf)?-1:Ans);
}

```

**点分树-在线求原树距离-BIT** *(求距离小于等于K的点权值之和 震波)*

> 【点分树-在线求原树距离-BIT（求距离小于等于K的点权值之和 震波）】
点分治/边分治模板，用于树上路径统计问题。

核心函数：
  void add(Re x,Re y) — 加法更新
  void in(Re &x) — 核心算法函数
  void dfs1(Re x,Re Fa) — 深度优先搜索遍历
  void dfs2(Re x,Re rt) — 深度优先搜索遍历
  void build(无参数) — 构建数据结构（建树/建图）
  int lca(Re x,Re y) — 查询最近公共祖先
  int Dis(Re x,Re y) — 核心算法函数
  void build(Re N) — 构建数据结构（建树/建图）

核心结构体：QAQ, LCA, BIT

关键配置：
N=1e5+3,inf=2e9,logN=17

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<vector>
#define LL long long
#define Re register int
using namespace std;
const int N=1e5+3,inf=2e9,logN=17;
int n,m,o,x,y,T,op,lastans,A[N],deep[N],head[N];
struct QAQ{int to,next;}a[N<<1];
inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct LCA{
	int fa[N],top[N],son[N],size[N];
	inline void dfs1(Re x,Re Fa){
		size[x]=1,deep[x]=deep[fa[x]=Fa]+1;
		for(Re i=head[x],to;i;i=a[i].next)
			if((to=a[i].to)!=Fa){
				dfs1(to,x),size[x]+=size[to];
				if(size[son[x]]<size[to])son[x]=to;
			}
	}
	inline void dfs2(Re x,Re rt){
		top[x]=rt;
		if(!son[x])return;
		dfs2(son[x],rt);
		for(Re i=head[x],to;i;i=a[i].next)
			if((to=a[i].to)!=fa[x]&&to!=son[x])dfs2(to,to);
	}
	inline void build(){dfs1(1,0),dfs2(1,1);}
	inline int lca(Re x,Re y){
		while(top[x]!=top[y]){
			if(deep[top[x]]<deep[top[y]])swap(x,y);
			x=fa[top[x]];
		}
		if(deep[x]>deep[y])swap(x,y);
		return x;
	}
}T1;
inline int Dis(Re x,Re y){return deep[x]+deep[y]-(deep[T1.lca(x,y)]<<1);}
struct BIT{
	int n;vector<int>C;
	inline void build(Re N){C.resize((n=N)+1);}
	inline void add(Re x,Re v){++x;while(x<=n)C[x]+=v,x+=x&-x;}
	inline int ask(Re x){++x,x=min(x,n);Re ans=0;while(x)ans+=C[x],x-=x&-x;return ans;}
}TR1[N],TR2[N];
int rt,sum,fa[N],vis[N],maxp[N],size[N];
inline void getrt(Re x,Re fa){
	size[x]=1,maxp[x]=0;
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to]&&to!=fa)
			getrt(to,x),size[x]+=size[to],maxp[x]=max(maxp[x],size[to]);
	maxp[x]=max(maxp[x],sum-size[x]);
	if(maxp[x]<maxp[rt])rt=x;
}
inline void sakura(Re x,Re Fa){
	Re now=sum;vis[x]=1,fa[x]=Fa;
	TR1[x].build(now/2+1),TR2[x].build(now+1);
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to])
			sum=size[to]>size[x]?now-size[x]:size[to],maxp[rt=0]=inf,getrt(to,0),sakura(rt,x);
}
inline void change(Re x,Re v){
	TR1[x].add(0,v);//subtree(x)
	for(Re i=x;fa[i];i=fa[i]){
		Re tmp=Dis(x,fa[i]);
		TR1[fa[i]].add(tmp,v);
		TR2[i].add(tmp,v);
	}
}
inline int ask(Re x,Re K){
	Re ans=TR1[x].ask(K);//subtree(x)
	for(Re i=x;fa[i];i=fa[i]){
		Re tmp=Dis(x,fa[i]);if(tmp>K)continue;
		ans+=TR1[fa[i]].ask(K-tmp);
		ans-=TR2[i].ask(K-tmp);
	}
	return ans;
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T),m=n-1;
	for(Re i=1;i<=n;++i)in(A[i]);
	while(m--)in(x),in(y),add(x,y),add(y,x);
	T1.build(),sum=n,maxp[rt=0]=inf,getrt(1,0),sakura(rt,0);
	for(Re i=1;i<=n;++i)change(i,A[i]);
	while(T--){
		in(op),in(x),in(y),x^=lastans,y^=lastans;
		if(op)change(x,y-A[x]),A[x]=y;
		else printf("%d\n",lastans=ask(x,y));
	}
}

```

**点分树-在线求原树距离-Seg** *(求距离小于等于K的点权值之和 震波)*

> 【点分树-在线求原树距离-Seg（求距离小于等于K的点权值之和 震波）】
点分治/边分治模板，用于树上路径统计问题。

核心函数：
  void add(Re x,Re y) — 加法更新
  void in(Re &x) — 核心算法函数
  void dfs1(Re x,Re Fa) — 深度优先搜索遍历
  void dfs2(Re x,Re rt) — 深度优先搜索遍历
  void build(无参数) — 构建数据结构（建树/建图）
  int lca(Re x,Re y) — 查询最近公共祖先
  int Dis(Re x,Re y) — 核心算法函数
  void change(Re &p,Re L,Re R,Re x,Re v) — 核心算法函数

核心结构体：QAQ, LCA, Segment_Tree, QAQ

关键配置：
N=1e5+3,inf=2e9,logN=17

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=1e5+3,inf=2e9,logN=17;
int n,m,o,x,y,T,op,lastans,A[N],deep[N],head[N];
struct QAQ{int to,next;}a[N<<1];
inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct LCA{
	int fa[N],top[N],son[N],size[N];
	inline void dfs1(Re x,Re Fa){
		size[x]=1,deep[x]=deep[fa[x]=Fa]+1;
		for(Re i=head[x],to;i;i=a[i].next)
			if((to=a[i].to)!=Fa){
				dfs1(to,x),size[x]+=size[to];
				if(size[son[x]]<size[to])son[x]=to;
			}
	}
	inline void dfs2(Re x,Re rt){
		top[x]=rt;
		if(!son[x])return;
		dfs2(son[x],rt);
		for(Re i=head[x],to;i;i=a[i].next)
			if((to=a[i].to)!=fa[x]&&to!=son[x])dfs2(to,to);
	}
	inline void build(){dfs1(1,0),dfs2(1,1);}
	inline int lca(Re x,Re y){
		while(top[x]!=top[y]){
			if(deep[top[x]]<deep[top[y]])swap(x,y);
			x=fa[top[x]];
		}
		if(deep[x]>deep[y])swap(x,y);
		return x;
	}
}T1;
inline int Dis(Re x,Re y){return deep[x]+deep[y]-(deep[T1.lca(x,y)]<<1);}
int pt[N<<1];
struct Segment_Tree{
	#define pl tr[p].lp
	#define pr tr[p].rp
	#define mid (L+R>>1)
	int O;
	struct QAQ{int S,lp,rp;}tr[N*60];
	inline void change(Re &p,Re L,Re R,Re x,Re v){
		if(!p)p=++O;
		if(L==R){tr[p].S+=v;return;}
		if(x<=mid)change(pl,L,mid,x,v);
		else change(pr,mid+1,R,x,v);
		tr[p].S=tr[pl].S+tr[pr].S;
	}
	inline int ask(Re p,Re L,Re R,Re l,Re r){
		if(!p)return 0;
		if(l<=L&&R<=r)return tr[p].S;
		Re ans=0;
		if(l<=mid)ans+=ask(pl,L,mid,l,r);
		if(r>mid)ans+=ask(pr,mid+1,R,l,r);
		return ans;
	}
}TR;
int rt,sum,fa[N],vis[N],maxp[N],size[N];
inline void getrt(Re x,Re fa){
	size[x]=1,maxp[x]=0;
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to]&&to!=fa)
			getrt(to,x),size[x]+=size[to],maxp[x]=max(maxp[x],size[to]);
	maxp[x]=max(maxp[x],sum-size[x]);
	if(maxp[x]<maxp[rt])rt=x;
}
inline void sakura(Re x,Re Fa){
	Re now=sum;vis[x]=1,fa[x]=Fa;
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to])
			sum=size[to]>size[x]?now-size[x]:size[to],maxp[rt=0]=inf,getrt(to,0),sakura(rt,x);
}
inline void change(Re x,Re v){
	TR.change(pt[x],0,n,0,v);
	for(Re i=x;fa[i];i=fa[i]){
		Re tmp=Dis(x,fa[i]);
		TR.change(pt[fa[i]],0,n,tmp,v);
		TR.change(pt[i+n],0,n,tmp,v);
	}
}
inline int ask(Re x,Re K){
	Re ans=TR.ask(pt[x],0,n,0,K);
	for(Re i=x;fa[i];i=fa[i]){
		Re tmp=Dis(x,fa[i]);if(tmp>K)continue;
		ans+=TR.ask(pt[fa[i]],0,n,0,K-tmp);
		ans-=TR.ask(pt[i+n],0,n,0,K-tmp);
	}
	return ans;
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T),m=n-1;
	for(Re i=1;i<=n;++i)in(A[i]);
	while(m--)in(x),in(y),add(x,y),add(y,x);
	T1.build(),sum=n,maxp[rt=0]=inf,getrt(1,0),sakura(rt,0);
	for(Re i=1;i<=n;++i)change(i,A[i]);
	while(T--){
		in(op),in(x),in(y),x^=lastans,y^=lastans;
		if(op)change(x,y-A[x]),A[x]=y;
		else printf("%d\n",lastans=ask(x,y));
	}
}

```

**点分树-预处理原树距离-BIT** *(求距离小于等于K的点权值之和 震波)*

> 【点分树-预处理原树距离-BIT（求距离小于等于K的点权值之和 震波）】
点分治/边分治模板，用于树上路径统计问题。

核心函数：
  void add(Re x,Re y) — 加法更新
  void in(Re &x) — 核心算法函数
  void build(Re N) — 构建数据结构（建树/建图）
  void add(Re x,Re v) — 加法更新
  int ask(Re x) — 核心算法函数
  void getrt(Re x,Re fa) — 获取值
  void getdis(Re x,Re rt,Re fa,Re d) — 获取值
  void sakura(Re x) — 后缀数组

核心结构体：QAQ, BIT

关键配置：
N=1e5+3,inf=2e9,logN=17

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<vector>
#define LL long long
#define Re register int
using namespace std;
const int N=1e5+3,inf=2e9,logN=17;
int n,m,o,x,y,T,op,lastans,A[N],head[N];
struct QAQ{int to,next;}a[N<<1];
inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct BIT{
	int n;vector<int>C;
	inline void build(Re N){C.resize((n=N)+1);}
	inline void add(Re x,Re v){++x;while(x<=n)C[x]+=v,x+=x&-x;}
	inline int ask(Re x){++x,x=min(x,n);Re ans=0;while(x)ans+=C[x],x-=x&-x;return ans;}
}TR1[N],TR2[N];
int rt,sum,gs[N],vis[N],maxp[N],size[N],frt[N][20],fdis[N][20];
inline void getrt(Re x,Re fa){
	size[x]=1,maxp[x]=0;
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to]&&to!=fa)
			getrt(to,x),size[x]+=size[to],maxp[x]=max(maxp[x],size[to]);
	maxp[x]=max(maxp[x],sum-size[x]);
	if(maxp[x]<maxp[rt])rt=x;
}
inline void getdis(Re x,Re rt,Re fa,Re d){
	frt[x][++gs[x]]=rt,fdis[x][gs[x]]=d;
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to]&&to!=fa)getdis(to,rt,x,d+1);
}
inline void sakura(Re x){
	Re now=sum;vis[x]=1,getdis(x,x,0,0);
	TR1[x].build(now/2+1),TR2[x].build(now+1);
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to])
			sum=size[to]>size[x]?now-size[x]:size[to],maxp[rt=0]=inf,getrt(to,0),sakura(rt);
}
inline void change(Re x,Re v){
	TR1[x].add(0,v);//subtree(x)
	for(Re i=gs[x];i>=2;--i){
		Re tmp=fdis[x][i-1];
		TR1[frt[x][i-1]].add(tmp,v);
		TR2[frt[x][i]].add(tmp,v);
	}
}
inline int ask(Re x,Re K){
	Re ans=TR1[x].ask(K);//subtree(x)
	for(Re i=gs[x];i>=2;--i){
		Re tmp=fdis[x][i-1];if(tmp>K)continue;
		ans+=TR1[frt[x][i-1]].ask(K-tmp);
		ans-=TR2[frt[x][i]].ask(K-tmp);
	}
	return ans;
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T),m=n-1;
	for(Re i=1;i<=n;++i)in(A[i]);
	while(m--)in(x),in(y),add(x,y),add(y,x);
	sum=n,maxp[rt=0]=inf,getrt(1,0),sakura(rt);
	for(Re i=1;i<=n;++i)change(i,A[i]);
	while(T--){
		in(op),in(x),in(y),x^=lastans,y^=lastans;
		if(op)change(x,y-A[x]),A[x]=y;
		else printf("%d\n",lastans=ask(x,y));
	}
}

```

**点分树-预处理原树距离-Seg** *(求距离小于等于K的点权值之和 震波)*

> 【点分树-预处理原树距离-Seg（求距离小于等于K的点权值之和 震波）】
点分治/边分治模板，用于树上路径统计问题。

核心函数：
  void add(Re x,Re y) — 加法更新
  void in(Re &x) — 核心算法函数
  void change(Re &p,Re L,Re R,Re x,Re v) — 核心算法函数
  int ask(Re p,Re L,Re R,Re l,Re r) — 核心算法函数
  void getrt(Re x,Re fa) — 获取值
  void getdis(Re x,Re rt,Re fa,Re d) — 获取值
  void sakura(Re x) — 后缀数组
  void change(Re x,Re v) — 核心算法函数

核心结构体：QAQ, Segment_Tree, QAQ

关键配置：
N=1e5+3,inf=2e9,logN=17

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=1e5+3,inf=2e9,logN=17;
int n,m,o,x,y,T,op,lastans,A[N],head[N];
struct QAQ{int to,next;}a[N<<1];
inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
int pt[N<<1];
struct Segment_Tree{
	#define pl tr[p].lp
	#define pr tr[p].rp
	#define mid (L+R>>1)
	int O;
	struct QAQ{int S,lp,rp;}tr[N*60];
	inline void change(Re &p,Re L,Re R,Re x,Re v){
		if(!p)p=++O;
		if(L==R){tr[p].S+=v;return;}
		if(x<=mid)change(pl,L,mid,x,v);
		else change(pr,mid+1,R,x,v);
		tr[p].S=tr[pl].S+tr[pr].S;
	}
	inline int ask(Re p,Re L,Re R,Re l,Re r){
		if(!p)return 0;
		if(l<=L&&R<=r)return tr[p].S;
		Re ans=0;
		if(l<=mid)ans+=ask(pl,L,mid,l,r);
		if(r>mid)ans+=ask(pr,mid+1,R,l,r);
		return ans;
	}
}TR;
int rt,sum,gs[N],vis[N],maxp[N],size[N],frt[N][20],fdis[N][20];
inline void getrt(Re x,Re fa){
	size[x]=1,maxp[x]=0;
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to]&&to!=fa)
			getrt(to,x),size[x]+=size[to],maxp[x]=max(maxp[x],size[to]);
	maxp[x]=max(maxp[x],sum-size[x]);
	if(maxp[x]<maxp[rt])rt=x;
}
inline void getdis(Re x,Re rt,Re fa,Re d){
	frt[x][++gs[x]]=rt,fdis[x][gs[x]]=d;
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to]&&to!=fa)getdis(to,rt,x,d+1);
}
inline void sakura(Re x){
	Re now=sum;vis[x]=1,getdis(x,x,0,0);
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to])
			sum=size[to]>size[x]?now-size[x]:size[to],maxp[rt=0]=inf,getrt(to,0),sakura(rt);
}
inline void change(Re x,Re v){
	TR.change(pt[x],0,n,0,v);
	for(Re i=gs[x];i>=2;--i){
		Re tmp=fdis[x][i-1];
		TR.change(pt[frt[x][i-1]],0,n,tmp,v);
		TR.change(pt[frt[x][i]+n],0,n,tmp,v);
	}
}
inline int ask(Re x,Re K){
	Re ans=TR.ask(pt[x],0,n,0,K);
	for(Re i=gs[x];i>=2;--i){
		Re tmp=fdis[x][i-1];if(tmp>K)continue;
		ans+=TR.ask(pt[frt[x][i-1]],0,n,0,K-tmp);
		ans-=TR.ask(pt[frt[x][i]+n],0,n,0,K-tmp);
	}
	return ans;
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T),m=n-1;
	for(Re i=1;i<=n;++i)in(A[i]);
	while(m--)in(x),in(y),add(x,y),add(y,x);
	sum=n,maxp[rt=0]=inf,getrt(1,0),sakura(rt);
	for(Re i=1;i<=n;++i)change(i,A[i]);
	while(T--){
		in(op),in(x),in(y),x^=lastans,y^=lastans;
		if(op)change(x,y-A[x]),A[x]=y;
		else printf("%d\n",lastans=ask(x,y));
	}
}

```

**点分治  (询问是否有长度等于K的路径)** *(分各子树求解)*

> 【点分治  (询问是否有长度等于K的路径)（分各子树求解）】
点分治/边分治模板，用于树上路径统计问题。

核心函数：
  void add(Re x,Re y,Re z) — 加法更新
  void in(Re &x) — 核心算法函数
  void getrt(Re x,Re fa) — 获取值
  void getdis(Re x,Re fa,Re w) — 获取值
  void calc(Re x) — 计算函数
  void sakura(Re x) — 后缀数组

核心结构体：QAQ

关键配置：
N=1e4+3,M=103,INF=1e7+3,inf=2e9

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=1e4+3,M=103,INF=1e7+3,inf=2e9;
int n,m,o,x,y,z,T,maxK,K[M],Ans[M],head[N];
struct QAQ{int w,to,next;}a[N<<1];
inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
int rt,sum,dd[N],vis[N],tmp[N],dis[N],maxp[N],size[N];bool judge[INF];
inline void getrt(Re x,Re fa){
	size[x]=1,maxp[x]=0;
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to]&&to!=fa)
			getrt(to,x),size[x]+=size[to],maxp[x]=max(maxp[x],size[to]);
	maxp[x]=max(maxp[x],sum-size[x]);
	if(maxp[x]<maxp[rt])rt=x;
}
inline void getdis(Re x,Re fa,Re w){
	if(dis[fa]+w>maxK)return;
	dd[++dd[0]]=dis[x]=dis[fa]+w;
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to]&&to!=fa)getdis(to,x,a[i].w);
}
inline void calc(Re x){
	tmp[0]=0,judge[tmp[++tmp[0]]=0]=1;
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to]){
			dis[x]=dd[0]=0,getdis(to,x,a[i].w);
			for(Re j=1;j<=dd[0];++j)
				for(Re k=1;k<=T;++k)
					if(K[k]>=dd[j])Ans[k]|=judge[K[k]-dd[j]];
			for(Re j=1;j<=dd[0];++j)judge[tmp[++tmp[0]]=dd[j]]=1;
		}
	for(Re i=1;i<=tmp[0];++i)judge[tmp[i]]=0;
}
inline void sakura(Re x){
	Re now=sum;vis[x]=1,calc(x);
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to])
			sum=size[to]>size[x]?now-size[x]:size[to],maxp[rt=0]=inf,getrt(to,x),sakura(rt);
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T),m=n-1;
	while(m--)in(x),in(y),in(z),add(x,y,z),add(y,x,z);
	for(Re i=1;i<=T;++i)in(K[i]),maxK=max(maxK,K[i]);
	sum=n,maxp[rt=0]=inf,getrt(1,0),sakura(rt);
	for(Re i=1;i<=T;++i)puts(Ans[i]?"AYE":"NAY");
}

```

**点分治  (长度小于等于K的路径数 Tree)** *(容斥)*

> 【点分治  (长度小于等于K的路径数 Tree)（容斥）】
点分治/边分治模板，用于树上路径统计问题。

核心函数：
  void add(Re x,Re y,Re z) — 加法更新
  void in(Re &x) — 核心算法函数
  void getrt(Re x,Re fa) — 获取值
  void getdis(Re x,Re fa,Re w) — 获取值
  int calc(Re x,Re d) — 计算函数
  void sakura(Re x) — 后缀数组

核心结构体：QAQ

关键配置：
N=4e4+3,inf=2e9

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=4e4+3,inf=2e9;
int n,m,o,x,y,z,K,head[N];LL Ans;
struct QAQ{int w,to,next;}a[N<<1];
inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
int rt,sum,cnt,tmp[N],dis[N],vis[N],maxp[N],size[N];
inline void getrt(Re x,Re fa){
	size[x]=1,maxp[x]=0;
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to]&&to!=fa)
			getrt(to,x),size[x]+=size[to],maxp[x]=max(maxp[x],size[to]);
	maxp[x]=max(maxp[x],sum-size[x]);
	if(maxp[x]<maxp[rt])rt=x;
}
inline void getdis(Re x,Re fa,Re w){
	if(dis[fa]+w>K)return;
	tmp[++cnt]=dis[x]=dis[fa]+w;
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to]&&to!=fa)getdis(to,x,a[i].w);
}
inline int calc(Re x,Re d){
	Re ans=0;cnt=0,tmp[++cnt]=dis[x]=d;
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to])getdis(to,x,a[i].w);
	sort(tmp+1,tmp+cnt+1);
	Re R=cnt;
	for(Re i=1;i<=cnt&&i<R;++i){
		while(i<R&tmp[i]+tmp[R]>K)--R;
		if(i<R)ans+=(R-(i+1)+1);
	}
	return ans;
}
inline void sakura(Re x){
	Re now=sum;vis[x]=1,Ans+=calc(x,0);
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to])
			Ans-=calc(to,a[i].w),sum=size[to]>size[x]?now-size[x]:size[to],maxp[rt=0]=inf,getrt(to,x),sakura(rt);
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),m=n-1;
	while(m--)in(x),in(y),in(z),add(x,y,z),add(y,x,z);
	in(K);
	sum=n,maxp[rt=0]=inf,getrt(1,0),sakura(rt);
	printf("%lld\n",Ans);
}

```

**幻想乡战略游戏** *(点分树)*

> 【幻想乡战略游戏（点分树）】
树上问题算法模板。

核心函数：
  void add(Re x,Re y,Re z) — 加法更新
  void in(Re &x) — 核心算法函数
  void add(Re x,Re y,Re z) — 加法更新
  void getrt(Re x,Re fa) — 获取值
  void getdis(Re x,Re rt,Re fa,Re d) — 获取值
  void sakura(Re x) — 后缀数组
  void change(Re x,Re v) — 核心算法函数
  LL ask(Re x) — 核心算法函数

核心结构体：QAQ, TREE, QAQ

关键配置：
N=1e5+3,inf=2e9

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<vector>
#define LL long long
#define Re register int
using namespace std;
const int N=1e5+3,inf=2e9;
int n,m,o,x,y,z,T,root,A[N],head[N];
struct QAQ{int w,to,next;}a[N<<1];
inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct TREE{
	int o,head[N];
	struct QAQ{int rt,to,next;}a[N];
	inline void add(Re x,Re y,Re z){a[++o].rt=z,a[o].to=y,a[o].next=head[x],head[x]=o;}
}T0;
int rt,sum,Sv[N],gs[N],vis[N],size[N],maxp[N],frt[N][20],fdis[N][20];LL Sdv1[N],Sdv2[N];
inline void getrt(Re x,Re fa){
	size[x]=1,maxp[x]=0;
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to]&&to!=fa)
			getrt(to,x),size[x]+=size[to],maxp[x]=max(maxp[x],size[to]);
	maxp[x]=max(maxp[x],sum-size[x]);
	if(maxp[x]<maxp[rt])rt=x;
}
inline void getdis(Re x,Re rt,Re fa,Re d){
	if(x!=rt)frt[x][++gs[x]]=rt,fdis[x][gs[x]]=d;
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to]&&to!=fa)getdis(to,rt,x,d+a[i].w);
}
inline void sakura(Re x){
	Re now=sum;vis[x]=1,getdis(x,x,0,0);
	for(Re i=head[x],to;i;i=a[i].next)
		if(!vis[to=a[i].to])
			sum=size[to]>size[x]?now-size[x]:size[to],maxp[rt=0]=inf,getrt(to,0),T0.add(x,to,rt),sakura(rt);
}
inline void change(Re x,Re v){
	Sdv1[x]+=v*0,Sv[x]+=v;
	for(Re i=gs[x];i>=2;--i){
		Re tmp=fdis[x][i-1];
		Sdv1[frt[x][i-1]]+=(LL)v*tmp;
		Sdv2[frt[x][i]]+=(LL)v*tmp;
		Sv[frt[x][i-1]]+=v;
	}
}
inline LL ask(Re x){
	LL ans=Sdv1[x];
	for(Re i=gs[x];i>=2;--i){
		Re tmp=fdis[x][i-1];
		ans+=Sdv1[frt[x][i-1]];
		ans-=Sdv2[frt[x][i]];
		ans+=(LL)(Sv[frt[x][i-1]]-Sv[frt[x][i]])*tmp;
	}
	return ans;
}
inline LL find(Re x){
	LL tmp=ask(x);
	for(Re i=T0.head[x];i;i=T0.a[i].next)
		if(ask(T0.a[i].to)<tmp)return find(T0.a[i].rt);
	return tmp;
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T),m=n-1;
	while(m--)in(x),in(y),in(z),add(x,y,z),add(y,x,z);
	sum=n,maxp[rt=0]=inf,getrt(1,0),sakura(root=rt);
	for(Re i=1;i<=n;++i)frt[i][++gs[i]]=i;
	while(T--)in(x),in(y),change(x,y),printf("%lld\n",find(root));
}

```

### 4.4 Kruskal重构树

**Kruskal 重构树** *(KruskalReconstructionTree)*

> 【Kruskal 重构树（Kruskal Reconstruction Tree）】
▪ KruskalReconstructionTree — 结构体封装：
  — n（原图节点数）、tot（重构树总节点数 = 2N-1）
  — g[][]（树邻接表）、val[]（节点权值，叶子为 0，虚拟节点为合并时的边权）
  — build(edges) — 按边权排序后 Kruskal 建树：每次合并 u,v 时新建节点 tot，权值为边权，将 u,v 所在连通块的根作为 tot 的子节点
  — lca(u, v) — 查询 u,v 在重构树上的 LCA，其权值即为原图 u↔v 路径上最大边权的最小值
适用于瓶颈路径问题（最小化路径最大边权），可将瓶颈查询转化为 LCA 查询。

```cpp
struct KruskalReconstructionTree {
    int n;                      // 原图节点数
    int tot;                    // 重构树总节点数
    vector<vector<int>> g;      // 树邻接表
    vector<int> val;            // 节点权值 (原节点 -1)
    vector<int> parent;         // 父节点
    vector<int> dsu;            // 并查集

    static const int LOG = 20;  // 倍增 LCA 参数
    vector<int> depth;
    vector<vector<int>> up;

    KruskalReconstructionTree(int n_) : n(n_) {
        tot = n;
        g.resize(2 * n);
        val.resize(2 * n);
        parent.assign(2 * n, -1);
        dsu.resize(2 * n);
        iota(dsu.begin(), dsu.end(), 0);
        for (int i = 0; i < n; i++) val[i] = -1;
        depth.resize(2 * n);
    }

    int find(int x) {
        while (dsu[x] != x) dsu[x] = dsu[dsu[x]], x = dsu[x];
        return x;
    }

    // 构建重构树。edges: {u,v,w}
    void build(vector<tuple<int, int, int>> edges, bool sorted = false) {
        if (!sorted) {
            sort(edges.begin(), edges.end(),
                 [](const auto &a, const auto &b) {
                     return get<2>(a) > get<2>(b); // 最大瓶颈路
                 });
        }
        for (auto &[u, v, w] : edges) {
            int ru = find(u), rv = find(v);
            if (ru == rv) continue;
            int node = tot++;
            val[node] = w;
            g[node].push_back(ru);
            g[node].push_back(rv);
            parent[ru] = parent[rv] = node;
            dsu[ru] = dsu[rv] = node;
            dsu[node] = node;
            if (tot >= (int)g.size()) {
                g.resize(tot + 5);
                val.resize(tot + 5);
                parent.resize(tot + 5);
                depth.resize(tot + 5);
            }
        }
        g.resize(tot);
        val.resize(tot);
        parent.resize(tot);
        // 建立倍增表
        initLCA();
    }

    void initLCA() {
        depth.assign(tot, 0);
        up.assign(tot, vector<int>(LOG, -1));
        for (int i = 0; i < tot; i++)
            if (parent[i] == -1) dfs(i, -1);
    }

    void dfs(int u, int p) {
        up[u][0] = p;
        for (int j = 1; j < LOG; j++) {
            if (up[u][j - 1] != -1)
                up[u][j] = up[up[u][j - 1]][j - 1];
            else
                up[u][j] = -1;
        }
        for (int v : g[u]) {
            if (v == p) continue;
            depth[v] = depth[u] + 1;
            dfs(v, u);
        }
    }

    // 查询 u, v 的 LCA
    int lca(int u, int v) {
        if (depth[u] < depth[v]) swap(u, v);
        int diff = depth[u] - depth[v];
        for (int j = 0; j < LOG; j++) {
            if (diff >> j & 1) u = up[u][j];
        }
        if (u == v) return u;
        for (int j = LOG - 1; j >= 0; j--) {
            if (up[u][j] != up[v][j]) {
                u = up[u][j];
                v = up[v][j];
            }
        }
        return up[u][0];
    }

    // 查询原图 u->v 瓶颈路（最小边权的最大值）
    int queryMaxEdgeMin(int u, int v) {
        int w = lca(u, v);
        if (w == -1) return -1;
        return val[w];
    }

    // 从 s 出发，仅走边权 ≤ lim 的边能到达的所有节点
    vector<int> queryReachable(int s, int lim) {
        int u = s;
        for (int j = LOG - 1; j >= 0; j--)
            if (up[u][j] != -1 && val[up[u][j]] <= lim)
                u = up[u][j];
        vector<int> res;
        collectLeaves(u, -1, res);
        return res;
    }

    // 从 s 出发，仅走边权 ≥ lim 的边能到达的所有节点（需降序构建）
    vector<int> queryReachableMin(int s, int lim) {
        int u = s;
        for (int j = LOG - 1; j >= 0; j--)
            if (up[u][j] != -1 && val[up[u][j]] >= lim)
                u = up[u][j];
        vector<int> res;
        collectLeaves(u, -1, res);
        return res;
    }

    // 收集子树中所有原图节点
    void collectLeaves(int u, int p, vector<int> &out) {
        if (u < n) { out.push_back(u); return; }
        for (int v : g[u]) if (v != p) collectLeaves(v, u, out);
    }
};
```

### 4.5 树形DP

**Crash的文明世界** *(树形dp)*

> 【Crash的文明世界（树形dp）】
树形 DP 模板，在树上进行 DFS 递推动态规划。

核心函数：
  void add(Re x,Re y) — 加法更新
  void in(Re &x) — 核心算法函数
  void dfs1(Re x,Re fa) — 深度优先搜索遍历
  void dfs2(Re x,Re fa) — 深度优先搜索遍历
  void Stirling(Re N) — 核心算法函数

核心结构体：QAQ

关键配置：
N=5e4+3,M=153,P=10007

复杂度：时间复杂度取决于状态数和转移复杂度

说明：freopen("123.txt","r",stdin);

适用场景：树上的最优化问题（最大独立集、最小支配集、直径等）

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=5e4+3,M=153,P=10007;
int n,m,x,y,o,K,jc[M],fto[M],head[N],S[M][M],f[N][M],g[N][M];
struct QAQ{int to,next;}a[N<<1];
inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int dp=0;x=0;char c=getchar();
    while(c<'0'||c>'9')dp|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=dp?-x:x;
}
inline void dfs1(Re x,Re fa){
	f[x][0]=1;
	for(Re i=head[x],to;i;i=a[i].next)
		if((to=a[i].to)!=fa){
			dfs1(to,x),(f[x][0]+=f[to][0])%=P;
			for(Re j=1;j<=K;++j)(f[x][j]+=(f[to][j]+f[to][j-1])%P)%=P;
		}
}
inline void dfs2(Re x,Re fa){
	if(fa){
		fto[0]=(g[fa][0]+f[fa][0]-f[x][0]+P)%P;
		for(Re j=1;j<=K;++j)fto[j]=(g[fa][j]+f[fa][j]-(f[x][j]+f[x][j-1])%P+P)%P;
		g[x][0]=fto[0];
		for(Re j=1;j<=K;++j)g[x][j]=(fto[j]+fto[j-1])%P;
	}
	for(Re i=head[x],to;i;i=a[i].next)
		if((to=a[i].to)!=fa)dfs2(to,x);
}
inline void Stirling(Re N){
	for(Re i=0;i<=N;++i)S[i][i]=1;
	for(Re i=1;i<=N;++i)
		for(Re j=1;j<i;++j)
			S[j][i]=(S[j-1][i-1]+j*S[j][i-1]%P)%P;
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(K),m=n-1;
	while(m--)in(x),in(y),add(x,y),add(y,x);
	dfs1(1,0),dfs2(1,0),Stirling(K),jc[0]=1;
	for(Re i=1;i<=K;++i)jc[i]=jc[i-1]*i%P;
	for(Re i=1;i<=n;++i){
		Re ans=0;
		for(Re j=0;j<=K;++j)
			(ans+=S[j][K]*jc[j]%P*(f[i][j]+g[i][j])%P)%=P;
		printf("%d\n",ans);
	}
}

```

**换根dp** *(Great Cow Gathering)*

> 【换根dp（Great Cow Gathering）】
树形 DP 模板，在树上进行 DFS 递推动态规划。

核心函数：
  void add(Re x,Re y,Re z) — 加法更新
  void in(Re &x) — 核心算法函数
  void dfs1(Re x,Re fa) — 深度优先搜索遍历
  void dfs2(Re x,Re fa) — 深度优先搜索遍历

核心结构体：QAQ

复杂度：时间复杂度取决于状态数和转移复杂度

说明：freopen("123.txt","r",stdin);

适用场景：树上的最优化问题（最大独立集、最小支配集、直径等）

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const LL N=1e5+3,inf=1e18;
int n,m,x,y,z,o,A[N],S[N],dis[N],size[N],head[N];LL ans=inf,f[N],g[N];
struct QAQ{int w,to,next;}a[N<<1];
inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void dfs1(Re x,Re fa){
	size[x]=1,S[x]=A[x];
	for(Re i=head[x],to;i;i=a[i].next)if((to=a[i].to)!=fa)
		dis[to]=a[i].w,dfs1(to,x),S[x]+=S[to],size[x]+=size[to],f[x]+=f[to]+(LL)S[to]*a[i].w;
}
inline void dfs2(Re x,Re fa){
	if(fa)g[x]=g[fa]+f[fa]-f[x]-(LL)S[x]*dis[x]+(LL)(S[1]-S[x])*dis[x];
	for(Re i=head[x],to;i;i=a[i].next)if((to=a[i].to)!=fa)dfs2(to,x);
	ans=min(ans,f[x]+g[x]);
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),m=n-1;
	for(Re i=1;i<=n;++i)in(A[i]);
	while(m--)in(x),in(y),in(z),add(x,y,z),add(y,x,z);
	dfs1(1,0),dfs2(1,0),printf("%lld\n",ans);
}

```

**树形dp** *(没有上司的舞会)*

> 【树形dp（没有上司的舞会）】
树形 DP 模板，在树上进行 DFS 递推动态规划。

核心函数：
  void add(int x,int y) — 加法更新
  void dfs(int w) — 深度优先搜索遍历

核心结构体：QAQ

复杂度：时间复杂度取决于状态数和转移复杂度

适用场景：树上的最优化问题（最大独立集、最小支配集、直径等）

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define R register int
using namespace std;
int head[6010],a,b,t,i,j,n,f[6010][2],pan[6010];
struct QAQ{int next,to;}Q[6010];
inline void add(int x,int y){Q[++t].to=y,Q[t].next=head[x],head[x]=t;}
inline void dfs(int w){
    for(R k=head[w];k;k=Q[k].next){
        int to=Q[k].to;
        dfs(to);
        f[w][0]+=max(f[to][0],f[to][1]);
        f[w][1]+=f[to][0];
    }
}
int main(){
    scanf("%d",&n);
    for(i=1;i<=n;i++)scanf("%d",&f[i][1]);
    for(i=1;i<n;i++)scanf("%d%d",&a,&b),pan[a]++,add(b,a);
    for(i=1;i<=n;i++)
        if(!pan[i]){
            dfs(i);
            printf("%d\n",max(f[i][0],f[i][1]));
            return 0;
        }
}

```

**保安站岗，皇宫看守** *(树形dp)*

> 【保安站岗，皇宫看守（树形dp）】
树形 DP 模板，在树上进行 DFS 递推动态规划。

核心函数：
  void add(int x,int y) — 加法更新
  void dfs(int x) — 深度优先搜索遍历

核心结构体：QAQ

复杂度：时间复杂度取决于状态数和转移复杂度

适用场景：树上的最优化问题（最大独立集、最小支配集、直径等）

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define R register int
using namespace std;
struct QAQ{int to,next;}a[1505]; 
int m,pan[1505],n,t,w[1505],dp[1505][3],head[1505];
inline void add(int x,int y){a[++t].to=y,a[t].next=head[x],head[x]=t;}
  //dp[i][0] 以及各种情况的具体转移方程和初始状态 
inline void dfs(int x){
    R i,to,dd=0xfffffff;
    dp[x][1]=w[x];dp[x][2]=0;dp[x][0]=0;
    for(i=head[x];i;i=a[i].next){
        dfs(to=a[i].to);
        dd=min(dd,dp[to][1]-min(dp[to][0],dp[to][1]));
        dp[x][0]+=min(dp[to][0],dp[to][1]);
        dp[x][1]+=min(dp[to][1],dp[to][2]);
        dp[x][2]+=min(dp[to][0],dp[to][1]);
    }
    dp[x][0]+=dd;
}
int main(){
	memset(dp,127,sizeof(dp));
    scanf("%d",&n);
    R i,j,a,k,r;
    for(i=1;i<=n;i++){
        scanf("%d%d%d",&a,&k,&m);w[a]=k;
        for(j=1;j<=m;j++)scanf("%d",&r),pan[r]=1,add(a,r);
    }
    for(i=1;i<=n;i++)
        if(!pan[i]){
            dfs(i);
            printf("%d",min(dp[i][1],dp[i][0]));
            return 0;
        }
}

```

**树上背包优化O复杂度 (NOI Online 2 游戏)** *(nk)*

> 【树上背包优化O复杂度 (NOI Online 2 游戏)（nk）】
树形 DP 模板，在树上进行 DFS 递推动态规划。

核心函数：
  void add(Re x,Re y) — 加法更新
  void in(Re &x) — 核心算法函数
  int mi(Re x,Re k) — 核心算法函数
  int inv(Re x) — 求模逆元
  void dfs0(Re x,Re fa) — 深度优先搜索遍历
  void dfs(Re x,Re fa) — 深度优先搜索遍历
  int C(Re m,Re n) — 核心算法函数

核心结构体：QAQ

关键配置：
N=5003,P=998244353

复杂度：时间复杂度取决于状态数和转移复杂度

适用场景：树上的最优化问题（最大独立集、最小支配集、直径等）

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=5003,P=998244353;
int n,m,o,x,y,f[N],g[N],A[N],jc[N],head[N];char s[N];
struct QAQ{int to,next;}a[N<<1];
inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline int mi(Re x,Re k){
	Re s=1;
	while(k){
		if(k&1)s=(LL)s*x%P;
		x=(LL)x*x%P,k>>=1;
	}
	return s;
}
inline int inv(Re x){return mi(x,P-2);}
int sz1[N],sz0[N],lim[N],dp[N][N],tmp[N];
inline void dfs0(Re x,Re fa){
	sz0[x]=(!A[x]),sz1[x]=A[x];
	for(Re i=head[x],to;i;i=a[i].next)
		if((to=a[i].to)!=fa)dfs0(to,x),sz1[x]+=sz1[to],sz0[x]+=sz0[to];
//	lim[x]=min(sz1[x],size[x]-sz1[x]);
}
inline void dfs(Re x,Re fa){
	dp[x][0]=1;
	for(Re i=head[x],to;i;i=a[i].next)
		if((to=a[i].to)!=fa){
			dfs(to,x);
			for(Re j=0;j<=lim[x]+lim[to];++j)tmp[j]=0;
			for(Re j=lim[x];j>=0;--j)
				for(Re k=lim[to];k>=0;--k)
					(tmp[j+k]+=(LL)dp[x][j]*dp[to][k]%P)%=P;
			lim[x]+=lim[to];
			for(Re j=0;j<=lim[x];++j)dp[x][j]=tmp[j];
		}
	++lim[x];
	if(A[x])for(Re j=min(lim[x],sz0[x]);j>=1;--j)
		(dp[x][j]+=(LL)dp[x][j-1]*(sz0[x]-(j-1))%P)%=P;
	else for(Re j=min(lim[x],sz1[x]);j>=1;--j)
		(dp[x][j]+=(LL)dp[x][j-1]*(sz1[x]-(j-1))%P)%=P;
	while(!dp[x][lim[x]])--lim[x];
}
inline int C(Re m,Re n){return (LL)jc[n]*inv(jc[m])%P*inv(jc[n-m])%P;}
int main(){
//	freopen("match.in","r",stdin);
//	freopen("match.out","w",stdout);
	in(n),scanf("%s",s+1),m=n-1,jc[0]=1;
	for(Re i=1;i<=n;++i)A[i]=s[i]-'0',jc[i]=(LL)jc[i-1]*i%P;
	while(m--)in(x),in(y),add(x,y),add(y,x);
	dfs0(1,0),dfs(1,0);
//	for(Re i=1;i<=n;++i)printf("lim[%d]=%d\n",i,lim[i]);
//	for(Re i=0;i<=n/2;++i)printf("dp[%d]=%d\n",i,dp[1][i]);
//	for(Re j=0;j<=lim[1];++j)printf("%d ",dp[1][j]);
	for(Re j=0;j<=lim[1];++j)g[j]=(LL)dp[1][j]*jc[n/2-j]%P;
	for(Re i=lim[1];i>=0;--i){
		f[i]=g[i];
		for(Re j=i+1;j<=lim[1];++j)f[i]=(f[i]-(LL)C(i,j)*f[j]%P+P)%P;
	}
	for(Re i=0;i<=n/2;++i)printf("%d\n",f[i]);
	fclose(stdin);
	fclose(stdout);
	return 0;
}

```

**树上背包优化O复杂度 (树上染色)** *(nk)*

> 【树上背包优化O复杂度 (树上染色)（nk）】
树形 DP 模板，在树上进行 DFS 递推动态规划。

核心函数：
  void add(Re x,Re y,Re z) — 加法更新
  void in(Re &x) — 核心算法函数
  void dfs(Re x,Re fa) — 深度优先搜索遍历

核心结构体：QAQ

关键配置：
N=2003

复杂度：时间复杂度取决于状态数和转移复杂度

说明：freopen("123.txt","r",stdin);

适用场景：树上的最优化问题（最大独立集、最小支配集、直径等）

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=2003;
int n,m,x,y,z,o,K,size[N],head[N];LL tmp[N],dp[N][N];
struct QAQ{int w,to,next;}a[N<<1];
inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void dfs(Re x,Re fa){
	size[x]=1,dp[x][0]=dp[x][1]=0;
	for(Re i=head[x],to;i;i=a[i].next)
		if((to=a[i].to)!=fa){
			dfs(to,x);
			for(Re j=0;j<=size[x]+size[to];++j)tmp[j]=dp[0][0];
			for(Re j=size[x];j>=0;--j)
				if(dp[x][j]>=0)for(Re k=size[to];k>=0;--k)
					if(dp[to][k]>=0)
						tmp[j+k]=max(tmp[j+k],dp[x][j]+dp[to][k]+
							(LL)a[i].w*((LL)k*(K-k)+(LL)(size[to]-k)*(n-size[to]-(K-k)))
						);
			size[x]+=size[to];
			for(Re j=0;j<=size[x];++j)dp[x][j]=tmp[j];
		}
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(K),m=n-1;
	while(m--)in(x),in(y),in(z),add(x,y,z),add(y,x,z);
	memset(dp,-20,sizeof(dp));
	dfs(1,0),printf("%lld\n",dp[1][K]);
}

```

## 5. 动态规划

### 5.1 DP优化

**二进制优化多重背包** *(宝物筛选)*

> 【二进制优化多重背包（宝物筛选）】
DP 优化模板，利用数据结构或数学性质加速状态转移。

核心函数：
  void in(Re &x) — 核心算法函数

关键配置：
N=103,M=4e4+3

复杂度：时间复杂度取决于状态数和转移复杂度

适用场景：加速DP转移，将O(N²)优化至O(N)/O(N log N)

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define Re register int
using namespace std;
const int N=103,M=4e4+3;
int n,m,x,y,z,V,ans,v[N*17],w[N*17],dp[M];
inline void in(Re &x){
	Re fu=0;x=0;char ch=getchar();
	while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=fu?-x:x;
}
int main(){
	in(m),in(V);
	memset(dp,-127,sizeof(dp));
	dp[0]=0;
	while(m--){
		in(x),in(y),in(z);Re p=1;
		while(z>=p)v[++n]=y*p,w[n]=x*p,z-=p,p<<=1;
		if(z)v[++n]=y*z,w[n]=x*z;
	}
	for(Re i=1;i<=n;++i)
		for(Re j=V;j>=v[i];--j)	
			dp[j]=max(dp[j],dp[j-v[i]]+w[i]);
	for(Re i=0;i<=V;++i)ans=max(ans,dp[i]);
	printf("%d\n",ans);
}

```

**单调队列优化多重背包** *(CodeVS 5429)*

> 【单调队列优化多重背包（CodeVS 5429）】
单调队列优化 DP 模板，滑动窗口维护转移最值。

核心函数：
  void in(Re &x) — 核心算法函数
  int max(Re a,Re b) — 核心算法函数
  int min(Re a,Re b) — 核心算法函数

关键配置：
N=7003,M=7003

复杂度：时间复杂度取决于状态数和转移复杂度

适用场景：加速DP转移，将O(N²)优化至O(N)/O(N log N)

```cpp
#include<cstdio>
#define Re register int
const int N=7003,M=7003;
int n,h,t,V,mp,tmp,v[N],w[N],c[N],Q[N],K[N],dp[M];
inline void in(Re &x){
	Re fu=0;x=0;char ch=getchar();
	while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=fu?-x:x;
}
inline int max(Re a,Re b){return a>b?a:b;}
inline int min(Re a,Re b){return a<b?a:b;}
int main(){
    in(n),in(V);
    for(Re i=1;i<=n;++i)in(v[i]),in(w[i]),in(c[i]);
    for(Re i=1;i<=n;++i)
    	for(Re r=0;r<v[i];++r){
    		h=1,t=0,mp=(V-r)/v[i];
    		for(Re p=0;p<=mp;++p){
    			tmp=dp[p*v[i]+r]-w[i]*p;
    			while(h<=t&&Q[t]<=tmp)--t;
    			Q[++t]=tmp,K[t]=p;
    			while(h<=t&&p-K[h]>min(c[i],V/v[i]))++h;
    			dp[p*v[i]+r]=max(dp[p*v[i]+r],Q[h]+p*w[i]);
			}
		}
    printf("%d",dp[V]);
}

```

**最长公共子序列** *(二分)*

> luogu-judger-enable-o2

```cpp
// luogu-judger-enable-o2
#include<bits/stdc++.h>
using namespace std;
int pan[100010],b[100010],f[100010],n,i,a,len=1,l,r,mid;
inline int in(){
    int x=0,fh=1;char c=getchar();
    while(c<'0'||c>'9')c=getchar();
    while(c>='0'&&c<='9')x=x*10+c-'0',c=getchar();
    return x*fh;
}
int main(){
    n=in();
    for(i=1;i<=n;i++)a=in(),pan[a]=i,f[i]=0xfffffff;
    for(i=1;i<=n;i++)a=in(),b[i]=pan[a];
    for(i=1;i<=n;i++)printf("%d ",b[i]);puts("");
    f[1]=b[1];
    for(i=2;i<=n;i++){
    	l=0;r=len;
    	if(b[i]>f[len])f[++len]=b[i];
    	else{
    		while(l<r){
    			mid=(l+r)/2;
    			if(f[mid]<b[i])l=mid+1;
    			else r=mid;
    		}
    		f[l]=min(b[i],f[l]);
    	}
    }
    for(i=1;i<=n;i++)printf("%d ",f[i]);puts("");
    printf("%d",len);
    return 0;
}

```

**基站选址** *(线段树优化)*

> 【基站选址（线段树优化）】
DP 优化模板，利用数据结构或数学性质加速状态转移。

核心函数：
  void in(Re &x) — 核心算法函数
  LL calc(Re j,Re i) — 计算函数
  void updata(Re p,LL v) — 核心算法函数
  void pushdown(Re p) — 下传懒标记
  void build(Re p,Re L,Re R) — 构建数据结构（建树/建图）
  void change(Re p,Re L,Re R,Re l,Re r,Re v) — 核心算法函数
  void change(Re p,Re L,Re R,Re x,Re v) — 核心算法函数
  LL ask(Re p,Re L,Re R,Re l,Re r) — 核心算法函数

核心结构体：Segment_Tree

复杂度：时间复杂度取决于状态数和转移复杂度

说明：freopen("123.txt","r",stdin);

适用场景：加速DP转移，将O(N²)优化至O(N)/O(N log N)

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<vector>
#define LL long long
#define Re register int
using namespace std;
const LL N=2e4+3,inf=1e18;
int n,K,L[N],R[N],D[N],C[N],W[N],S[N];LL ans=inf,dp[N];vector<int>V[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline LL calc(Re j,Re i){
	LL ans=0;
	for(Re k=j+1;k<i;++k)if(L[k]>j&&R[k]<i)ans+=W[k];
	return ans;
}
struct Segment_Tree{
	#define pl (p<<1)
	#define pr (p<<1|1)
	#define mid ((L+R)>>1)
	LL tr[N<<2],add[N<<2];
	inline void updata(Re p,LL v){tr[p]+=v,add[p]+=v;}
	inline void pushdown(Re p){
		if(add[p])updata(pl,add[p]),updata(pr,add[p]),add[p]=0;
	}
	inline void build(Re p,Re L,Re R){
		add[p]=0;
		if(L==R){tr[p]=dp[L];return;}
		build(pl,L,mid),build(pr,mid+1,R);
		tr[p]=min(tr[pl],tr[pr]);
	}
	inline void change(Re p,Re L,Re R,Re l,Re r,Re v){
		if(l<=L&&R<=r){updata(p,v);return;}
		pushdown(p);
		if(l<=mid)change(pl,L,mid,l,r,v);
		if(r>mid)change(pr,mid+1,R,l,r,v);
		tr[p]=min(tr[pl],tr[pr]);
	}
	inline void change(Re p,Re L,Re R,Re x,Re v){
		if(L==R){tr[p]+=v;return;}
		pushdown(p);
		if(x<=mid)change(pl,L,mid,x,v);
		else change(pr,mid+1,R,x,v);
		tr[p]=min(tr[pl],tr[pr]);
	}
	inline LL ask(Re p,Re L,Re R,Re l,Re r){
		if(l<=L&&R<=r)return tr[p];
		LL ans=inf;pushdown(p);
		if(l<=mid)ans=min(ans,ask(pl,L,mid,l,r));
		if(r>mid)ans=min(ans,ask(pr,mid+1,R,l,r));
		return ans; 
	}
	#undef mid
}TR;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(K);
	for(Re i=2;i<=n;++i)in(D[i]);
	for(Re i=1;i<=n;++i)in(C[i]);
	for(Re i=1;i<=n;++i){
		in(S[i]);
		Re l=1,r=i;
		while(l<r){
			Re mid=l+r>>1;
			if(D[mid]>=D[i]-S[i])r=mid;
			else l=mid+1;
		}
		L[i]=r;
		l=i,r=n;
		while(l<r){
			Re mid=l+r+1>>1;
			if(D[mid]<=D[i]+S[i])l=mid;
			else r=mid-1;
		}
		R[i]=l,V[R[i]].push_back(i);
	}
	for(Re i=1;i<=n;++i)in(W[i]);
	memset(dp,20,sizeof(dp));
	dp[0]=0,D[0]=-1e9,C[n+1]=0;
	for(Re k=1;k<=K;++k){
		TR.build(1,0,n);
		for(Re i=1;i<=n+1;++i){
			LL tmp=dp[i];
			dp[i]=min(dp[i],TR.ask(1,0,n,0,i-1)+C[i]);
			for(Re j=0,SZ=V[i].size();j<SZ;++j)TR.change(1,0,n,0,L[V[i][j]]-1,W[V[i][j]]);
			if(dp[i]!=tmp)TR.change(1,0,n,i,dp[i]-tmp);
		}
		ans=min(ans,dp[n+1]);
	}
	printf("%lld\n",ans);
}

```

**Yet Another Minimization Problem** *(分治套莫队)*

> 【Yet Another Minimization Problem（分治套莫队）】
DP 优化模板，利用数据结构或数学性质加速状态转移。

核心函数：
  void in(Re &x) — 核心算法函数
  LL calc(Re L,Re R) — 计算函数
  void sakura(Re l,Re r,Re L,Re R,Re k) — 后缀数组

核心结构体：MODUI

关键配置：
N=1e5+3,M=23

复杂度：时间复杂度取决于状态数和转移复杂度

说明：freopen("123.txt","r",stdin);

适用场景：加速DP转移，将O(N²)优化至O(N)/O(N log N)

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=1e5+3,M=23;
int n,K,A[N];LL dp[M][N];
inline void in(Re &x){
	int f=0;x=0;char ch=getchar();
	while(ch<'0'||ch>'9')f|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=f?-x:x;
}
struct MODUI{
	int nowL,nowR,cnt[N];LL ans;
	inline LL calc(Re L,Re R){
		while(nowR<R)++nowR,ans+=cnt[A[nowR]]++;
		while(nowL>L)--nowL,ans+=cnt[A[nowL]]++;
		while(nowR>R)ans-=--cnt[A[nowR]],--nowR;
		while(nowL<L)ans-=--cnt[A[nowL]],++nowL;
		return ans;
	}
}TR;
inline void sakura(Re l,Re r,Re L,Re R,Re k){
	if(l>r)return;Re mid=l+r>>1,w=0;LL tmp;
	for(Re j=L;j<=R&&j<mid;++j)
		if((tmp=dp[k-1][j]+TR.calc(j+1,mid))<=dp[k][mid])
			dp[k][mid]=tmp,w=j;
	sakura(l,mid-1,L,w,k),sakura(mid+1,r,w,R,k);
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(K);
	for(Re i=1;i<=n;++i)in(A[i]);
	memset(dp,19,sizeof(dp)),dp[0][0]=0;
	TR.nowL=1,TR.nowR=0;
	for(Re k=1;k<=K;++k)sakura(k,n,k-1,n-1,k);
	printf("%lld\n",dp[K][n]);
}

```

**[P5574]任务分配问题** *(分治套莫队套树状数组)*

> 【[P5574]任务分配问题（分治套莫队套树状数组）】
DP 优化模板，利用数据结构或数学性质加速状态转移。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re v) — 加法更新
  int ask(Re x) — 核心算法函数
  LL calc(Re L,Re R) — 计算函数
  void sakura(Re l,Re r,Re L,Re R,Re k) — 后缀数组

核心结构体：BIT

关键配置：
N=25003,M=27

复杂度：时间复杂度取决于状态数和转移复杂度

说明：freopen("123.txt","r",stdin);

适用场景：加速DP转移，将O(N²)优化至O(N)/O(N log N)

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=25003,M=27;
int n,K,A[N];LL dp[M][N];
inline void in(Re &x){
	int f=0;x=0;char ch=getchar();
	while(ch<'0'||ch>'9')f|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=f?-x:x;
}
struct BIT{
	int nowL,nowR,C[N];LL ans;
	inline void add(Re x,Re v){if(!x)return;while(x<=n)C[x]+=v,x+=x&-x;}
	inline int ask(Re x){Re ans=0;while(x)ans+=C[x],x-=x&-x;return ans;}
	inline LL calc(Re L,Re R){
		while(nowR<R)++nowR,ans+=ask(A[nowR]-1),add(A[nowR],1);
		while(nowL>L)--nowL,ans+=nowR-nowL-ask(A[nowL]),add(A[nowL],1);
		while(nowR>R)add(A[nowR],-1),ans-=ask(A[nowR]-1),--nowR;
		while(nowL<L)add(A[nowL],-1),ans-=nowR-nowL-ask(A[nowL]),++nowL;
		return ans;
	}
}TR;
inline void sakura(Re l,Re r,Re L,Re R,Re k){
	if(l>r)return;Re mid=l+r>>1,w=0;LL tmp;
	for(Re j=L;j<=R&&j<mid;++j)
		if((tmp=dp[k-1][j]+TR.calc(j+1,mid))<=dp[k][mid])
			dp[k][mid]=tmp,w=j;
	sakura(l,mid-1,L,w,k),sakura(mid+1,r,w,R,k);
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(K);
	for(Re i=1;i<=n;++i)in(A[i]);
	memset(dp,19,sizeof(dp)),dp[0][0]=0;
	TR.nowL=1,TR.nowR=0;
	for(Re k=1;k<=K;++k)sakura(k,n,k-1,n-1,k);
	printf("%lld\n",dp[K][n]);
}

```

**Lightning Conductor** *(二分栈)*

> 【Lightning Conductor（二分栈）】
DP 优化模板，利用数据结构或数学性质加速状态转移。

核心函数：
  void in(Re &x) — 核心算法函数
  double Y(Re i,Re j) — 核心算法函数
  int find_Poi(int j1,int j2) — 查找（并查集寻根/二分查找）
  void sakura(无参数) — 后缀数组

关键配置：
N=5e5+3

复杂度：时间复杂度取决于状态数和转移复杂度

说明：当前位置i使用直线j1的值小于直线j2的值，说明交点i在当前位置右侧，因此右边界要缩小；找到位置j使得直线Q[j]与直线Q[j+1]的交点大于i；��ôֱ��Q[j]����iǰ�����������ֱ�ߣ����𰸣��Լ�����ͼģ��һ�¾Ͷ���

适用场景：加速DP转移，将O(N²)优化至O(N)/O(N log N)

```cpp
#include<algorithm>
#include<cstdio>
#include<cmath>
#define Re register int
using namespace std;
const int N=5e5+3;
int i,j,n,h,t,a[N],Q[N],Poi[N];
double p[N],sqr[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline double Y(Re i,Re j){return a[j]+sqr[i-j];}
inline int find_Poi(int j1,int j2){// 找到两条直线的交点i 
    Re l=j2,r=n,mid,ans=n+1;// 为了防止两条直线没有交点，预设一个最大边界值
    while(l<=r){
        mid=l+r>>1;
        if(Y(mid,j1)<=Y(mid,j2))ans=mid,r=mid-1;
// 当前位置i使用直线j1的值小于直线j2的值，说明交点i在当前位置右侧，因此右边界要缩小
        else l=mid+1;
    }
    return ans;
}
inline void sakura(){
    h=1,t=0;
    for(i=1;i<=n;++i){
    	while(h<t&&Poi[t-1]>=find_Poi(Q[t],i))--t;
    	Poi[t]=find_Poi(Q[t],i),Q[++t]=i;
    	while(h<t&&Poi[h]<=i)++h;
// 找到位置j使得直线Q[j]与直线Q[j+1]的交点大于i
// 那么直线Q[j]是在i之前的最优直线，记录答案，自己画图模拟一下就懂了
    	p[i]=max(p[i],Y(i,Q[h]));
    }
}
int main(){
    in(n);
    for(Re i=1;i<=n;++i)in(a[i]),sqr[i]=sqrt(i);
    sakura();
    for(Re i=1;i<n-i+1;++i)swap(a[i],a[n-i+1]),swap(p[i],p[n-i+1]);
    sakura();
    for(Re i=n;i;--i)printf("%d\n",(int)ceil(p[i])-a[i]);
}

```

**Lightning Conductor** *(分治)*

> 【Lightning Conductor（分治）】
DP 优化模板，利用数据结构或数学性质加速状态转移。

核心函数：
  void in(Re &x) — 核心算法函数
  void sakura(Re l,Re r,Re L,Re R) — 后缀数组

关键配置：
N=5e5+3

复杂度：时间复杂度取决于状态数和转移复杂度

说明：������p[i]�����ž��ߵ�j0��������ߵ�j��������j<=i�����˴���j<=mid

适用场景：加速DP转移，将O(N²)优化至O(N)/O(N log N)

```cpp
#include<algorithm>
#include<cstdio>
#include<cmath>
#define Re register int
using namespace std;
const int N=5e5+3;
int i,j,n,h,t,a[N],Q[N],Poi[N];
double tmp,p[N],sqr[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void sakura(Re l,Re r,Re L,Re R){
	if(l>r)return;
	Re mid=l+r>>1,j0;double mx=0;
	for(Re j=L;j<=mid&&j<=R;++j)
		if((tmp=a[j]+sqr[mid-j])>mx)mx=tmp,j0=j;
	p[mid]=max(p[mid],mx);
	sakura(l,mid-1,L,j0),sakura(mid+1,r,j0,R);
}
int main(){
    in(n);
    for(Re i=1;i<=n;++i)in(a[i]),sqr[i]=sqrt(i);
    sakura(1,n,1,n);
    for(Re i=1;i<n-i+1;++i)swap(a[i],a[n-i+1]),swap(p[i],p[n-i+1]);
    sakura(1,n,1,n);
    for(Re i=n;i;--i)printf("%d\n",(int)ceil(p[i])-a[i]);
}

```

**Cats Transport** *(min)*

> 【Cats Transport】
DP 优化模板，利用数据结构或数学性质加速状态转移。

核心函数：
  LL min(Re a,Re b) — 核心算法函数
  LL X(Re j) — 核心算法函数
  LL Y(Re j) — 核心算法函数
  long double slope(Re i,Re j) — 核心算法函数

关键配置：
N=1e5+5

复杂度：时间复杂度取决于状态数和转移复杂度

适用场景：加速DP转移，将O(N²)优化至O(N)/O(N log N)

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register LL
const int N=1e5+5;
LL p,n,m,P,w,h,t,H[N],T[N],Q[N],S[N],dp[105][N];
inline LL min(Re a,Re b){return a<b?a:b;}
//                         i
//                         k=j+1
//dp[p][i]=dp[p-1][j]+(i-j)*T[i]-(S[i]-S[j])
//(T[i]) * j + (dp[p][i]-i*T[i]+S[i]) = (dp[p-1][j]+S[j])
//  k    * x +            b           =        y
inline LL X(Re j){return j;}
inline LL Y(Re j){return dp[p-1][j]+S[j];}
inline long double slope(Re i,Re j){return (long double)(Y(j)-Y(i))/(X(j)-X(i));}
int main(){
	memset(dp,0x3f,sizeof(dp));dp[0][0]=0;
    scanf("%lld%lld%lld",&n,&m,&P);
    for(Re i=2;i<=n;H[i]+=H[i-1],++i)scanf("%lld",&H[i]);
    for(Re i=1;i<=m;T[i]=t-H[w],++i)scanf("%lld%lld",&w,&t);
    std::sort(T+1,T+m+1);
    for(Re i=1;i<=m;++i)S[i]=S[i-1]+T[i];
    for(p=1;p<=P;++p){
    	h=1,t=0,Q[++t]=0,dp[p][0]=0;
	    for(Re i=1;i<=m;++i){
	        while(h<t&&slope(Q[h],Q[h+1])<=T[i])++h;
	        dp[p][i]=min(dp[p-1][i],dp[p-1][j=Q[h]]+(i-j)*T[i]-S[i]+S[j]);
	        if(Y(i)>=0x3f3f3f3f3f3f3f3fll)continue;
			while(h<t&&slope(Q[t-1],Q[t])>=slope(Q[t-1],i))--t;
	        Q[++t]=i;
	    }
	}
    printf("%lld",dp[P][m]); 
}

```

**CDQ 斜率优化  (k x均不单调)** *(Building Bridges)*

> 【CDQ 斜率优化  (k x均不单调)（Building Bridges）】
斜率优化 DP 模板，维护凸包将转移复杂度降至 O(N)/O(N log N)。

核心函数：
  void in(Re &x) — 核心算法函数
  bool cmp(QAQ A,QAQ B) — 核心算法函数
  LD slope(Re i,Re j) — 核心算法函数
  void CDQ(Re L,Re R) — 核心算法函数

核心结构体：QAQ

复杂度：时间复杂度取决于状态数和转移复杂度

适用场景：加速DP转移，将O(N²)优化至O(N)/O(N log N)

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LD long double
#define LL long long
#define Re register int
#define S2(a) (1ll*(a)*(a))
using namespace std;
const LL N=1e5+3,inf=1e18;
int n,H[N],W[N],Q[N];LL S[N],dp[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
//dp[i]=min(dp[i],dp[j]+(H[i]-H[j])*(H[i]-H[j])+S[i-1]-S[j]);
//dp[i]=dp[j]-2*H[i]*H[j]+H[j]*H[j]+H[i]*H[i]+S[i-1]-S[j]
//(2*H[i]) * H[j] + (dp[i]-S[i-1]-H[i]*H[i]) = (dp[j]+H[j]*H[j]-S[j])
//   k     *  x   +            b             =          y
#define X(j) (a[j].x)
#define Y(j) (a[j].y)
struct QAQ{
	int k,x,id;LL y;
	inline bool operator<(const QAQ &O)const{return x!=O.x?x<O.x:y<O.y;}
}a[N],b[N];
inline bool cmp(QAQ A,QAQ B){return A.k<B.k;}
inline LD slope(Re i,Re j){return X(i)==X(j)?(Y(j)>Y(i)?inf:-inf):(LD)(Y(j)-Y(i))/(X(j)-X(i));}
inline void CDQ(Re L,Re R){
	if(L==R){Re j=a[L].id;a[L].y=dp[j]+(LL)H[j]*H[j]-S[j];return;}
	Re mid=L+R>>1,p1=L,p2=mid+1,h=1,t=0;
	for(Re i=L;i<=R;++i)a[i].id<=mid?b[p1++]=a[i]:b[p2++]=a[i];
	for(Re i=L;i<=R;++i)a[i]=b[i];
	CDQ(L,mid);
	for(Re i=L;i<=mid;++i){
		while(h<t&&slope(Q[t-1],Q[t])>=slope(Q[t-1],i))--t;
		Q[++t]=i;
	}
	for(Re i=mid+1,j,id;i<=R;++i){
		while(h<t&&slope(Q[h],Q[h+1])<=a[i].k)++h;
		if(h<=t)id=a[i].id,j=Q[h],dp[id]=min(dp[id],a[j].y-(LL)a[i].k*a[j].x+S[id-1]+(LL)H[id]*H[id]);
	}
	CDQ(mid+1,R);
	Re w=L-1;p1=L,p2=mid+1;
	while(p1<=mid&&p2<=R)b[++w]=a[p1]<a[p2]?a[p1++]:a[p2++];
	while(p1<=mid)b[++w]=a[p1++];while(p2<=R)b[++w]=a[p2++];
	for(Re i=L;i<=R;++i)a[i]=b[i];
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n);
	for(Re i=1;i<=n;++i)in(H[i]);
	for(Re i=1;i<=n;++i)in(W[i]);
	for(Re i=1;i<=n;++i)S[i]=S[i-1]+W[i],dp[i]=inf;
	for(Re i=1;i<=n;++i)a[i].k=(H[i]<<1),a[i].x=H[i],a[i].id=i;
	sort(a+1,a+n+1,cmp);
	dp[1]=0,CDQ(1,n);
	printf("%lld\n",dp[n]);
}

```

**二分 斜率优化   (x单调 k不单调)** *(任务安排3)*

> 【二分 斜率优化   (x单调 k不单调)（任务安排3）】
斜率优化 DP 模板，维护凸包将转移复杂度降至 O(N)/O(N log N)。

核心函数：
  LL min(Re a,Re b) — 核心算法函数
  LL X(Re j) — 核心算法函数
  LL Y(Re j) — 核心算法函数
  long double slope(Re i,Re j) — 核心算法函数
  LL sakura(Re k) — 后缀数组

关键配置：
N=3e5+5

复杂度：时间复杂度取决于状态数和转移复杂度

适用场景：加速DP转移，将O(N²)优化至O(N)/O(N log N)

```cpp
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register LL
const int N=3e5+5;
LL i,j,n,h=1,t=0,S,Q[N],ST[N],SF[N],dp[N];
//dp[p][i]=min(dp[p-1][j]+(ST[i]+S*p)*(SF[i]-SF[j]));
//dp[i]=dp[j]+ST[i]*(SF[i]-SF[j])+S*(SF[n]-SF[j]);
//(S+ST[i]) * SF[j] + (dp[i]-ST[i]*SF[i]-S*SF[i]) = (dp[j])
//    k     *   x   +              b              = y
//ti� 均>0，且ST[i]是单调递增
inline LL min(Re a,Re b){return a<b?a:b;}
inline LL X(Re j){return SF[j];}
inline LL Y(Re j){return dp[j];}
inline long double slope(Re i,Re j){return X(j)==X(i)?(Y(j)>=Y(i)?1e18:-1e18):(long double)(Y(j)-Y(i))/(X(j)-X(i));}
inline LL sakura(Re k){
	if(h==t)return Q[h];
	Re l=h,r=t;
	while(l<r){
		Re mid=l+r>>1,i=Q[mid],j=Q[mid+1];
		if(slope(i,j)<k)l=mid+1;
		else r=mid;
	}
	return Q[l];
}
int main(){
    scanf("%lld%lld",&n,&S);
    for(i=1;i<=n;ST[i]+=ST[i-1],SF[i]+=SF[i-1],++i)scanf("%lld%lld",&ST[i],&SF[i]);
    Q[++t]=0;
	for(i=1;i<=n;++i){
		j=sakura(S+ST[i]);
        dp[i]=dp[j]+ST[i]*(SF[i]-SF[j])+S*(SF[n]-SF[j]);
        while(h<t&&slope(Q[t-1],Q[t])>=slope(Q[t-1],i))--t;
        Q[++t]=i;
	}
    printf("%lld",dp[n]);
}

```

**单调队列 斜率优化  (x k 均单调)** *(玩具装箱 Toy)*

> 【单调队列 斜率优化  (x k 均单调)（玩具装箱 Toy）】
斜率优化 DP 模板，维护凸包将转移复杂度降至 O(N)/O(N log N)。

核心函数：
  LL min(Re a,Re b) — 核心算法函数
  LL X(Re j) — 核心算法函数
  LL Y(Re j) — 核心算法函数
  long double slope(Re i,Re j) — 核心算法函数

关键配置：
N=5e4+5

复杂度：时间复杂度取决于状态数和转移复杂度

适用场景：加速DP转移，将O(N²)优化至O(N)/O(N log N)

```cpp
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register LL
const int N=5e4+5;
LL i,j,n,L,h=1,t=0,Q[N],S[N],dp[N];
//dp[i]=S[i]^2-2*S[i]*L+dp[j]+(S[j]+L)^2-2S[i]*S[j]
//(2*S[i]) * S[j] + (dp[i]-S[i]^2+2S[i]L)=(dp[j]+(S[j]+L)^2)
//   k     *  x   +           b          =        y
inline LL min(Re a,Re b){return a<b?a:b;}
inline LL X(Re j){return S[j];}
inline LL Y(Re j){return dp[j]+(S[j]+L)*(S[j]+L);}
inline long double slope(Re i,Re j){return (long double)(Y(j)-Y(i))/(X(j)-X(i));}
int main(){
    scanf("%lld%lld",&n,&L);++L; 
    for(i=1;i<=n;S[i]+=S[i-1]+1,++i)scanf("%lld",&S[i]);
    Q[++t]=0;
    for(i=1;i<=n;++i){
        while(h<t&&slope(Q[h],Q[h+1])<=2*S[i])++h;
        dp[i]=dp[j=Q[h]]+(S[i]-S[j]-L)*(S[i]-S[j]-L);
        while(h<t&&slope(Q[t-1],Q[t])>=slope(Q[t-1],i))--t;
        Q[++t]=i;
    }
    printf("%lld",dp[n]);
}

```

**仓库建设** *(min)*

> 【仓库建设】
DP 优化模板，利用数据结构或数学性质加速状态转移。

核心函数：
  LL min(Re a,Re b) — 核心算法函数
  LL X(Re j) — 核心算法函数
  LL Y(Re j) — 核心算法函数
  long double slope(Re i,Re j) — 核心算法函数

关键配置：
N=1e6+5

复杂度：时间复杂度取决于状态数和转移复杂度

适用场景：加速DP转移，将O(N²)优化至O(N)/O(N log N)

```cpp
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register LL
const int N=1e6+5;
LL i,j,n,w,h=1,t=0,W[N],P[N],C[N],Q[N],SP[N],SC[N],dp[N];
inline LL min(Re a,Re b){return a<b?a:b;}
//dp[i]=dp[j]+Ci+Wi*(SP[i]-SP[j])-(SC[i]-SC[j])
//(Wi) * SP[j] + (dp[i]+SC[i]-Wi*SP[i]) = (dp[j]+SC[j])
// k   *   x   +           b            =       y
inline LL X(Re j){return SP[j];}
inline LL Y(Re j){return dp[j]+SC[j];}
inline long double slope(Re i,Re j){return (long double)(Y(j)-Y(i))/(X(j)-X(i));}
int main(){
    scanf("%lld",&n);
    for(i=1;i<=n;SC[i]=SC[i-1]+W[i]*SP[i],SP[i]+=SP[i-1],++i)scanf("%lld%lld%lld",&W[i],&SP[i],&C[i]);
    Q[++t]=0;
    for(i=1;i<=n;++i){
        while(h<t&&slope(Q[h],Q[h+1])<W[i])++h;
        dp[i]=dp[j=Q[h]]+C[i]+W[i]*(SP[i]-SP[j])-SC[i]+SC[j];
        while(h<t&&slope(Q[t-1],Q[t])>slope(Q[t-1],i))--t;
        Q[++t]=i;
    }
    printf("%lld",dp[n]);
}

```

**任务安排1 O** *(n^2)*

> 【任务安排1 O（n^2）】
DP 优化模板，利用数据结构或数学性质加速状态转移。

核心函数：
  LL min(Re a,Re b) — 核心算法函数

关键配置：
N=1e4+5

复杂度：时间复杂度取决于状态数和转移复杂度

说明：dp[p][i]=min(dp[p-1][j]+(ST[i]+S*p)*(SF[i]-SF[j]));；dp[i]=min(dp[i],dp[j]+ST[i]*(SF[i]-SF[j])+S*(SF[n]-SF[j]));

适用场景：加速DP转移，将O(N²)优化至O(N)/O(N log N)

```cpp
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register LL
const int N=1e4+5;
LL i,j,n,h=1,t=0,S,Q[N],ST[N],SF[N],dp[N];
//dp[p][i]=min(dp[p-1][j]+(ST[i]+S*p)*(SF[i]-SF[j]));
//dp[i]=min(dp[i],dp[j]+ST[i]*(SF[i]-SF[j])+S*(SF[n]-SF[j]));
inline LL min(Re a,Re b){return a<b?a:b;}
int main(){
    memset(dp,127,sizeof(dp));dp[0]=0;
    scanf("%lld%lld",&n,&S);
    for(i=1;i<=n;ST[i]+=ST[i-1],SF[i]+=SF[i-1],++i)scanf("%lld%lld",&ST[i],&SF[i]);
    for(i=1;i<=n;++i)
    	for(j=0;j<i;++j)
    		dp[i]=min(dp[i],dp[j]+ST[i]*(SF[i]-SF[j])+S*(SF[n]-SF[j]));
    printf("%lld",dp[n]);
}

```

**任务安排2 O** *(n)*

> 【任务安排2 O（n）】
DP 优化模板，利用数据结构或数学性质加速状态转移。

核心函数：
  LL min(Re a,Re b) — 核心算法函数
  LL X(Re j) — 核心算法函数
  LL Y(Re j) — 核心算法函数
  long double slope(Re i,Re j) — 核心算法函数

关键配置：
N=3e5+5

复杂度：时间复杂度取决于状态数和转移复杂度

适用场景：加速DP转移，将O(N²)优化至O(N)/O(N log N)

```cpp
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register LL
const int N=3e5+5;
LL i,j,n,h=1,t=0,S,Q[N],ST[N],SF[N],dp[N];
//dp[p][i]=min(dp[p-1][j]+(ST[i]+S*p)*(SF[i]-SF[j]));
//dp[i]=dp[j]+ST[i]*(SF[i]-SF[j])+S*(SF[n]-SF[j]);
//(S+ST[i]) * SF[j] + (dp[i]-ST[i]*SF[i]-S*SF[i]) = (dp[j])
//    k     *   x   +              b              = y
inline LL min(Re a,Re b){return a<b?a:b;}
inline LL X(Re j){return SF[j];}
inline LL Y(Re j){return dp[j];}
inline long double slope(Re i,Re j){return (long double)(Y(j)-Y(i))/(X(j)-X(i));}
int main(){
    scanf("%lld%lld",&n,&S);
    for(i=1;i<=n;ST[i]+=ST[i-1],SF[i]+=SF[i-1],++i)scanf("%lld%lld",&ST[i],&SF[i]);
    Q[++t]=0;
	for(i=1;i<=n;++i){
		while(h<t&&slope(Q[h],Q[h+1])<(S+ST[i]))++h;
        dp[i]=dp[j=Q[h]]+ST[i]*(SF[i]-SF[j])+S*(SF[n]-SF[j]);
        while(h<t&&slope(Q[t-1],Q[t])>slope(Q[t-1],i))--t;
        Q[++t]=i;
	}
    printf("%lld",dp[n]);
}

```

**土地征用 Land Acquisition** *(min)*

> 【土地征用 Land Acquisition】
DP 优化模板，利用数据结构或数学性质加速状态转移。

核心函数：
  LL min(Re a,Re b) — 核心算法函数
  LL X(Re j) — 核心算法函数
  LL Y(Re j) — 核心算法函数
  long double slope(Re i,Re j) — 核心算法函数

核心结构体：QAQ

关键配置：
N=5e4+5

复杂度：时间复杂度取决于状态数和转移复杂度

适用场景：加速DP转移，将O(N²)优化至O(N)/O(N log N)

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register LL
const int N=5e4+5;
struct QAQ{LL L,W;inline bool operator<(QAQ p)const{return W<p.W;}}a[N];
LL i,j,n,m,h=1,t=0,H=1,T,L[N],W[N],Q[N],dp[N];
inline LL min(Re a,Re b){return a<b?a:b;}
inline LL X(Re j){return -L[j+1];}
inline LL Y(Re j){return dp[j];}
inline long double slope(Re i,Re j){return (long double)(Y(j)-Y(i))/(X(j)-X(i));}
int main(){
    scanf("%lld",&m);
    for(i=1;i<=m;++i)scanf("%lld%lld",&a[i].L,&a[i].W);
    std::sort(a+1,a+m+1);
    for(i=1;i<=m;++i){
    	while(1<=n&&L[n]<=a[i].L)--n;
    	L[++n]=a[i].L,W[n]=a[i].W;
	}
    Q[++t]=0;
    for(i=1;i<=n;++i){
        while(h<t&&slope(Q[h],Q[h+1])<W[i])++h;
        dp[i]=dp[j=Q[h]]+L[j+1]*W[i];
        while(h<t&&slope(Q[t-1],Q[t])>slope(Q[t-1],i))--t;
        Q[++t]=i;
    }
    printf("%lld",dp[n]);
}

```

**序列分割** *(max)*

> 【序列分割】
DP 优化模板，利用数据结构或数学性质加速状态转移。

核心函数：
  LL max(Re a,Re b) — 核心算法函数
  LL X(Re j) — 核心算法函数
  LL Y(Re j) — 核心算法函数
  long double slope(Re i,Re j) — 核心算法函数

关键配置：
N=1e5+5,M=205

复杂度：时间复杂度取决于状态数和转移复杂度

说明：dp[p][i]=dp[p-1][j]+S[j]*(S[i]-S[j])；(S[i]) * S[j] + (-dp[p][i]) = (S[j]^2-dp[p-1][j])；k    *  x   +       b     =          y

适用场景：加速DP转移，将O(N²)优化至O(N)/O(N log N)

```cpp
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register LL
const int N=1e5+5,M=205;
LL tmp,i,j,p,n,K,h,t,Q[N],S[N],to[M][N],dp[M][N];
inline LL max(Re a,Re b){return a>b?a:b;}
//dp[p][i]=dp[p-1][j]+S[j]*(S[i]-S[j])
//(S[i]) * S[j] + (-dp[p][i]) = (S[j]^2-dp[p-1][j])
//  k    *  x   +       b     =          y
inline LL X(Re j){return S[j];}
inline LL Y(Re j){return S[j]*S[j]-dp[p-1][j];}
inline long double slope(Re i,Re j){return X(j)==X(i)?-1e18:(long double)(Y(j)-Y(i))/(X(j)-X(i));}
int main(){
    scanf("%lld%lld",&n,&K);
    for(i=1;i<=n;S[i]+=S[i-1],++i)scanf("%lld",&S[i]);
    for(p=1;p<=K;++p){
        h=1,t=0,Q[++t]=p-1;
        for(i=p;i+K-p<=n;++i){
            while(h<t&&slope(Q[h],Q[h+1])<S[i])++h;
        	dp[p][i]=dp[p-1][to[p][i]=j=Q[h]]+S[j]*(S[i]-S[j]);
       		while(h<t&&slope(Q[t-1],Q[t])>slope(Q[t-1],i))--t;
        	Q[++t]=i;
        }
    }
    printf("%lld\n",dp[K][n]);
    for(i=n,j=K;j>=1;--j)printf("%lld ",i=to[j][i]);
}

```

**征途** *(min)*

> 【征途】
DP 优化模板，利用数据结构或数学性质加速状态转移。

核心函数：
  LL min(Re a,Re b) — 核心算法函数
  LL X(Re j) — 核心算法函数
  LL Y(Re j) — 核心算法函数
  long double slope(Re i,Re j) — 核心算法函数

关键配置：
N=3e3+5

复杂度：时间复杂度取决于状态数和转移复杂度

适用场景：加速DP转移，将O(N²)优化至O(N)/O(N log N)

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register LL
const int N=3e3+5;
LL p,i,j,n,m,h,t,Q[N],S[N],dp[N][N];
//S_walk[m]=S[n]
//              m                               m
//             i=1                             i=1
//        m
//       i=1
//dp[p][i]=min(dp[p-1][j]+(S[i]-S[j])^2)
//(2*S[i]) * S[j] + (dp[p][i]-S[i]^2) = (dp[p-1][j]+S[j]^2)
//   k     *  x   +         b         =          y
inline LL min(Re a,Re b){return a<b?a:b;}
inline LL X(Re j){return S[j];}
inline LL Y(Re j){return dp[p-1][j]+S[j]*S[j];}
inline long double slope(Re i,Re j){return (long double)(Y(j)-Y(i))/(X(j)-X(i));}
int main(){
    memset(dp,127,sizeof(dp));dp[0][0]=0;
    scanf("%lld%lld",&n,&m);
    for(i=1;i<=n;S[i]+=S[i-1],++i)scanf("%lld",&S[i]);
    for(p=1;p<=m;++p){
    	h=1,t=0,Q[++t]=0,dp[p][0]=0;
	    for(i=1;i<=n;++i){
	        while(h<t&&slope(Q[h],Q[h+1])<2*S[i])++h;
	        dp[p][i]=min(dp[p-1][i],dp[p-1][j=Q[h]]+(S[i]-S[j])*(S[i]-S[j]));
			while(h<t&&slope(Q[t-1],Q[t])>slope(Q[t-1],i))--t;
	        Q[++t]=i;
	    }
	}
    printf("%lld",m*dp[m][n]-S[n]*S[n]);
}

```

**摆渡车** *(min)*

> 【摆渡车】
DP 优化模板，利用数据结构或数学性质加速状态转移。

核心函数：
  int min(Re a,Re b) — 核心算法函数
  int X(Re j) — 核心算法函数
  int Y(Re j) — 核心算法函数
  long double slope(Re i,Re j) — 核心算法函数

关键配置：
N=4e6+105

复杂度：时间复杂度取决于状态数和转移复杂度

适用场景：加速DP转移，将O(N²)优化至O(N)/O(N log N)

```cpp
#include<cstdio>
#define Re register int
const int N=4e6+105;
int i,j,n,m,h=1,t=0,T,ti,ans=2e9,G[N],S[N],Q[N],dp[N];
inline int min(Re a,Re b){return a<b?a:b;}
//                 i
//                 k=j+1
//dp[i]=dp[j]+(G[i]-G[j])*i-(S[i]-S[j])
//(i) * G[j] + (dp[i]+S[j]-i*G[i]) = (dp[j]+S[j])
// k  *  x   +          b          =      y
inline int X(Re j){return G[j];}
inline int Y(Re j){return dp[j]+S[j];}
inline long double slope(Re i,Re j){return X(i)==X(j)?(Y(j)>Y(i)?2e9:-2e9):(long double)(Y(j)-Y(i))/(long double)(X(j)-X(i));}
int main(){
    scanf("%d%d",&n,&m);
    for(i=1;i<=n;T=-min(-T,-ti),++G[ti],S[ti]+=ti,++i)scanf("%d",&ti);
    for(i=1;i<T+m;++i)G[i]+=G[i-1],S[i]+=S[i-1];
    for(i=0;i<m;++i)dp[i]=G[i]*i-S[i];
    Q[++t]=0;
    for(i=m;i<T+m;++i){
    	while(h<t&&slope(Q[h],Q[h+1])<=i)++h;
        dp[i]=dp[j=Q[h]]+(G[i]-G[j])*i-S[i]+S[j];
       	while(h<t&&slope(Q[t-1],Q[t])>=slope(Q[t-1],i-m+1))--t;
        Q[++t]=i-m+1;//(j+1)+m<=i
	}
    for(i=T;i<T+m;++i)ans=min(ans,dp[i]);
    printf("%d",ans);
}

```

**特别行动队** *(max)*

> 【特别行动队】
DP 优化模板，利用数据结构或数学性质加速状态转移。

核心函数：
  LL max(Re a,Re b) — 核心算法函数
  LL X(Re j) — 核心算法函数
  LL Y(Re j) — 核心算法函数
  long double slope(Re i,Re j) — 核心算法函数

关键配置：
N=1e6+5

复杂度：时间复杂度取决于状态数和转移复杂度

说明：dp[i]=dp[j]+a*(S[i]-S[j])^2+b*(S[i]-S[j])+c；(-2a*S[i]) * S[j] + (b*S[i]+a*S[i]^2-dp[i]) = (b*S[j]-dp[j]-a*S[j]^2)；k      * x    +           b             =             y

适用场景：加速DP转移，将O(N²)优化至O(N)/O(N log N)

```cpp
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register LL
const int N=1e6+5;
LL tmp,i,j,n,a,b,c,h=1,t=0,Q[N],S[N],dp[N];
inline LL max(Re a,Re b){return a>b?a:b;}
//dp[i]=dp[j]+a*(S[i]-S[j])^2+b*(S[i]-S[j])+c
//(-2a*S[i]) * S[j] + (b*S[i]+a*S[i]^2-dp[i]) = (b*S[j]-dp[j]-a*S[j]^2)
//    k      * x    +           b             =             y
inline LL X(Re j){return S[j];}
inline LL Y(Re j){return b*S[j]-dp[j]-a*S[j]*S[j];}
inline long double slope(Re i,Re j){return (long double)(Y(j)-Y(i))/(X(j)-X(i));}
int main(){
	scanf("%lld%lld%lld%lld",&n,&a,&b,&c);
	for(i=1;i<=n;S[i]+=S[i-1],++i)scanf("%lld",&S[i]);
	Q[++t]=0;
	for(i=1;i<=n;++i){
		while(h<t&&slope(Q[h],Q[h+1])<(-2*a*S[i]))++h;
		dp[i]=dp[j=Q[h]]+a*(S[i]-S[j])*(S[i]-S[j])+b*(S[i]-S[j])+c;
		while(h<t&&slope(Q[t-1],Q[t])>slope(Q[t-1],i))--t;
		Q[++t]=i;
	}
	printf("%lld",dp[n]);
}

```

**货币兑换** *(CDQ斜率优化)*

> 【货币兑换（CDQ斜率优化）】
DP 优化模板，利用数据结构或数学性质加速状态转移。

核心函数：
  int dcmp(LD a) — 核心算法函数
  void in(Re &x) — 核心算法函数
  void in(LD &X) — 核心算法函数
  bool cmp(QAQ A,QAQ B) — 核心算法函数
  LD slope(Re i,Re j) — 核心算法函数
  void CDQ(Re L,Re R) — 核心算法函数

核心结构体：QAQ

复杂度：时间复杂度取决于状态数和转移复杂度

适用场景：加速DP转移，将O(N²)优化至O(N)/O(N log N)

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define LD long double
#define Re register int
using namespace std;
const LL N=1e5+3,inf=1e18;
const LD eps=1e-20;
inline int dcmp(LD a){return a<-eps?-1:(a>eps?1:0);}
int n,h,t,Q[N];LD S,A[N],B[N],Ra[N],f[N],dp[N];
inline void in(Re &x){
    int dp=0;x=0;char c=getchar();
    while(c<'0'||c>'9')dp|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=dp?-x:x;
}
inline void in(LD &X){
	X=0;LD Y=1.0;int dp=0;char c=getchar();
	while(c<'0'||c>'9')dp|=c=='-',c=getchar(); 
	while(c>='0'&&c<='9')X=X*10+(c^48),c=getchar(); 
	if(c=='.'){c=getchar();while(c>='0'&&c<='9')X+=(Y/=10)*(c^48),c=getchar();}
	X=dp?-X:X;
}
//dp[i]=max((B[i]/A[i])*f[j]+Ra[j]*f[j]),f[i]=dp[i]/(A[i]*Ra[i]+B[i])
//(B[i]/A[i])*f[j]+(-dp[i])=(-Ra[j]*f[j])
//     k     * x  +   b    =     y
#define X(i) (a[i].x)
#define Y(i) (a[i].y)
struct QAQ{
	LD k,x,y;int id;
	inline bool operator<(const QAQ &O)const{return dcmp(x-O.x)?x<O.x:y<O.y;}
}a[N],b[N];
inline bool cmp(QAQ A,QAQ B){return dcmp(A.k-B.k)<0;}
inline LD slope(Re i,Re j){return X(i)==X(j)?(Y(j)>Y(i)?inf:-inf):(Y(j)-Y(i))/(X(j)-X(i));}
inline void CDQ(Re L,Re R){
	if(L==R){
		Re j=a[L].id;
//		printf("getdp(%d), dp=%.3Lf\n",j,dp[j]);
		if(j>1)dp[j]=max(dp[j-1],A[j]*dp[j]),f[j]=dp[j]/(A[j]*Ra[j]+B[j]);
		a[L].x=f[j],a[L].y=-Ra[j]*f[j];
//		printf("k=%.3Lf, x=%.3Lf, y=%.3Lf\n",a[L].k,a[L].x,a[L].y);
		return;
	}
	Re mid=(L+R)>>1,p1=L,p2=mid+1,h=1,t=0;
	for(Re i=L;i<=R;++i)a[i].id<=mid?b[p1++]=a[i]:b[p2++]=a[i];
	for(Re i=L;i<=R;++i)a[i]=b[i];
	CDQ(L,mid);
	for(Re i=L;i<=mid;++i){
		while(h<t&&slope(Q[t-1],Q[t])>=slope(Q[t-1],i))--t;
		Q[++t]=i;
	}
	for(Re i=mid+1,j,id;i<=R;++i){
		while(h<t&&slope(Q[h],Q[h+1])<=a[i].k)++h;
		if(h<=t)id=a[i].id,j=Q[h],dp[id]=max(dp[id],-(a[j].y-a[i].k*a[j].x));
	}
	CDQ(mid+1,R);Re p=L-1;p1=L,p2=mid+1;
	while(p1<=mid&&p2<=R)b[++p]=a[p1]<a[p2]?a[p1++]:a[p2++];
	while(p1<=mid)b[++p]=a[p1++];while(p2<=R)b[++p]=a[p2++];
	for(Re i=L;i<=R;++i)a[i]=b[i];
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(S);
	for(Re i=1;i<=n;++i)in(A[i]),in(B[i]),in(Ra[i]),dp[i]=-inf;
	for(Re i=1;i<=n;++i)a[i].k=B[i]/A[i],a[i].id=i;
	f[1]=(dp[1]=S)/(A[1]*Ra[1]+B[1]);
//	for(Re i=2;i<=n;++i){
//		for(Re j=1;j<i;++j)dp[i]=max(dp[i],f[j]*Ra[j]+f[j]*B[i]/A[i]);
//		dp[i]=max(dp[i-1],A[i]*dp[i]),f[i]=dp[i]/(A[i]*Ra[i]+B[i]);
//	}
	sort(a+1,a+n+1,cmp),CDQ(1,n);
	printf("%.3Lf",dp[n]);
}

```

**锯木厂选址** *(X)*

> 【锯木厂选址】
DP 优化模板，利用数据结构或数学性质加速状态转移。

核心函数：
  void in(Re &x) — 核心算法函数
  LL X(Re j) — 核心算法函数
  LL Y(Re j) — 核心算法函数
  LD slope(Re i,Re j) — 核心算法函数

复杂度：时间复杂度取决于状态数和转移复杂度

适用场景：加速DP转移，将O(N²)优化至O(N)/O(N log N)

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LD long double
#define LL long long
#define Re register int
using namespace std;
const LL N=2e5+3,inf=1e18;
int n,x,h=1,t,Q[N];LL ans=inf,Ans,D[N],S[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
// S严格递增
// D严格递减
//F[j]=max(D[i]*S[i]-D[i]*S[j]+D[j]*S[j])
//D[i]*S[j] + F[i]-D[i]*S[i] = D[j]*S[j]
// k  * x   +       b        =     y
inline LL X(Re j){return S[j];}
inline LL Y(Re j){return D[j]*S[j];}
inline LD slope(Re i,Re j){return (LD)(Y(j)-Y(i))/(X(j)-X(i));}
int main(){
//	freopen("123.txt","r",stdin);
	in(n);
	for(Re i=1;i<=n;++i)in(x),S[i]=S[i-1]+x,in(x),D[i+1]=D[i]+x;
	for(Re i=1;i<=n+1;++i)D[i]=D[n+1]-D[i],Ans+=D[i]*(S[i]-S[i-1]);
	for(Re i=1;i<=n;++i){
		LL tmp=-inf;
		while(h<t&&slope(Q[h],Q[h+1])>=D[i])++h;
		if(h<=t)ans=min(ans,Ans-(D[i]*(S[i]-S[Q[h]])+D[Q[h]]*S[Q[h]]));
		while(h<t&&slope(Q[t-1],i)>=slope(Q[t-1],Q[t]))--t;
		Q[++t]=i;
//		for(Re j=1;j<i;++j)tmp=max(tmp,D[i]*(S[i]-S[j])+D[j]*S[j]);
	}
	printf("%lld\n",ans);
}

```

**高速公路** *(x单调 k不单调，树上转移)*

> 【高速公路（x单调 k不单调，树上转移）】
DP 优化模板，利用数据结构或数学性质加速状态转移。

核心函数：
  void add(Re x,Re y,Re z) — 加法更新
  void in(Re &x) — 核心算法函数
  LL Y(Re j) — 核心算法函数
  LL X(Re j) — 核心算法函数
  LD slope(Re i,Re j) — 核心算法函数
  void dfs(Re x,Re fa) — 深度优先搜索遍历

核心结构体：QAQ

复杂度：时间复杂度取决于状态数和转移复杂度

适用场景：加速DP转移，将O(N²)优化至O(N)/O(N log N)

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LD double
#define LL long long
#define Re register int
using namespace std;
const LL N=1e6+3,inf=4e18;
int n,m,x,y,z,o,h,t,P[N],Q[N],A[N],Fa[N],head[N];LL ans,dp[N],dis[N];
struct QAQ{int w,to,next;}a[N];
inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
//dp[i]=min(dp[j]+P[i]*(dis[i]-dis[j])+A[i])
//dp[i]=dp[j]+P[i]*dis[i]-P[i]*dis[j]+A[i]
//P[i]*dis[j]+dp[i]-P[i]*dis[i]-A[i]=dp[j]
//  k *  x   +          b           =  y
inline LL Y(Re j){return dp[j];}
inline LL X(Re j){return dis[j];}
inline LD slope(Re i,Re j){return (LD)(Y(j)-Y(i))/(X(j)-X(i));}
inline void dfs(Re x,Re fa){
	dp[x]=inf;Re h0=h,t0=t;
	Re l=h,r=t;
	while(l<r){
		Re mid=l+r>>1;
		if(slope(Q[mid],Q[mid+1])<=P[x])l=mid+1;
		else r=mid;
	}
	h=r;
	dp[x]=dp[Q[h]]+(LL)P[x]*(dis[x]-dis[Q[h]])+A[x];
	l=h,r=t;
	while(l<r){
		Re mid=l+r+1>>1;
		if(slope(Q[mid-1],x)<=slope(Q[mid-1],Q[mid]))r=mid-1;
		else l=mid;
	}
	Re Qx0=Q[r+1];t=r,Q[++t]=x;
	for(Re i=head[x],to;i;i=a[i].next)dis[to=a[i].to]=dis[x]+a[i].w,dfs(to,x);
	h=h0,Q[t]=Qx0,t=t0;
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n);
	for(Re i=2;i<=n;++i)in(x),in(z),in(P[i]),in(A[i]),add(x,i,z),Fa[i]=x;
	dp[1]=0,h=1,t=0,Q[++t]=1;
	for(Re i=head[1],to;i;i=a[i].next)
		dis[to=a[i].to]=dis[1]+a[i].w,dfs(to,1);
	for(Re i=2;i<=n;++i)printf("%lld\n",dp[i]);
}

```

### 5.2 背包问题

**01背包** *(采药)*

> 【01背包（采药）】
01背包的算法实现模板。

适用场景：资源分配问题、物品选取的最优方案

```cpp
#include<algorithm>
#include<cstdio>
int T,n,i,j,v[110],w[110],f[1010];
int main(){
    scanf("%d%d",&T,&n);
    for(i=1;i<=n;i++)
        scanf("%d%d",&v[i],&w[i]);
    for(i=1;i<=n;i++)
        for(j=T;j>=v[i];j--)
            f[j]=std::max(f[j],f[j-v[i]]+w[i]);
    printf("%d",f[T]);
    return 0;
}

```

**二维费用** *(找啊找啊找GF)*

> 【二维费用（找啊找啊找GF）】
二维费用的算法实现模板。

适用场景：资源分配问题、物品选取的最优方案

```cpp
#include<algorithm>
#include<cstdio>
using namespace std;
int tmp,T1,T2,x,y,n,i,j,k,v1[105],v2[105],w[105],dp[105][105],ans[105][105];
int main(){
    scanf("%d",&n);
    for(i=1;i<=n;i++)scanf("%d%d%d",&v1[i],&v2[i],&w[i]);
    scanf("%d%d",&T1,&T2);
    for(i=1;i<=n;++i)
        for(j=T1;j>=v1[i];--j)
            for(k=T2;k>=v2[i];--k){
            	if(dp[j][k]<(tmp=dp[j-v1[i]][k-v2[i]]+1)){
            		dp[j][k]=tmp;
            		ans[j][k]=ans[j-v1[i]][k-v2[i]]+w[i];
				}
				else if(dp[j][k]==tmp)ans[j][k]=min(ans[j][k],ans[j-v1[i]][k-v2[i]]+w[i]);
            }
    printf("%d",ans[T1][T2]);
}

```

**分组背包** *(金明的预算方案)*

> 【分组背包（金明的预算方案）】
分组背包的算法实现模板。

适用场景：资源分配问题、物品选取的最优方案

```cpp
#include<algorithm>
#include<cstdio>
using namespace std;
int T,n,i,j,a[65],s,t,r1,r2,r[65][3],v[65],w[65],f[32010];
int main(){
    scanf("%d%d",&T,&n);
    v[0]=0xfffffff;
    for(i=1;i<=n;i++){
        scanf("%d%d%d",&v[i],&s,&a[i]);
        if(a[i])r[a[i]][++r[a[i]][0]]=i;w[i]=v[i]*s;
    }
    for(i=1;i<=n;i++)
        for(j=T;j>=v[i]&&(!a[i]);j--){
            t=j-v[i],r1=r[i][1],r2=r[i][2];
            f[j]=max(f[j],f[t]+w[i]);
            if(v[r1]<=t)f[j]=max(f[j],f[t-v[r1]]+w[i]+w[r1]);
            if(v[r2]<=t)f[j]=max(f[j],f[t-v[r2]]+w[i]+w[r2]);
            if(v[r1]+v[r2]<=t)f[j]=max(f[j],f[t-v[r1]-v[r2]]+w[i]+w[r1]+w[r2]);
        }
    printf("%d",f[T]);
}

```

**多人背包** *(kth_knapsack)*

> 【多人背包】
多人背包的算法实现模板。

适用场景：资源分配问题、物品选取的最优方案

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
int ans,T,n,i,j,k,K,a,b,t,re[45],v[210],w[210],f[5010][45];
int main(){
    scanf("%d%d%d",&K,&T,&n);
    memset(f,-127,sizeof(f));f[0][1]=0;
    for(i=1;i<=n;i++)
        scanf("%d%d",&v[i],&w[i]);
    for(i=1;i<=n;i++)
        for(j=T;j>=v[i];j--){
            a=b=1,t=0;
            while(t<=K){
                if(f[j][a]>=f[j-v[i]][b]+w[i])re[++t]=f[j][a++];
                else re[++t]=f[j-v[i]][b++]+w[i];
            }
            for(k=1;k<=K;k++)f[j][k]=re[k];
        }
    for(i=1;i<=K;i++)ans+=f[T][i];
    printf("%d",ans);
    return 0;
}

```

**多重背包  (宝物筛选)** *(二进制优化)*

> 【多重背包  (宝物筛选)（二进制优化）】
代码包含 in 等核心函数，实现了 多重背包  (宝物筛选) 的算法逻辑。

核心函数：
  void in(Re &x) — 核心算法函数

关键配置：
N=103,M=4e4+3

适用场景：资源分配问题、物品选取的最优方案

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define Re register int
using namespace std;
const int N=103,M=4e4+3;
int n,m,x,y,z,V,ans,v[N*17],w[N*17],dp[M];
inline void in(Re &x){
	Re fu=0;x=0;char ch=getchar();
	while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=fu?-x:x;
}
int main(){
	in(m),in(V);
	memset(dp,-127,sizeof(dp));
	dp[0]=0;
	while(m--){
		in(x),in(y),in(z);Re p=1;
		while(z>=p)v[++n]=y*p,w[n]=x*p,z-=p,p<<=1;
		if(z)v[++n]=y*z,w[n]=x*z;
	}
	for(Re i=1;i<=n;++i)
		for(Re j=V;j>=v[i];--j)	
			dp[j]=max(dp[j],dp[j-v[i]]+w[i]);
	for(Re i=0;i<=V;++i)ans=max(ans,dp[i]);
	printf("%d\n",ans);
}

```

**完全背包** *(货币系统)*

> 【完全背包（货币系统）】
完全背包的算法实现模板。

适用场景：资源分配问题、物品选取的最优方案

```cpp
#include<bits/stdc++.h>
using namespace std;
int T,n,ans,a[105],dp[30005];
int main(){
    scanf("%d",&T);
    while(T--){
    	memset(dp,-127,sizeof(dp));
    	scanf("%d",&n);dp[0]=ans=0;
		for(int i=1;i<=n;i++)scanf("%d",&a[i]);
		for(int i=1;i<=n;i++)
		    for(int j=a[i];j<=25000;j++)
		        dp[j]=max(dp[j],dp[j-a[i]]+1);
		for(int i=1;i<=n;++i)ans+=dp[a[i]]==1;
		printf("%d\n",ans);
	}
}

```

**混合背包** *(樱花)*

> 【混合背包（樱花）】
混合背包的算法实现模板。

适用场景：资源分配问题、物品选取的最优方案

```cpp
#include<algorithm>
#include<cstdio>
using namespace std;
int x,a,b,c,d,T,n,i,j,t,f[1010],v[100010],w[100010];
int main(){
	scanf("%d:%d%d:%d%d",&a,&b,&c,&d,&n);
	T=c*60+d-a*60-b;
	for(i=1;i<=n;i++){
		scanf("%d%d%d",&a,&b,&c);
		if(!c){
			for(j=0;j+a<=T;j++)
				f[j+a]=max(f[j+a],f[j]+b);
			continue;
		}
		x=1;
		while(c>=x){v[++t]=x*a,w[t]=x*b,c-=x,x<<=1;}
		v[++t]=c*a,w[t]=c*b;
	}
	for(i=1;i<=t;i++)
		for(j=T;j>=v[i];j--)
			f[j]=max(f[j],f[j-v[i]]+w[i]);
	printf("%d",f[T]);
	return 0;
}

```

### 5.3 数位DP

**数位DP  (Windy数)** *(dfs)*

> 【数位DP  (Windy数)（dfs）】
数位 DP 模板，在数字的十进制/二进制位上做记忆化搜索。

核心函数：
  int dfs(int len,int up,int ok) — 深度优先搜索遍历
  int sovle(int x) — 核心算法函数

复杂度：时间复杂度取决于状态数和转移复杂度

适用场景：与数字各位有关的计数/最优化问题

```cpp
#include<cstring>
#include<cstdio>
#include<cmath>
#define R register int
using namespace std;
int a,b,l,num[12],dp[12][10];
inline int dfs(int len,int up,int ok){
    R i,ed,ans=0;
    if(len<1)return 1;
    if(!ok&&~dp[len][up]&&up!=-7)return dp[len][up];
    ed=ok?num[len]:9;
    for(i=0;i<=ed;i++)if(abs(i-up)>=2)
        ans+=dfs(len-1,(!i&&up==-7)?up:i,ok&&(i==ed));
    if(!ok&&up!=-7)dp[len][up]=ans;
    return ans;
}
inline int sovle(int x){
    l=0;
    while(x)num[++l]=x%10,x/=10;
    return dfs(l,-7,1);
}
int main(){
    scanf("%d%d",&a,&b);
    memset(dp,-1,sizeof(dp));
    printf("%d",sovle(b)-sovle(a-1));
}

```

**数位DP  (Windy数)** *(dp)*

> 【数位DP  (Windy数)（dp）】
数位 DP 模板，在数字的十进制/二进制位上做记忆化搜索。

核心函数：
  int dpp(int len) — 核心算法函数
  int sovle(int x) — 核心算法函数
  int sakura(无参数) — 后缀数组

复杂度：时间复杂度取决于状态数和转移复杂度

适用场景：与数字各位有关的计数/最优化问题

```cpp
#include<cstdio>
#include<cmath>
#define R register int
using namespace std;
int i,j,k,a,b,l,ans,num[12],dp[12][10];
inline int dpp(int len){
    ans=0;
    for(i=1;i<len;i++)
        for(j=1;j<10;j++)
            ans+=dp[i][j];
    for(j=1;j<num[len];j++)ans+=dp[len][j];
    for(i=len-1;i>0;i--){
        for(j=0;j<num[i];j++)
            if(abs(num[i+1]-j)>=2)ans+=dp[i][j];
        if(abs(num[i]-num[i+1])<2)break;
    }
    if(!i)ans++;
    return ans;
}
inline int sovle(int x){
    l=0;
    while(x)num[++l]=x%10,x/=10;
    return dpp(l);
}
inline int sakura(){
    scanf("%d%d",&a,&b);
    for(i=0;i<10;i++)dp[1][i]=1;
    for(i=2;i<11;i++)
        for(j=0;j<10;j++)
            for(k=0;k<10;k++)
                if(abs(j-k)>=2)
                    dp[i][j]+=dp[i-1][k];
    printf("%d",sovle(b)-sovle(a-1));
}
int QAQWQ=sakura();
int main(){}

```

### 5.4 插头DP

**插头DP** *(Eat the Trees)*

> 【插头DP（Eat the Trees）】
插头 DP（Plug DP / 轮廓线 DP）模板，用于网格路径覆盖问题。

核心函数：
  void in(Re &x) — 核心算法函数

关键配置：
N=15,M=8192+3

复杂度：时间复杂度取决于状态数和转移复杂度

说明：freopen("123.txt","r",stdin);

适用场景：网格上的路径覆盖/回路计数问题（如哈密顿回路、多米诺覆盖）

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=15,M=8192+3;
int n,m,o,V,T,A[N][N];LL dp[2][M];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
int main(){
//	freopen("123.txt","r",stdin);
	in(T);
	while(T--){
		in(n),in(m),V=(1<<m+1)-1;
		for(Re i=1;i<=n;++i)
			for(Re j=1;j<=m;++j)
				in(A[i][j]);
		for(Re j=0;j<=V;++j)dp[0][j]=dp[1][j]=0;
		dp[o][0]=1;
		for(Re i=1;i<=n;++i){
			o^=1;
			for(Re s=0;s<=V;++s)dp[o][s]=(s&1)?0:dp[o^1][s>>1];
			for(Re j=1;j<=m;++j){
				o^=1;
				for(Re s=0;s<=V;++s)dp[o][s]=0;
				for(Re s=0;s<=V;++s)if(dp[o^1][s]){
					Re L=(s>>j-1)&1,U=(s>>j+1-1)&1;
					if(A[i][j]){// 撤销操作
						dp[o][s^(1<<j-1)^(1<<j+1-1)]+=dp[o^1][s];
						if(L!=U)dp[o][s]+=dp[o^1][s];
					}
					else{
						if(!L&&!U)dp[o][s]+=dp[o^1][s];
					}
				}
			}
		}
		printf("%lld\n",dp[o][0]);
	}
}

```

**插头DP  (括号表示法)** *(单回路)*

> 【插头DP  (括号表示法)（单回路）】
插头 DP（Plug DP / 轮廓线 DP）模板，用于网格路径覆盖问题。

核心函数：
  void in(Re &x) — 核心算法函数

关键配置：
N=14,M=1594323+3

复杂度：时间复杂度取决于状态数和转移复杂度

说明：freopen("123.txt","r",stdin);；printf("edx=%d, edy=%d\n",edx,edy);

适用场景：网格上的路径覆盖/回路计数问题（如哈密顿回路、多米诺覆盖）

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=14,M=1594323+3;
int n,m,o,V,edx,edy,Mi[N],A[N][N];LL ans,dp[2][M];char s[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(m),Mi[0]=1;
	for(Re i=1;i<=m+1;++i)Mi[i]=Mi[i-1]*3;V=Mi[m+1]-1;
	for(Re i=1;i<=n;++i){
		scanf("%s",s+1);
		for(Re j=1;j<=m;++j)if(!(A[i][j]=(s[j]=='*')))edx=i,edy=j;
	}
//	printf("edx=%d, edy=%d\n",edx,edy);
	dp[o][0]=1;
	for(Re i=1;i<=n;++i){
		o^=1;
		for(Re s=0;s<=V;++s)dp[o][s]=s%3?0:dp[o^1][s/3];
		for(Re j=1;j<=m;++j){
			o^=1;
			for(Re s=0;s<=V;++s)dp[o][s]=0;
			for(Re s=0;s<=V;++s)if(dp[o^1][s]){
				Re L=s/Mi[j-1]%3,U=s/Mi[j+1-1]%3;
				if(A[i][j]){if(!L&&!U)dp[o][s]+=dp[o^1][s];}
				else if(!L&&!U)dp[o][s+Mi[j-1]+2*Mi[j+1-1]]+=dp[o^1][s];
				else if(!L&&U)dp[o][s]+=dp[o^1][s],dp[o][s+U*Mi[j-1]-U*Mi[j+1-1]]+=dp[o^1][s];
				else if(L&&!U)dp[o][s]+=dp[o^1][s],dp[o][s-L*Mi[j-1]+L*Mi[j+1-1]]+=dp[o^1][s];
				else if(L==1&&U==1){
					Re cnt=1;
					for(Re k=j+2;k<=m;++k){
						if(s/Mi[k-1]%3==1)++cnt;
						else if(s/Mi[k-1]%3==2)--cnt;
						if(!cnt){dp[o][s-Mi[j-1]-Mi[j+1-1]-Mi[k-1]]+=dp[o^1][s];break;}
					}
				}
				else if(L==2&&U==2){
					Re cnt=1;
					for(Re k=j-1;k>=1;--k){
						if(s/Mi[k-1]%3==1)--cnt;
						else if(s/Mi[k-1]%3==2)++cnt;
						if(!cnt){dp[o][s-2*Mi[j-1]-2*Mi[j+1-1]+Mi[k-1]]+=dp[o^1][s];break;}
					}
				}
				else if(L==2&&U==1)dp[o][s-2*Mi[j-1]-Mi[j+1-1]]+=dp[o^1][s];
				else if(L==1&&U==2)if(i==edx&&j==edy&&!(s-Mi[j-1]-2*Mi[j+1-1]))ans+=dp[o^1][s];
			}
		}
	}
	printf("%lld\n",ans);
}

```

**插头DP  (括号表示法+优化状态枚举)** *(单回路)*

> 【插头DP  (括号表示法+优化状态枚举)（单回路）】
插头 DP（Plug DP / 轮廓线 DP）模板，用于网格路径覆盖问题。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re s,LL v) — 加法更新
  void CL(无参数) — 核心算法函数

关键配置：
N=14,M=1594323+3

复杂度：时间复杂度取决于状态数和转移复杂度

说明：freopen("123.txt","r",stdin);；printf("edx=%d, edy=%d\n",edx,edy);

适用场景：网格上的路径覆盖/回路计数问题（如哈密顿回路、多米诺覆盖）

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=14,M=1594323+3;
int n,m,o,V,edx,edy,Mi[N],A[N][N];LL ans,dp[2][M];char s[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
int st[2][M];
inline void add(Re s,LL v){
	if(!dp[o][s])st[o][++st[o][0]]=s;
	dp[o][s]+=v;
}
inline void CL(){
	for(Re i=1;i<=st[o][0];++i)dp[o][st[o][i]]=0;
	st[o][0]=0;
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(m),Mi[0]=1;
	for(Re i=1;i<=m+1;++i)Mi[i]=Mi[i-1]*3;V=Mi[m+1]-1;
	for(Re i=1;i<=n;++i){
		scanf("%s",s+1);
		for(Re j=1;j<=m;++j)if(!(A[i][j]=(s[j]=='*')))edx=i,edy=j;
	}
//	printf("edx=%d, edy=%d\n",edx,edy);
	dp[o][st[o][++st[o][0]]=0]=1;
	for(Re i=1;i<=n;++i){
		o^=1,CL();
		for(Re I=1;I<=st[o^1][0];++I)if(st[o^1][I]*3<=V&&dp[o^1][st[o^1][I]])
			dp[o][st[o][++st[o][0]]=st[o^1][I]*3]=dp[o^1][st[o^1][I]];
		for(Re j=1;j<=m;++j){
			o^=1,CL();
			for(Re I=1;I<=st[o^1][0];++I)if(dp[o^1][st[o^1][I]]){
				Re s=st[o^1][I];LL v=dp[o^1][s];
				Re L=s/Mi[j-1]%3,U=s/Mi[j+1-1]%3;
				if(A[i][j]){if(!L&&!U)add(s,v);}
				else if(!L&&!U)add(s+Mi[j-1]+2*Mi[j+1-1],v);
				else if(!L&&U)add(s,v),add(s+U*Mi[j-1]-U*Mi[j+1-1],v);
				else if(L&&!U)add(s,v),add(s-L*Mi[j-1]+L*Mi[j+1-1],v);
				else if(L==1&&U==1){
					Re cnt=1;
					for(Re k=j+2;k<=m;++k){
						if(s/Mi[k-1]%3==1)++cnt;
						else if(s/Mi[k-1]%3==2)--cnt;
						if(!cnt){add(s-Mi[j-1]-Mi[j+1-1]-Mi[k-1],v);break;}
					}
				}
				else if(L==2&&U==2){
					Re cnt=1;
					for(Re k=j-1;k>=1;--k){
						if(s/Mi[k-1]%3==1)--cnt;
						else if(s/Mi[k-1]%3==2)++cnt;
						if(!cnt){add(s-2*Mi[j-1]-2*Mi[j+1-1]+Mi[k-1],v);break;}
					}
				}
				else if(L==2&&U==1)add(s-2*Mi[j-1]-Mi[j+1-1],v);
				else if(L==1&&U==2)if(i==edx&&j==edy&&!(s-Mi[j-1]-2*Mi[j+1-1]))ans+=v;
			}
		}
	}
	printf("%lld\n",ans);
}

```

**地板** *(三进制插头dp)*

> 【地板（三进制插头dp）】
插头 DP（Plug DP / 轮廓线 DP）模板，用于网格路径覆盖问题。

核心函数：
  void in(Re &x) — 核心算法函数
  void mo(Re &x) — 核心算法函数

关键配置：
N=103,M=177147+3,P=20110520

复杂度：时间复杂度取决于状态数和转移复杂度

说明：freopen("123.txt","r",stdin);

适用场景：网格上的路径覆盖/回路计数问题（如哈密顿回路、多米诺覆盖）

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=103,M=177147+3,P=20110520;
int n,m,o,V,Mi[N],A[N][N],A_[N][N],dp[2][M];char s[N];//0:没有插头 1:还没完成的插头 2:已经完成的插头
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void mo(Re &x){if(x>P)x-=P;}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(m);
	for(Re i=1;i<=n;++i){
		scanf("%s",s+1);
		for(Re j=1;j<=m;++j)A[i][j]=(s[j]=='*');
	}
	if(n<m){
		for(Re i=1;i<=n;++i)
			for(Re j=1;j<=m;++j)
				A_[j][i]=A[i][j];
		swap(n,m);
		for(Re i=1;i<=n;++i)
			for(Re j=1;j<=m;++j)
				A[i][j]=A_[i][j];
	}
	Mi[0]=1;for(Re i=1;i<=m+1;++i)Mi[i]=Mi[i-1]*3;
	V=Mi[m+1]-1,dp[o][0]=1;
	for(Re i=1;i<=n;++i){
		o^=1;
		for(Re s=0;s<=V;++s)dp[o][s]=s%3?0:dp[o^1][s/3];
		for(Re j=1;j<=m;++j){
			o^=1;
			for(Re s=0;s<=V;++s)dp[o][s]=0;
			for(Re s=0;s<=V;++s)if(dp[o^1][s]){
				Re L=s/Mi[j-1]%3,U=s/Mi[j+1-1]%3,ML=Mi[j-1],MU=Mi[j+1-1];
				if(A[i][j]){
					if(!L&&!U)mo(dp[o][s]+=dp[o^1][s]);
				}
				else{
					if(L==0&&U==0){
						mo(dp[o][s+ML]+=dp[o^1][s]);
						mo(dp[o][s+MU]+=dp[o^1][s]);
						mo(dp[o][s+2*ML+2*MU]+=dp[o^1][s]);
					}
					if(L==0&&U==1){
						mo(dp[o][s+MU]+=dp[o^1][s]);
						mo(dp[o][s+ML-MU]+=dp[o^1][s]);
					}
					if(L==0&&U==2){
						mo(dp[o][s+2*ML-2*MU]+=dp[o^1][s]);
						mo(dp[o][s-2*MU]+=dp[o^1][s]);
					}
					if(L==1&&U==0){
						mo(dp[o][s+ML]+=dp[o^1][s]);
						mo(dp[o][s-ML+MU]+=dp[o^1][s]);
					}
					if(L==1&&U==1)mo(dp[o][s-ML-MU]+=dp[o^1][s]);
					if(L==1&&U==2);
					if(L==2&&U==0){
						mo(dp[o][s-2*ML+2*MU]+=dp[o^1][s]);
						mo(dp[o][s-2*ML]+=dp[o^1][s]);
					}
					if(L==2&&U==1);
					if(L==2&&U==2);
				}
			}
		}
	}
	printf("%d\n",dp[o][0]);
}

```

## 6. 字符串

### 6.1 KMP

**KMP** *(kmp)*

> 【KMP（Knuth-Morris-Pratt）字符串匹配算法】
▪ buildNext(pattern) — 构建 next 数组（前缀函数）：对模式串每个位置 i，计算以 i 结尾的最长公共前后缀长度。失配时 j=next[j-1] 回退，O(M)
▪ search(text, pattern) — 在 text 中搜索 pattern：双指针扫描，匹配时 i++,j++；失配时若 j>0 则 j=next[j-1] 否则 i++，O(N+M)
无回溯匹配，效率远高于暴力。适用于单模式串匹配、字符串周期分析、最小循环节计算。

```cpp
// KMP算法：构建next数组
vector<int> buildNext(const string& pattern) {
    int n = pattern.size();
    vector<int> next(n, 0);
    int j = 0;
    for (int i = 1; i < n; ++i) {
        while (j > 0 && pattern[i] != pattern[j]) {
            j = next[j - 1];
        }
        if (pattern[i] == pattern[j]) {
            j++;
        }
        next[i] = j;
    }
    return next;
}

// KMP算法：在文本中查找模式串，返回所有匹配的起始位置
vector<int> kmpSearch(const string& text, const string& pattern) {
    vector<int> result;
    int n = text.size();
    int m = pattern.size();
    if (m == 0) return result;
    
    vector<int> next = buildNext(pattern);
    int j = 0;
    for (int i = 0; i < n; ++i) {
        while (j > 0 && text[i] != pattern[j]) {
            j = next[j - 1];
        }
        if (text[i] == pattern[j]) {
            j++;
        }
        if (j == m) {
            result.push_back(i - m + 1);
            j = next[j - 1];
        }
    }
    return result;
}
```

**KMP** *(kmp)*

> 【KMP】
KMP（Knuth-Morris-Pratt）字符串匹配模板，失配时利用前缀函数快速回退。

复杂度：预处理 O(M)，匹配 O(N+M)

```cpp
#include<iostream>
#include<cstdio>
#include<string>
using namespace std;
int i,j,n,m,next[1000005];string a,b;
int main(){
	cin>>a>>b;
	n=a.size();a='$'+a;
	m=b.size();b='$'+b;
	for(i=2,j=0;i<=m;i++){
		while(j&&b[i]!=b[j+1])j=next[j];
		if(b[i]==b[j+1])j++;
		next[i]=j;
	}
	for(i=1,j=0;i<=n;i++){
		while(j&&a[i]!=b[j+1])j=next[j];
		if(a[i]==b[j+1])j++;
		if(j==m){j=next[j];printf("%d\n",i-m+1);}
	}
	for(i=1;i<=m;i++)printf("%d ",next[i]);
}

```

### 6.2 Manacher

**manacher** *(标准700ms)*

> luogu-judger-enable-o2

```cpp
// luogu-judger-enable-o2
#include<algorithm>
#include<cstdio>
using namespace std;
const int N=22000003;
char a[N]={'$','|'},c=getchar();int r[N],mid,ans,R,n=1,i;
int main(){
    while(c>='a'&&c<='z')a[++n]=c,a[++n]='|',c=getchar();
    for(i=1;i<=n;i++){
        if(i<=R)r[i]=min(r[(mid<<1)-i],R-i+1);
        else r[i]=1;
        while(a[i-r[i]]==a[i+r[i]])r[i]++;
        if(i+r[i]-1>R)mid=i,R=i+r[i]-1;
        ans=max(ans,r[i]-1);
    }
    printf("%d",ans);
}

```

**manacher(仅适用于找最长回文长度)** *(玄学150ms)*

> luogu-judger-enable-o2

```cpp
// luogu-judger-enable-o2
#include<cstdio>
char a[11550000]={'$'};int T,i,s,l,r;
int main(){
    gets(a+1);
    for(i=1;a[i];++i){
        l=r=i;
        while(a[i]==a[r+1])++r;
        i=r;
        while(a[r+1]==a[l-1])++r,--l;
        if(r-l+1>s)s=r-l+1;
    }
    printf("%d",s);
}

```

### 6.3 Trie

**Trie树** *(于是他错误的点名开始了)*

> 【Trie树（于是他错误的点名开始了）】
Trie（字典树/前缀树）模板，高效存储和检索字符串集合。

核心函数：
  void add(char ch[]) — 加法更新
  int find(char ch[]) — 查找（并查集寻根/二分查找）

```cpp
#pragma once
#include<cstring>
#include<cstdio>
#define R register int
using namespace std;
const int SP=500003;
int trie[SP][26],pan[SP],ed[SP],re,t=1,n;
char ch[55];
inline void add(char ch[]){
    R a,i=0,p=1,m=strlen(ch);
    for(;i<m;i++){
        a=ch[i]-'a';
        if(!trie[p][a])trie[p][a]=++t;
        p=trie[p][a];
    }
    ed[p]=1;
}
inline int find(char ch[]){
    R re,i=0,p=1,m=strlen(ch);
    for(;i<m;i++){
        p=trie[p][ch[i]-'a'];
        if(!p)return 0;
    }
    re=ed[p];
    if(ed[p])ed[p]++;
    return re;
}
int main(){
    scanf("%d",&n);
    while(n--){scanf("%s",ch);add(ch);}
    scanf("%d",&n);
    while(n--){
        scanf("%s",ch);
        re=find(ch);
        if(!re)printf("WRONG\n");
        else if(re==1)printf("OK\n");
        else printf("REPEAT\n");
    }
}

```

**Trie树** *(前缀统计)*

> 【Trie树（前缀统计）】
Trie（字典树/前缀树）模板，高效存储和检索字符串集合。

核心函数：
  void add(char ch[]) — 加法更新
  int find(char ch[]) — 查找（并查集寻根/二分查找）

```cpp
#include<cstring>
#include<cstdio>
#define R register int
using namespace std;
const int SP=500003;
int trie[SP][26],pan[SP],ed[SP],re,t=1,n,m;char ch[55];
inline void add(char ch[]){
    R a,i=0,p=1,l=strlen(ch);
    for(;i<l;i++){
        a=ch[i]-'a';
        if(!trie[p][a])trie[p][a]=++t;
        p=trie[p][a];
    }
    ++ed[p];
}
inline int find(char ch[]){
    R i=0,p=1,ans=0,l=strlen(ch);
    for(;i<l;i++){
        p=trie[p][ch[i]-'a'];
        ans+=ed[p];
        if(!p)return ans;
    }
    return ans;
}
int main(){
    scanf("%d%d",&n,&m);
    while(n--){scanf("%s",ch);add(ch);}
    while(m--){scanf("%s",ch);printf("%d\n",find(ch));}
}

```

**可持久化Trie树** *(最大异或和)*

> 【可持久化Trie树（最大异或和）】
Trie（字典树/前缀树）模板，高效存储和检索字符串集合。

核心函数：
  void in(Re &x) — 核心算法函数
  void insert(Re p,Re q,Re o,Re x) — 插入元素
  int ask(Re p,Re q,Re o,Re x) — 核心算法函数

核心结构体：Trie

关键配置：
N=6e5+5,logN=24

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#define LL long long
#define Re register int
using namespace std;
const int N=6e5+5,logN=24;
int n,x,y,z,T,A[N],pt[N];char op;
inline void in(Re &x){
	Re fu=0;x=0;char ch=getchar();
	while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=fu?-x:x;
}
struct Trie{
	int O,cnt[N*(logN+2)],tr[N*(logN+2)][2];
	inline void insert(Re p,Re q,Re o,Re x){
		if(o<0)return;Re i=(x>>o)&1;
		tr[p][i]=++O,tr[p][i^1]=tr[q][i^1];
		cnt[tr[p][i]]=cnt[tr[q][i]]+1;
		insert(tr[p][i],tr[q][i],o-1,x);
	}
	inline int ask(Re p,Re q,Re o,Re x){
		if(o<0)return 0;Re i=(x>>o)&1;
		if(cnt[tr[q][i^1]]>cnt[tr[p][i^1]])return (1<<o)+ask(tr[p][i^1],tr[q][i^1],o-1,x);
		else return ask(tr[p][i],tr[q][i],o-1,x);
	}
}T1;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T);
	for(Re i=1;i<=n;++i)in(A[i]),A[i]^=A[i-1],T1.insert(pt[i]=++T1.O,pt[i-1],logN,A[i]);
	T1.insert(pt[0]=++T1.O,0,logN,0);
	while(T--){
		scanf(" %c",&op),in(x);
		if(op=='A')++n,A[n]=A[n-1]^x,T1.insert(pt[n]=++T1.O,pt[n-1],logN,A[n]);
		else in(y),in(z),--x,--y,printf("%d\n",T1.ask(x?pt[x-1]:0,pt[y],logN,z^A[n]));
	}
}

```

### 6.4 字符串Hash

**Snowflake Snow Snowflakes** *(最小表示法+Hash)*

> 【Snowflake Snow Snowflakes（最小表示法+Hash）】
字符串哈希（String Hashing）模板，将字符串映射为整数便于快速比较。

核心函数：
  int sakura(int a[]) — 后缀数组
  uLL Hash(int a[],int st) — 哈希计算
  uLL find(int a[]) — 查找（并查集寻根/二分查找）

适用场景：字符串匹配、回文检测、子串统计、字典树检索

```cpp
#include<algorithm>
#include<cstdio>
#include<map>
#define R register int
#define uLL long long
int n,t,p=13333331,re,A[13];
std::map<uLL,int>pan;
inline int sakura(int a[]){
    R i=1,j=2,k;
    while(i<=6&&j<=6){
        k=0;
        while(k<6&&a[i+k]==a[j+k])++k;
        if(k==6)break;
        if(a[i+k]>a[j+k]){i+=k+1;if(i==j)++i;}
        else{j+=k+1;if(i==j)++j;}
    }
    return i<j?i:j;
}
inline uLL Hash(int a[],int st){
    R i=0;uLL x=0;
    for(;i<6;++i)x=x*p+(uLL)a[st+i];
    return x;
}
inline uLL find(int a[]){
    R x,y,i=1,k=0,b[13];
    for(;i<=6;i++)b[i]=a[7-i];
    for(i=1;i<=6;i++)a[i+6]=a[i],b[i+6]=b[i];
	x=sakura(a),y=sakura(b);
    for(i=0;i<6;i++)
		if(a[x+i]<b[y+i])return Hash(a,x);
		else if(a[x+i]>b[y+i])return Hash(b,y);
    return Hash(a,x);
}
int main(){
    scanf("%d",&n);R i,j;
    for(i=1;i<=n;i++){
        for(j=1;j<=6;j++)scanf("%d",&A[j]);
        uLL re=find(A);
        if(pan[re]){printf("Twin snowflakes found.");return 0;}
    	pan[re]=1;
	}
    printf("No two snowflakes are alike.");
}

```

**字符串Hash表** *(兔子与兔子)*

> 【字符串Hash表（兔子与兔子）】
字符串哈希（String Hashing）模板，将字符串映射为整数便于快速比较。

核心函数：
  LL Hash(int l,int r) — 哈希计算

关键配置：
N=1e6+5

适用场景：字符串匹配、回文检测、子串统计、字典树检索

```cpp
#include<iostream>
#include<string>
#include<cstdio>
#define LL long long
using namespace std;
const int N=1e6+5;
int l1,r1,l2,r2,n,m,i,p=27;
LL f[N],mi[N];string a;
inline LL Hash(int l,int r){return f[r]-f[l-1]*mi[r-l+1];}
int main(){
    cin>>a;n=a.size();a='$'+a;mi[0]=1;
    for(i=1;i<=n;i++)f[i]=f[i-1]*p+a[i]-'a'+1,mi[i]=mi[i-1]*p;
    scanf("%d",&m);
    while(m--){
        scanf("%d%d%d%d",&l1,&r1,&l2,&r2);
        if(Hash(l1,r1)==Hash(l2,r2))printf("Yes\n");
        else printf("No\n");
    }
}

```

### 6.5 最小表示法

**Necklace** *(最小表示法判断同构)*

> 【Necklace（最小表示法判断同构）】
最小表示法模板，求字符串循环同构的最小字典序表示。

核心函数：
  int sakura(char a[]) — 后缀数组
  int judge(char a[],char b[]) — 判定函数

```cpp
#include<cstring>
#include<cstdio>
int i,j,k,n,m,x,y,st;char a[2000003],b[2000003];
inline int sakura(char a[]){
    i=1,j=2;
    while(i<=n&&j<=n){
        k=0;
        while(k<n&&a[i+k]==a[j+k])++k;
        if(k==n)break;
        if(a[i+k]>a[j+k]){i+=k+1;if(i==j)++i;}
        else{j+=k+1;if(i==j)++j;}
    }
    return i<j?i:j;
}
inline int judge(char a[],char b[]){
    n=strlen(a+1);
    for(i=1;i<=n;++i)a[i+n]=a[i],b[i+n]=b[i];
    x=sakura(a),y=sakura(b);
    a[x+n]=b[y+n]='\0';
    return !strcmp(a+x,b+y);
}
int main(){
    scanf("%s%s",a+1,b+1);
    if(judge(a,b)){printf("Yes\n");puts(a+x);}
    else printf("No");
}

```

**Snowflake Snow Snowflakes** *(最小表示法+Hash)*

> 【Snowflake Snow Snowflakes（最小表示法+Hash）】
最小表示法模板，求字符串循环同构的最小字典序表示。

核心函数：
  int sakura(int a[]) — 后缀数组
  uLL Hash(int a[],int st) — 哈希计算
  uLL find(int a[]) — 查找（并查集寻根/二分查找）

```cpp
#include<algorithm>
#include<cstdio>
#include<map>
#define R register int
#define uLL long long
int n,t,p=13333331,re,A[13];
std::map<uLL,int>pan;
inline int sakura(int a[]){
    R i=1,j=2,k;
    while(i<=6&&j<=6){
        k=0;
        while(k<6&&a[i+k]==a[j+k])++k;
        if(k==6)break;
        if(a[i+k]>a[j+k]){i+=k+1;if(i==j)++i;}
        else{j+=k+1;if(i==j)++j;}
    }
    return i<j?i:j;
}
inline uLL Hash(int a[],int st){
    R i=0;uLL x=0;
    for(;i<6;++i)x=x*p+(uLL)a[st+i];
    return x;
}
inline uLL find(int a[]){
    R x,y,i=1,k=0,b[13];
    for(;i<=6;i++)b[i]=a[7-i];
    for(i=1;i<=6;i++)a[i+6]=a[i],b[i+6]=b[i];
	x=sakura(a),y=sakura(b);
    for(i=0;i<6;i++)
		if(a[x+i]<b[y+i])return Hash(a,x);
		else if(a[x+i]>b[y+i])return Hash(b,y);
    return Hash(a,x);
}
int main(){
    scanf("%d",&n);R i,j;
    for(i=1;i<=n;i++){
        for(j=1;j<=6;j++)scanf("%d",&A[j]);
        uLL re=find(A);
        if(pan[re]){printf("Twin snowflakes found.");return 0;}
    	pan[re]=1;
	}
    printf("No two snowflakes are alike.");
}

```

**最小表示法** *(工艺)*

> 【最小表示法（工艺）】
最小表示法模板，求字符串循环同构的最小字典序表示。

核心函数：
  void in(Re &x) — 核心算法函数

关键配置：
N=3e5+5

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=3e5+5;
int n,s[N<<1];
inline void in(Re &x){
    Re f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
int main(){
	in(n);
	for(Re i=1;i<=n;++i)in(s[i]),s[i+n]=s[i];
	Re i=1,j=2;
	while(i<=n&&j<=n){
		Re k=1;
		while(k<=n&&s[i+k-1]==s[j+k-1])++k;
		if(k>n)break;
		if(s[i+k-1]>s[j+k-1])i+=k;
		else j+=k;
		if(i==j)++i;
	}
	Re st=min(i,j);
	for(Re i=0;i<n;++i)printf("%d ",s[st+i]);
}

```

### 6.6 AC自动机与后缀数组

**Cyclical Quest** *(暴力解法-广义SAM不加特判会MLE)*

> 【Cyclical Quest（暴力解法-广义SAM不加特判会MLE）】
字符串高级算法模板。

核心函数：
  void in(Re &x) — 核心算法函数
  int insert(Re ch,Re op,Re last) — 插入元素
  void add(Re x,Re y) — 加法更新
  void dfs(Re x) — 深度优先搜索遍历
  void build(无参数) — 构建数据结构（建树/建图）
  int ask(Re p,Re len) — 核心算法函数

核心结构体：Suffix_Automaton, QAQ

关键配置：
N=3e6+5,M=1e6+3,logN=21

说明：freopen("123.txt","r",stdin);

适用场景：最长公共子串、不同子串计数、字符串周期分析

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<vector>
#include<map>
#define LL long long
#define Re register int
using namespace std;
const int N=3e6+5,M=1e6+3,logN=21;
int n,T,len[M],vis[N<<1],tmp[N<<1];LL ans;char s[M];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
vector<int>Q[M];
struct Suffix_Automaton{
	int O,last,siz[N<<1],link[N<<1],maxlen[N<<1];map<int,int>trans[N<<1];
	Suffix_Automaton(){O=1;}
	inline int insert(Re ch,Re op,Re last){
		if(trans[last].find(ch)!=trans[last].end()){
			Re p=last,x=trans[p][ch];
            if(maxlen[p]+1==maxlen[x])return x;
            else{
                Re y=++O;maxlen[y]=maxlen[p]+1;
                for(map<int,int>::iterator it=trans[x].begin();it!=trans[x].end();++it)trans[y].insert(*it);
                while(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];
                link[y]=link[x],link[x]=y;
                return y;
            }
		}
		Re z=++O,p=last;if(op)siz[z]=1;maxlen[z]=maxlen[p]+1;
		while(p&&trans[p].find(ch)==trans[p].end())trans[p][ch]=z,p=link[p];
		if(!p)link[z]=1;
		else{
			Re x=trans[p][ch];
			if(maxlen[x]==maxlen[p]+1)link[z]=x;
			else{
				Re y=++O;maxlen[y]=maxlen[p]+1;
				for(map<int,int>::iterator it=trans[x].begin();it!=trans[x].end();++it)trans[y].insert(*it);
				while(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];
				link[y]=link[x],link[x]=link[z]=y;
			}
		}
		return z;
	}
	int o,head[N<<1];
	struct QAQ{int to,next;}a[N<<1];
	inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
	inline void dfs(Re x){
		for(Re i=head[x];i;i=a[i].next)dfs(a[i].to),siz[x]+=siz[a[i].to];
	}
	inline void build(){
		for(Re i=2;i<=O;++i)add(link[i],i);dfs(1);
	}
	inline int ask(Re p,Re len){
		while(maxlen[link[p]]>=len)p=link[p];return p;
	}
}SAM;
int main(){
//    freopen("123.txt","r",stdin);
    scanf("%s",s+1),n=strlen(s+1),in(T);
    for(Re i=1,last=1;s[i];++i)last=SAM.insert(s[i]-'a',1,last);
    for(Re i=1;i<=T;++i){
    	scanf("%s",s+1),len[i]=strlen(s+1);Re last=1;
    	for(Re j=1;j<len[i];++j)last=SAM.insert(s[j]-'a',0,last);
    	Q[i].push_back(last=SAM.insert(s[len[i]]-'a',0,last));
    	for(Re j=1;j<len[i];++j)Q[i].push_back(last=SAM.insert(s[j]-'a',0,last));
	}
	SAM.build();
    for(Re i=1;i<=T;++i){
    	tmp[0]=ans=0;
    	for(Re j=0,SZ=Q[i].size();j<SZ;++j){
    		Re x=SAM.ask(Q[i][j],len[i]);
    		if(vis[x])continue;
    		tmp[++tmp[0]]=x,vis[x]=1,ans+=SAM.siz[x];
		}
		for(Re j=1;j<=tmp[0];++j)vis[tmp[j]]=0;
		printf("%lld\n",ans);
	}
}

```

**Sevenk Love Oimaster** *(在线广义SAM)*

> 【Sevenk Love Oimaster（在线广义SAM）】
字符串高级算法模板。

核心函数：
  void in(Re &x) — 核心算法函数
  int insert(Re ch,Re last) — 插入元素
  void updata(Re p,Re id) — 核心算法函数
  void ask(char ch[]) — 核心算法函数

核心结构体：Suffix_Automaton

关键配置：
N=2e5+5

适用场景：最长公共子串、不同子串计数、字符串周期分析

```cpp
#include<algorithm>
#include<cstdio>
#include<queue>
#define Re register int
#define LL long long
using namespace std;
const int N=2e5+5;
int n,t,T,Len[N];char s[N],ch[360003];
inline void in(Re &x){
    int fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
struct Suffix_Automaton{
	int O,cnt[N],link[N],maxlen[N],trans[N][26];
	Suffix_Automaton(){O=1;}
	inline int insert(Re ch,Re last){
		if(trans[last][ch]&&maxlen[last]+1==maxlen[trans[last][ch]])return trans[last][ch];
		Re x,y,z=++O,p=last,flag=0;maxlen[z]=maxlen[last]+1;
		while(p&&!trans[p][ch])trans[p][ch]=z,p=link[p];
		if(!p)link[z]=1;
		else{
			x=trans[p][ch];
			if(maxlen[p]+1==maxlen[x])link[z]=x;
			else{
				if(maxlen[p]+1==maxlen[z]/*����д��p==last*/)flag=1;
				y=++O;maxlen[y]=maxlen[p]+1;
				for(Re i=0;i<26;++i)trans[y][i]=trans[x][i];
				while(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];
				link[y]=link[x],link[z]=link[x]=y;
			}
		}
		return flag?y:z;
	}
	int co[N];
	inline void updata(Re p,Re id){
		while(p&&co[p]!=id)++cnt[p],co[p]=id,p=link[p];
	}
	inline void ask(char ch[]){
		Re p=1,flag=1;
		for(Re i=1;ch[i]&&flag;++i){
			Re a=ch[i]-'a';
			if(trans[p][a])p=trans[p][a];
			else flag=0;
		}
		printf("%d\n",flag?cnt[p]:0);
	}
}SAM;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T);
	for(Re i=1;i<=n;++i){
		scanf("%s",ch+1);Re last=1;
		for(Re j=1;ch[j];Len[i]=j,++j)last=SAM.insert(s[++t]=ch[j]-'a',last);
	}
	for(Re i=1,t=0;i<=n;++i)
		for(Re j=1,p=1;j<=Len[i];++j)
			SAM.updata(p=SAM.trans[p][s[++t]],i);
	while(T--)scanf("%s",ch+1),SAM.ask(ch);
}

```

**Sevenk Love Oimaster** *(离线广义SAM)*

> 【Sevenk Love Oimaster（离线广义SAM）】
字符串高级算法模板。

核心函数：
  void in(Re &x) — 核心算法函数
  void insert(char ch[],Re id) — 插入元素
  int insert(Re ch,Re last) — 插入元素
  void updata(Re p,Re id) — 核心算法函数
  void build(无参数) — 构建数据结构（建树/建图）
  void ask(char ch[]) — 核心算法函数

核心结构体：Trie, Suffix_Automaton

关键配置：
N=2e5+5

适用场景：最长公共子串、不同子串计数、字符串周期分析

```cpp
#include<algorithm>
#include<cstdio>
#include<queue>
#define Re register int
#define LL long long
using namespace std;
const int N=2e5+5;
int n,t,T,Len[N];char s[N],ch[360003];
inline void in(Re &x){
    int fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
struct Trie{
	int O,c[N],fa[N],tr[N][26];
	Trie(){O=1;}
	inline void insert(char ch[],Re id){
		Re p=1;
		for(Re i=1;ch[i];Len[id]=i,++i){
			Re a=ch[i]-'a';s[++t]=a;
			if(!tr[p][a])tr[p][a]=++O,fa[O]=p,c[O]=a;
			p=tr[p][a];
		}
	}
}T1;
struct Suffix_Automaton{
	int O,pos[N],cnt[N],link[N],maxlen[N],trans[N][26];queue<int>Q;
	Suffix_Automaton(){O=1;}
	inline int insert(Re ch,Re last){
		Re x,y,z=++O,p=last,flag=0;maxlen[z]=maxlen[last]+1;
		while(p&&!trans[p][ch])trans[p][ch]=z,p=link[p];
		if(!p)link[z]=1;
		else{
			x=trans[p][ch];
			if(maxlen[p]+1==maxlen[x])link[z]=x;
			else{
				y=++O;maxlen[y]=maxlen[p]+1;
				for(Re i=0;i<26;++i)trans[y][i]=trans[x][i];
				while(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];
				link[y]=link[x],link[z]=link[x]=y;
			}
		}
		return flag?y:z;
	}
	int co[N];
	inline void updata(Re p,Re id){
		while(p&&co[p]!=id)++cnt[p],co[p]=id,p=link[p];
	}
	inline void build(){
		for(Re i=0;i<26;++i)if(T1.tr[1][i])Q.push(T1.tr[1][i]);
		pos[1]=1;
		while(!Q.empty()){
			Re x=Q.front();Q.pop();
			pos[x]=insert(T1.c[x],pos[T1.fa[x]]);
			for(Re i=0;i<26;++i)if(T1.tr[x][i])Q.push(T1.tr[x][i]);
		}
		for(Re i=1,t=0;i<=n;++i)
			for(Re j=1,p=1;j<=Len[i];++j)
				updata(pos[p=T1.tr[p][s[++t]]],i);
	}
	inline void ask(char ch[]){
		Re p=1,flag=1;
		for(Re i=1;ch[i]&&flag;++i){
			Re a=ch[i]-'a';
			if(trans[p][a])p=trans[p][a];
			else flag=0;
		}
		printf("%d\n",flag?cnt[p]:0);
	}
}SAM;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T);
	for(Re i=1;i<=n;++i)scanf("%s",ch+1),T1.insert(ch,i);
	SAM.build();
	while(T--)scanf("%s",ch+1),SAM.ask(ch);
}

```

**AC自动机** *(Trie图)*

> 【AC自动机（Trie图）】
AC 自动机（Aho-Corasick Automaton）模板，多模式串匹配。

核心函数：
  void in(Re &x) — 核心算法函数
  void insert(char ch[],Re id) — 插入元素
  void get_fail(无参数) — 获取值
  void sakura(char ch[]) — 后缀数组

核心结构体：AC_Automaton

关键配置：
N=2e5+3

说明：freopen("123.txt","r",stdin);

适用场景：最长公共子串、不同子串计数、字符串周期分析

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#define Re register int
#define LL long long
using namespace std;
const int N=2e5+3;
int n;char ch[N*10];
inline void in(Re &x){
    int fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
struct AC_Automaton{
	int O,edp[N],fail[N],tr[N][26];queue<int>Q;
	AC_Automaton(){O=1;}
	inline void insert(char ch[],Re id){
		Re p=1;
		for(Re i=1;ch[i];++i){
			Re a=ch[i]-'a';
			if(!tr[p][a])tr[p][a]=++O;
			p=tr[p][a];
		}
		edp[id]=p;
	}
	inline void get_fail(){
		for(Re i=0;i<26;++i)tr[0][i]=1;
		Q.push(1);
		while(!Q.empty()){
			Re x=Q.front();Q.pop();
			for(Re i=0;i<26;++i)
				if(tr[x][i])fail[tr[x][i]]=tr[fail[x]][i],Q.push(tr[x][i]);
				else tr[x][i]=tr[fail[x]][i];
		}
	}
	int ru[N],cnt[N];
	inline void sakura(char ch[]){
		for(Re i=1,p=1;ch[i];++i)p=tr[p][ch[i]-'a'],++cnt[p];
		for(Re i=2;i<=O;++i)++ru[fail[i]];
		for(Re i=1;i<=O;++i)if(!ru[i])Q.push(i);
		while(!Q.empty()){
			Re x=Q.front();Q.pop();
			cnt[fail[x]]+=cnt[x];
			if(!(--ru[fail[x]]))Q.push(fail[x]);
		}
		for(Re i=1;i<=n;++i)printf("%d\n",cnt[edp[i]]);
	}
}AC;
int main(){
//	freopen("123.txt","r",stdin);
	in(n);
	for(Re i=1;i<=n;++i)scanf("%s",ch+1),AC.insert(ch,i);
	AC.get_fail();
	scanf("%s",ch+1);AC.sakura(ch);
}

```

**LCT动态维护SAM** *(Substring[Bzoj2555])*

> 【LCT动态维护SAM（Substring[Bzoj2555]）】
后缀自动机（Suffix Automaton）模板，压缩存储所有子串。

核心函数：
  void in(Re &x) — 核心算法函数
  string In(Re mask) — 核心算法函数
  void add(Re p,Re v) — 加法更新
  void pushdown(Re p) — 下传懒标记
  int nort(Re p) — 核心算法函数
  int which(Re p) — 核心算法函数
  void connect(Re p,Re fa,Re o) — 核心算法函数
  void rotate(Re p) — 旋转操作（平衡树）

核心结构体：Suffix_Automaton, Link_Cut_Tree, QAQ

关键配置：
N=12e5+3

说明：freopen("123.txt","r",stdin);

适用场景：最长公共子串、不同子串计数、字符串周期分析

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<string>
#include<queue>
#define LL long long
#define Re register int
using namespace std;
const int N=12e5+3;
int T,ans,mask;char op[10],s[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline string In(Re mask){
    scanf("%s",s);string chars=s;
    for(int j=0;j<chars.length();j++){
        mask=(mask*131+j)%chars.length();
        char t=chars[j];
        chars[j]=chars[mask];
        chars[mask]=t;
    }
    return chars;
}
struct Suffix_Automaton{
	struct Link_Cut_Tree{
		#define pl tr[p].ps[0]
		#define pr tr[p].ps[1]
		#define pf tr[p].fa
		int Q[N];
		struct QAQ{int fa,ans,add,ps[2];}tr[N];
		inline void add(Re p,Re v){tr[p].ans+=v,tr[p].add+=v;}
		inline void pushdown(Re p){
			Re v=tr[p].add;
			if(v){
				if(pl)add(pl,v);
				if(pr)add(pr,v);
				tr[p].add=0;
			}
		}
		inline int nort(Re p){return tr[pf].ps[0]==p||tr[pf].ps[1]==p;}
		inline int which(Re p){return tr[pf].ps[1]==p;}
		inline void connect(Re p,Re fa,Re o){tr[pf=fa].ps[o]=p;}
		inline void rotate(Re p){
			Re fa=pf,fas=which(p);
			Re pa=tr[fa].fa,pas=which(fa);
			Re x=tr[p].ps[fas^1];
			if(nort(fa))tr[pa].ps[pas]=p;pf=pa;
			connect(x,fa,fas),connect(fa,p,fas^1);
		}
		inline void splay(Re p){
			Re x=p,t=0;Q[++t]=x;
			while(nort(x))Q[++t]=x=tr[x].fa;
			while(t)pushdown(Q[t--]);
			for(Re fa;nort(p);rotate(p))
				if(nort(fa=pf))rotate(which(p)==which(fa)?fa:p);
		}
		inline void access(Re p){for(Re son=0;p;son=p,p=pf)splay(p),pr=son;}
		inline void link(Re x,Re y){tr[x].fa=y,access(y),splay(y),add(y,tr[x].ans);}
		inline void cut(Re x){
			access(x),splay(x),add(tr[x].ps[0],-tr[x].ans);
			tr[tr[x].ps[0]].fa=0,tr[x].ps[0]=0;
		}
		inline int ask(Re x){splay(x);return tr[x].ans;}
	}LCT;
	int O,last,link[N],maxlen[N],trans[N][30];
	Suffix_Automaton(){last=O=1;}
	inline void insert(char ch){
		Re z=++O,p=last;LCT.tr[z].ans=1,maxlen[z]=maxlen[last]+1;
		while(p&&!trans[p][ch])trans[p][ch]=z,p=link[p];
		if(!p)link[z]=1,LCT.link(z,1);
		else{
			Re x=trans[p][ch];
			if(maxlen[x]==maxlen[p]+1)link[z]=x,LCT.link(z,x);
			else{
				Re y=++O;maxlen[y]=maxlen[p]+1;
				for(Re i=0;i<26;++i)trans[y][i]=trans[x][i];
				while(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];
				link[y]=link[x],LCT.cut(x),LCT.link(y,link[y]);
				link[x]=link[z]=y,LCT.link(x,y),LCT.link(z,y);
			}
		}
		last=z;
	}
	inline void add(string ch){
		for(Re i=0;ch[i];++i)insert(ch[i]-'A');
	}
	inline int ask(string ch){
		Re p=1;
		for(Re i=0;ch[i];++i)if(!(p=trans[p][ch[i]-'A']))return 0;
		return LCT.ask(p);
	}
}SAM;
int main(){
//    freopen("123.txt","r",stdin);
    in(T),scanf("%s",s+1);
    for(Re i=1;s[i];++i)SAM.insert(s[i]-'A');
	while(T--){
		scanf("%s",op);string s=In(mask);
		if(op[0]=='A')SAM.add(s);
		else mask^=(ans=SAM.ask(s)),printf("%d\n",ans);
	}
}

```

**SAM后缀自动机** *(Suffix_Automaton)*

> 【SAM后缀自动机】
后缀自动机（Suffix Automaton）模板，压缩存储所有子串。

核心函数：
  void in(Re &x) — 核心算法函数
  void insert(char ch) — 插入元素
  void Tuopu(无参数) — 核心算法函数
  void sakura(无参数) — 后缀数组

核心结构体：Suffix_Automaton

关键配置：
N=2e6+5

说明：siz:һ���ȼ���ڵ�endpos��С�������ִ�����；freopen("123.txt","r",stdin);

适用场景：最长公共子串、不同子串计数、字符串周期分析

```cpp
#include<algorithm>
#include<cstdio>
#include<queue>
#define Re register int
#define LL long long
using namespace std;
const int N=2e6+5;
char ch[2000003];
inline void in(Re &x){
    int fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
struct Suffix_Automaton{
	int O,last,ru[N],siz[N],link[N],maxlen[N],minlen[N],trans[N][26];queue<int>Q;
	Suffix_Automaton(){last=O=1;}
	inline void insert(char ch){
		Re z=++O,p=last;siz[z]=1,maxlen[z]=maxlen[last]+1;
		while(p&&!trans[p][ch])trans[p][ch]=z,p=link[p];
		if(!p)link[z]=1;//û�ҵ�trans[...][ch]
		else{
			Re x=trans[p][ch];
			if(maxlen[p]+1==maxlen[x])link[z]=x;
			else{
				Re y=++O;maxlen[y]=maxlen[p]+1;
				
				for(Re i=0;i<26;++i)trans[y][i]=trans[x][i];
				while(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];
				link[y]=link[x];
				
				link[z]=link[x]=y;
			}
		}
		last=z;
	}
	inline void Tuopu(){
		for(Re i=2;i<=O;++i)++ru[link[i]];
		for(Re i=1;i<=O;++i)if(!ru[i])Q.push(i);
		while(!Q.empty()){
			Re x=Q.front();Q.pop();
			siz[link[x]]+=siz[x];
			if(!(--ru[link[x]]))Q.push(link[x]);
		}
	}
	inline void sakura(){
		for(Re i=2;i<=O;++i)minlen[i]=maxlen[link[i]]+1;
		Tuopu();Re ans=0;
		for(Re i=1;i<=O;++i)if(siz[i]>1)ans=max(ans,siz[i]*maxlen[i]);
		printf("%d\n",ans);
	}
}SAM;
int main(){
//	freopen("123.txt","r",stdin);
	scanf("%s",ch+1);
	for(Re i=1;ch[i];++i)SAM.insert(ch[i]-'a');
	SAM.sakura();
}

```

**SAM转后缀树** *(字母 letter)*

> 【SAM转后缀树（字母 letter）】
后缀自动机（Suffix Automaton）模板，压缩存储所有子串。

核心函数：
  void in(Re &x) — 核心算法函数
  void insert(Re ch,Re id) — 插入元素
  void dfs1(Re x) — 深度优先搜索遍历
  void dfs2(Re x) — 深度优先搜索遍历
  LL calc(Re L,Re R) — 计算函数
  void build(无参数) — 构建数据结构（建树/建图）
  char ask(LL K) — 核心算法函数
  void sakura(无参数) — 后缀数组

核心结构体：Sakura2

关键配置：
N=4e5+10

适用场景：最长公共子串、不同子串计数、字符串周期分析

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=4e5+10;
int n,x,y,T;LL P,M,G,K;char s[N>>1];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Sakura2{
    int O,last,pos[N],siz[N],link[N],maxlen[N],trans[N][26];
    // siz[x]: 节点x的出现次数 (endpos的大小)
    inline void insert(Re ch,Re id){
        Re z=++O,p=last;pos[z]=id,siz[z]=1,maxlen[z]=maxlen[last]+1;
        while(p&&!trans[p][ch])trans[p][ch]=z,p=link[p];
        if(!p)link[z]=1;
        else{
            Re x=trans[p][ch];
            if(maxlen[p]+1==maxlen[x])link[z]=x;
            else{
                Re y=++O;maxlen[y]=maxlen[p]+1,pos[y]=pos[x];
                for(Re i=0;i<26;++i)trans[y][i]=trans[x][i];
                while(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];
                link[y]=link[x],link[z]=link[x]=y;
            }
        }
        last=z;
    }
    int t,ID[N],to[N][26];LL S[N];
    inline void dfs1(Re x){
        for(Re i=0;i<26;++i)
            if(to[x][i])dfs1(to[x][i]),siz[x]+=siz[to[x][i]];
    }
    inline void dfs2(Re x){
        if(x!=1)ID[++t]=x;
        for(Re i=0;i<26;++i)if(to[x][i])dfs2(to[x][i]);
    }
    inline LL calc(Re L,Re R){return 1ll*(L+R)*(R-L+1)/2;}
    inline void build(){
        last=O=1;
        for(Re i=1;i<=n/2;++i)swap(s[i],s[n-i+1]);
        for(Re i=1;i<=n;++i)insert(s[i]-'a',i);
        for(Re i=2;i<=O;++i)to[link[i]][s[pos[i]-maxlen[link[i]]]-'a']=i;
        dfs1(1),dfs2(1);
        for(Re i=1;i<=t;++i)x=ID[i],S[i]=S[i-1]+1ll*siz[x]*calc(maxlen[link[x]]+1,maxlen[x]);
    }
    inline char ask(LL K){
        Re l=1,r=t,x;
        while(l<r){
            Re mid=l+r>>1;
            if(S[mid]<K)l=mid+1;
            else r=mid;
        }
        x=ID[l],K-=S[l-1],l=maxlen[link[x]]+1,r=maxlen[x];
        while(l<r){
            Re mid=l+r>>1;
            if(1ll*siz[x]*calc(maxlen[link[x]]+1,mid)<K)l=mid+1;
            else r=mid;
        }
        K-=1ll*siz[x]*calc(maxlen[link[x]]+1,l-1),K=(K-1)%l+1;
        return s[pos[x]-K+1];
    }
    char ans;
    inline void sakura(){
        build();
        while(T--)scanf("%lld%lld",&P,&M),K=P*G%M+1,G+=(ans=ask(K)),putchar(ans),puts("");
    }
}T2;
int main(){
    freopen("letter.in","r",stdin);
    freopen("letter.out","w",stdout);
    scanf("%s",s+1),n=strlen(s+1);in(T);
    T2.sakura();
    fclose(stdin);
    fclose(stdout);
}

```

**SAM转后缀树转后缀数组** *(不同子串个数)*

> 【SAM转后缀树转后缀数组（不同子串个数）】
后缀自动机（Suffix Automaton）模板，压缩存储所有子串。

核心函数：
  void in(Re &x) — 核心算法函数
  void get_height(无参数) — 获取值
  void add(Re x,Re y,Re c) — 加法更新
  void dfs(Re x) — 深度优先搜索遍历
  void insert(Re ch,Re id) — 插入元素
  void build(无参数) — 构建数据结构（建树/建图）

核心结构体：Suffix_Array, Suffix_Tree, Suffix_Automaton

关键配置：
N=1e5+5

说明：freopen("123.txt","r",stdin);

适用场景：最长公共子串、不同子串计数、字符串周期分析

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=1e5+5;
int n;char s[N];LL ans;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Suffix_Array{
	int H[N],SA[N],rank[N],height[N];
	inline void get_height(){
		for(Re i=1;i<=n;++i)rank[SA[i]]=i;
		for(Re i=1,k=0;i<=n;++i){
			if(rank[i]==1)continue;
			if(k)--k;
			Re j=SA[rank[i]-1];
			while(i+k<=n&&j+k<=n&&s[i+k]==s[j+k])++k;
			height[rank[i]]=H[i]=k;
		}
	}
}SA;
int pan[N<<1],pos[N<<1];
struct Suffix_Tree{
	int t,tr[N<<1][26];
	inline void add(Re x,Re y,Re c){tr[x][c]=y;}
	inline void dfs(Re x){
		if(pan[x])SA.SA[++t]=pos[x];
		for(Re i=0;i<26;++i)if(tr[x][i])dfs(tr[x][i]);
	}
}ST;
struct Suffix_Automaton{
	int O,last,link[N<<1],maxlen[N<<1],trans[N<<1][26];
	Suffix_Automaton(){last=O=1;}
	inline void insert(Re ch,Re id){
		Re z=++O,p=last;maxlen[z]=maxlen[p]+1,pan[z]=1,pos[z]=id;
		while(p&&!trans[p][ch])trans[p][ch]=z,p=link[p];
		if(!p)link[z]=1;
		else{
			Re x=trans[p][ch];
			if(maxlen[p]+1==maxlen[x])link[z]=x;
			else{
				Re y=++O;maxlen[y]=maxlen[p]+1;
				for(Re i=0;i<26;++i)trans[y][i]=trans[x][i];
				while(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];
				pos[y]=pos[x],link[y]=link[x],link[x]=link[z]=y;
			}
		}
		last=z;
	}
	inline void build(){
		for(Re i=n;i>=1;--i)insert(s[i]-'a',i);
		for(Re i=2;i<=O;++i)ST.add(link[i],i,s[pos[i]+maxlen[link[i]]]-'a');
	}
}SAM;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),scanf("%s",s+1),SAM.build(),ST.dfs(1),SA.get_height();
	for(Re i=1;i<=n;++i)ans+=n-SA.SA[i]+1-SA.height[i];
	printf("%lld\n",ans);
}

```

**后缀数组** *(倍增)*

> 【后缀数组（倍增）】
后缀数组（Suffix Array）模板（倍增法/DC3），排序所有后缀。

核心函数：
  void in(Re &x) — 核心算法函数
  void get_SA(无参数) — 获取值
  void get_Height(无参数) — 获取值

核心结构体：Suffix_Array

关键配置：
N=1e6+3

适用场景：最长公共子串、不同子串计数、字符串周期分析

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define Re register int
#define LL long long
using namespace std;
const int N=1e6+3;
inline void in(Re &x){
    int fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
struct Suffix_Array{
	int n,m,x[N],y[N],H[N],SA[N],cnt[N],rank[N],Height[N];char s[N];
	//Suf[i]: s[i,n]
	inline void get_SA(){
		m=128;
		for(Re i=1;i<=n;++i)++cnt[x[i]=s[i]];
		for(Re i=2;i<=m;++i)cnt[i]+=cnt[i-1];
		for(Re i=n;i>=1;--i)SA[cnt[x[i]]--]=i;
		for(Re len=1;len<=n;len<<=1){
			Re t=0;
			for(Re i=n-len+1;i<=n;++i)y[++t]=i;
			for(Re i=1;i<=n;++i)if(SA[i]>len)y[++t]=SA[i]-len;
			
			for(Re i=1;i<=m;++i)cnt[i]=0;
			for(Re i=1;i<=n;++i)++cnt[x[i]];
			for(Re i=2;i<=m;++i)cnt[i]+=cnt[i-1];
			for(Re i=n;i>=1;--i)SA[cnt[x[y[i]]]--]=y[i],y[i]=0;
			
			swap(x,y);
			x[SA[1]]=m=1;
			for(Re i=2;i<=n;++i)
				x[SA[i]]=(y[SA[i]]==y[SA[i-1]]&&y[SA[i]+len]==y[SA[i-1]+len])?m:++m;
			if(m==n)break;
		}
		for(Re i=1;i<=n;++i)printf("%d ",SA[i]);
	}
	inline void get_Height(){
		for(Re i=1;i<=n;++i)rank[SA[i]]=i;
		for(Re i=1,k=0;i<=n;++i){
			if(rank[i]==1)continue;
			if(k)--k;//H[i-1]-1<=H[i]
			Re j=SA[rank[i]-1];
			while(i+k<=n&&j+k<=n&&s[i+k]==s[j+k])++k;
			Height[rank[i]]=k;
		}
//		for(Re i=1;i<=n;++i)printf("%d ",Height[i]);
	}
}SA;
int main(){
//	freopen("123.txt","r",stdin);
	scanf("%s",SA.s+1),SA.n=strlen(SA.s+1);
	SA.get_SA(),SA.get_Height();
}

```

**回文自动机** *(回文树)*

> 【回文自动机（回文树）】
回文自动机（Palindromic Tree）模板，存储所有回文子串。

核心函数：
  void in(Re &x) — 核心算法函数
  int find(Re p,Re id) — 查找（并查集寻根/二分查找）
  void insert(Re ch,Re id) — 插入元素
  void sakura(无参数) — 后缀数组

核心结构体：Palindromic_Automaton

关键配置：
N=5e5+5

适用场景：最长公共子串、不同子串计数、字符串周期分析

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define Re register int
using namespace std;
const int N=5e5+5;
char s[N];
inline void in(Re &x){
    Re f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Palindromic_Automaton{
	int O,last,siz[N],cnt[N],len[N],fail[N],trans[N][26];
	Palindromic_Automaton(){O=1,len[1]=-1,fail[0]=fail[1]=last=1;}
	// 0:偶数回文的根节点
	// 1:奇数回文的根节点
	inline int find(Re p,Re id){while(s[id-1-len[p]]!=s[id])p=fail[p];return p;}
	inline void insert(Re ch,Re id){
		Re cur=find(last,id),now=trans[cur][ch];
		if(!now){
			now=++O,len[now]=len[cur]+2;
			fail[now]=trans[find(fail[cur],id)][ch];
			cnt[now]=cnt[fail[now]]+1;
			trans[cur][ch]=now;
		}
		++siz[now],last=now;
	}
	inline void sakura(){
		for(Re i=O;i>=2;--i)siz[fail[i]]+=siz[i];
	}
}PAM;
int main(){
//	freopen("123.txt","r",stdin);
	scanf("%s",s+1);
	for(Re i=1,k=0;s[i];++i){
		s[i]=(s[i]-'a'+k)%26+'a';
		PAM.insert(s[i]-'a',i);
		printf("%d ",k=PAM.cnt[PAM.last]);
	}
}

```

**广义SAM** *(在线)*

> 【广义SAM（在线）】
后缀自动机（Suffix Automaton）模板，压缩存储所有子串。

核心函数：
  void in(Re &x) — 核心算法函数
   Suffix_Automaton(无参数) — 核心算法函数
  int insert(Re ch,Re last) — 插入元素
  void sakura(无参数) — 后缀数组

核心结构体：Suffix_Automaton

关键配置：
N=2e6+5

说明：link[i]: ��׺����；trans[i]: ״̬ת������；freopen("123.txt","r",stdin);

适用场景：最长公共子串、不同子串计数、字符串周期分析

```cpp
#include<algorithm>
#include<cstdio>
#include<queue>
#define Re register int
#define LL long long
using namespace std;
const int N=2e6+5;
int n;char ch[N];
inline void in(Re &x){
    int fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
struct Suffix_Automaton{
    int O,link[N],maxlen[N],trans[N][26];
    //trans[i]: 状态转移指针
    Suffix_Automaton(){O=1;}
    inline int insert(Re ch,Re last){
        if(trans[last][ch]){
            Re p=last,x=trans[p][ch];
            if(maxlen[p]+1==maxlen[x])return x;
            else{
                Re y=++O;maxlen[y]=maxlen[p]+1;
                for(Re i=0;i<26;++i)trans[y][i]=trans[x][i];
                while(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];
                link[y]=link[x],link[x]=y;
                return y;
            }
        }
        Re z=++O,p=last;maxlen[z]=maxlen[last]+1;
        while(p&&!trans[p][ch])trans[p][ch]=z,p=link[p];
        if(!p)link[z]=1;
        else{
            Re x=trans[p][ch];
            if(maxlen[p]+1==maxlen[x])link[z]=x;
            else{
                Re y=++O;maxlen[y]=maxlen[p]+1;
                for(Re i=0;i<26;++i)trans[y][i]=trans[x][i];
                while(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];
                link[y]=link[x],link[z]=link[x]=y;
            }
        }
        return z;
    }
    inline void sakura(){
        LL ans=0;
        for(Re i=2;i<=O;++i)ans+=maxlen[i]-maxlen[link[i]];
        printf("%lld\n",ans);
    }
}SAM;
int main(){
//    freopen("123.txt","r",stdin);
    in(n);
    for(Re i=1;i<=n;++i){
        scanf("%s",ch+1);Re last=1;
        for(Re j=1;ch[j];++j)last=SAM.insert(ch[j]-'a',last);
    }
    SAM.sakura();
}

```

**广义SAM** *(离线bfs)*

> 【广义SAM（离线bfs）】
后缀自动机（Suffix Automaton）模板，压缩存储所有子串。

核心函数：
  void in(Re &x) — 核心算法函数
   Trie(无参数) — 核心算法函数
  void insert(char ch[]) — 插入元素
   Suffix_Automaton(无参数) — 核心算法函数
  int insert(Re ch,Re last) — 插入元素
  void build(无参数) — 构建数据结构（建树/建图）
  void sakura(无参数) — 后缀数组

核心结构体：Trie, Suffix_Automaton

关键配置：
N=2e6+5,M=1e6+3

适用场景：最长公共子串、不同子串计数、字符串周期分析

```cpp
#include<algorithm>
#include<cstdio>
#include<queue>
#define Re register int
#define LL long long
using namespace std;
const int N=2e6+5,M=1e6+3;
int n,t;char ch[N];
inline void in(Re &x){
    int fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
struct Trie{
    int O,c[M],fa[M],tr[M][26];
    Trie(){O=1;}
    inline void insert(char ch[]){
        Re p=1;
        for(Re i=1;ch[i];++i){
            Re a=ch[i]-'a';
            if(!tr[p][a])tr[p][a]=++O,fa[O]=p,c[O]=a;
            p=tr[p][a];
        }
    }
}T1;
struct Suffix_Automaton{
    int O,pos[N],link[N],maxlen[N],trans[N][26];queue<int>Q;
    //trans[i]: 状态转移指针
    Suffix_Automaton(){O=1;}
    inline int insert(Re ch,Re last){
        Re x,y,z=++O,p=last;maxlen[z]=maxlen[last]+1;
        while(p&&!trans[p][ch])trans[p][ch]=z,p=link[p];
        if(!p)link[z]=1;
        else{
            x=trans[p][ch];
            if(maxlen[p]+1==maxlen[x])link[z]=x;
            else{
                y=++O;maxlen[y]=maxlen[p]+1;
                for(Re i=0;i<26;++i)trans[y][i]=trans[x][i];
                while(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];
                link[y]=link[x],link[z]=link[x]=y;
            }
        }
        return z;
    }
    inline void build(){
        for(Re i=0;i<26;++i)if(T1.tr[1][i])Q.push(T1.tr[1][i]);
        pos[1]=1;
        while(!Q.empty()){
            Re x=Q.front();Q.pop();
            pos[x]=insert(T1.c[x],pos[T1.fa[x]]);
            for(Re i=0;i<26;++i)if(T1.tr[x][i])Q.push(T1.tr[x][i]);
        }
    }
    inline void sakura(){
        LL ans=0;
        for(Re i=2;i<=O;++i)ans+=maxlen[i]-maxlen[link[i]];
        printf("%lld\n",ans);
    }
}SAM;
int main(){
//    freopen("123.txt","r",stdin);
    in(n);
    for(Re i=1;i<=n;++i)scanf("%s",ch+1),T1.insert(ch);
    SAM.build(),SAM.sakura();
}

```

**广义SAM** *(离线dfs)*

> 【广义SAM（离线dfs）】
后缀自动机（Suffix Automaton）模板，压缩存储所有子串。

核心函数：
  void in(Re &x) — 核心算法函数
   Trie(无参数) — 核心算法函数
  void insert(char ch[]) — 插入元素
   Suffix_Automaton(无参数) — 核心算法函数
  int insert(Re ch,Re last) — 插入元素
  void dfs(Re x) — 深度优先搜索遍历
  void build(无参数) — 构建数据结构（建树/建图）
  void sakura(无参数) — 后缀数组

核心结构体：Trie, Suffix_Automaton

关键配置：
N=2e6+5,M=1e6+3

适用场景：最长公共子串、不同子串计数、字符串周期分析

```cpp
#include<algorithm>
#include<cstdio>
#include<queue>
#define Re register int
#define LL long long
using namespace std;
const int N=2e6+5,M=1e6+3;
int n,t;char ch[N];
inline void in(Re &x){
    int fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
struct Trie{
    int O,c[M],fa[M],tr[M][26];
    Trie(){O=1;}
    inline void insert(char ch[]){
        Re p=1;
        for(Re i=1;ch[i];++i){
            Re a=ch[i]-'a';
            if(!tr[p][a])tr[p][a]=++O,fa[O]=p,c[O]=a;
            p=tr[p][a];
        }
    }
}T1;
struct Suffix_Automaton{
    int O,pos[N],link[N],maxlen[N],trans[N][26];queue<int>Q;
    //trans[i]: 状态转移指针
    Suffix_Automaton(){O=1;}
    inline int insert(Re ch,Re last){
        Re x,y,z=++O,p=last;maxlen[z]=maxlen[last]+1;
        while(p&&!trans[p][ch])trans[p][ch]=z,p=link[p];
        if(!p)link[z]=1;
        else{
            x=trans[p][ch];
            if(maxlen[p]+1==maxlen[x])link[z]=x;
            else{
                y=++O;maxlen[y]=maxlen[p]+1;
                for(Re i=0;i<26;++i)trans[y][i]=trans[x][i];
                while(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];
                link[y]=link[x],link[z]=link[x]=y;
            }
        }
        return z;
    }
    inline void dfs(Re x){
		for(Re i=0,to;i<26;++i)if(to=T1.tr[x][i])
			pos[to]=insert(T1.c[to],pos[x]),dfs(to);
	}
    inline void build(){pos[1]=1,dfs(1);}
    inline void sakura(){
        LL ans=0;
        for(Re i=2;i<=O;++i)ans+=maxlen[i]-maxlen[link[i]];
        printf("%lld\n",ans);
    }
}SAM;
int main(){
//    freopen("123.txt","r",stdin);
    in(n);
    for(Re i=1;i<=n;++i)scanf("%s",ch+1),T1.insert(ch);
    SAM.build(),SAM.sakura();
}

```

**广义SAM+线段树合并维护siz+倍增** *(Forensic Examination)*

> 【广义SAM+线段树合并维护siz+倍增（Forensic Examination）】
后缀自动机（Suffix Automaton）模板，压缩存储所有子串。

核心函数：
  void in(Re &x) — 核心算法函数
  QWQ max(QWQ A,QWQ B) — 核心算法函数
  void pushup(Re p) — 上推更新节点信息
  void change(Re &p,Re L,Re R,Re x) — 核心算法函数
  int merge(Re p,Re q,Re L,Re R) — 合并操作
  QWQ ask(Re p,Re L,Re R,Re l,Re r) — 核心算法函数
   Suffix_Automaton(无参数) — 核心算法函数
  int insert(Re ch,Re last,Re id) — 插入元素

核心结构体：QWQ, Segment_Tree, QAQ, Suffix_Automaton, QAQ

关键配置：
N=5e5+3,M=5e4+3,logN=21

说明：freopen("123.txt","r",stdin);

适用场景：最长公共子串、不同子串计数、字符串周期分析

```cpp
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<string>
#define LL long long
#define Re register int
using namespace std;
const int N=5e5+3,M=5e4+3,logN=21;
int n,m,x,y,l,r,T,pos[N];char s[N],ch[M];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct QWQ{
    int x,id;QWQ(Re X=0,Re ID=0){x=X,id=ID;}
    inline bool operator>(const QWQ &O)const{return x!=O.x?x>O.x:id<O.id;}
};
inline QWQ max(QWQ A,QWQ B){return A>B?A:B;}
int pt[N+M<<1];
struct Segment_Tree{
    #define pl (tr[p].lp)
    #define pr (tr[p].rp)
    #define mid ((L+R)>>1)
    int O;
    struct QAQ{int lp,rp;QWQ ans;}tr[(M<<1)*30];
    inline void pushup(Re p){
        tr[p].ans=max(tr[pl].ans,tr[pr].ans);
    }
    inline void change(Re &p,Re L,Re R,Re x){
        if(!p)p=++O;
        if(L==R){++tr[p].ans.x,tr[p].ans.id=L;return;}
        if(x<=mid)change(pl,L,mid,x);
        else change(pr,mid+1,R,x);
        pushup(p);
    }
    inline int merge(Re p,Re q,Re L,Re R){
        if(!p||!q)return p+q;
        Re x=++O;
        if(L==R){tr[x]=tr[p],tr[x].ans.x+=tr[q].ans.x;return x;}
        tr[x].lp=merge(pl,tr[q].lp,L,mid);
        tr[x].rp=merge(pr,tr[q].rp,mid+1,R);
        pushup(x);return x;
    }
    inline QWQ ask(Re p,Re L,Re R,Re l,Re r){
        if(!p)return QWQ(0,m+1);
        if(l<=L&&R<=r)return tr[p].ans;
        QWQ ans=QWQ(0,m+1);
        if(l<=mid)ans=max(ans,ask(pl,L,mid,l,r));
        if(r>mid)ans=max(ans,ask(pr,mid+1,R,l,r));
        return ans;
    }
}TR;
struct Suffix_Automaton{
    int O,link[N+M<<1],maxlen[N+M<<1],trans[N+M<<1][26];
    Suffix_Automaton(){O=1;}
    inline int insert(Re ch,Re last,Re id){
        if(trans[last][ch]){
            Re p=last,x=trans[p][ch];
            if(maxlen[p]+1==maxlen[x]){if(id)TR.change(pt[x],1,m,id);return x;}
            else{
                Re y=++O;maxlen[y]=maxlen[p]+1;
                for(Re i=0;i<26;++i)trans[y][i]=trans[x][i];
                while(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];
                link[y]=link[x],link[x]=y;
                if(id)TR.change(pt[y],1,m,id);
                return y;
            }
        }
        Re z=++O,p=last;maxlen[z]=maxlen[p]+1;
        while(p&&!trans[p][ch])trans[p][ch]=z,p=link[p];
        if(!p)link[z]=1;
        else{
            Re x=trans[p][ch];
            if(maxlen[x]==maxlen[p]+1)link[z]=x;
            else{
                Re y=++O;maxlen[y]=maxlen[p]+1;
                for(Re i=0;i<26;++i)trans[y][i]=trans[x][i];
                while(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];
                link[y]=link[x],link[x]=link[z]=y;
            }
        }
        if(id)TR.change(pt[z],1,m,id);
        return z;
    }
    int o,deep[N+M<<1],head[N+M<<1],ant[N+M<<1][23];
    struct QAQ{int to,next;}a[N+M<<1];
    inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
    inline void dfs(Re x,Re fa){
        deep[x]=deep[ant[x][0]=fa]+1;
        for(Re i=1;(1<<i)<=deep[x];++i)ant[x][i]=ant[ant[x][i-1]][i-1];
        for(Re i=head[x],to;i;i=a[i].next)
            dfs(to=a[i].to,x),pt[x]=TR.merge(pt[x],pt[to],1,m);
    }
    inline void build(){
        for(Re i=2;i<=O;++i)add(link[i],i);dfs(1,0);
    }
    inline int get(Re x,Re len){
        Re p=pos[x];
        for(Re i=logN;i>=0;--i)if(ant[p][i]&&maxlen[ant[p][i]]>=len)p=ant[p][i];
        return p;
    }
    inline void sakura(Re l,Re r,Re x,Re y){
        QWQ ans=TR.ask(pt[get(y,y-x+1)],1,m,l,r);
        if(ans.x==0)ans.id=l;
        printf("%d %d\n",ans.id,ans.x);
    }
}SAM;
int main(){
//    freopen("123.txt","r",stdin);
    scanf("%s",s+1),n=strlen(s+1),in(m);
    for(Re i=1;i<=m;++i){
        scanf("%s",ch+1);Re last=1;
        for(Re j=1;ch[j];++j)last=SAM.insert(ch[j]-'a',last,i);
    }
    for(Re i=1,last=1;i<=n;++i)pos[i]=last=SAM.insert(s[i]-'a',last,0);
    SAM.build(),in(T);
    while(T--)in(l),in(r),in(x),in(y),SAM.sakura(l,r,x,y);
}

```

**区间本质不同子串个数** *(SAM+LCT+线段树)*

> 【区间本质不同子串个数（SAM+LCT+线段树）】
字符串高级算法模板。

核心函数：
  void in(Re &x) — 核心算法函数
  void updata(Re p,Re L,Re R,LL v) — 核心算法函数
  void pushdown(Re p,Re L,Re R) — 下传懒标记
  void change(Re p,Re L,Re R,Re l,Re r,Re v) — 核心算法函数
  LL ask(Re p,Re L,Re R,Re l,Re r) — 核心算法函数
  void insert(Re ch,Re id) — 插入元素
  void updata(Re p,Re v) — 核心算法函数
  void pushdown(Re p) — 下传懒标记

核心结构体：Query, Segment_Tree, QAQ, Suffix_Automaton, Link_Cut_Tree

关键配置：
N=1e5+3,M=2e5+3

说明：freopen("123.txt","r",stdin);

适用场景：最长公共子串、不同子串计数、字符串周期分析

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=1e5+3,M=2e5+3;
int n,T;LL Ans[M];char s[N];
struct Query{int l,r,id;inline bool operator<(const Query &O)const{return r<O.r;}}Q[M];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Segment_Tree{
	#define pl (p<<1)
	#define pr (p<<1|1)
	#define mid ((L+R)>>1)
	struct QAQ{LL S,add;}tr[N<<2];
	inline void updata(Re p,Re L,Re R,LL v){tr[p].add+=v,tr[p].S+=v*(R-L+1);}
	inline void pushdown(Re p,Re L,Re R){
		if(tr[p].add)updata(pl,L,mid,tr[p].add),updata(pr,mid+1,R,tr[p].add),tr[p].add=0;
	}
	inline void change(Re p,Re L,Re R,Re l,Re r,Re v){
		if(l<=L&&R<=r){updata(p,L,R,v);return;}
		pushdown(p,L,R);
		if(l<=mid)change(pl,L,mid,l,r,v);
		if(r>mid)change(pr,mid+1,R,l,r,v);
		tr[p].S=tr[pl].S+tr[pr].S;
	}
	inline LL ask(Re p,Re L,Re R,Re l,Re r){
		if(l<=L&&R<=r)return tr[p].S;
		pushdown(p,L,R);LL ans=0;
		if(l<=mid)ans+=ask(pl,L,mid,l,r);
		if(r>mid)ans+=ask(pr,mid+1,R,l,r);
		return ans;
	}
	#undef pl
	#undef pr
}TR;
struct Suffix_Automaton{
	int O,last,pos[N],link[N<<1],maxlen[N<<1],trans[N<<1][26];
	Suffix_Automaton(){last=O=1;}
	inline void insert(Re ch,Re id){
		Re z=++O,p=last;maxlen[z]=maxlen[p]+1;
		while(p&&!trans[p][ch])trans[p][ch]=z,p=link[p];
		if(!p)link[z]=1;
		else{
			Re x=trans[p][ch];
			if(maxlen[x]==maxlen[p]+1)link[z]=x;
			else{
				Re y=++O;maxlen[y]=maxlen[p]+1;
				for(Re i=0;i<26;++i)trans[y][i]=trans[x][i];
				while(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];
				link[y]=link[x],link[z]=link[x]=y;
			}
		}
		pos[id]=last=z;
	}
}SAM;
struct Link_Cut_Tree{
	#define pl (tr[p].ps[0])
	#define pr (tr[p].ps[1])
	#define pf (tr[p].fa)
	#define pv (tr[p].v)
	int Q[N<<1];
	struct QAQ{int v,fa,tag,ps[2];}tr[N<<1];
	inline void updata(Re p,Re v){tr[p].tag=tr[p].v=v;}
	inline void pushdown(Re p){
		if(tr[p].tag){
			if(pl)updata(pl,tr[p].tag);
			if(pr)updata(pr,tr[p].tag);
			tr[p].tag=0;
		}
	}
	inline int which(Re p){return tr[pf].ps[1]==p;}
	inline int nort(Re p){return tr[pf].ps[0]==p||tr[pf].ps[1]==p;}
	inline void connect(Re p,Re fa,Re o){tr[pf=fa].ps[o]=p;}
	inline void rotate(Re p){
		Re fa=pf,fas=which(p);
		Re pa=tr[fa].fa,pas=which(fa);
		Re x=tr[p].ps[fas^1];
		if(nort(fa))tr[pa].ps[pas]=p;pf=pa;
		connect(x,fa,fas),connect(fa,p,fas^1);
	}
	inline void splay(Re p){
		Re x=p,t=0;Q[++t]=x;
		while(tr[x].fa)Q[++t]=x=tr[x].fa;
		while(t)pushdown(Q[t--]);
		for(Re fa;nort(p);rotate(p))
			if(nort(fa=pf))rotate(which(p)==which(fa)?fa:p);
	}
	inline void access(Re p,Re r){
		Re son=0;
		for(;p;son=p,p=pf){
			splay(p);
			if(pv)TR.change(1,1,n,pv-SAM.maxlen[p]+1,pv-SAM.maxlen[pf],-1);
			pr=son;
		}
		updata(son,r),TR.change(1,1,n,1,r,1);
	}
}T1;
int main(){
//    freopen("123.txt","r",stdin);
    scanf("%s",s+1),n=strlen(s+1),in(T);
	for(Re i=1;i<=n;++i)SAM.insert(s[i]-'a',i);
	for(Re i=2;i<=SAM.O;++i)T1.tr[i].fa=SAM.link[i];
	for(Re i=1;i<=T;++i)in(Q[i].l),in(Q[i].r),Q[i].id=i;
    sort(Q+1,Q+T+1);
    for(Re i=1,r=0;i<=T;++i){
    	while(r<Q[i].r)++r,T1.access(SAM.pos[r],r);
    	Ans[Q[i].id]=TR.ask(1,1,n,Q[i].l,Q[i].r);
	}
	for(Re i=1;i<=T;++i)printf("%lld\n",Ans[i]);
}

```

**喵星球上的点名** *(广义SAM)*

> 【喵星球上的点名（广义SAM）】
字符串高级算法模板。

核心函数：
  void in(Re &x) — 核心算法函数
  int insert(Re ch,Re last) — 插入元素
  void updata(Re p,Re id) — 核心算法函数
  void updata_(Re p,Re id) — 核心算法函数
  void ask(Re ch[],Re L) — 核心算法函数

核心结构体：Suffix_Automaton

关键配置：
N=2e5+5

说明：freopen("123.txt","r",stdin);

适用场景：最长公共子串、不同子串计数、字符串周期分析

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#include<map>
#define Re register int
#define LL long long
using namespace std;
const int N=2e5+5;
int n,t,T,x,s[N],ch[N],Len[N];
inline void in(Re &x){
    int fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
struct Suffix_Automaton{	
	int O,pos[N],cnt[N],link[N],maxlen[N],minlen[N];queue<int>Q;map<int,int>trans[N];
	Suffix_Automaton(){O=1;}
	inline int insert(Re ch,Re last){
		if(trans[last][ch]&&maxlen[last]+1==maxlen[trans[last][ch]])return trans[last][ch];
		Re x,y,z=++O,p=last,flag=0;maxlen[z]=maxlen[last]+1;
		while(p&&!trans[p][ch])trans[p][ch]=z,p=link[p];
		if(!p)link[z]=1;
		else{
			x=trans[p][ch];
			if(maxlen[p]+1==maxlen[x])link[z]=x;
			else{
				if(maxlen[p]+1==maxlen[z])flag=1;
				y=++O;maxlen[y]=maxlen[p]+1;
				trans[y]=trans[x];
				while(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];
				link[y]=link[x],link[z]=link[x]=y;
			}
		}
		return flag?y:z;
	}
	int co[N];
	inline void updata(Re p,Re id){
		while(p&&co[p]!=id)++cnt[p],co[p]=id,p=link[p];
	}
	int gs[N],Ans[N];
	inline void updata_(Re p,Re id){
		while(p&&co[p]!=id)Ans[id]+=gs[p],co[p]=id,p=link[p];
	}
	inline void ask(Re ch[],Re L){
		Re p=1,flag=1;
		for(Re i=1;i<=L&&flag;++i){
			Re a=ch[i];
			if(trans[p][a])p=trans[p][a];
			else flag=0;
		}
		if(flag)++gs[p];
		printf("%d\n",flag?cnt[p]:0);
	}
}SAM;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T);
	for(Re i=1;i<=n;++i){
		in(Len[(i<<1)-1]);Re last=1;
		for(Re j=1;j<=Len[(i<<1)-1];++j)in(x),last=SAM.insert(s[++t]=x,last);
		in(Len[i<<1]);last=1;
		for(Re j=1;j<=Len[i<<1];++j)in(x),last=SAM.insert(s[++t]=x,last);
	}
	for(Re i=1,t=0;i<=n;++i){
		for(Re j=1,p=1;j<=Len[(i<<1)-1];++j)
			SAM.updata(p=SAM.trans[p][s[++t]],i);
		for(Re j=1,p=1;j<=Len[i<<1];++j)
			SAM.updata(p=SAM.trans[p][s[++t]],i);
	}
	while(T--){
		in(Len[0]);
		for(Re i=1;i<=Len[0];++i)in(ch[i]);
		SAM.ask(ch,Len[0]);
	}
	memset(SAM.co,0,sizeof(SAM.co));
	for(Re i=1,t=0;i<=n;++i){
		for(Re j=1,p=1;j<=Len[(i<<1)-1];++j)
			SAM.updata_(p=SAM.trans[p][s[++t]],i);
		for(Re j=1,p=1;j<=Len[i<<1];++j)
			SAM.updata_(p=SAM.trans[p][s[++t]],i);
	}
	for(Re i=1;i<=n;++i)printf("%d ",SAM.Ans[i]);
}

```

**回文串** *(Manacher+SAM+倍增)*

> 【回文串（Manacher+SAM+倍增）】
回文自动机（Palindromic Tree）模板，存储所有回文子串。

核心函数：
  void in(Re &x) — 核心算法函数
  void insert(Re ch) — 插入元素
  void add(Re x,Re y) — 加法更新
  void dfs(Re x,Re fa) — 深度优先搜索遍历
  void build(无参数) — 构建数据结构（建树/建图）
  void check(Re x,Re len) — 判定/检查函数
  void sakura(无参数) — 后缀数组

核心结构体：Suffix_Automaton, QAQ

关键配置：
N=6e5+5,logN=19

适用场景：最长公共子串、不同子串计数、字符串周期分析

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=6e5+5,logN=19;
char s[N>>1];
inline void in(Re &x){
    Re f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Suffix_Automaton{
	int O,last,pos[N],siz[N],link[N],maxlen[N],trans[N][26];LL ans;
	Suffix_Automaton(){last=O=1;}
	inline void insert(Re ch){
		Re z=++O,p=last;siz[z]=1,maxlen[z]=maxlen[last]+1;
		while(p&&!trans[p][ch])trans[p][ch]=z,p=link[p];
		if(!p)link[z]=1;
		else{
			Re x=trans[p][ch];
			if(maxlen[p]+1==maxlen[x])link[z]=x;
			else{
				Re y=++O;maxlen[y]=maxlen[p]+1;
				for(Re i=0;i<26;++i)trans[y][i]=trans[x][i];
				while(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];
				link[y]=link[x],link[x]=link[z]=y;
			}
		}
		last=z;
	}
	int o,deep[N],head[N],ant[N][20];
	struct QAQ{int to,next;}a[N];
	inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
	inline void dfs(Re x,Re fa){
		deep[x]=deep[ant[x][0]=fa]+1;
		for(Re j=1;(1<<j)<=deep[x];++j)ant[x][j]=ant[ant[x][j-1]][j-1];
		for(Re i=head[x];i;i=a[i].next)dfs(a[i].to,x),siz[x]+=siz[a[i].to];
	}
	inline void build(){
		for(Re i=1;s[i];++i)insert(s[i]-'a'),pos[i]=last;
		for(Re i=2;i<=O;++i)add(link[i],i);
		dfs(1,0);
	}
	inline void check(Re x,Re len){
		Re p=pos[x+len-1];
		for(Re i=logN;i>=0;--i)
			if(maxlen[ant[p][i]]>=len)p=ant[p][i];
		ans=max(ans,(LL)len*siz[p]);
	}
	int m,r[N];char b[N];
	inline void sakura(){
		build();
		b[m=0]='$',b[++m]='|';
		for(Re i=1;s[i];++i)b[++m]=s[i],b[++m]='|';
		for(Re i=1,R=0,mid=0;i<=m;++i){
			r[i]=i<=R?min(r[(mid<<1)-i],R-i+1):1;
			while(b[i-r[i]]==b[i+r[i]]){
				++r[i];
				if(i+r[i]-1>R)check(i-r[i]+1+1>>1,r[i]-!(i+r[i]&1));
			}
			if(i+r[i]-1>R)mid=i,R=i+r[i]-1;
		}
		printf("%lld\n",ans);
	}
}SAM;
int main(){
	freopen("123.txt","r",stdin);
	scanf("%s",s+1),SAM.sakura();
}

```

**回文串** *(PAM)*

> 【回文串（PAM）】
回文自动机（Palindromic Tree）模板，存储所有回文子串。

核心函数：
  void in(Re &x) — 核心算法函数
  int find(Re p,Re id) — 查找（并查集寻根/二分查找）
  void insert(Re ch,Re id) — 插入元素
  void sakura(无参数) — 后缀数组

核心结构体：Palindromic_Automaton

关键配置：
N=3e5+5

说明：freopen("123.txt","r",stdin);

适用场景：最长公共子串、不同子串计数、字符串周期分析

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=3e5+5;
char s[N];
inline void in(Re &x){
    Re f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Palindromic_Automaton{
	int O,last,siz[N],len[N],fail[N],trans[N][26];
	Palindromic_Automaton(){O=1,len[1]=-1,fail[0]=fail[1]=last=1;}
	inline int find(Re p,Re id){while(s[id-1-len[p]]!=s[id])p=fail[p];return p;}
	inline void insert(Re ch,Re id){
		Re cur=find(last,id),now=trans[cur][ch];
		if(!now){
			now=++O,len[now]=len[cur]+2;
			fail[now]=trans[find(fail[cur],id)][ch];
			trans[cur][ch]=now;
		}
		++siz[now],last=now;
	}
	inline void sakura(){
		LL ans=0;
		for(Re i=O;i>=2;--i)siz[fail[i]]+=siz[i],ans=max(ans,(LL)siz[i]*len[i]);
		printf("%lld\n",ans);
	}
}PAM;
int main(){
//	freopen("123.txt","r",stdin);
	scanf("%s",s+1);
	for(Re i=1;s[i];++i)PAM.insert(s[i]-'a',i);
	PAM.sakura();
}

```

**找相同子串 (广义SAM记录siz)** *(在线)*

> 【找相同子串 (广义SAM记录siz)（在线）】
后缀自动机（Suffix Automaton）模板，压缩存储所有子串。

核心函数：
  void in(Re &x) — 核心算法函数
   Suffix_Automaton(无参数) — 核心算法函数
  int insert(Re ch,Re last,Re id) — 插入元素
  void sakura(无参数) — 后缀数组

核心结构体：Suffix_Automaton

关键配置：
N=8e5+5

说明：siz[x]: |endpos[x]| ���ڵ�x��endpos��С；freopen("123.txt","r",stdin);

适用场景：最长公共子串、不同子串计数、字符串周期分析

```cpp
#include<algorithm>
#include<cstdio>
#include<queue>
#define Re register int
#define LL long long
using namespace std;
const int N=8e5+5;
char ch[200003];LL ans;
inline void in(Re &x){
    int fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
struct Suffix_Automaton{
    int O,ru[N],link[N],maxlen[N],siz[N][2],trans[N][26];queue<int>Q;
    // siz[x]: |endpos[x]| 节点x的endpos大小
    Suffix_Automaton(){O=1;}
    inline int insert(Re ch,Re last,Re id){
        if(trans[last][ch]){
            Re p=last,x=trans[p][ch];
            if(maxlen[p]+1==maxlen[x]){siz[x][id]=1;return x;} 
            else{
                Re y=++O;maxlen[y]=maxlen[p]+1;
                for(Re i=0;i<26;++i)trans[y][i]=trans[x][i];
                while(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];
                link[y]=link[x],link[x]=y;
                siz[y][id]=1;return y;
            }
        }
        Re z=++O,p=last;maxlen[z]=maxlen[last]+1;
        while(p&&!trans[p][ch])trans[p][ch]=z,p=link[p];
        if(!p)link[z]=1;
        else{
            Re x=trans[p][ch];
            if(maxlen[p]+1==maxlen[x])link[z]=x;
            else{
                Re y=++O;maxlen[y]=maxlen[p]+1;
                for(Re i=0;i<26;++i)trans[y][i]=trans[x][i];
                while(p&&trans[p][ch]==x)trans[p][ch]=y,p=link[p];
                link[y]=link[x],link[z]=link[x]=y;
            }
        }
        siz[z][id]=1;
        return z;
    }
    inline void sakura(){
        for(Re i=2;i<=O;++i)++ru[link[i]];
        for(Re i=1;i<=O;++i)if(!ru[i])Q.push(i);
        while(!Q.empty()){
            Re x=Q.front();Q.pop();
            siz[link[x]][0]+=siz[x][0];
            siz[link[x]][1]+=siz[x][1];
            if(!(--ru[link[x]]))Q.push(link[x]);
        }
        for(Re i=2;i<=O;++i)//ͳ�ƴ�
            ans+=(LL)siz[i][0]*siz[i][1]*(maxlen[i]-maxlen[link[i]]);
        printf("%lld\n",ans);
    }
}SAM;
int main(){
//    freopen("123.txt","r",stdin);
    for(Re i=0;i<2;++i){
        scanf("%s",ch+1);Re last=1;
        for(Re j=1;ch[j];++j)last=SAM.insert(ch[j]-'a',last,i);
    }
    SAM.sakura();
}

```

## 7. 数论与数学

### 7.1 素数筛法

**线性筛** *(xianxingshai)*

> 【线性筛（欧拉筛 / Euler Sieve）——质数筛选】
▪ pre(n) — 筛出 [2,n] 所有质数存入 pri 向量：
  遍历 i=2..n：若 not_prime[i]==false 则 i 为质数加入 pri；  对每个已知质数 pri_j，标记 i*pri_j 为合数，若 i%pri_j==0 则 break（关键！保证每个合数只被其最小质因子筛一次）
▪ pri[] — 存储筛出的所有质数
▪ not_prime[] — 合数标记数组
时间复杂度严格 O(N)。与传统埃氏筛 O(N log log N) 相比，常数稍大但理论更优，N 可达 1e7+。

```cpp
vector<int> pri;
bool not_prime[N];
void pre(int n) {
    for (int i = 2; i <= n; i++) {
        if (!not_prime[i]) {
            pri.push_back(i);
        }
        for (int pri_j : pri) {
            if (i * pri_j > n) break;
            not_prime[i * pri_j] = true;
            if (i % pri_j == 0) {
                break;
            }
        }
    }
}
```

**欧拉筛.返回质数的个数。** *(oulashai)*

> 【欧拉筛（线性筛）——返回质数个数】
▪ euler_sieve(n) — 筛出 [2,n] 所有质数并返回质数个数 cnt：
  遍历 i=2..n，若 !vis[i] 则 prime[cnt++]=i；对每个已找到的质数 prime[j]，标记 vis[i*prime[j]]=1，若 i%prime[j]==0 则 break。
▪ prime[] — 按发现顺序存储质数
▪ vis[] — 合数标记
时间复杂度严格 O(N)，比 ID=24 的 `pre()` 多返回了质数个数 cnt。

```cpp
int prime[MAXN];              //保存质数
int vis[MAXN];                //记录是否被筛
int euler_sieve(int n){       //欧拉筛。返回质数的个数。
    int cnt = 0;              //记录质数个数
    memset(vis,0,sizeof(vis));
    memset(prime,0,sizeof(prime));
    for(int i=2;i<=n;i++){             //检查每个数，筛去其中的合数
        if(!vis[i]) prime[cnt++]=i;    //如果没有筛过，是质数，记录。第一个质数是2
        for(int j=0; j<cnt; j++){      //用已经得到的质数去筛后面的数
            if(i*prime[j] >n)  break;  //只筛小于等于n的数
            vis[i*prime[j]]=1;         //关键1。用x的最小质因数筛去x
            if(i%prime[j]==0)  break;  //关键2。如果不是这个数的最小质因子，结束
        }
    }
    return cnt;                        //返回小于等于n的素数的个数
}
```

**求等比数列和** *(二分)*

> 【求等比数列和（二分）】
质数与筛法相关模板。

核心函数：
  void prime_devisor(int x) — Prim最小生成树
  int sakura(无参数) — 后缀数组

复杂度：O(N)（线性筛）或 O(N log log N)（埃氏筛）

```cpp
#include<cstdio>
#define R register int
int n,t,px[10005],pk[10005];
inline void prime_devisor(int x){
	if(x%2==0){
		px[++t]=2;
		while(x%2==0)pk[t]++,x/=2;
	}
	for(R i=3;i*i<=x;i+=2){
		if(x%i==0){
			px[++t]=i;
			while(x%i==0)pk[t]++,x/=i;
		}
	}
	if(x!=1)px[++t]=x,pk[t]=1;
}
inline int sakura(){
	scanf("%d",&n);
	printf("%d=",n);
	prime_devisor(n);
	for(R i=1;i<=t;i++){
		printf("%d^%d",px[i],pk[i]);
		if(i<t)printf("+");
	}
}
int QAQWQ=sakura();
int main(){}

```

**gcd** *(辗转相模)*

> 【gcd（辗转相模）】
质数与筛法相关模板。

核心函数：
  int GCD(int a,int b) — 最大公约数
  int gcd(int a,int b) — 最大公约数

复杂度：O(N)（线性筛）或 O(N log log N)（埃氏筛）

```cpp
#include<cstdio>
int n,a,b;
inline int GCD(int a,int b){while(b^=a^=b^=a%=b);return a;}
inline int gcd(int a,int b){return b==0?a:gcd(b,a%b);}
int main(){
	scanf("%d",&n);
	while(n--)scanf("%d%d",&a,&b),printf("%d\n",GCD(a,b));
}
```

**Mobius函数** *(埃氏筛)*

> 【Mobius函数（埃氏筛）】
质数与筛法相关模板。

核心函数：
  void get_miu(无参数) — 获取值

关键配置：
N=1e7+3

复杂度：O(N)（线性筛）或 O(N log log N)（埃氏筛）

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)
#include<cstdio>
const int N=1e7+3;
int i,j,n,cnt,pan[N],miu[N];
inline void get_miu(){
	for(i=1;i<=n;++i)miu[i]=1;
	for(i=2;i<=n;++i)
		if(!pan[i]){
			miu[i]=-1;
			for(j=i<<1;j<=n;j+=i)pan[j]=1,miu[j]*=(j/i%i==0)?0:-1;
		}
}
int main(){
	n=N;
	get_miu();
	for(i=1;i<=n;++i)printf("%d: %d\n",i,miu[i]);
}

```

**Mobius函数** *(线筛)*

> 【Mobius函数（线筛）】
质数与筛法相关模板。

核心函数：
  void get_miu(无参数) — 获取值

关键配置：
N=1e7+3

复杂度：O(N)（线性筛）或 O(N log log N)（埃氏筛）

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)
#include<cstdio>
const int N=1e7+3;
int i,j,n,cnt,pri[N>>1],pan[N],miu[N];
inline void get_miu(){
	pan[1]=1,miu[1]=1;
	for(i=2;i<=n;++i){
		if(!pan[i])pri[++cnt]=i,miu[i]=-1;
		for(j=1;j<=cnt&&i*pri[j]<=n;++j){
            pan[i*pri[j]]=1;
            if(i%pri[j])miu[i*pri[j]]=-miu[i];
            else{miu[i*pri[j]]=0;break;}
        }
	}
}
int main(){
	n=N;
	get_miu();
	for(i=1;i<=n;++i)printf("%d: %d\n",i,miu[i]);
}

```

**最值反演  (Card Collector)** *(Min-Max容斥)*

> 【最值反演  (Card Collector)（Min-Max容斥）】
质数与筛法相关模板。

核心函数：
  void in(Re &x) — 核心算法函数

关键配置：
N=23,M=1048576+3

复杂度：O(N)（线性筛）或 O(N log log N)（埃氏筛）

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LD double
#define LL long long
#define Re register int
using namespace std;
const int N=23,M=1048576+3;
int n,V,cnt[M];LD ans,p[N],Min[M];
inline void in(Re &x){
    int f=0;x=0;char ch=getchar();
    while(ch<'0'||ch>'9')f|=ch=='-',ch=getchar();
    while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
    x=f?-x:x;
}
int main(){
//    freopen("123.txt","r",stdin);
    while(~scanf("%d",&n)){
        V=(1<<n)-1,ans=0;
        for(Re i=1;i<=n;++i)scanf("%lf",&p[i]);
        for(Re s=1;s<=V;++s){
            Min[s]=0,cnt[s]=cnt[s>>1]+(s&1);
            for(Re i=1;i<=n;++i)if(s&(1<<i-1))Min[s]+=p[i];
            Min[s]=1.0/Min[s];
        }
        for(Re t=1;t<=V;++t)ans+=(cnt[t]&1)?Min[t]:-Min[t];
        printf("%lf\n",ans);
    }
}

```

**杜教筛** *(map)*

> 【杜教筛（map）】
杜教筛模板，O(N^(2/3)) 求积性函数前缀和。

核心函数：
  void in(Re &x) — 核心算法函数
  void get_(Re N) — 获取值
  LL get_Sphi(Re n) — 获取值
  int get_Smiu(Re n) — 获取值

复杂度：O(N)（线性筛）或 O(N log log N)（埃氏筛）

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<map>
#define Re register int
#define LL long long
using namespace std;
const int N23=1664511+3,N=2147483647;
int x,T,cnt,pan[N23],pri[N23],phi[N23],miu[N23];
int TO,Smiu[N23];LL Sphi[N23];
map<int,int>Smiu_;map<int,LL>Sphi_;
inline void in(Re &x){
	Re fu=0;x=0;char ch=getchar();
	while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=fu?-x:x;
}
inline void get_(Re N){
	miu[1]=phi[1]=pan[1]=1;
	for(Re i=2;i<=N;++i){
		if(!pan[i])pri[++cnt]=i,miu[i]=-1,phi[i]=i-1;
		for(Re j=1;j<=cnt&&pri[j]<=N/i;++j){
			pan[i*pri[j]]=1;
			if(i%pri[j])miu[i*pri[j]]=-miu[i],phi[i*pri[j]]=phi[i]*phi[pri[j]];
			else{miu[i*pri[j]]=0,phi[i*pri[j]]=phi[i]*pri[j];break;}
		}
	}
	for(Re i=1;i<=N;++i)Smiu[i]=Smiu[i-1]+miu[i],Sphi[i]=Sphi[i-1]+phi[i];
}
inline LL get_Sphi(Re n){
	if(n<=TO)return Sphi[n];
	if(Sphi_[n])return Sphi_[n];
	LL ans=(LL)n*(n+1)>>1;
	for(Re l=2,r;l<=n;l=r+1){
		r=n/(n/l);
		ans-=(LL)(r-l+1)*get_Sphi(n/l);
	}
	return Sphi_[n]=ans;
}
inline int get_Smiu(Re n){
	if(n<=TO)return Smiu[n];
	if(Smiu_[n])return Smiu_[n];
	Re ans=1;
	for(Re l=2,r;l<=n;l=r+1){
		r=n/(n/l);
		ans-=(r-l+1)*get_Smiu(n/l);
	}
	return Smiu_[n]=ans;
}
int main(){
//	freopen("123.txt","r",stdin);
	in(T),get_(TO=N23-3);
	while(T--)in(x),printf("%lld %d\n",get_Sphi(x),get_Smiu(x));
}

```

**杜教筛** *(数组记忆化)*

> 【杜教筛（数组记忆化）】
杜教筛模板，O(N^(2/3)) 求积性函数前缀和。

核心函数：
  void in(Re &x) — 核心算法函数
  void get_(Re N) — 获取值
  LL get_Sphi(Re n) — 获取值
  int get_Smiu(Re n) — 获取值

复杂度：O(N)（线性筛）或 O(N log log N)（埃氏筛）

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#define Re register int
#define LL long long
using namespace std;
const int N23=1664511+3,N13=1303,N=2147483647;
int x,T,cnt,pan[N23],pri[N23],phi[N23],miu[N23];
int TO,vis1[N13],vis2[N13],Smiu[N23],Smiu_[N13];
LL Sphi[N23],Sphi_[N13];
inline void in(Re &x){
	Re fu=0;x=0;char ch=getchar();
	while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=fu?-x:x;
}
inline void get_(Re N){
	miu[1]=phi[1]=pan[1]=1;
	for(Re i=2;i<=N;++i){
		if(!pan[i])pri[++cnt]=i,miu[i]=-1,phi[i]=i-1;
		for(Re j=1;j<=cnt&&pri[j]<=N/i;++j){
			pan[i*pri[j]]=1;
			if(i%pri[j])miu[i*pri[j]]=-miu[i],phi[i*pri[j]]=phi[i]*phi[pri[j]];
			else{miu[i*pri[j]]=0,phi[i*pri[j]]=phi[i]*pri[j];break;}
		}
	}
	for(Re i=1;i<=N;++i)Smiu[i]=Smiu[i-1]+miu[i],Sphi[i]=Sphi[i-1]+phi[i];
}
inline LL get_Sphi(Re n){
	if(n<=TO)return Sphi[n];
	Re nn=N/n;
	if(vis1[nn])return Sphi_[nn];
	LL ans=(LL)n*(n+1)>>1;
	for(Re l=2,r;l<=n;l=r+1){
		r=n/(n/l);
		ans-=(LL)(r-l+1)*get_Sphi(n/l);
	}
	vis1[nn]=1;
	return Sphi_[nn]=ans;
}
inline int get_Smiu(Re n){
	if(n<=TO)return Smiu[n];
	Re nn=N/n;
	if(vis2[nn])return Smiu_[nn];
	Re ans=1;
	for(Re l=2,r;l<=n;l=r+1){
		r=n/(n/l);
		ans-=(r-l+1)*get_Smiu(n/l);
	}
	vis2[nn]=1;
	return Smiu_[nn]=ans;
}
int main(){
//	freopen("123.txt","r",stdin);
	in(T),get_(TO=N23-3);
	while(T--){
		in(x),printf("%lld %d\n",get_Sphi(x),get_Smiu(x));
		memset(vis1,0,sizeof(vis1));
		memset(vis2,0,sizeof(vis2));
	}
}

```

**欧拉函数 暴力)** *(sqrt(n)*

> 【欧拉函数 暴力)（sqrt(n）】
线性筛（欧拉筛）模板，O(N) 筛出质数并可同时计算积性函数。

核心函数：
  int phi(Re x) — 核心算法函数

复杂度：O(N)（线性筛）或 O(N log log N)（埃氏筛）

```cpp
#include<cstdio>
#define Re register int
int n;
inline int phi(Re x){
	Re ans=x;
	for(Re i=2;i*i<=x;i++)
		if(x%i==0){
			ans/=i,ans*=i-1;
			while(x%i==0)x/=i;
		}
	if(x>1)ans/=x,ans*=x-1;
	return ans;
}
int main(){
	scanf("%d",&n),printf("%d\n",phi(n));
}

```

**欧拉函数** *(埃氏筛)*

> 【欧拉函数（埃氏筛）】
线性筛（欧拉筛）模板，O(N) 筛出质数并可同时计算积性函数。

核心函数：
  void get_phi(无参数) — 获取值

关键配置：
N=1e6

复杂度：O(N)（线性筛）或 O(N log log N)（埃氏筛）

```cpp
#include<cstdio>
const int N=1e6;
int cnt,n=N,phi[N/3],pan[N],pri[N];
inline void get_phi(){
	phi[1]=1;
    for(int i=2;i<=n;i++)if(!phi[i]){
    	for(int j=i;j<=n;j+=i){
            if(!phi[j])phi[j]=j;
            phi[j]=phi[j]/i*(i-1);
        }
    }
}
int main(){
	get_phi();
	for(int i=1;i<=n;++i)printf("%d: %d\n",i,phi[i]);
}

```

**欧拉函数** *(线筛)*

> 【欧拉函数（线筛）】
线性筛（欧拉筛）模板，O(N) 筛出质数并可同时计算积性函数。

核心函数：
  void get_phi(int N) — 获取值

关键配置：
N=1e6

复杂度：O(N)（线性筛）或 O(N log log N)（埃氏筛）

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)
#include<cstdio>
const int N=1e6;
int cnt,i,j,pan[N+1],pri[N/3],phi[N+1];
inline void get_phi(int N){
    pan[1]=1,phi[1]=1;
    for(int i=2;i<=N;++i){
        if(!pan[i])pri[++cnt]=i,phi[i]=i-1;
        for(int j=1;j<=cnt&&pri[j]<=N/i;++j){
            pan[i*pri[j]]=1;
            if(i%pri[j])phi[i*pri[j]]=phi[i]*(pri[j]-1);
            else{phi[i*pri[j]]=phi[i]*pri[j];break;}
        }
    }
}
int main(){
	get_phi(N);
	for(i=1;i<=N;++i)printf("%d: %d\n",i,phi[i]);
}

```

**Power Tower  (欧拉定理)** *(炸勃龙弱化)*

> 【Power Tower  (欧拉定理)（炸勃龙弱化）】
线性筛（欧拉筛）模板，O(N) 筛出质数并可同时计算积性函数。

核心函数：
  void in(Re &x) — 核心算法函数
  LL Phi(Re x) — 核心算法函数
  LL mi(Re x,Re k,Re P) — 核心算法函数
  LL sakura(Re l,Re r,Re P) — 后缀数组

关键配置：
N=1e5+3

复杂度：O(N)（线性筛）或 O(N log log N)（埃氏筛）

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)
#include<cstdio>
#include<cmath>
#include<map>
#define LL long long
#define Re register LL
using namespace std;
const int N=1e5+3;
LL n,l,r,T,P,fu,a[N];char ch;map<LL,LL>phi;
inline void in(Re &x){
    x=fu=0;ch=getchar();
    while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
    while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();x=fu?-x:x;
}
inline LL Phi(Re x){
    Re ans=x,pos=x;
    if(phi.count(x))return phi[x];
    for(Re i=2;i<=sqrt(x);i++)
        if(!(x%i)){
            ans=ans/i*(i-1);
            while(!(x%i)) x/=i;
        }
    if(x>1)ans=ans/x*(x-1);
    return phi[pos]=ans;
}
inline LL mi(Re x,Re k,Re P){
    Re s=1,ok=0,flag=0;ok|=(x>=P);x%=P;
    while(k){
        if(k&1){s*=x;flag|=(ok||s>=P);s%=P;}
        x*=x;ok|=(x>=P);x%=P;k>>=1;
    }
    return s+(flag?P:0);
}
inline LL sakura(Re l,Re r,Re P){
    if(P==1|l>r)return 1;
    return mi(a[l],sakura(l+1,r,Phi(P)),P);
}
int main(){
    in(n),in(P);
    for(Re i=1;i<=n;++i)in(a[i]);
    in(T);
    while(T--){
        in(l),in(r);
    	printf("%lld\n",sakura(l,r,P)%P);
    }
}

```

**BSGS拔山盖世** *(可爱的质数)*

> 【BSGS拔山盖世（可爱的质数）】
质数与筛法相关模板。

核心函数：
  void in(Re &x) — 核心算法函数
  int mi(Re x,Re k) — 核心算法函数

关键配置：
N=1e5+3

复杂度：O(N)（线性筛）或 O(N log log N)（埃氏筛）

```cpp
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<map>
#define LL long long
#define Re register int
using namespace std;
const int N=1e5+3;
int x,y,m,P;map<int,int>B;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
//x^k = y (mod P)
//k = am-b (m=sqrt(P)+1, a\in[1,m], b\in[0,m-1])
//(x^m)^a = y x^b (mod P)
inline int mi(Re x,Re k){
	Re s=1;
	while(k){
		if(k&1)s=(LL)s*x%P;
		x=(LL)x*x%P,k>>=1;
	}
	return s;
}
int main(){
//	freopen("123.txt","r",stdin);
	in(P),in(x),in(y),m=sqrt(P)+1;
	for(Re b=0,s=y;b<m;++b)B[s]=b,s=(LL)s*x%P;
	Re tmp=mi(x,m);
	for(Re a=1,s=1;a<=m;++a){
		s=(LL)s*tmp%P;
		if(B.find(s)!=B.end()){printf("%d\n",a*m-B[s]);return 0;}
	}
	puts("no solution");
}

```

**CRT中国剩余定理 (P两两互质)** *(同余方程组)*

> 【CRT中国剩余定理 (P两两互质)（同余方程组）】
质数与筛法相关模板。

核心函数：
  void in(Re &x) — 核心算法函数
  void exgcd(Re a,Re b,Re &x,Re &y) — 最大公约数
  LL cf(Re x,Re k,Re P) — 核心算法函数

关键配置：
N=13

复杂度：O(N)（线性筛）或 O(N log log N)（埃氏筛）

说明：freopen("123.txt","r",stdin);

```cpp
#include<cstdio>
#define LL long long
#define Re register LL
const int N=13;
LL n,ans,lcm=1,a[N],m[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void exgcd(Re a,Re b,Re &x,Re &y){
	if(!b){x=1,y=0;return;}
	exgcd(b,a%b,x,y);Re x0=x,y0=y;
	x=y0,y=x0-a/b*y0;return;
}
inline LL cf(Re x,Re k,Re P){
	Re s=0;
	while(k){
		if(k&1)(s+=x)%=P;
		(x+=x)%=P,k>>=1;
	}
	return s;
}
int main(){
//    freopen("123.txt","r",stdin);
    in(n);
    for(Re i=1;i<=n;++i)in(m[i]),in(a[i]),lcm*=m[i];
    for(Re i=1;i<=n;++i){
		Re x,y,M=lcm/m[i];exgcd(M,m[i],x,y);//M[i]*inv+m[i]*y=1
		x=(x%m[i]+m[i])%m[i],(ans+=cf(cf(a[i],M,lcm),x,lcm))%=lcm;
	}
	printf("%lld\n",ans);
}

```

**EXBSGS扩展拔山盖世** *(mi)*

> 【EXBSGS扩展拔山盖世】
质数与筛法相关模板。

核心函数：
  void in(Re &x) — 核心算法函数
  int mi(Re x,Re k,Re P) — 核心算法函数
  int gcd(Re a,Re b) — 最大公约数
  void exBSGS(Re x,Re y,Re P) — SG函数计算

复杂度：O(N)（线性筛）或 O(N log log N)（埃氏筛）

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<map>
#define LL long long
#define Re register int
using namespace std;
int x,y,z;map<int,int>B;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline int mi(Re x,Re k,Re P){
	Re s=1;
	while(k){
		if(k&1)s=(LL)s*x%P;
		x=(LL)x*x%P,k>>=1;
	}
	return s;
}
inline int gcd(Re a,Re b){return !b?a:gcd(b,a%b);}
inline void exBSGS(Re x,Re y,Re P){
	if(y==1){puts("0");return;}
	Re d=gcd(x,P),tmp=1,t=0;
	while(d!=1){
		if(y%d){puts("No Solution");return;}
		++t,y/=d,P/=d,tmp=(LL)tmp*(x/d)%P;
		if(y==tmp){printf("%d\n",t);return;}
		d=gcd(x,P);
	}
	Re m=sqrt(P)+1;B.clear();
	for(Re b=0,s=y;b<m;++b)B[s]=b,s=(LL)s*x%P;
	Re s=tmp;tmp=mi(x,m,P);
	for(Re a=1;a<=m;++a){
		s=(LL)s*tmp%P;
		if(B.find(s)!=B.end()){printf("%d\n",a*m-B[s]+t);return;}
	}
	puts("No Solution");
}
int main(){
//	freopen("123.txt","r",stdin);
	while(1){
		in(x),in(y),in(z);
		if(!x&&!y&&!z)break;
		exBSGS(x,z,y);
	}
}

```

**EXCRT扩展中国剩余定理** *(P不一定两两互质)*

> 【EXCRT扩展中国剩余定理（P不一定两两互质）】
质数与筛法相关模板。

核心函数：
  void in(Re &x) — 核心算法函数
  LL exgcd(Re a,Re b,Re &x,Re &y) — 最大公约数
  LL cf(Re x,Re k,Re P) — 核心算法函数

关键配置：
N=1e5+3

复杂度：O(N)（线性筛）或 O(N log log N)（埃氏筛）

说明：freopen("123.txt","r",stdin);

```cpp
#include<cstdio>
#define LL long long
#define Re register LL
const int N=1e5+3;
LL n,ans,lcm=1,a[N],m[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline LL exgcd(Re a,Re b,Re &x,Re &y){
	if(!b){x=1,y=0;return a;}
	Re gcd=exgcd(b,a%b,x,y);Re x0=x,y0=y;
	x=y0,y=x0-a/b*y0;return gcd;
}
inline LL cf(Re x,Re k,Re P){
	Re s=0;
	while(k){
		if(k&1)(s+=x)%=P;
		(x+=x)%=P,k>>=1;
	}
	return s;
}
int main(){
//    freopen("123.txt","r",stdin);
    in(n);
    for(Re i=1;i<=n;++i)in(m[i]),in(a[i]),lcm*=m[i];
    ans=a[1]%m[1],lcm=m[1];
    for(Re i=2;i<=n;++i){//ans+lcm*k=a[i](mod m[i]) -> lcm*k=a[i]-ans(mod m[i]) -> lcm*k+m[i]*y=a[i]-ans
		Re c=((a[i]-ans)%m[i]+m[i])%m[i],x,y;
		Re gcd=exgcd(lcm,m[i],x,y);
		Re k=cf(x,c/gcd,m[i]/gcd);
		ans+=lcm*k,lcm*=m[i]/gcd,ans=(ans%lcm+lcm)%lcm;
	}
	printf("%lld\n",ans);
}

```

**EXGCD** *(线性同余方程)*

> 【EXGCD（线性同余方程）】
质数与筛法相关模板。

核心函数：
  void exgcd(Re a,Re b,Re &x,Re &y) — 最大公约数

复杂度：O(N)（线性筛）或 O(N log log N)（埃氏筛）

```cpp
#include<cstdio>
#define Re register int
int a,b,x,y;
inline void exgcd(Re a,Re b,Re &x,Re &y){
	if(!b){x=1,y=0;return;}
	exgcd(b,a%b,x,y);Re x0=x,y0=y;
	x=y0,y=x0-a/b*y0;return;
}
int main(){
    scanf("%d%d",&a,&b),exgcd(a,b,x,y);
	printf("%d\n",(x%b+b)%b);
}

```

**二次剩余** *(mi)*

> 【二次剩余】
质数与筛法相关模板。

核心函数：
  void in(Re &x) — 核心算法函数
  int mi(Re x,Re k) — 核心算法函数
  CP mi_(CP x,Re k) — 核心算法函数
  LL Sqrt(Re n) — 开平方

核心结构体：CP

复杂度：O(N)（线性筛）或 O(N log log N)（埃氏筛）

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
int n,T,P,W,det;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline int mi(Re x,Re k){
	Re s=1;
	while(k){
		if(k&1)s=(LL)s*x%P;
		x=(LL)x*x%P,k>>=1;
	}
	return s;
}
struct CP{
	int x,y;CP(Re X=0,Re Y=0){x=X,y=Y;}
	inline CP operator*(const CP &O)const{return CP(((LL)x*O.x%P+(LL)y*O.y%P*W%P)%P,((LL)x*O.y%P+(LL)y*O.x%P)%P);}
	inline CP operator*=(const CP &O){return *this=*this*O;}
};
inline CP mi_(CP x,Re k){
	CP s=CP(1,0);
	while(k){
		if(k&1)s*=x;
		x*=x,k>>=1;
	}
	return s;
}
inline LL Sqrt(Re n){
    if(!n)return 0;Re x;
    while(1){
        x=rand()%P,W=((LL)x*x%P-n+P)%P;
        if(mi(W,(P-1)/2)==P-1)break;
    }
    return mi_(CP(x,1),(P+1)/2).x;
}
int main(){
//	freopen("123.txt","r",stdin);
	in(T);
	while(T--){
		in(n),in(P);
		if(mi(n,(P-1)/2)==P-1)puts("Hola!");//�޽�
	    else{
		    det=Sqrt(n);
		    if(det)printf("%d %d\n",min(det,P-det),max(det,P-det));
		    else printf("%d\n",det);
		}
	}
}

```

**扩展欧拉定理** *(a^b%m)*

> 【扩展欧拉定理（a^b%m）】
线性筛（欧拉筛）模板，O(N) 筛出质数并可同时计算积性函数。

核心函数：
  LL cf(Re x,Re k) — 核心算法函数

复杂度：O(N)（线性筛）或 O(N log log N)（埃氏筛）

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)
#include<cstdio>
#include<cctype>
#define LL long long
#define Re register LL
LL i,a,b,m,x,s,phi,flag;char c;
inline LL cf(Re x,Re k){
	Re s=0;
	while(k){
		if(k&1)(s+=x)%=m;
		(x<<=1)%=m,k>>=1;
	}
	return s;
}
int main(){
    scanf("%lld%lld",&a,&m);phi=x=m;
    for(i=2;i*i<=m;++i)if(!(x%i)){phi-=phi/i;while(!(x%i))x/=i;}
    if(x>1)phi-=phi/x;
    while(!isdigit(c=getchar()));
    while(isdigit(c))flag|=((b=(b<<1)+(b<<3)+(c^48))>=phi),b%=phi,c=getchar();
    b+=flag?phi:0;x=1;
    while(b){if(b&1)x=cf(x,a)%m;a=cf(a,a)%m,b>>=1;}
    printf("%lld",x);
}

```

**有理数取模** *(mi)*

> 【有理数取模】
质数与筛法相关模板。

核心函数：
  void in(Re &x) — 核心算法函数
  LL mi(Re x,Re k) — 核心算法函数

复杂度：O(N)（线性筛）或 O(N log log N)（埃氏筛）

说明：freopen("123.txt","r",stdin);

```cpp
#include<cstdio>
#define LL long long
#define Re register LL
using namespace std;
const LL N=1e4+3,P=19260817;
LL a,b;
inline void in(Re &x){
    Re f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),x%=P,c=getchar();
}
inline LL mi(Re x,Re k){
    Re s=1;
    while(k){
        if(k&1)(s*=x)%=P;
        (x*=x)%=P,k>>=1;
    }
    return s;
}
int main(){
    // freopen("123.txt","r",stdin);
    in(a),in(b);
    if(b)printf("%lld\n",a%P*mi(b,P-2)%P);
    else puts("Angry!");
}
```

**逆元** *(快速幂)*

> 【逆元（快速幂）】
质数与筛法相关模板。

核心函数：
  int inv(Re x,Re P) — 求模逆元

复杂度：O(N)（线性筛）或 O(N log log N)（埃氏筛）

```cpp
#include<cstdio>
#define LL long long
#define Re register int
int n,P;
inline int inv(Re x,Re P){
    Re s=1,k=P-2;
    while(k){
    	if(k&1)s=(LL)s*x%P;
    	x=(LL)x*x%P,k>>=1;
    }
    return s%P;
}
int main(){
    scanf("%d%d",&n,&P);
    for(Re i=1;i<=n;++i)printf("%d\n",inv(i,P));
}

```

**逆元** *(递推)*

> 【逆元（递推）】
质数与筛法相关模板。

关键配置：
N=3e6+3

复杂度：O(N)（线性筛）或 O(N log log N)（埃氏筛）

```cpp
#include<cstdio>
#define LL long long
#define Re register int
const int N=3e6+3;
int n,P,inv[N];
int main(){
    scanf("%d%d",&n,&P);
    inv[1]=1;
    for(Re i=2;i<=n;++i)inv[i]=(LL)(P-P/i)*inv[P%i]%P;
    for(Re i=1;i<=n;++i)printf("%d\n",inv[i]);
}

```

**炸勃龙** *(树状数组+扩展欧拉定理)*

> 【炸勃龙（树状数组+扩展欧拉定理）】
质数与筛法相关模板。

核心函数：
  void in(Re &x) — 核心算法函数
  void add(Re x,Re k) — 加法更新
  LL ask(Re x) — 核心算法函数
  LL mi(Re x,Re k,Re P) — 核心算法函数
  LL sakura(Re l,Re r,Re P) — 后缀数组

关键配置：
N=5e5+3,Np=2e7

复杂度：O(N)（线性筛）或 O(N log log N)（埃氏筛）

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)
#include<cstdio>
#define LL long long
#define Re register LL
#define F(a,b) for(i=a;i<=b;++i)
const int N=5e5+3,Np=2e7;
LL i,j,n,x,l,r,K,T,fu,cnt,c[N],C[N],pan[Np+1],pri[Np+1],phi[Np+1];char ch;
inline void in(Re &x){
    x=fu=0;ch=getchar();
    while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
    while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();x=fu?-x:x;
}
inline void add(Re x,Re k){while(x<=n)C[x]+=k,x+=x&-x;}
inline LL ask(Re x){Re tmp=0;while(x)tmp+=C[x],x-=x&-x;return tmp;}
inline LL mi(Re x,Re k,Re P){
    Re s=1,ok=0,flag=0;ok|=(x>=P);x%=P;
    while(k){
        if(k&1){s*=x;flag|=(ok||s>=P);s%=P;}
        x*=x;ok|=(x>=P);x%=P;k>>=1;
    }
    return s+(flag?P:0);
}

inline LL sakura(Re l,Re r,Re P){
    if(P==1|l>r)return 1;
    return mi(ask(l),sakura(l+1,r,phi[P]),P);
}
int main(){
    for(i=2;i<=Np;++i){
        if(!pan[i])pri[++cnt]=i,phi[i]=i-1;
        for(j=1;j<=cnt;++j){
      		if(i*pri[j]>Np)break;
      		pan[i*pri[j]]=1;
      		if(i%pri[j])phi[i*pri[j]]=phi[i]*(pri[j]-1);
      		else{phi[i*pri[j]]=phi[i]*pri[j];break;}
   		}
    }
    in(n),in(T);
    F(1,n)in(x),add(i,x-l),l=x;
    while(T--){
        in(K),in(l),in(r),in(x);
        if(K<2)add(l,x),add(r+1,-x);
        else printf("%lld\n",sakura(l,r,x)%x);
    }
}

```

**判素数** *(Miller Rabin)*

> 【判素数（Miller Rabin）】
质数与筛法相关模板。

核心函数：
  LL cf(Re x,Re k,Re P) — 核心算法函数
  LL mi(Re x,Re k,Re P) — 核心算法函数
  bool Miller_Rabin(Re x) — 核心算法函数

复杂度：O(N)（线性筛）或 O(N log log N)（埃氏筛）

```cpp
#include<cstdio>
#define LL long long
#define Re register LL
LL n,prime[10]={2,3,5,7,11,13,17,19,23,29};
inline LL cf(Re x,Re k,Re P){
	Re s=0;
	while(k){
		if(k&1)(s+=x)%=P;
		(x<<=1)%=P,k>>=1;
	}
	return s%P;
}
inline LL mi(Re x,Re k,Re P){
	Re s=1;
    while(k){
    	if(k&1)s=cf(s,x,P)%P;
    	x=cf(x,x,P)%P,k>>=1;
    }
    return s%P;
}
inline bool Miller_Rabin(Re x){
    Re s=0,t=x-1;
    if(x==2)return 1;
    if(x<2||!(x&1))return 0;
    while(!(t&1))s++,t>>=1;
    for(Re i=0;i<10&&prime[i]<x;++i){
        Re a=prime[i],b=mi(a,t,x);
        for(Re j=1,k;j<=s;++j){
            k=cf(b,b,x);
            if(k==1&&b!=1&&b!=x-1)return 0;
            b=k;
        }
        if(b!=1)return 0;
    }
    return 1;
}
int main(){
	while(scanf("%lld",&n)!=EOF)puts(Miller_Rabin(n)?"Y":"N");
}

```

**判素数** *(暴力)*

> 【判素数（暴力）】
质数与筛法相关模板。

核心函数：
  bool judge(int n) — 判定函数

复杂度：O(N)（线性筛）或 O(N log log N)（埃氏筛）

```cpp
#include<cstdio>
#include<cmath>
int x;
inline bool judge(int n){
	if(n<4)return 1;
	if(n%2==0)return 0;
	int half=sqrt(n);
	for(int i=3;i<=half;i+=2)
		if(n%i==0)return 0;
	return 1;
}
int main(){
	scanf("%d",&x);
	puts(judge(x)?"YES":"NO");
}

```

**筛素数** *(埃氏筛)*

> 【筛素数（埃氏筛）】
质数与筛法相关模板。

核心函数：
  void creat_prime(无参数) — Prim最小生成树
  int sakura(无参数) — 后缀数组

复杂度：O(N)（线性筛）或 O(N log log N)（埃氏筛）

```cpp
#include<cstdio>
#define R register int
int pri[10005],pan[10005],gs;
inline void creat_prime(){
	for(R i=2;i<=10000;i++)
		if(pan[i]==0){
			pri[++gs]=i;
			for(R j=2;i*j<=10000;j++)pan[i*j]=1;
		}
}
inline int sakura(){
	creat_prime();
	for(R i=1;i<=gs;i++)printf("%d\n",pri[i]);
}
int QAQWQ=sakura();
int main(){}

```

**筛质数** *(线筛)*

> 【筛质数（线筛）】
质数与筛法相关模板。

核心函数：
  void get_pri(无参数) — 获取值

关键配置：
N=1e6

复杂度：O(N)（线性筛）或 O(N log log N)（埃氏筛）

```cpp
#include<cstdio>
#include<ctime>
const int N=1e6;
int cnt,i,j,pri[N/3];bool pan[N+1];
inline void get_pri(){
	pan[0]=pan[1]=1;
	for(i=2;i<=N;++i){
		if(!pan[i])pri[++cnt]=i;
		for(j=1;j<=cnt&&i*pri[j]<=N;++j){
			pan[i*pri[j]]=1;
			if(i%pri[j]==0)break;
		}
	}
}
int main(){
	get_pri();
	for(j=0,i=1;i<=cnt;++i)printf("%d ",pri[i]);
}
```

### 7.2 组合数学与计数

**组合数学** *(Comb)*

> 【组合数学工具类 Combinatorics】
▪ Combinatorics(n) — 构造函数，预处理 [0,n] 的阶乘 fact[] 和逆阶乘 inv_fact[]，O(N)
▪ qpow(a, b) — 快速幂（内部使用），用于求逆元，O(log MOD)
▪ inv(x) — 求 x 的模逆元：qpow(x, MOD-2)（费马小定理，需 MOD 为质数）
▪ C(n, k) — 组合数 C(n,k) = fact[n] * inv_fact[k] * inv_fact[n-k] % MOD，O(1)
▪ A(n, k) — 排列数 A(n,k) = fact[n] * inv_fact[n-k] % MOD，O(1)
▪ Lucas(n, k) — 卢卡斯定理求 C(n,k)%MOD，适用于 n,k 很大但 MOD 较小（质数），O(log_MOD n)
▪ Stirling2(n, k) — 第二类斯特林数 S(n,k)，n 个元素划分为 k 个非空子集的方案数，O(nk)

```cpp
class Combinatorics {
private:
    vector<ll> fact, inv_fact;
    int max_n;
    
public:
    // 预处理阶乘和逆阶乘，O(n)
    Combinatorics(int n) : max_n(n) {
        fact.resize(n + 1);
        inv_fact.resize(n + 1);
        
        fact[0] = 1;
        for (int i = 1; i <= n; i++) {
            fact[i] = fact[i - 1] * i % MOD;
        }
        
        inv_fact[n] = inv(fact[n]);
        for (int i = n - 1; i >= 0; i--) {
            inv_fact[i] = inv_fact[i + 1] * (i + 1) % MOD;
        }
    }
    
    // 快速幂计算逆元，O(log MOD)
    ll inv(ll x) {
        return qpow(x, MOD - 2);
    }
    
    // 快速幂，O(log exponent)
    ll qpow(ll a, ll b) {
        ll res = 1;
        while (b) {
            if (b & 1) res = res * a % MOD;
            a = a * a % MOD;
            b >>= 1;
        }
        return res;
    }
    
    // 组合数C(n,k)，O(1)
    ll C(int n, int k) {
        if (k < 0 || k > n) return 0;
        return fact[n] * inv_fact[k] % MOD * inv_fact[n - k] % MOD;
    }
    
    // 排列数A(n,k)，O(1)
    ll A(int n, int k) {
        if (k < 0 || k > n) return 0;
        return fact[n] * inv_fact[n - k] % MOD;
    }
    
    // 卢卡斯定理计算组合数，适用于n,k很大但MOD较小的情况
    ll Lucas(ll n, ll k) {
        if (k == 0) return 1;
        return C(n % MOD, k % MOD) * Lucas(n / MOD, k / MOD) % MOD;
    }
    
    // 第二类斯特林数S(n,k)，将n个元素划分为k个非空子集，O(nk)
    ll Stirling2(int n, int k) {
        ll res = 0;
        for (int i = 0; i <= k; i++) {
            ll term = C(k, i) * qpow(i, n) % MOD;
            if ((k - i) % 2) {
                res = (res - term + MOD) % MOD;
            } else {
                res = (res + term) % MOD;
            }
        }
        return res * inv_fact[k] % MOD;
    }
    
    // 贝尔数B(n)，基于第二类斯特林数的实现，O(n^2)
    // B(n) = Σ S(n,k) for k=0 to n
    ll Bell_Stirling(int n) {
        ll res = 0;
        for (int k = 0; k <= n; k++) {
            res = (res + Stirling2(n, k)) % MOD;
        }
        return res;
    }
    
    // 贝尔数B(n)，基于动态规划的实现，O(n^2)
    // 使用递推关系：B(n+1) = Σ C(n,k)*B(k) for k=0 to n
    ll Bell_DP(int n) {
        if (n == 0) return 1;
        vector<ll> bell(n + 1);
        bell[0] = 1;
        
        for (int i = 1; i <= n; i++) {
            bell[i] = 0;
            for (int k = 0; k < i; k++) {
                bell[i] = (bell[i] + C(i - 1, k) * bell[k]) % MOD;
            }
        }
        return bell[n];
    }
    
    // 卡特兰数，O(1)
    ll Catalan(int n) {
        return C(2 * n, n) * inv(n + 1) % MOD;
    }
    
    // 错位排列数，O(n)预处理后O(1)查询
    ll Derangement(int n) {
        if (n == 0) return 1;
        if (n == 1) return 0;
        // D(n) = (n-1)*(D(n-1)+D(n-2))
        vector<ll> d(n + 1);
        d[0] = 1;
        d[1] = 0;
        for (int i = 2; i <= n; i++) {
            d[i] = (i - 1) * (d[i - 1] + d[i - 2]) % MOD;
        }
        return d[n];
    }
    
    // 计算gcd，O(log min(a,b))
    ll gcd(ll a, ll b) {
        return b == 0 ? a : gcd(b, a % b);
    }
    
    // 计算lcm，O(log min(a,b))
    ll lcm(ll a, ll b) {
        return a / gcd(a, b) * b;
    }
    
    // 扩展欧几里得算法，求解ax + by = gcd(a,b)
    ll ext_gcd(ll a, ll b, ll &x, ll &y) {
        if (b == 0) {
            x = 1;
            y = 0;
            return a;
        }
        ll d = ext_gcd(b, a % b, y, x);
        y -= a / b * x;
        return d;
    }
    
    // 中国剩余定理，求解x ≡ a_i (mod m_i)
    ll CRT(const vector<ll> &a, const vector<ll> &m) {
        ll M = 1, x = 0;
        int n = a.size();
        for (int i = 0; i < n; i++) M *= m[i];
        
        for (int i = 0; i < n; i++) {
            ll Mi = M / m[i];
            ll y, z;
            ext_gcd(Mi, m[i], y, z);
            x = (x + a[i] * Mi % M * y % M) % M;
        }
        return (x + M) % M;
    }
    
    // 欧拉函数，计算小于n且与n互质的数的个数，O(sqrt(n))
    ll EulerPhi(ll n) {
        ll res = n;
        for (ll i = 2; i * i <= n; i++) {
            if (n % i == 0) {
                res = res / i * (i - 1);
                while (n % i == 0) n /= i;
            }
        }
        if (n > 1) res = res / n * (n - 1);
        return res;
    }
};

Combinatorics comb(1000000); // 预处理1e6以内的阶乘
```

**Polya定理** *(mi)*

> 【Polya定理】
组合数学与计数模板。

核心函数：
  void in(Re &x) — 核心算法函数
  int mi(Re x,Re k) — 核心算法函数
  int inv(Re x) — 求模逆元
  int phi(Re x) — 核心算法函数

关键配置：
N=1e6+3,P=1e9+7

说明：freopen("123.txt","r",stdin);

适用场景：计数问题、排列组合求值（含模运算）

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=1e6+3,P=1e9+7;
int n,T,pri[N/3];bool pan[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline int mi(Re x,Re k){
	Re s=1;
	while(k){
		if(k&1)s=(LL)s*x%P;
		x=(LL)x*x%P,k>>=1;
	}
	return s;
}
inline int inv(Re x){return mi(x,P-2);}
inline int phi(Re x){
	Re ans=x;
	for(Re i=2;i*i<=x;i++)
		if(x%i==0){
			ans/=i,ans*=i-1;
			while(x%i==0)x/=i;
		}
	if(x>1)ans/=x,ans*=x-1;
	return ans;
}
int main(){
//	freopen("123.txt","r",stdin);
	in(T);
	while(T--){
		in(n);Re ans=0;
		for(Re i=1;i*i<=n;++i)
			if(n%i==0){
				(ans+=(LL)mi(n,i-1)*phi(n/i)%P)%=P;
				if(i!=n/i)(ans+=(LL)mi(n,n/i-1)*phi(i)%P)%=P;
			}
		printf("%d\n",ans);
	}
}

```

**卡特兰数Catalan** *(质因数分解 取模)*

> 【卡特兰数Catalan（质因数分解 取模）】
卡特兰数（Catalan Number）模板，常见于括号序列、出栈序列等计数。

核心函数：
  void get_pri(Re N) — 获取值
  LL Catalan(Re n) — 核心算法函数

关键配置：
N=1e6+3

适用场景：计数问题、排列组合求值（含模运算）

```cpp
#include<cstdio>
#define LL long long
#define Re register LL
const int N=1e6+3;
LL n,P,cnt,pri[N],pan[N<<1];
inline void get_pri(Re N){
    for(Re i=2;i<=N;++i){
        if(!pan[i])pri[++cnt]=i;
        for(Re j=1;j<=cnt&&i*pri[j]<=N;++j)pan[i*pri[j]]=1;
    }
}
inline LL Catalan(Re n){
    Re ans=1;cnt=0;get_pri(n<<1);
    for(Re i=1;i<=cnt;i++){
        Re x=pri[i],t=0;
        while(x<=2*n){t+=2*n/x-n/x-(n+1)/x;x*=pri[i];}
        while(t--)(ans*=pri[i])%=P;
    }
    return ans%P;
}
int main(){
    scanf("%lld%lld",&n,&P);
	printf("%lld",Catalan(n));
}

```

**卡特兰数Catalan** *(质因数分解 高精度)*

> 【卡特兰数Catalan（质因数分解 高精度）】
卡特兰数（Catalan Number）模板，常见于括号序列、出栈序列等计数。

核心函数：
  void cf(int x) — 核心算法函数

适用场景：计数问题、排列组合求值（含模运算）

```cpp
#include<cstdio>
#define R register int
int n,t,x,len,ans[100000],pan[120005];
void cf(int x){
    R i,j;
    for(i=1;i<=len;i++)ans[i]*=x;
    len+=6;
    for(i=1;i<=len;i++)ans[i+1]+=ans[i]/10,ans[i]%=10;
    while(!ans[len])len--;
}
int main(){
    scanf("%d",&n);R i,j;len=ans[1]=1;
    for(i=2;i<=2*n;i++)
        if(pan[i]==0){
            x=i;t=0;
            while(x<=2*n){t+=2*n/x-n/x-(n+1)/x;x*=i;}
            while(t--)cf(i);
            for(j=i;j<=2*n/i;j++)pan[i*j]=1;
        }
    for(i=len;i>=1;i--)printf("%d",ans[i]);
}

```

**卢卡斯定理** *(mi)*

> 【卢卡斯定理】
Lucas 定理模板，用于大组合数对质数取模。

核心函数：
  void in(Re &x) — 核心算法函数
  int mi(Re x,Re k) — 核心算法函数
  int inv(Re x) — 求模逆元
  int C(Re m,Re n) — 核心算法函数
  int Lucas(Re m,Re n) — 卢卡斯定理

关键配置：
N=1e5+3

说明：freopen("123.txt","r",stdin);

适用场景：计数问题、排列组合求值（含模运算）

```cpp
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=1e5+3;
int n,m,P,T,jc[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline int mi(Re x,Re k){
	Re s=1;
	while(k){
		if(k&1)s=(LL)s*x%P;
		x=(LL)x*x%P,k>>=1;
	}
	return s;
}
inline int inv(Re x){return mi(x,P-2);}
inline int C(Re m,Re n){
	return m>n?0:(LL)jc[n]*inv(jc[m])%P*inv(jc[n-m])%P;
}
inline int Lucas(Re m,Re n){
	return m==0?1:(LL)Lucas(m/P,n/P)*C(m%P,n%P)%P;
}
int main(){
//	freopen("123.txt","r",stdin);
	in(T);
	while(T--){
		in(n),in(m),in(P),jc[0]=1;
		for(Re i=1;i<=P-1;++i)jc[i]=(LL)jc[i-1]*i%P;
		printf("%d\n",Lucas(n,n+m));
	}
}

```

**康托展开** *(optimize)*

> 【康托展开】
组合数学与计数模板。

核心函数：
  void add(int x) — 加法更新
  int ask(int x) — 核心算法函数

关键配置：
N=1e6+5,P=998244353

适用场景：计数问题、排列组合求值（含模运算）

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)
#include<cstdio>
#define LL long long
const int N=1e6+5,P=998244353;
int n,i,ans,a[N],g[N],C[N],jc[N]={1};
inline void add(int x){while(x<=n)++C[x],x+=x&-x;}
inline int ask(int x){
	int ans=0;
	while(x)ans+=C[x],x-=x&-x;
	return ans;
}
int main(){
	scanf("%d",&n);
	for(i=1;i<=n;++i)scanf("%d",&a[i]);
	for(i=n;i;--i)g[i]=ask(a[i]-1),add(a[i]);
	for(i=1;i<=n;++i)jc[i]=(LL)jc[i-1]*i%P;
	for(i=1;i<=n;++i)(ans+=(LL)g[i]*jc[n-i]%P)%=P;
	printf("%d",ans+1);
}

```

**球盒模型全套** *(Cat)*

> 【球盒模型全套（Cat）】
组合数学与计数模板。

核心函数：
  void in(Re &x) — 核心算法函数
  LL mi(Re x,Re k) — 核心算法函数
  LL niv(Re x) — 核心算法函数
  LL c(Re m,Re n) — 核心算法函数
  void Stirling(无参数) — 核心算法函数
  void DP(无参数) — 核心算法函数
  LL Catalan(Re n) — 核心算法函数

说明：freopen("cat.in","r",stdin);；freopen("cat.out","w",stdout);

适用场景：计数问题、排列组合求值（含模运算）

```cpp
#include<cstdio>
#define LL long long
#define Re register LL
const int P=998244353,N=1e6+5;
LL T,a,b,f,opt,cnt,jc[N*2+5],dp[205][205],S[105][105];
inline void in(Re &x){
    x=f=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    if(f)x=-x;
}
inline LL mi(Re x,Re k){
    Re ans=1;
    while(k){
        if(k&1)ans=(ans*x)%P;
        x=(x*x)%P;k>>=1;
    }
    return ans%P;
} 
inline LL niv(Re x){return mi(x,P-2);}
inline LL c(Re m,Re n){
    if(n<m)return 0;
    if(n<P)return jc[n]*niv(jc[m])%P*niv(jc[n-m])%P;
    return c(m/P,n/P)*c(m%P,n%P)%P;
}
inline void Stirling(){
    for(Re i=0;i<=100;++i)S[i][i]=1;
    for(Re i=1;i<=100;++i)
        for(Re j=1;j<=100;++j)
            S[i][j]=(S[i-1][j-1]+S[i-1][j]*j%P)%P;
}
inline void DP(){
    dp[0][0]=1;
    for(Re i=1;i<=200;++i)
        for(Re j=1;j<=i;++j)
            dp[i][j]=(dp[i-j][j]+dp[i-1][j-1])%P;
}
inline LL Catalan(Re n){return c(n,n<<1)*niv(n+1)%P;}
int main(){
//  freopen("cat.in","r",stdin);
//  freopen("cat.out","w",stdout);
    jc[0]=1;for(Re i=1;i<=N*2;i++)jc[i]=jc[i-1]*i%P;
    in(T);Stirling();DP();
    while(T--){
        in(opt),in(a),in(b);
        if(opt==1)printf("%lld\n",mi(b,a));
        else if(opt==2)printf("%lld\n",c(b-1,a-1));
        else if(opt==3)printf("%lld\n",c(b-1,a+b-1));
        else if(opt==4)printf("%lld\n",S[a][b]);
        else if(opt==5)printf("%lld\n",jc[b]*S[a][b]%P);
        else if(opt==6){
            Re ans=0;
            for(Re i=1;i<=b;++i)(ans+=S[a][i])%=P;
            printf("%lld\n",ans);
        }
        else if(opt==7)printf("%lld\n",dp[a+b][b]);
        else if(opt==8)printf("%lld\n",dp[a][b]);
        else if(opt==9)printf("%lld\n",Catalan(a));
    }
}

```

**第一类斯特林数** *(n^2递推)*

> 【第一类斯特林数（n^2递推）】
斯特林数（Stirling Number）模板，划分子集/排列的计数。

核心函数：
  void get_stiring(Re N) — 获取值

关键配置：
N=1003,P=998244353

适用场景：计数问题、排列组合求值（含模运算）

```cpp
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=1003,P=998244353;
int s[N][N]; 
inline void get_stiring(Re N){
	for(Re i=0;i<=N;++i)s[i][i]=1;
	for(Re i=1;i<=N;++i)
		for(Re j=1;j<i;++j)
			s[j][i]=s[j-1][i-1]+(LL)(i-1)*s[j][i-1]%P;
}
int main(){}

```

**第一类斯特林数·行** *(nlogn 优化倍增 NTT)*

> 【第一类斯特林数·行（nlogn 优化倍增 NTT）】
斯特林数（Stirling Number）模板，划分子集/排列的计数。

核心函数：
  void in(Re &x) — 核心算法函数
  int mi(Re x,Re k) — 核心算法函数
  int inv(Re x) — 求模逆元
  void NTT(Re *f,Re n,Re op) — 数论变换
  void times(Re *f,Re n,Re *g,Re m) — 核心算法函数
  void xplus(Re *f,Re *F,Re n,Re c) — 核心算法函数
  void sakura(Re *f,Re n) — 后缀数组
  void get_Stirling(Re n) — 获取值

关键配置：
N=262144+3,P=167772161,G=3

说明：freopen("123.txt","r",stdin);

适用场景：计数问题、排列组合求值（含模运算）

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#define LD double
#define LL long long
#define Re register int
using namespace std;
const int N=262144+3,P=167772161,G=3;
int n,m,invn,invG,f[N],g[N],h[N],p[N],tr[N],jc[N],invjc[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline int mi(Re x,Re k){
	Re s=1;
	while(k){
		if(k&1)s=(LL)s*x%P;
		x=(LL)x*x%P,k>>=1;
	}
	return s;
}
inline int inv(Re x){return mi(x,P-2);}
inline void NTT(Re *f,Re n,Re op){
	for(Re i=0;i<n;++i)if(i<tr[i])swap(f[i],f[tr[i]]);
	for(Re p=2;p<=n;p<<=1)
		for(Re st=0,len=p>>1,w1=mi(op?invG:G,(P-1)/p);st<n;st+=p)
			for(Re i=st,base=1;i<=st+len-1;++i){
				Re tmp=(LL)base*f[i+len]%P;
				f[i+len]=(f[i]-tmp+P)%P,f[i]=(f[i]+tmp)%P,base=(LL)base*w1%P;
			}
}
inline void times(Re *f,Re n,Re *g,Re m){
	Re n_=n,m_=m;
	for(m+=n,n=1;n<=m;n<<=1);
	for(Re i=n_+1;i<=n;++i)f[i]=0;
	for(Re i=m_+1;i<=n;++i)g[i]=0;
	for(Re i=1;i<n;++i)tr[i]=(tr[i>>1]>>1)|((i&1)?n>>1:0);
	NTT(f,n,0),NTT(g,n,0);
	for(Re i=0;i<n;++i)f[i]=(LL)f[i]*g[i]%P;
	NTT(f,n,1);
	for(Re i=0,invn=inv(n);i<=m;++i)f[i]=(LL)f[i]*invn%P;
}
inline void xplus(Re *f,Re *F,Re n,Re c){
	for(Re i=0;i<=n;++i)h[i]=(LL)F[i]*jc[i]%P;
	for(Re i=0,Mi=1;i<=n;++i)p[n-i]=(LL)Mi*invjc[i]%P,Mi=(LL)Mi*c%P;
	times(h,n,p,n);
	for(Re i=0;i<=n;++i)f[i]=(LL)h[n+i]*invjc[i]%P;
}
inline void sakura(Re *f,Re n){
	if(n==1){f[0]=0,f[1]=1;return;}//(x+0)
	if(n&1){
		sakura(f,n-1);
		for(Re i=n;i;--i)f[i]=((LL)f[i]*(n-1)%P+f[i-1])%P;
		f[0]=(LL)f[0]*(n-1)%P;
	}
	else sakura(f,n>>1),xplus(g,f,n>>1,n>>1),times(f,n>>1,g,n>>1);
}
int s[N];
inline void get_Stirling(Re n){
	invjc[1]=invjc[0]=jc[0]=1,invG=inv(G);
	if(n==0){s[0]=1;return;}
	for(Re i=1;i<=n;++i)jc[i]=(LL)jc[i-1]*i%P;
	for(Re i=2;i<=n;++i)invjc[i]=(LL)invjc[P%i]*(P-P/i)%P;
	for(Re i=2;i<=n;++i)invjc[i]=(LL)invjc[i]*invjc[i-1]%P;
	sakura(s,n);
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),get_Stirling(n);
	for(Re i=0;i<=n;++i)printf("%d ",s[i]);
}

```

**第一类斯特林数·行** *(nlog^2n 暴力分治 NTT)*

> 【第一类斯特林数·行（nlog^2n 暴力分治 NTT）】
斯特林数（Stirling Number）模板，划分子集/排列的计数。

核心函数：
  void in(Re &x) — 核心算法函数
  int mi(Re x,Re k) — 核心算法函数
  int inv(Re x) — 求模逆元
  void NTT(Re *f,Re n,Re op) — 数论变换
  void times(Re *f,Re n,Re *g,Re m) — 核心算法函数
  void CDQ(Re L,Re R,Re deep) — 核心算法函数
  void get_Stirling(Re n) — 获取值

关键配置：
N=262144+3,P=167772161,G=3

说明：freopen("123.txt","r",stdin);

适用场景：计数问题、排列组合求值（含模运算）

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#define LD double
#define LL long long
#define Re register int
using namespace std;
const int N=262144+3,P=167772161,G=3;
int n,m,invn,invG,tr[N],A[20][N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline int mi(Re x,Re k){
	Re s=1;
	while(k){
		if(k&1)s=(LL)s*x%P;
		x=(LL)x*x%P,k>>=1;
	}
	return s;
}
inline int inv(Re x){return mi(x,P-2);}
inline void NTT(Re *f,Re n,Re op){
	for(Re i=0;i<n;++i)if(i<tr[i])swap(f[i],f[tr[i]]);
	for(Re p=2;p<=n;p<<=1)
		for(Re st=0,len=p>>1,w1=mi(op?invG:G,(P-1)/p);st<n;st+=p)
			for(Re i=st,base=1;i<=st+len-1;++i){
				Re tmp=(LL)base*f[i+len]%P;
				f[i+len]=(f[i]-tmp+P)%P,f[i]=(f[i]+tmp)%P,base=(LL)base*w1%P;
			}
}
inline void times(Re *f,Re n,Re *g,Re m){
	Re n_=n,m_=m;
	for(m+=n,n=1;n<=m;n<<=1);
	for(Re i=n_+1;i<=n;++i)f[i]=0;
	for(Re i=m_+1;i<=n;++i)g[i]=0;
	for(Re i=1;i<n;++i)tr[i]=(tr[i>>1]>>1)|((i&1)?n>>1:0);
	NTT(f,n,0),NTT(g,n,0);
	for(Re i=0;i<n;++i)f[i]=(LL)f[i]*g[i]%P;
	NTT(f,n,1);
	for(Re i=0,invn=inv(n);i<=m;++i)f[i]=(LL)f[i]*invn%P;
}
inline void CDQ(Re L,Re R,Re deep){
	if(L==R){A[deep][0]=L,A[deep][1]=1;return;}
	Re mid=L+R>>1;
	CDQ(L,mid,deep+1);
	for(Re i=0;i<=mid-L+1;++i)A[deep][i]=A[deep+1][i];
	CDQ(mid+1,R,deep+1);
	times(A[deep],mid-L+1,A[deep+1],R-mid);
}
int s[N];
inline void get_Stirling(Re n){
	invG=inv(G),CDQ(0,n-1,0);
	for(Re i=0;i<=n;++i)s[i]=A[0][i];
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),get_Stirling(n);
	for(Re i=0;i<=n;++i)printf("%d ",s[i]);
}

```

**第二类斯特林数** *(n^2递推)*

> 【第二类斯特林数（n^2递推）】
斯特林数（Stirling Number）模板，划分子集/排列的计数。

核心函数：
  void get_Stiring(Re N) — 获取值

关键配置：
N=1003,P=998244353

适用场景：计数问题、排列组合求值（含模运算）

```cpp
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=1003,P=998244353;
int S[N][N]; 
inline void get_Stiring(Re N){
	for(Re i=0;i<=N;++i)S[i][i]=1;
	for(Re i=1;i<=N;++i)
		for(Re j=1;j<i;++j)
			S[j][i]=S[j-1][i-1]+(LL)j*S[j][i-1]%P;
}
int main(){}

```

**第二类斯特林数·行** *(NTT)*

> 【第二类斯特林数·行（NTT）】
斯特林数（Stirling Number）模板，划分子集/排列的计数。

核心函数：
  void in(Re &x) — 核心算法函数
  int mi(Re x,Re k) — 核心算法函数
  int inv(Re x) — 求模逆元
  void NTT(Re *f,Re n,Re op) — 数论变换
  void sakura(Re *f,Re n,Re *g,Re m) — 后缀数组
  void get_Stirling(Re n) — 获取值

关键配置：
N=524288+3,P=167772161,G=3

说明：freopen("123.txt","r",stdin);

适用场景：计数问题、排列组合求值（含模运算）

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=524288+3,P=167772161,G=3;
int n,invG,f[N],g[N],tr[N],jc[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline int mi(Re x,Re k){
	Re s=1;
	while(k){
		if(k&1)s=(LL)s*x%P;
		x=(LL)x*x%P,k>>=1;
	}
	return s;
}
inline int inv(Re x){return mi(x,P-2);}
inline void NTT(Re *f,Re n,Re op){
	for(Re i=0;i<n;++i)if(i<tr[i])swap(f[i],f[tr[i]]);
	for(Re p=2;p<=n;p<<=1)
		for(Re st=0,len=p>>1,w1=mi(op?invG:G,(P-1)/p);st<n;st+=p)
			for(Re i=st,base=1;i<=st+len-1;++i){
				Re tmp=(LL)f[i+len]*base%P;
				f[i+len]=(f[i]-tmp+P)%P,(f[i]+=tmp)%=P,base=(LL)base*w1%P;
			}
}
inline void sakura(Re *f,Re n,Re *g,Re m){
	for(m+=n,n=1;n<=m;n<<=1);
	for(Re i=1;i<n;++i)tr[i]=(tr[i>>1]>>1)|((i&1)?n>>1:0);
	NTT(f,n,0),NTT(g,n,0);
	for(Re i=0;i<n;++i)f[i]=(LL)f[i]*g[i]%P;
	NTT(f,n,1);
	for(Re i=0,invn=inv(n);i<=m;++i)f[i]=(LL)f[i]*invn%P;
}
int S[N];
inline void get_Stirling(Re n){
	jc[0]=1,invG=inv(G);
	for(Re i=1;i<=n;++i)jc[i]=(LL)jc[i-1]*i%P;
	for(Re i=0;i<=n;++i)f[i]=(LL)inv(jc[i])*((i&1)?P-1:1)%P,g[i]=(LL)mi(i,n)*inv(jc[i])%P;
	sakura(f,n,g,n);
	for(Re i=0;i<=n;++i)S[i]=f[i];
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),get_Stirling(n);
	for(Re i=0;i<=n;++i)printf("%d ",S[i]);
}

```

**组合数** *(n^2记搜)*

> 【组合数（n^2记搜）】
组合数学与计数模板。

核心函数：
  int C(Re m,Re n) — 核心算法函数

关键配置：
N=1003,P=998244353

适用场景：计数问题、排列组合求值（含模运算）

```cpp
#include<cstdio>
#define Re register int
using namespace std;
const int N=1003,P=998244353;
int C_[N][N]; 
inline int C(Re m,Re n){
    if(m>n)return 0;
    if(!m||m==n)return C_[m][n]=1;
    if(C_[m][n])return C_[m][n];
    return C_[m][n]=(C(m,n-1)+C(m-1,n-1))%P;
}
int main(){}

```

**组合数** *(n^2递推)*

> 【组合数（n^2递推）】
组合数学与计数模板。

核心函数：
  void get_C(Re N) — 获取值

关键配置：
N=1003,P=998244353

适用场景：计数问题、排列组合求值（含模运算）

```cpp
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=1003,P=998244353;
int C[N][N];
inline void get_C(Re N){
	for(Re i=0;i<=N;++i)C[0][i]=C[i][i]=1;
	for(Re i=1;i<=N;++i)
		for(Re j=1;j<i;++j)
			C[j][i]=(C[j-1][i-1]+C[j][i-1])%P;
}
int main(){}

```

**贝尔数Bell** *(n^2递推)*

> 【贝尔数Bell（n^2递推）】
组合数学与计数模板。

核心函数：
  void get_C(Re N) — 获取值
  void get_Bell(Re N) — 获取值
  void get_Stiring(Re N) — 获取值
  void get_Bell_(Re N) — 获取值

关键配置：
N=1003,P=998244353

适用场景：计数问题、排列组合求值（含模运算）

```cpp
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=1003,P=998244353;
int B[N],C[N][N],S[N][N];
inline void get_C(Re N){
	for(Re i=0;i<=N;++i)C[0][i]=C[i][i]=1;
	for(Re i=1;i<=N;++i)
		for(Re j=1;j<i;++j)
			C[j][i]=(C[j-1][i-1]+C[j][i-1])%P;
}
inline void get_Bell(Re N){
	B[0]=1,get_C(N);
	for(Re i=1;i<=N;++i)
		for(Re j=0;j<=i-1;++j)
			(B[i]+=(LL)C[j][i-1]*B[j]%P)%=P;
}
inline void get_Stiring(Re N){
	for(Re i=0;i<=N;++i)S[i][i]=1;
	for(Re i=1;i<=N;++i)
		for(Re j=1;j<i;++j)
			S[j][i]=S[j-1][i-1]+(LL)j*S[j][i-1]%P;
}
inline void get_Bell_(Re N){
	B[0]=1,get_Stiring(N);
	for(Re i=1;i<=N;++i)
		for(Re j=1;j<=i;++j)
			(B[i]+=S[j][i])%=P;
}
int main(){}

```

### 7.3 博弈论

**sg函数** *(sg)*

> 【sg函数（sg）】
SG 函数（Sprague-Grundy）模板，用于公平组合游戏的胜负判定。

核心函数：
  void get_sg(int n) — 获取值

关键配置：
N=1e5 + 5

适用场景：公平组合游戏胜负判定、Nim-like 游戏分析

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

const int N = 1e5 + 5;
int sg[N], f[105], k; // f存允许的步数(需升序), k是步数种类
int vis[N];

void get_sg(int n) {
	for (int i = 1; i <= n; i++) {
		// vis时间戳黑科技：严格O(1)标记，绝对不写 memset
		for (int j = 1; j <= k && f[j] <= i; j++) {
			vis[sg[i - f[j]]] = i;
		}
		// 求 mex
		for (int j = 0; ; j++) {
			if (vis[j] != i) {
				sg[i] = j;
				break;
			}
		}
	}
}
int main() {
	// 1. 初始化规则数组 (必须升序!)
	k = 3;
	f[1] = 1; 
	f[2] = 3; 
	f[3] = 4;
	// sort(f + 1, f + 1 + k); // 如果题目给的规则没排序，一定要加上这句！
	
	// 2. 预处理 SG 函数
	// 假设题目告诉你，单堆石子最多 10000 个
	get_sg(10000); 
	
	// 3. 处理多堆石子的异或和
	int m;
	cin >> m; // m 堆石子
	
	int ans = 0;
	for (int i = 1; i <= m; i++) {
		int a;
		cin >> a; // 读入这一堆有 a 个石子
		
		// 核心：把这一堆的 sg 值异或进去
		ans ^= sg[a]; 
	}
	
	// 4. 审判时刻
	if (ans != 0) {
		cout << "先手必胜！" << endl;
	} else {
		cout << "后手必胜！" << endl;
	}
	
	return 0;
}
```

**对抗搜索+Alpha-Beta  (一双木棋chess TLE)** *(最大分数)*

> 【对抗搜索+Alpha-Beta  (一双木棋chess TLE)（最大分数）】
博弈论算法模板。

核心函数：
  void in(Re &x) — 核心算法函数
  int findmin(Re alpha,Re op) — 查找（并查集寻根/二分查找）
  int findmax(Re beta,Re op) — 查找（并查集寻根/二分查找）

关键配置：
N=13,inf=2e9

说明：freopen("123.txt","r",stdin);

适用场景：公平组合游戏胜负判定、Nim-like 游戏分析

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=13,inf=2e9;
int n,m,cnt,h[N],can[N],vis[N][N],A[2][N][N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline int findmin(Re alpha,Re op);
inline int findmax(Re beta,Re op);
inline int findmin(Re alpha,Re op){
	if(cnt==n*m)return 0;
	Re ans=inf;
	for(Re i=1,j;i<=n;++i)
		if(h[i]<m&&vis[i][j=h[i]+1]==-1&&h[i-1]>=j){
			vis[i][j]=op,++cnt,++h[i];
			ans=min(ans,-A[op][i][j]+findmax(ans+A[op][i][j],op^1));
			vis[i][j]=-1,--cnt,--h[i];
			if(ans<=alpha)return ans;
		}
	return ans;
}
inline int findmax(Re beta,Re op){
	if(cnt==n*m)return 0;
	Re ans=-inf;
	for(Re i=1,j;i<=n;++i)
		if(h[i]<m&&vis[i][j=h[i]+1]==-1&&h[i-1]>=j){
			vis[i][j]=op,++cnt,++h[i];
			ans=max(ans,A[op][i][j]+findmin(ans-A[op][i][j],op^1));
			vis[i][j]=-1,--cnt,--h[i];
			if(ans>=beta)return ans;
		}
	return ans;
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(m);
	for(Re i=1;i<=n;++i)
		for(Re j=1;j<=m;++j)
			in(A[1][i][j]);
	for(Re i=1;i<=n;++i)
		for(Re j=1;j<=m;++j)
			in(A[0][i][j]);
	memset(vis,-1,sizeof(vis));
	h[0]=inf; 
	printf("%d\n",findmax(inf,1));
}

```

**对抗搜索+Alpha-Beta  (Find the Winning Move)** *(胜负)*

> 【对抗搜索+Alpha-Beta  (Find the Winning Move)（胜负）】
博弈论算法模板。

核心函数：
  void in(Re &x) — 核心算法函数
  int check(Re op) — 判定/检查函数
  int findmin(Re alpha,Re op) — 查找（并查集寻根/二分查找）
  int findmax(Re beta,Re op) — 查找（并查集寻根/二分查找）

关键配置：
N=6,inf=2e9

适用场景：公平组合游戏胜负判定、Nim-like 游戏分析

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=6,inf=2e9;
int n=4,cnt,ansX,ansY,A[N][N];char op[5],s[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline int check(Re op){
	for(Re i=1;i<=n;++i){
		Re cnt1=0,cnt2=0;
		for(Re j=1;j<=n;++j)cnt1+=(A[i][j]==op),cnt2+=(A[j][i]==op);
		if(cnt1==4||cnt2==4)return 1;
	}
	Re cnt1=0,cnt2=0;
	for(Re i=1;i<=n;++i)cnt1+=(A[i][i]==op),cnt2+=(A[i][n-i+1]==op);
	if(cnt1==4||cnt2==4)return 1;
	return 0;
}
inline int findmin(Re alpha,Re op);
inline int findmax(Re beta,Re op);//[op=1:�ҵĻغ�]
inline int findmin(Re alpha,Re op){
	if(cnt==16)return 0;
	if(check(op^1))return inf;
	Re ans=inf;
	for(Re i=1;i<=n;++i)
		for(Re j=1;j<=n;++j)
			if(A[i][j]==-1){
				A[i][j]=op,++cnt;
				ans=min(ans,findmax(ans,op^1));
				A[i][j]=-1,--cnt;
				if(ans<=alpha)return ans;
			}
	return ans;
}
inline int findmax(Re beta,Re op){
	if(cnt==16)return 0;
	if(check(op^1))return -inf;
	Re ans=-inf;
	for(Re i=1;i<=n;++i)
		for(Re j=1;j<=n;++j)
			if(A[i][j]==-1){
				A[i][j]=op,++cnt;
				ans=max(ans,findmin(ans,op^1));
				A[i][j]=-1,--cnt;
				ansX=i,ansY=j;
				if(ans>=beta)return ans;
			}
	return ans;
}
int main(){
//	freopen("123.txt","r",stdin);
	while(~scanf("%s",op)&&op[0]!='$'){
		cnt=0;
		for(Re i=1;i<=n;++i){
			scanf("%s",s+1);
			for(Re j=1;j<=n;++j)
				if(s[j]=='.')A[i][j]=-1,++cnt;
				else A[i][j]=(s[j]=='x');
		}
		if(cnt<=4)puts("#####");
		else if(findmax(inf,1)==inf)printf("(%d,%d)\n",ansX-1,ansY-1);
		else puts("#####");
	}
}

```

**对抗搜索+记忆化  (一双木棋chess)** *(最大分数)*

> 【对抗搜索+记忆化  (一双木棋chess)（最大分数）】
博弈论算法模板。

核心函数：
  void in(Re &x) — 核心算法函数
  LL Hash(Re op) — 哈希计算
  int dfs(Re op) — 深度优先搜索遍历

关键配置：
N=13,inf=2e9

说明：freopen("123.txt","r",stdin);

适用场景：公平组合游戏胜负判定、Nim-like 游戏分析

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<map>
#define LL long long
#define Re register int
using namespace std;
const int N=13,inf=2e9;
int n,m,cnt,h[N],can[N],vis[N][N],A[2][N][N];
map<LL,int>pan;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline LL Hash(Re op){LL ans=op+1;for(Re i=1;i<=n;++i)ans=ans*11ll+h[i];return ans;}
inline int dfs(Re op){
	if(cnt==n*m)return 0;
	LL H=Hash(op);
	if(pan.find(H)!=pan.end())return pan[H];
	Re ans=op?-inf:inf;
	for(Re i=1,j;i<=n;++i)
		if(h[i]<m&&vis[i][j=h[i]+1]==-1&&h[i-1]>=j){
			vis[i][j]=op,++cnt,++h[i];
			if(op)ans=max(ans,dfs(op^1)+A[op][i][j]);
			else ans=min(ans,dfs(op^1)-A[op][i][j]);
			vis[i][j]=-1,--cnt,--h[i];
		}
	return pan[H]=ans;
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(m);
	for(Re i=1;i<=n;++i)
		for(Re j=1;j<=m;++j)
			in(A[1][i][j]);
	for(Re i=1;i<=n;++i)
		for(Re j=1;j<=m;++j)
			in(A[0][i][j]);
	memset(vis,-1,sizeof(vis));
	h[0]=inf;
	printf("%d\n",dfs(1));
}

```

### 7.4 多项式与FFT

**多项式乘法-快速傅里叶变换** *(FFT)*

> 【快速傅里叶变换（FFT）——多项式乘法】
▪ Complex — 复数结构体，支持 +、-、* 运算符重载（复数运算）
▪ getSize(n) — 计算 ≥n 的最小 2 的幂作为变换长度
▪ change(a, n) — 位逆序重排（bit-reversal permutation），将系数数组重排为蝴蝶变换所需顺序
▪ fft(a, n, opt) — 快速傅里叶变换核心：opt=1 正变换，opt=-1 逆变换；Cooley–Tukey 迭代算法，每层蝴蝶变换 O(N)，共 log N 层
两个 n 次多项式乘法从 O(N²) 优化到 O(N log N)。适用于大整数乘法、生成函数卷积、信号处理。

```cpp
struct Polynoial{
    struct Complex{
        double x,y;
        Complex(double _x = 0.0,double _y = 0.0){
            x = _x;
            y = _y;
        }
        Complex operator-(const Complex &rhs) const{
            return Complex(x-rhs.x,y-rhs.y);
        }
        Complex operator+(const Complex &rhs) const{
            return Complex(x+rhs.x,y+rhs.y);
        }
        Complex operator*(const Complex &rhs) const{
            return Complex(x*rhs.x-y*rhs.y,x*rhs.y+y*rhs.x);
        }
    };
    
    int getSize(int n) {
        int size = 1;
        while (size < n) size <<= 1;
        return size;
    }
    
    void change(vector<Complex>&a,int n){
        for(int i = 1,j = n/2;i < n-1;i++){
            if(i < j){
                swap(a[i],a[j]);
            }
            int k = n/2;
            while(j >= k){
                j -= k;
                k /= 2;
            }
            if(j < k)j += k;
        }
    }
    
    void fft(vector<Complex>&a,int n,int opt){
        change(a,n);
        for(int h = 2;h <= n;h*=2){
            Complex wn(cos(2*PI/h),sin(opt*2*PI/h));  // 修正：PI/h 而不是 PI/n
            for(int j = 0;j < n;j+=h){
                Complex w(1,0);
                for(int k = j;k < j+h/2;k++){
                    Complex u = a[k];
                    Complex t = w*a[k+h/2];
                    a[k]=u+t;
                    a[k+h/2]=u-t;
                    w=w*wn;
                }
            }
        }
        if(opt == -1){
            for(int i = 0;i < n;i++){
                a[i].x /= n;
            }
        }
    }

    vector<int> multiply(vector<int>& a, vector<int>& b) {
        int size = getSize(a.size() + b.size() - 1);
        
        vector<Complex> fa(size), fb(size);
        for(int i = 0; i < (int)a.size(); i++) fa[i] = Complex(a[i], 0);
        for(int i = 0; i < (int)b.size(); i++) fb[i] = Complex(b[i], 0);
        for(int i = a.size(); i < size; i++) fa[i] = Complex(0, 0);
        for(int i = b.size(); i < size; i++) fb[i] = Complex(0, 0);
        
        fft(fa, size, 1);
        fft(fb, size, 1);
        
        for(int i = 0; i < size; i++) {
            fa[i] = fa[i] * fb[i];
        }
        
        fft(fa, size, -1);
        
        vector<int> res(size);
        for(int i = 0; i < size; i++) {
            res[i] = (int)(fa[i].x + 0.5);
        }
        return res;
    }
};
```

**Perpetual Subtraction** *(生成函数 移位)*

> 【Perpetual Subtraction（生成函数 移位）】
多项式算法模板。

核心函数：
  template<typename T>inline void in(T &x) — 核心算法函数
  int mi(Re x,LL k) — 核心算法函数
  int Inv(Re x) — 求模逆元
  void NTT(Re *f,Re n,Re op) — 数论变换
  void times(Re *f,Re n,Re *g,Re m) — 核心算法函数

关键配置：
N=262144+3,P=998244353,G=3

复杂度：O(N log N)

说明：freopen("123.txt","r",stdin);；for(Re i=0;i<=n;++i)printf("%d ",g0[i]);puts("");；for(Re i=0;i<=n;++i)printf("%d ",gm[i]);puts("");

适用场景：多项式卷积（大整数乘法、生成函数计算）、信号处理

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=262144+3,P=998244353,G=3;
int n,invn,invG,f[N],g[N],g0[N],gm[N],f0[N],fm[N],tr[N],jc[N],inv[N],invjc[N];LL m;
template<typename T>inline void in(T &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline int mi(Re x,LL k){
	Re s=1;
	while(k){
		if(k&1)s=(LL)s*x%P;
		x=(LL)x*x%P,k>>=1;
	}
	return s;
}
inline int Inv(Re x){return mi(x,P-2);}
inline void NTT(Re *f,Re n,Re op){
	for(Re i=0;i<n;++i)if(i<tr[i])swap(f[i],f[tr[i]]);
	for(Re p=2;p<=n;p<<=1){
		Re len=p>>1,w1=mi(op?invG:G,(P-1)/p);
		for(Re st=0;st<n;st+=p)
			for(Re i=st,base=1;i<=st+len-1;++i){
				Re tmp=(LL)base*f[len+i]%P;
				f[len+i]=(f[i]-tmp+P)%P,(f[i]+=tmp)%=P,base=(LL)base*w1%P;
			}
	}
}
inline void times(Re *f,Re n,Re *g,Re m){
	for(m+=n,n=1;n<=m;n<<=1);invn=Inv(n),invG=Inv(G);
	for(Re i=1;i<n;++i)tr[i]=(tr[i>>1]>>1)|((i&1)?n>>1:0);
	NTT(f,n,0),NTT(g,n,0);
	for(Re i=0;i<n;++i)f[i]=(LL)f[i]*g[i]%P;
	NTT(f,n,1);
	for(Re i=0;i<=m;++i)f[i]=(LL)f[i]*invn%P;
}
int main(){
//    freopen("123.txt","r",stdin);
    in(n),in(m);
    for(Re i=0;i<=n;++i)in(f0[i]);
    invjc[1]=invjc[0]=inv[1]=jc[1]=jc[0]=1;
    for(Re i=2;i<=n+1;++i)inv[i]=(LL)inv[P%i]*(P-P/i)%P,jc[i]=(LL)jc[i-1]*i%P,invjc[i]=(LL)invjc[i-1]*inv[i]%P;
    
	for(Re i=0;i<=n;++i)f[i]=(LL)jc[n-i]*f0[n-i]%P,g[i]=invjc[i];
    times(f,n,g,n);
	for(Re i=0;i<=n;++i)g0[i]=(LL)f[n-i]*invjc[i]%P;
	
//	for(Re i=0;i<=n;++i)printf("%d ",g0[i]);puts("");
	for(Re i=0;i<=n;++i)gm[i]=(LL)g0[i]*mi(inv[i+1],m)%P;
//	for(Re i=0;i<=n;++i)printf("%d ",gm[i]);puts("");

	memset(f,0,sizeof(f)),memset(g,0,sizeof(g));
	for(Re i=0;i<=n;++i)f[i]=(LL)jc[n-i]*gm[n-i]%P,g[i]=(LL)invjc[i]*((i&1)?P-1:1)%P;
	times(f,n,g,n);
	for(Re i=0;i<=n;++i)fm[i]=(LL)f[n-i]*invjc[i]%P;
	
	for(Re i=0;i<=n;++i)printf("%d ",fm[i]);
}

```

**A×B Problem** *(FFT)*

> 【A×B Problem（FFT）】
多项式算法模板。

核心函数：
  void in(Re &x) — 核心算法函数
  void FFT(CP *f,Re n,Re op) — 快速傅里叶变换

核心结构体：CP

关键配置：
N=2097152+5

复杂度：O(N log N)

说明：freopen("123.txt","r",stdin);

适用场景：多项式卷积（大整数乘法、生成函数计算）、信号处理

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#define LD double
#define LL long long
#define Re register int
using namespace std;
const int N=2097152+5;
const LD Pi=acos(-1);
int n,m,tr[N],Ans[N];char s1[N>>1],s2[N>>1];
inline void in(Re &x){
	Re fu=0;x=0;char ch=getchar();
	while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=fu?-x:x;
}
struct CP{
	LD x,y;
	CP(LD X=0,LD Y=0){x=X,y=Y;}
	inline CP operator+(const CP &O)const{return CP(x+O.x,y+O.y);}
	inline CP operator-(const CP &O)const{return CP(x-O.x,y-O.y);}
	inline CP operator*(const CP &O)const{return CP(x*O.x-y*O.y,x*O.y+y*O.x);}
	inline CP operator*=(const CP &O){return *this=*this*O;}
}f[N],g[N];
inline void FFT(CP *f,Re n,Re op){
	for(Re i=0;i<n;++i)if(i<tr[i])swap(f[i],f[tr[i]]);
	for(Re p=2;p<=n;p<<=1){
		Re len=p>>1;
		CP w1(cos(2*Pi/p),sin(2*Pi/p));
		if(op)w1.y*=-1;
		for(Re st=0;st<n;st+=p){
			CP base(1,0);
			for(Re i=st;i<=st+len-1;++i){
				CP tmp=f[len+i]*base;
				f[len+i]=f[i]-tmp,f[i]=f[i]+tmp,base*=w1;
			}
		}
	}
}
int main(){
//	freopen("123.txt","r",stdin);
	scanf("%s%s",s1,s2),n=strlen(s1),m=strlen(s2);
	for(Re i=0;i<n;++i)f[i].x=s1[n-i-1]-'0';
	for(Re i=0;i<m;++i)g[i].x=s2[m-i-1]-'0';
	for(m+=n,n=1;n<=m;n<<=1);
	for(Re i=1;i<n;++i)tr[i]=(tr[i>>1]>>1)|((i&1)?n>>1:0);
	FFT(f,n,0),FFT(g,n,0);
	for(Re i=0;i<n;++i)f[i]*=g[i];
	FFT(f,n,1);
	for(Re i=0;i<=m;++i){
		Ans[i]+=(int)(f[i].x/n+0.5);
		if(Ans[i]>9)Ans[i+1]+=Ans[i]/10,Ans[i]%=10,m+=(i==m);
	}
	while(!Ans[m]&&m>=1)--m;
	for(Re i=m;i>=0;--i)printf("%d",Ans[i]);
}

```

**分治NTT** *(循环卷积优化)*

> 【分治NTT（循环卷积优化）】
数论变换（NTT）模板，在模意义下计算多项式卷积，避免浮点误差。

核心函数：
  void in(Re &x) — 核心算法函数
  int mi(Re x,Re k) — 核心算法函数
  int inv(Re x) — 求模逆元
  void NTT(Re *f,Re n,Re op) — 数论变换
  void times(Re *f,Re n,Re *g,Re m) — 核心算法函数
  void CDQ(Re L,Re R) — 核心算法函数

关键配置：
N=131072+3,P=998244353,G=3

复杂度：O(N log N)

说明：freopen("123.txt","r",stdin);

适用场景：多项式卷积（大整数乘法、生成函数计算）、信号处理

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#define LD double
#define LL long long
#define Re register int
using namespace std;
const int N=131072+3,P=998244353,G=3;
int n,m,invn,invG,f[N],g[N],A[N],tr[N],ans[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline int mi(Re x,Re k){
	Re s=1;
	while(k){
		if(k&1)s=(LL)s*x%P;
		x=(LL)x*x%P,k>>=1;
	}
	return s;
}
inline int inv(Re x){return mi(x,P-2);}
inline void NTT(Re *f,Re n,Re op){
	for(Re i=0;i<n;++i)if(i<tr[i])swap(f[i],f[tr[i]]);
	for(Re p=2;p<=n;p<<=1){
		Re len=p>>1,w1=mi(op?invG:G,(P-1)/p);
		for(Re st=0;st<n;st+=p)
			for(Re i=st,base=1;i<=st+len-1;++i){
				Re tmp=(LL)base*f[i+len]%P;
				f[i+len]=(f[i]-tmp+P)%P;
				f[i]=(f[i]+tmp)%P;
				base=(LL)base*w1%P;
			}
	}
}
inline void times(Re *f,Re n,Re *g,Re m){
	for(n=1;n<=m;n<<=1);
	for(Re i=m+1;i<=n;++i)f[i]=g[i]=0;
	for(Re i=1;i<n;++i)tr[i]=(tr[i>>1]>>1)|((i&1)?n>>1:0);
	NTT(f,n,0),NTT(g,n,0);
	for(Re i=0;i<n;++i)f[i]=(LL)f[i]*g[i]%P;
	NTT(f,n,1);
	for(Re i=0,invn=inv(n);i<=m;++i)f[i]=(LL)f[i]*invn%P;
}
inline void CDQ(Re L,Re R){
	if(L==R)return;
	Re mid=L+R>>1;CDQ(L,mid);
	for(Re i=L;i<=R;++i)g[i-L]=A[i-L];
	for(Re i=L;i<=mid;++i)f[i-L]=ans[i];
	for(Re i=mid+1;i<=R;++i)f[i-L]=0;
	times(f,mid-L,g,R-L);
	for(Re i=mid+1;i<=R;++i)(ans[i]+=f[i-L])%=P;
	CDQ(mid+1,R);
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),invG=inv(G);
	for(Re i=1;i<n;++i)in(A[i]);
	ans[0]=1,CDQ(0,n-1);
	for(Re i=0;i<n;++i)printf("%d ",ans[i]);
}

```

**多项式 乘法** *(FFT)*

> 【多项式 乘法（FFT）】
多项式算法模板。

核心函数：
  void in(Re &x) — 核心算法函数
  void FFT(CP *f,Re n,Re op) — 快速傅里叶变换
  void times(CP *f,Re n,CP *g,Re m) — 核心算法函数

核心结构体：CP

关键配置：
N=2097152+3

复杂度：O(N log N)

说明：freopen("123.txt","r",stdin);

适用场景：多项式卷积（大整数乘法、生成函数计算）、信号处理

```cpp
#include<algorithm>
#include<cstdio>
#include<cmath>
#define LD double
#define LL long long
#define Re register int
using namespace std;
const int N=2097152+3;
const LD Pi=acos(-1);
int n,m,tr[N];
inline void in(Re &x){
	Re fu=0;x=0;char ch=getchar();
	while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=fu?-x:x;
}
struct CP{
	LD x,y;CP(LD X=0,LD Y=0){x=X,y=Y;}
	inline CP operator+(const CP &O)const{return CP(x+O.x,y+O.y);}
	inline CP operator-(const CP &O)const{return CP(x-O.x,y-O.y);}
	inline CP operator*(const CP &O)const{return CP(x*O.x-y*O.y,x*O.y+y*O.x);}//(ac-bd,bc+ad)
	inline CP operator/(const CP &O)const{
		LD tmp=O.x*O.x+O.y*O.y;//tmp=c^2+d^2
		return CP((x*O.x+y*O.y)/tmp,(y*O.x-x*O.y)/tmp);//( (ac+bd)/tmp,(bc-ad)/tmp )
	}
	inline CP operator*=(const CP &O){return *this=*this*O;}
}f[N],g[N];
inline void FFT(CP *f,Re n,Re op){//op=0:DFT, op=1:IDFT
	for(Re i=0;i<n;++i)if(i<tr[i])swap(f[i],f[tr[i]]);
	for(Re p=2;p<=n;p<<=1){
		Re len=p>>1;CP w1(cos(2*Pi/p),sin(2*Pi/p));
		if(op)w1.y*=-1;
		for(Re st=0;st<n;st+=p){
			CP base(1,0);
			for(Re i=st;i<=st+len-1;++i){
				CP tmp=base*f[len+i];
				f[len+i]=f[i]-tmp,f[i]=f[i]+tmp,base*=w1;
			}
		}
	}
}
inline void times(CP *f,Re n,CP *g,Re m){
	for(m+=n,n=1;n<=m;n<<=1);
	for(Re i=1;i<n;++i)tr[i]=(tr[i>>1]>>1)|((i&1)?n>>1:0);
	FFT(f,n,0),FFT(g,n,0);
	for(Re i=0;i<n;++i)f[i]*=g[i];
	FFT(f,n,1);
	for(Re i=0;i<=m;++i)f[i].x/=n;
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(m);
	for(Re i=0;i<=n;++i)scanf("%lf",&f[i].x);
	for(Re i=0;i<=m;++i)scanf("%lf",&g[i].x);
	times(f,n,g,m);
	for(Re i=0;i<=n+m;++i)printf("%d ",(int)(f[i].x+0.5));
}

```

**多项式 乘法** *(NTT)*

> 【多项式 乘法（NTT）】
多项式算法模板。

核心函数：
  void in(Re &x) — 核心算法函数
  int mi(Re x,Re k) — 核心算法函数
  int inv(Re x) — 求模逆元
  void NTT(Re *f,Re n,Re op) — 数论变换
  void times(Re *f,Re n,Re *g,Re m) — 核心算法函数

关键配置：
N=2097152+3,P=998244353,G=3

复杂度：O(N log N)

说明：freopen("123.txt","r",stdin);

适用场景：多项式卷积（大整数乘法、生成函数计算）、信号处理

```cpp
#include<algorithm>
#include<cstdio>
#include<cmath>
#define LL long long
#define Re register int
using namespace std;
const int N=2097152+3,P=998244353,G=3;
int n,m,invn,invG,f[N],g[N],tr[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline int mi(Re x,Re k){
	Re s=1;
	while(k){
		if(k&1)s=(LL)s*x%P;
		x=(LL)x*x%P,k>>=1;
	}
	return s;
}
inline int inv(Re x){return mi(x,P-2);}
inline void NTT(Re *f,Re n,Re op){
	for(Re i=0;i<n;++i)if(i<tr[i])swap(f[i],f[tr[i]]);
	for(Re p=2;p<=n;p<<=1){
		Re len=p>>1,w1=mi(op?invG:G,(P-1)/p);
		for(Re st=0;st<n;st+=p)
			for(Re i=st,base=1;i<=st+len-1;++i){
				Re tmp=(LL)base*f[len+i]%P;
				f[len+i]=(f[i]-tmp+P)%P,(f[i]+=tmp)%=P,base=(LL)base*w1%P;
			}
	}
}
inline void times(Re *f,Re n,Re *g,Re m){
	for(m+=n,n=1;n<=m;n<<=1);invn=inv(n),invG=inv(G);
	for(Re i=1;i<n;++i)tr[i]=(tr[i>>1]>>1)|((i&1)?n>>1:0);
	NTT(f,n,0),NTT(g,n,0);
	for(Re i=0;i<n;++i)f[i]=(LL)f[i]*g[i]%P;
	NTT(f,n,1);
	for(Re i=0;i<=m;++i)f[i]=(LL)f[i]*invn%P;
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(m);
	for(Re i=0;i<=n;++i)in(f[i]);
	for(Re i=0;i<=m;++i)in(g[i]);
	times(f,n,g,m);
	for(Re i=0;i<=n+m;++i)printf("%d ",f[i]);
}

```

**多项式 位运算卷积** *(FWT)*

> 【多项式 位运算卷积（FWT）】
多项式算法模板。

核心函数：
  void in(Re &x) — 核心算法函数
  int inv(Re x) — 求模逆元
  void FWT(Re *f,Re n,Re op) — 核心算法函数
  void sakura(Re *A,Re *B,Re n,Re id_) — 后缀数组

关键配置：
N=131072+3,P=998244353

复杂度：O(N log N)

说明：freopen("123.txt","r",stdin);

适用场景：多项式卷积（大整数乘法、生成函数计算）、信号处理

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#define LD double
#define LL long long
#define Re register int
using namespace std;
const int N=131072+3,P=998244353;
int n,m,inv2,A[N],B[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline int inv(Re x){
	Re s=1,k=P-2;
	while(k){
		if(k&1)s=(LL)s*x%P;
		x=(LL)x*x%P,k>>=1;
	}
	return s;
}
int id,f[N],g[N];
inline void FWT(Re *f,Re n,Re op){
	for(Re p=2;p<=n;p<<=1)
		for(Re st=1,len=p>>1;st<n;st+=p)
			for(Re j=st;j<=st+len-1;++j)
				if(id==1)(f[j+len]+=(op?P-f[j]:f[j]))%=P;
				else if(id==2)(f[j]+=(op?P-f[j+len]:f[j+len]))%=P;
				else{
					Re g0=f[j],g1=f[j+len];
					f[j]=(g0+g1)%P,f[j+len]=(g0-g1+P)%P;
					if(op)f[j]=(LL)f[j]*inv2%P,f[j+len]=(LL)f[j+len]*inv2%P;
				}
}
inline void sakura(Re *A,Re *B,Re n,Re id_){
	for(Re i=1;i<=n;++i)f[i]=A[i],g[i]=B[i];id=id_;
	FWT(f,n,0),FWT(g,n,0);
	for(Re i=1;i<=n;++i)f[i]=(LL)f[i]*g[i]%P;
	FWT(f,n,1);
	for(Re i=1;i<=n;++i)printf("%d ",f[i]);puts("");
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),n=(1<<n),inv2=inv(2);
	for(Re i=1;i<=n;++i)in(A[i]);
	for(Re i=1;i<=n;++i)in(B[i]);
	sakura(A,B,n,1),sakura(A,B,n,2),sakura(A,B,n,3);
}

```

**多项式 快速幂** *(nlog^2n 暴力)*

> 【多项式 快速幂（nlog^2n 暴力）】
多项式算法模板。

核心函数：
  void in(Re &x) — 核心算法函数
  int in_(无参数) — 核心算法函数
  int mi(Re x,Re k) — 核心算法函数
  int inv(Re x) — 求模逆元
  void NTT(Re *f,Re n,Re op) — 数论变换
  void times(Re *f,Re n,Re *g,Re m) — 核心算法函数
  void polymi(Re *x,Re n,Re k,Re *s) — 核心算法函数

关键配置：
N=262144+3,P=998244353,G=3,phi=P-1

复杂度：O(N log N)

说明：freopen("123.txt","r",stdin);

适用场景：多项式卷积（大整数乘法、生成函数计算）、信号处理

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int 
using namespace std;
const int N=262144+3,P=998244353,G=3,phi=P-1;
inline void in(Re &x){
	int f=0;x=0;char ch=getchar();
	while(ch<'0'||ch>'9')f|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=f?-x:x;
}
inline int in_(){
	int f=0;LL x=0;char ch=getchar();
	while(ch<'0'||ch>'9')ch=getchar();
	while(ch>='0'&&ch<='9')x=x*10+(ch^48),x%=P,ch=getchar();
	return x;
}
inline int mi(Re x,Re k){
	Re s=1;
	while(k){
		if(k&1)s=(LL)s*x%P;
		x=(LL)x*x%P,k>>=1;
	}
	return s;
}
inline int inv(Re x){return mi(x,P-2);}
int invG,tr[N];
inline void NTT(Re *f,Re n,Re op){
	for(Re i=1;i<n;++i)if(i<tr[i])swap(f[i],f[tr[i]]);
	for(Re p=2;p<=n;p<<=1)
		for(Re st=0,len=p>>1,w1=mi(op?invG:G,(P-1)/p);st<n;st+=p)
			for(Re i=st,base=1;i<=st+len-1;++i){
				Re tmp=(LL)f[i+len]*base%P;
				f[i+len]=(f[i]-tmp+P)%P,(f[i]+=tmp)%=P,base=(LL)base*w1%P;
			}
}
inline void times(Re *f,Re n,Re *g,Re m){
	Re n_=n,m_=m;
	for(m+=n,n=1;n<=m;n<<=1);invG=inv(G);
	for(Re i=n_+1;i<n;++i)f[i]=0;
	for(Re i=m_+1;i<n;++i)g[i]=0;
	for(Re i=1;i<n;++i)tr[i]=(tr[i>>1]>>1)|((i&1)?n>>1:0);
	NTT(f,n,0),NTT(g,n,0);
	for(Re i=0;i<n;++i)f[i]=(LL)f[i]*g[i]%P;
	NTT(f,n,1);Re invn=inv(n);
	for(Re i=0;i<=m;++i)f[i]=(LL)f[i]*invn%P;
}
int c[N];
inline void polymi(Re *x,Re n,Re k,Re *s){
	k%=P,s[0]=1;
	for(Re i=1;i<=n;++i)s[i]=0;
	while(k){
		if(k&1){for(Re i=0;i<=n;++i)c[i]=x[i];times(s,n,c,n);}
		for(Re i=0;i<=n;++i)c[i]=x[i];times(x,n,c,n),k>>=1;
	}
}
int n,K,f[N],g[N];
int main(){
//	freopen("123.txt","r",stdin);
	in(n),--n,K=in_();
	for(Re i=0;i<=n;++i)in(f[i]);
	polymi(f,n,K,g);
	for(Re i=0;i<=n;++i)printf("%d ",g[i]);
}

```

**多项式 求逆** *(nlogn 优化倍增 NTT)*

> 【多项式 求逆（nlogn 优化倍增 NTT）】
多项式算法模板。

核心函数：
  void in(Re &x) — 核心算法函数
  int mi(Re x,Re k) — 核心算法函数
  int inv(Re x) — 求模逆元
  void NTT(Re *f,Re n,Re op) — 数论变换
  void times(Re *f,Re n,Re *g,Re m,Re op=0) — 核心算法函数
  void polyinv(Re *a,Re n,Re *b) — 求模逆元

关键配置：
N=262144+3,P=998244353,G=3

复杂度：O(N log N)

说明：freopen("123.txt","r",stdin);

适用场景：多项式卷积（大整数乘法、生成函数计算）、信号处理

```cpp
#include<algorithm>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=262144+3,P=998244353,G=3;
int n,A[N],B[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline int mi(Re x,Re k){
	Re s=1;
	while(k){
		if(k&1)s=(LL)s*x%P;
		x=(LL)x*x%P,k>>=1;
	}
	return s;
}
inline int inv(Re x){return mi(x,P-2);}
int invG,tr[N];
inline void NTT(Re *f,Re n,Re op){
	for(Re i=0;i<n;++i)if(i<tr[i])swap(f[i],f[tr[i]]);
	for(Re p=2;p<=n;p<<=1)
		for(Re st=0,len=p>>1,w1=mi(op?invG:G,(P-1)/p);st<n;st+=p)
			for(Re j=st,base=1;j<=st+len-1;++j){
				Re tmp=(LL)base*f[j+len]%P;
				f[j+len]=(f[j]-tmp+P)%P,(f[j]+=tmp)%=P,base=(LL)base*w1%P;
			}
}
inline void times(Re *f,Re n,Re *g,Re m,Re op=0){
	Re n_=n,m_=m;
	for(m+=n,n=1;n<=m;n<<=1);invG=inv(G);
	for(Re i=n_+1;i<n;++i)f[i]=0;
	for(Re i=m_+1;i<n;++i)g[i]=0;
	for(Re i=1;i<n;++i)tr[i]=(tr[i>>1]>>1)|((i&1)?n>>1:0);
	NTT(f,n,0),NTT(g,n,0);
	for(Re i=0;i<n;++i)f[i]=(LL)f[i]*g[i]%P*(op?g[i]:1)%P;
	NTT(f,n,1);Re invn=inv(n);
	for(Re i=0;i<=m;++i)f[i]=(LL)f[i]*invn%P;
}
int f[N],g[N];
inline void polyinv(Re *a,Re n,Re *b){
	if(n==0){b[0]=inv(a[0]);return;}
	polyinv(a,n>>1,b);
	for(Re i=0;i<=n;++i)f[i]=a[i],g[i]=b[i];
	times(f,n,g,n,1);
	for(Re i=0;i<=n;++i)b[i]=(2*b[i]%P-f[i]+P)%P;
}
int main(){
//    freopen("123.txt","r",stdin);
	in(n),--n;
	for(Re i=0;i<=n;++i)in(A[i]),A[i]%=P;
	polyinv(A,n,B);
	for(Re i=0;i<=n;++i)printf("%d ",B[i]);
}

```

**多项式 求逆** *(nlog^2n 暴力分治 FFT)*

> 【多项式 求逆（nlog^2n 暴力分治 FFT）】
多项式算法模板。

核心函数：
  void in(Re &x) — 核心算法函数
  int mi(Re x,Re k) — 核心算法函数
  int inv(Re x) — 求模逆元
  void NTT(Re *f,Re n,Re op) — 数论变换
  void times(Re *f,Re n,Re *g,Re m) — 核心算法函数
  void CDQ(Re L,Re R) — 核心算法函数
  void polyinv(Re *a,Re n,Re *b) — 求模逆元

关键配置：
N=262144+3,P=998244353,G=3

复杂度：O(N log N)

说明：freopen("123.txt","r",stdin);

适用场景：多项式卷积（大整数乘法、生成函数计算）、信号处理

```cpp
#include<algorithm>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=262144+3,P=998244353,G=3;
int n,A[N],B[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline int mi(Re x,Re k){
	Re s=1;
	while(k){
		if(k&1)s=(LL)s*x%P;
		x=(LL)x*x%P,k>>=1;
	}
	return s;
}
inline int inv(Re x){return mi(x,P-2);}
int invG,tr[N];
inline void NTT(Re *f,Re n,Re op){
	for(Re i=0;i<n;++i)if(i<tr[i])swap(f[i],f[tr[i]]);
	for(Re p=2;p<=n;p<<=1)
		for(Re st=0,len=p>>1,w1=mi(op?invG:G,(P-1)/p);st<n;st+=p)
			for(Re j=st,base=1;j<=st+len-1;++j){
				Re tmp=(LL)base*f[j+len]%P;
				f[j+len]=(f[j]-tmp+P)%P,(f[j]+=tmp)%=P,base=(LL)base*w1%P;
			}
}
inline void times(Re *f,Re n,Re *g,Re m){
	for(n=1;n<=m;n<<=1);invG=inv(G);
	for(Re i=m+1;i<n;++i)f[i]=g[i]=0;
	for(Re i=1;i<n;++i)tr[i]=(tr[i>>1]>>1)|((i&1)?n>>1:0);
	NTT(f,n,0),NTT(g,n,0);
	for(Re i=0;i<n;++i)f[i]=(LL)f[i]*g[i]%P;
	NTT(f,n,1);Re invn=inv(n);
	for(Re i=0;i<=m;++i)f[i]=(LL)f[i]*invn%P;
}
int f[N],g[N],c[N],ans[N];
inline void CDQ(Re L,Re R){
	if(L==R)return;
	Re mid=L+R>>1;CDQ(L,mid);
	for(Re i=L;i<=R;++i)g[i-L]=c[i-L];
	for(Re i=L;i<=mid;++i)f[i-L]=ans[i];
	for(Re i=mid+1;i<=R;++i)f[i-L]=0;
	times(f,mid-L,g,R-L);
	for(Re i=mid+1;i<=R;++i)(ans[i]+=f[i-L])%=P;
	CDQ(mid+1,R);
}
inline void polyinv(Re *a,Re n,Re *b){
	Re tmp=inv(a[0]);c[0]=0;
	for(Re i=1;i<=n;++i)c[i]=(LL)(P-a[i])*tmp%P;
	ans[0]=tmp,CDQ(0,n);
	for(Re i=0;i<=n;++i)b[i]=ans[i];
}
int main(){
//    freopen("123.txt","r",stdin);
	in(n),--n;
	for(Re i=0;i<=n;++i)in(A[i]),A[i]%=P;
	polyinv(A,n,B);
	for(Re i=0;i<=n;++i)printf("%d ",B[i]);
}

```

**字符串匹配** *(NTT)*

> 【字符串匹配（NTT）】
多项式算法模板。

核心函数：
  void in(Re &x) — 核心算法函数
  void get_next(无参数) — 获取值
  int mi(Re x,Re k) — 核心算法函数
  int inv(Re x) — 求模逆元
  void NTT(Re *f,Re n,Re op) — 数论变换
  void sakura(Re *f,Re n,Re *g,Re m) — 后缀数组

关键配置：
N=1048576+3,P=998244353,G=3

复杂度：O(N log N)

说明：freopen("123.txt","r",stdin);

适用场景：多项式卷积（大整数乘法、生成函数计算）、信号处理

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#define Re register int
#define LL long long
using namespace std;
const int N=1048576+3,P=998244353,G=3;
int n,m,ans,invG,f[N],g[N],tr[N],S1[N],S2[N],PA[N],nex[N];char A[N],B[N];
inline void in(Re &x){
    int fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
inline void get_next(){
	for(Re i=2,j=0;i<=m;++i){
		while(j&&B[i]!=B[j+1])j=nex[j];
		if(B[i]==B[j+1])++j;nex[i]=j;
	}
	for(Re i=1;i<=m;++i)printf("%d ",nex[i]);
}
inline int mi(Re x,Re k){
	Re s=1;
	while(k){
		if(k&1)s=(LL)s*x%P;
		x=(LL)x*x%P,k>>=1;
	}
	return s;
}
inline int inv(Re x){return mi(x,P-2);}
inline void NTT(Re *f,Re n,Re op){
	for(Re i=0;i<n;++i)if(i<tr[i])swap(f[i],f[tr[i]]);
	for(Re p=2;p<=n;p<<=1){
		Re len=p>>1,w1=mi(op?invG:G,(P-1)/p);
		for(Re st=0;st<n;st+=p)
			for(Re j=st,base=1;j<=st+len-1;++j){
				Re tmp=(LL)base*f[j+len]%P;
				f[j+len]=(f[j]-tmp+P)%P,(f[j]+=tmp)%=P;
				base=(LL)base*w1%P;
			}
	}
}
inline void sakura(Re *f,Re n,Re *g,Re m){
	for(m=n+1,n=1;n<=m;n<<=1);Re invn=inv(n);
	for(Re i=1;i<n;++i)tr[i]=(tr[i>>1]>>1)|((i&1)?n>>1:0);
	NTT(f,n,0),NTT(g,n,0);
	for(Re i=0;i<n;++i)f[i]=(LL)f[i]*g[i]%P;
	NTT(f,n,1);
	for(Re i=0;i<=m;++i)f[i]=(LL)f[i]*invn%P;
}
int main(){
//	freopen("123.txt","r",stdin);
	scanf("%s%s",A+1,B+1),invG=inv(G);
	n=strlen(A+1),m=strlen(B+1);
	for(Re i=1;i<=n;++i)f[i]=A[n-i+1]-'A'+1,S1[i]=S1[i-1]+f[i]*f[i];
	for(Re i=1;i<=m;++i)g[i]=B[i]-'A'+1,S2[i]=S2[i-1]+g[i]*g[i];
	sakura(f,n,g,m);
	for(Re i=m;i<=n;++i)PA[n-i+1]=((S1[i]-S1[i-m]+S2[m])%P-2*f[i+1]%P+P)%P;
	for(Re i=1;i<=n-m+1;++i)if(PA[i]==0)printf("%d\n",i);
	get_next();
}

```

**拉格朗日插值** *(x从0到n不连续)*

> 【拉格朗日插值（x从0到n不连续）】
拉格朗日插值法模板，通过 n+1 个点确定 n 次多项式。

核心函数：
  void in(Re &x) — 核心算法函数
  int mi(Re x,Re k) — 核心算法函数
  int Inv(Re x) — 求模逆元
  void mul(Re *f,Re n,Re a0,Re *g) — 核心算法函数
  void div(Re *g,Re n,Re a0,Re *f) — 核心算法函数
  void Lagrange(Re *x,Re *y,Re n,Re *F) — 核心算法函数

关键配置：
N=2003+3,P=998244353

复杂度：O(N log N)

说明：freopen("123.txt","r",stdin);

适用场景：多项式卷积（大整数乘法、生成函数计算）、信号处理

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=2003+3,P=998244353;
inline void in(Re &x){
	int f=0;x=0;char ch=getchar();
	while(ch<'0'||ch>'9')f|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=f?-x:x;
}
inline int mi(Re x,Re k){
	Re s=1;
	while(k){
		if(k&1)s=(LL)s*x%P;
		x=(LL)x*x%P,k>>=1;
	}
	return s;
}
inline int Inv(Re x){return mi(x,P-2);}
int ff[N],gg[N];
inline void mul(Re *f,Re n,Re a0,Re *g){
	for(Re i=0;i<=n;++i)ff[i]=f[i];
	g[0]=(LL)a0*ff[0]%P;for(Re i=1;i<=n+1;++i)g[i]=((LL)a0*ff[i]%P+ff[i-1])%P;
}
inline void div(Re *g,Re n,Re a0,Re *f){
	for(Re i=0;i<=n;++i)gg[i]=g[i];
	f[n-1]=gg[n];for(Re i=n-2;i>=0;--i)f[i]=(gg[i+1]-(LL)a0*f[i+1]%P+P)%P;
}
int fi[N],fmul[N];
inline void Lagrange(Re *x,Re *y,Re n,Re *F){
	fmul[0]=P-x[0],fmul[1]=1;
	for(Re i=1;i<=n;++i)mul(fmul,i,P-x[i],fmul);
	for(Re i=0;i<=n-1;++i)F[i]=0;
	for(Re i=0;i<=n;++i){
		Re tmp=1;
		for(Re j=0;j<=n;++j)if(i!=j)tmp=(LL)tmp*(x[i]-x[j]+P)%P;
		tmp=(LL)y[i]*Inv(tmp)%P;
		div(fmul,n+1,P-x[i],fi);
		for(Re i=0;i<=n;++i)(F[i]+=(LL)tmp*fi[i]%P)%=P;
	}
}
int n,X,ans,x[N],y[N],F[N];
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(X),--n;
	for(Re i=0;i<=n;++i)in(x[i]),in(y[i]);
	Lagrange(x,y,n,F);
	for(Re i=0,tmp=1;i<=n;++i)(ans+=(LL)F[i]*tmp%P)%=P,tmp=(LL)tmp*X%P;
	printf("%d\n",ans);
}

```

**拉格朗日插值** *(x从0到n连续)*

> 【拉格朗日插值（x从0到n连续）】
拉格朗日插值法模板，通过 n+1 个点确定 n 次多项式。

核心函数：
  void in(Re &x) — 核心算法函数
  int mi(Re x,Re k) — 核心算法函数
  int Inv(Re x) — 求模逆元
  void NTT(Re *f,Re n,Re op) — 数论变换
  void times(Re *f,Re n,Re *g,Re m) — 核心算法函数

关键配置：
N=1048576+3,P=998244353,G=3

复杂度：O(N log N)

说明：freopen("123.txt","r",stdin);

适用场景：多项式卷积（大整数乘法、生成函数计算）、信号处理

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=1048576+3,P=998244353,G=3;
int jc[N],inv[N],invjc[N];
inline void in(Re &x){
	int f=0;x=0;char ch=getchar();
	while(ch<'0'||ch>'9')f|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=f?-x:x;
}
inline int mi(Re x,Re k){
	Re s=1;
	while(k){
		if(k&1)s=(LL)s*x%P;
		x=(LL)x*x%P,k>>=1;
	}
	return s;
}
inline int Inv(Re x){return mi(x,P-2);}
int invG,tr[N];
inline void NTT(Re *f,Re n,Re op){
	for(Re i=0;i<n;++i)if(i<tr[i])swap(f[i],f[tr[i]]);
	for(Re p=2;p<=n;p<<=1){
		Re len=p>>1,w1=mi(op?invG:G,(P-1)/p);
		for(Re st=0;st<n;st+=p)
			for(Re i=st,base=1;i<=st+len-1;++i){
				Re tmp=(LL)base*f[len+i]%P;
				f[len+i]=(f[i]-tmp+P)%P,(f[i]+=tmp)%=P,base=(LL)base*w1%P;
			}
	}
}
inline void times(Re *f,Re n,Re *g,Re m){
	for(m+=n,n=1;n<=m;n<<=1);invG=Inv(G);
	for(Re i=1;i<n;++i)tr[i]=(tr[i>>1]>>1)|((i&1)?n>>1:0);
	NTT(f,n,0),NTT(g,n,0);
	for(Re i=0;i<n;++i)f[i]=(LL)f[i]*g[i]%P;
	NTT(f,n,1);Re invn=Inv(n);
	for(Re i=0;i<=m;++i)f[i]=(LL)f[i]*invn%P;
}
int n,m,y[N],f[N],g[N],F[N];
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(m),jc[0]=jc[1]=inv[1]=invjc[0]=invjc[1]=1;
	for(Re i=2;i<=n;++i)inv[i]=(LL)inv[P%i]*(P-P/i)%P,jc[i]=(LL)jc[i-1]*i%P,invjc[i]=(LL)invjc[i-1]*inv[i]%P;
	for(Re i=0;i<=n;++i)in(y[i]),g[i]=(LL)y[i]*((n-i&1)?P-1:1)%P*invjc[i]%P*invjc[n-i]%P;
	for(Re i=0;i<=(n<<1);++i)f[i]=Inv(m-n+i);
	times(f,n<<1,g,n);Re tmp=1;
	for(Re i=m-n;i<=m;++i)tmp=(LL)tmp*i%P;
	for(Re i=0;i<=n;tmp=(LL)tmp*Inv(m-n+i)%P,++i,tmp=(LL)tmp*(m+i)%P)F[i]=(LL)tmp*f[n+i]%P;
	for(Re i=m;i<=m+n;++i)printf("%d ",F[i-m]);
}

```

**字符串匹配套路一：通配符 (NTT)** *(残缺的字符串)*

> 【字符串匹配套路一：通配符 (NTT)（残缺的字符串）】
数论变换（NTT）模板，在模意义下计算多项式卷积，避免浮点误差。

核心函数：
  void in(Re &x) — 核心算法函数
  int mi(Re x,Re k) — 核心算法函数
  int inv(Re x) — 求模逆元
  void NTT(Re *f,Re n,Re op) — 数论变换
  void sakura(Re *f,Re n,Re *g,Re m) — 后缀数组

关键配置：
N=524288+3,P=998244353,G=3

复杂度：O(N log N)

说明：freopen("123.txt","r",stdin);

适用场景：多项式卷积（大整数乘法、生成函数计算）、信号处理

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#define Re register int
#define LL long long
using namespace std;
const int N=524288+3,P=998244353,G=3;
int n,m,ans,invG,a[N],b[N],f[N],g[N],tr[N],PA[N];char A[N],B[N];
inline void in(Re &x){
    int fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
inline int mi(Re x,Re k){
	Re s=1;
	while(k){
		if(k&1)s=(LL)s*x%P;
		x=(LL)x*x%P,k>>=1;
	}
	return s;
}
inline int inv(Re x){return mi(x,P-2);}
inline void NTT(Re *f,Re n,Re op){
	for(Re i=0;i<n;++i)if(i<tr[i])swap(f[i],f[tr[i]]);
	for(Re p=2;p<=n;p<<=1){
		Re len=p>>1,w1=mi(op?invG:G,(P-1)/p);
		for(Re st=0;st<n;st+=p)
			for(Re j=st,base=1;j<=st+len-1;++j){
				Re tmp=(LL)base*f[j+len]%P;
				f[j+len]=(f[j]-tmp+P)%P,(f[j]+=tmp)%=P;
				base=(LL)base*w1%P;
			}
	}
}
inline void sakura(Re *f,Re n,Re *g,Re m){
	for(m=n+1,n=1;n<=m;n<<=1);Re invn=inv(n);
	for(Re i=1;i<n;++i)tr[i]=(tr[i>>1]>>1)|((i&1)?n>>1:0);
	NTT(f,n,0),NTT(g,n,0);
	for(Re i=0;i<n;++i)f[i]=(LL)f[i]*g[i]%P;
	NTT(f,n,1);
	for(Re i=0;i<=m;++i)f[i]=(LL)f[i]*invn%P;
}
int main(){
//	freopen("123.txt","r",stdin);
	in(m),in(n),scanf("%s%s",B+1,A+1),invG=inv(G);
	for(Re i=1;i<=n/2;++i)swap(A[i],A[n-i+1]);
	for(Re i=1;i<=n;++i)a[i]=(A[i]=='*'?0:A[i]-'a'+1);
	for(Re i=1;i<=m;++i)b[i]=(B[i]=='*'?0:B[i]-'a'+1);
	for(Re i=1;i<=n;++i)f[i]=(LL)a[i]*a[i]%P*a[i]%P;
	for(Re i=1;i<=m;++i)g[i]=b[i];
	sakura(f,n,g,m);
	for(Re i=m;i<=n;++i)(PA[n-i+1]+=f[i+1])%=P;
	memset(f,0,sizeof(f)),memset(g,0,sizeof(g));
	for(Re i=1;i<=n;++i)f[i]=a[i];
	for(Re i=1;i<=m;++i)g[i]=(LL)b[i]*b[i]%P*b[i]%P;
	sakura(f,n,g,m);
	for(Re i=m;i<=n;++i)(PA[n-i+1]+=f[i+1])%=P;
	memset(f,0,sizeof(f)),memset(g,0,sizeof(g));
	for(Re i=1;i<=n;++i)f[i]=(LL)a[i]*a[i]%P;
	for(Re i=1;i<=m;++i)g[i]=(LL)b[i]*b[i]%P;
	sakura(f,n,g,m);
	for(Re i=m;i<=n;++i)(PA[n-i+1]+=P-2*f[i+1]%P)%=P;
	Re ans=0;
	for(Re i=1;i<=n-m+1;++i)ans+=(PA[i]==0);
	printf("%d\n",ans);
	for(Re i=1;i<=n-m+1;++i)if(PA[i]==0)printf("%d ",i);
}

```

**字符串匹配套路二：较小字符集 (NTT)** *(Fuzzy Search)*

> 【字符串匹配套路二：较小字符集 (NTT)（Fuzzy Search）】
数论变换（NTT）模板，在模意义下计算多项式卷积，避免浮点误差。

核心函数：
  void in(Re &x) — 核心算法函数
  int mi(Re x,Re k) — 核心算法函数
  int inv(Re x) — 求模逆元
  void NTT(Re *f,Re n,Re op) — 数论变换
  void sakura(Re *f,Re n,Re *g,Re m) — 后缀数组

关键配置：
N=262144+3,P=998244353,G=3

复杂度：O(N log N)

说明：freopen("123.txt","r",stdin);

适用场景：多项式卷积（大整数乘法、生成函数计算）、信号处理

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#define Re register int
#define LL long long
using namespace std;
const int N=262144+3,P=998244353,G=3;
int n,m,K,invG,a[N],b[N],f[N],g[N],S[N],tr[N],PA[N],id[200];char A[N],B[N];
inline void in(Re &x){
    int fu=0;x=0;char c=getchar();
    while(c<'0'||c>'9')fu|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=fu?-x:x;
}
inline int mi(Re x,Re k){
	Re s=1;
	while(k){
		if(k&1)s=(LL)s*x%P;
		x=(LL)x*x%P,k>>=1;
	}
	return s;
}
inline int inv(Re x){return mi(x,P-2);}
inline void NTT(Re *f,Re n,Re op){
	for(Re i=0;i<n;++i)if(i<tr[i])swap(f[i],f[tr[i]]);
	for(Re p=2;p<=n;p<<=1){
		Re len=p>>1,w1=mi(op?invG:G,(P-1)/p);
		for(Re st=0;st<n;st+=p)
			for(Re j=st,base=1;j<=st+len-1;++j){
				Re tmp=(LL)base*f[j+len]%P;
				f[j+len]=(f[j]-tmp+P)%P,(f[j]+=tmp)%=P;
				base=(LL)base*w1%P;
			}
	}
}
inline void sakura(Re *f,Re n,Re *g,Re m){
	for(m=n+1,n=1;n<=m;n<<=1);Re invn=inv(n);
	for(Re i=1;i<n;++i)tr[i]=(tr[i>>1]>>1)|((i&1)?n>>1:0);
	NTT(f,n,0),NTT(g,n,0);
	for(Re i=0;i<n;++i)f[i]=(LL)f[i]*g[i]%P;
	NTT(f,n,1);
	for(Re i=0;i<=m;++i)f[i]=(LL)f[i]*invn%P;
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(m),in(K),scanf("%s%s",A+1,B+1),invG=inv(G);
	id['A']=1,id['T']=2,id['C']=3,id['G']=4;
	for(Re i=1;i<=n;++i)a[i]=id[A[n-i+1]];
	for(Re i=1;i<=m;++i)b[i]=id[B[i]];
	for(Re o=1;o<=4;++o){
		for(Re i=1;i<=n;++i)S[i]=S[i-1]+(a[i]==o);
		for(Re i=1;i<=n;++i)f[i]=(S[i]-S[max(i-K-1,0)]||S[min(i+K,n)]-S[i-1]);
		for(Re i=1;i<=m;++i)g[i]=(b[i]==o);
		sakura(f,n,g,m);
		for(Re i=m;i<=n;++i)(PA[n-i+1]+=f[i+1])%=P;
		memset(f,0,sizeof(f)),memset(g,0,sizeof(g));
	}
	Re ans=0;
	for(Re i=1;i<=n-m+1;++i)ans+=(PA[i]==m);
	printf("%d\n",ans);
}

```

### 7.5 线性代数与高斯消元

**高斯消元** *(Gauss)*

> 【高斯消元法——解线性方程组（实系数）】
▪ Gauss(a, n) — 对 n×(n+1) 的增广矩阵 a 做高斯消元：
  ① 列主元选取：每列找绝对值最大的行 r 作为主元行，提高数值稳定性
  ② 消元：用第 i 行消去下方所有行第 i 列（a[j][k] -= t*a[i][k]）
  ③ 回代：从第 n 行向上，依次解出每个未知数
时间复杂度 O(N³)。含 eps 判零处理。适用于 n 元线性方程组、矩阵求逆、行列式计算。

```cpp
bool Gauss(Matrix a, int n) {
    for(int i=1; i<=n; i++) {
        int r=i;
        for(int j=i+1; j<=n; j++) 
            if(abs(a[j][i]) > abs(a[r][i])) r=j;
        if(abs(a[r][i])<eps) return false;
        if(r!=i) for(int j=1; j<=n+1; j++) swap(a[r][j], a[i][j]);
        
        for(int j=i+1; j<=n; j++) {
            double t = a[j][i]/a[i][i];
            for(int k=i; k<=n+1; k++) a[j][k] -= t*a[i][k];
        }
    }
    for(int i=n; i>=1; i--) {
        for(int j=n; j>i; j--) a[i][n+1] -= a[i][j]*a[j][n+1];
        a[i][n+1] /= a[i][i];
    }
    return true;
}
```

**高斯消元-解加法方程组** *(gauss-add)*

> 【高斯消元——解异或（加法）方程组（GF(2) 域）】
▪ Gauss(a, n) — 对 n×(n+1) 的增广矩阵在 GF(2) 域上做高斯消元：
  ① 列主元选取（找第 i 列绝对值最大的行）
  ② 消元（前向消去下方行）
  ③ 回代（从下往上解出各变量）
与 ID=11 的 Gauss 算法结构相同，但使用按位异或（^）替代加减法，在 GF(2) 域上操作。
时间复杂度 O(N³)。适用于解 XOR 方程组、开关灯问题、线性基构建等。

```cpp
bool Gauss(Matrix a, int n) {
	for(int i=1; i<=n; i++) {
		int r=i;
		for(int j=i+1; j<=n; j++) 
			if(abs(a[j][i]) > abs(a[r][i])) r=j;
		if(abs(a[r][i])<eps) return false;
		if(r!=i) for(int j=1; j<=n+1; j++) swap(a[r][j], a[i][j]);
		
		for(int j=i+1; j<=n; j++) {
			double t = a[j][i]/a[i][i];
			for(int k=i; k<=n+1; k++) a[j][k] -= t*a[i][k];
		}
	}
	for(int i=n; i>=1; i--) {
		for(int j=n; j>i; j--) a[i][n+1] -= a[i][j]*a[j][n+1];
		a[i][n+1] /= a[i][i];
	}
	return true;
}
```

**前缀线性基** *(Ivan and Burgers)*

> 【前缀线性基（Ivan and Burgers）】
线性代数模板。

核心函数：
  void in(Re &x) — 核心算法函数
  void insert(Re x,Re id) — 插入元素
  int ask(Re L) — 核心算法函数

核心结构体：JI

关键配置：
N=5e5+3,logN=20,inf=2e9

说明：freopen("456.txt","r",stdin);

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#pragma GCC optimize(2)
#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register int
using namespace std;
const int N=5e5+3,logN=20,inf=2e9;
int n,x,y,T;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct JI{
	int p[logN+1],ip[logN+1];JI(){memset(p,0,sizeof(p));}
	inline void insert(Re x,Re id){
		for(Re i=logN;i>=0;--i)
			if((x>>i)&1){
				if(!p[i]){p[i]=x,ip[i]=id;break;}
				if(ip[i]<id)swap(p[i],x),swap(ip[i],id);
				x^=p[i];
			}
	}
	inline int ask(Re L){
		Re ans=0;
		for(Re i=logN;i>=0;--i)if(ip[i]>=L)ans=max(ans,ans^p[i]);
		return ans;
	}
}A[N],S[N];
int main(){
//    freopen("456.txt","r",stdin);
    in(n);
    for(Re i=1;i<=n;++i)in(x),S[i]=S[i-1],S[i].insert(x,i);
    in(T);
    while(T--)in(x),in(y),printf("%d\n",S[y].ask(x));
}

```

**矩阵快速幂** *(结构体)*

> 【矩阵快速幂（结构体）】
矩阵运算模板（乘法、快速幂、求逆）。

核心函数：
  void in(Re &x) — 核心算法函数
  void read(无参数) — 核心算法函数
  void print(无参数) — 核心算法函数
  Matrix mi(Matrix x,Re k) — 核心算法函数

核心结构体：Matrix

关键配置：
N=103,P=1e9+7

```cpp
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register LL
const int N=103,P=1e9+7;
LL n,K;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Matrix{
	LL a[N][N];
	Matrix(){memset(a,0,sizeof(a));}
	inline void read(){
		for(Re i=1;i<=n;++i)
    		for(Re j=1;j<=n;++j)	
    			in(a[i][j]);
	}
	inline void print(){
		for(Re i=1;i<=n;puts(""),++i)
    		for(Re j=1;j<=n;++j)	
    			printf("%lld ",a[i][j]);
	}
	inline Matrix operator*(const Matrix &O)const{
		Matrix ans;
		for(Re i=1;i<=n;++i)
			for(Re j=1;j<=n;++j)
				for(Re k=1;k<=n;++k)
					(ans.a[i][j]+=a[i][k]*O.a[k][j]%P)%=P;
		return ans;
	}
	inline Matrix operator*=(Matrix &O){return *this=*this*O;}
}A;
inline Matrix mi(Matrix x,Re k){
	if(!k)return x;--k;
	Matrix s=x;
	while(k){
		if(k&1)s*=x;
		x*=x,k>>=1;
	}
	return s;
}
int main(){
	in(n),in(K),A.read(),mi(A,K).print();
}

```

**线性基** *(insert)*

> 【线性基】
线性代数模板。

核心函数：
  void in(Re &x) — 核心算法函数
  void insert(Re x) — 插入元素

关键配置：
N=55

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstdio>
#define LL long long
#define Re register LL
using namespace std;
const int N=55;
LL n,x,ans,p[N];
inline void in(Re &x){
	Re fu=0;x=0;char ch=getchar();
	while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=fu?-x:x;
}
inline void insert(Re x){
	for(Re i=50;i>=0;--i)
		if((x>>i)&1){
			if(!p[i]){p[i]=x;break;}
			x^=p[i];
		}
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n);
	for(Re i=1;i<=n;++i)in(x),insert(x);
	for(Re i=50;i>=0;--i)ans=max(ans,ans^p[i]);
	printf("%lld\n",ans);
}

```

**线性基合并** *(幸运数字)*

> 【线性基合并（幸运数字）】
线性代数模板。

核心函数：
  void add(Re x,Re y) — 加法更新
  void in(Re &x) — 核心算法函数
  void insert(Re x) — 插入元素
  void merge(JI O) — 合并操作
  LL ask(无参数) — 核心算法函数
  void dfs(Re x,Re fa) — 深度优先搜索遍历
  JI ask(Re x,Re y) — 核心算法函数

核心结构体：QAQ, JI, LCA

说明：freopen("lucky.in","r",stdin);；freopen("lucky.out","w",stdout);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#define LL long long
#define Re register LL
using namespace std;
const LL N=2e4+3,M=2e5+3,inf=2e18,logN=14;
LL n,m,o,x,y,T,A[N],head[N];
struct QAQ{LL to,next;}a[N<<1];
inline void add(Re x,Re y){a[++o].to=y,a[o].next=head[x],head[x]=o;}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct JI{
    LL p[61];JI(){memset(p,0,sizeof(p));}
    inline void insert(Re x){
        for(Re i=60;i>=0;--i)
            if((x>>i)&1){
                if(!p[i]){p[i]=x;break;}
                x^=p[i];
            }
    }
    inline void merge(JI O){
        for(Re i=60;i>=0;--i)if(O.p[i])insert(O.p[i]);
    }
    inline LL ask(){
        Re ans=0;
        for(Re i=60;i>=0;--i)ans=max(ans,ans^p[i]);
        return ans;
    }
};
struct LCA{
    LL deep[N],fa[N][15],ant[N][15];JI dp[N][15];
    inline void dfs(Re x,Re fa){
        deep[x]=deep[ant[x][0]=fa]+1,dp[x][0].insert(A[fa]);
        for(Re j=1;(1<<j)<=deep[x];++j)ant[x][j]=ant[ant[x][j-1]][j-1],dp[x][j]=dp[x][j-1],dp[x][j].merge(dp[ant[x][j-1]][j-1]);
        for(Re i=head[x];i;i=a[i].next)if(a[i].to!=fa)dfs(a[i].to,x);
    }
    inline JI ask(Re x,Re y){
        JI Ans;Ans.insert(A[x]),Ans.insert(A[y]);
        if(deep[x]<deep[y])swap(x,y);
        for(Re i=logN;i>=0;--i)if(deep[ant[x][i]]>=deep[y])Ans.merge(dp[x][i]),x=ant[x][i];
        if(x==y)return Ans;
        for(Re i=logN;i>=0;--i)if(ant[x][i]!=ant[y][i])Ans.merge(dp[x][i]),Ans.merge(dp[y][i]),x=ant[x][i],y=ant[y][i];
        Ans.merge(dp[x][0]);
        return Ans;
    }
}T1;
int main(){
//    freopen("lucky.in","r",stdin);
//    freopen("lucky.out","w",stdout);
    in(n),in(T),m=n-1;
    for(Re i=1;i<=n;++i)in(A[i]);
    while(m--)in(x),in(y),add(x,y),add(y,x);
    T1.dfs(1,0);
    while(T--)in(x),in(y),printf("%lld\n",T1.ask(x,y).ask());
}

```

**高斯消元** *(高斯约旦消元)*

> 【高斯消元（高斯约旦消元）】
高斯消元法模板，求解线性方程组、矩阵求逆或行列式计算。

核心函数：
  int dcmp(Re a) — 核心算法函数
  LD Abs(LD a) — 核心算法函数
  void in(Re &x) — 核心算法函数

关键配置：
N=103

说明：freopen("123.txt","r",stdin);

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#define LD double
#define LL long long
#define Re register int
using namespace std;
const int N=103;
int n;LD eps=1e-8,a[N][N];
inline int dcmp(Re a){return a<-eps?-1:(a>eps?1:0);}
inline LD Abs(LD a){return dcmp(a)*a;}
inline void in(Re &x){
	Re fu=0;x=0;char ch=getchar();
	while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x=fu?-x:x;
}
int main(){
//	freopen("123.txt","r",stdin);
	in(n);
	for(Re i=1;i<=n;++i)	
		for(Re j=1;j<=n+1;++j)
			scanf("%lf",&a[i][j]);
	for(Re j=1;j<=n;++j){
		Re w=j;
		for(Re i=j+1;i<=n;++i)
			if(dcmp(Abs(a[i][j])-Abs(a[w][j]))>0)w=i;
		for(Re k=1;k<=n+1;++k)swap(a[j][k],a[w][k]);
		if(!dcmp(a[j][j]))return !puts("No Solution");
		for(Re i=1;i<=n;++i)
			if(i!=j){
				LD tmp=a[i][j]/a[j][j];
				for(Re k=j;k<=n+1;++k)a[i][k]-=a[j][k]*tmp;
			}
	}
	for(Re i=1;i<=n;++i)printf("%.2lf\n",a[i][n+1]/a[i][i]);
}

```

### 7.6 线性基

**异或线性基** *(xianxingji)*

> 【异或线性基（XOR Basis）】
▪ Basis() — 构造函数，memset 清零 60 位基数组 a[]
▪ ins(x) — 插入数 x 到线性基：从高位向低位扫描，若 x 第 i 位为 1：若 a[i]==0 则 a[i]=x 返回 true（成功插入）；否则 x^=a[i] 继续消去该位。返回 false 表示 x 可被已有基线性表出
▪ max_val(x=0) — 查询与 x 异或的最大值：贪心从高到低，若 (x^a[i])>x 则 x^=a[i]
基的大小 ≤60（long long 位数）。适用于最大异或和、判断数是否可被表出、线性基求第 k 小异或和等。

```cpp
struct Basis{
    static const int K=60;
    ll a[K];
    Basis(){memset(a,0,sizeof a);}
    bool ins(ll x){
        for(int i=K-1;~i;--i)
        if(x>>i&1){
            if(!a[i]){a[i]=x;return true;}
            x^=a[i];
        }
        return false;
    }
    ll max_val(ll x=0){
        for(int i=K-1;~i;--i)if((x^a[i])>x)x^=a[i];
        return x;
    }
}B;
```

**前缀基** *(b)*

> 【前缀基（b）】
前缀线性基模板，维护每个位置的前缀线性基并可查询区间异或最大值。

核心函数：
  ll qpow(ll a, ll b) — 快速幂
  void linear_inv(const std::vector<ll>& a, std::vector<ll>& inv_a) — 求模逆元

关键配置：
MOD=998244353

```cpp
#include <iostream>
#include <vector>

using ll = long long;
using namespace std;
const int MOD = 998244353;

ll qpow(ll a, ll b) {
    ll res = 1;
    a %= MOD;
    while (b) {
        if (b & 1) res = res * a % MOD;
        a = a * a % MOD;
        b >>= 1;
    }
    return res;
}

/**
 * 线性批量求逆元 (前缀积法)
 * 传入需要求逆元的数组 a (1-indexed)，将结果存入 inv_a (1-indexed)
 * 时间复杂度: O(n + log(MOD))
 */
void linear_inv(const std::vector<ll>& a, std::vector<ll>& inv_a) {
    int n = a.size() - 1;
    if (n <= 0) return;
    std::vector<ll> pre(n + 1, 1), inv_pre(n + 1, 1);
    for (int i = 1; i <= n; i++) {
        pre[i] = pre[i - 1] * a[i] % MOD;
    }
    inv_pre[n] = qpow(pre[n], MOD - 2);
    for (int i = n; i >= 1; i--) {
        inv_pre[i - 1] = inv_pre[i] * a[i] % MOD;
    }
    for (int i = 1; i <= n; i++) {
        inv_a[i] = inv_pre[i] * pre[i - 1] % MOD;
    }
}
```

## 8. 计算几何

### 8.1 凸包

**求凸包面积** *(tubao)*

> 【求凸包面积（tubao）】
凸包（Convex Hull）模板（Graham Scan / Andrew 单调链法）。

核心函数：
  double polygon_area(const vector<Point>& p) — 核心算法函数

说明：传入多边形的顶点数组 p（不要求首尾点重合，只要是顺时针或逆时针按顺序排列即可）；返回多边形的面积

```cpp
// 传入多边形的顶点数组 p（不要求首尾点重合，只要是顺时针或逆时针按顺序排列即可）
// 返回多边形的面积
double polygon_area(const vector<Point>& p) {
    int n = p.size();
    if (n < 3) return 0.0; 
    double sum = 0;
    for (int i = 0; i < n; i++) {
        sum += cross(p[i], p[(i + 1) % n]); 
    }
    return abs(sum) / 2.0; 
}
```

**凸包（单调链法）** *(tubao)*

> 【凸包（单调链法）（tubao）】
凸包（Convex Hull）模板（Graham Scan / Andrew 单调链法）。

核心函数：
  int gcd(int x,int y) — 最大公约数
  int ksm(int a,int n,int p) — 核心算法函数
  int sgn(double x) — SG函数计算
  double cross(const Point& a, const Point& b) — 叉积运算
  double cross(const Point& p0, const Point& p1, const Point& p2) — 叉积运算
  vector<Point> convex_hull(vector<Point>& P) — 求凸包
  void solve(无参数) — 主解题函数

核心结构体：Point

关键配置：
N=1e6+5,mod=998244353,inf=1e9+7，eps=1e-9

```cpp
#pragma GCC optimize("O2")
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define up(i, a, b) for (int i = (a); i <= (b); ++i)
#define down(i, a, b) for (int i = (a); i >= (b); --i)
#define sm int,vector<int>,greater<int>
#define int long long
mt19937_64 gen(12345);
const int N=1e6+5,mod=998244353,inf=1e9+7;;
int n,m,q,k;
int a[N],b[N],c[N],d[N];
int gcd(int x,int y)
{
	if(y==0)return x;
	return gcd(y,x%y);
}
int ksm(int a,int n,int p)
{
	if(n<0)return 0;
	int res=1;
	while(n)
	{
		if(n&1)res=res*a%p;
		n>>=1;
		a=a*a%p;
	}
	return res;
}
const double eps = 1e-9;
int sgn(double x) {
	if (abs(x) < eps) return 0;
	return x < 0 ? -1 : 1;
}
struct Point {
	double x, y;
	Point(double _x = 0, double _y = 0) : x(_x), y(_y) {}
	
	Point operator - (const Point& b) const {
		return Point(x - b.x, y - b.y);
	}
	
	//优先按 x 排序，x 相同按 y 排序
	bool operator < (const Point& b) const {
		if (sgn(x - b.x) == 0) return sgn(y - b.y) < 0;
		return sgn(x - b.x) < 0;
	}
	
	// 判等（用于去重）
	bool operator == (const Point& b) const {
		return sgn(x - b.x) == 0 && sgn(y - b.y) == 0;
	}
};

double cross(const Point& a, const Point& b) {
	return a.x * b.y - a.y * b.x;
}

// 返回值 > 0：p2 在 p0->p1 的左侧（向左转）
// 返回值 < 0：p2 在 p0->p1 的右侧（向右转）
// 返回值 == 0：三点共线
double cross(const Point& p0, const Point& p1, const Point& p2) {
	return cross(p1 - p0, p2 - p0);
}

// 输入点集 P，返回凸包上的点集（逆时针顺序，起点和终点不重合）
vector<Point> convex_hull(vector<Point>& P) {
	int n = P.size();
	if (n <= 2) return P; // 退化情况：点数小于等于2，本身就是凸包
	
	// 1. 排序并去重
	sort(P.begin(), P.end());
	P.erase(unique(P.begin(), P.end()), P.end());
	n = P.size();
	if (n <= 2) return P;
	
	vector<Point> hull(2 * n); // 用数组模拟栈，速度最快
	int top = 0;               // 栈顶指针，表示栈内元素个数
	
	// 2. 求下凸壳
	for (int i = 0; i < n; i++) {
		// 【核心判断】：如果向右转或共线，则弹栈
		// 注意：如果你需要保留凸包边上的共线点，把 <= 改成 < 即可
		while (top >= 2 && sgn(cross(hull[top - 2], hull[top - 1], P[i])) <= 0) {
			top--;
		}
		hull[top++] = P[i];
	}
	
	// 3. 求上凸壳
	int tmp = top; // 记录下凸壳的元素个数，上凸壳弹栈时不能破坏下凸壳
	for (int i = n - 2; i >= 0; i--) {
		while (top > tmp && sgn(cross(hull[top - 2], hull[top - 1], P[i])) <= 0) {
			top--;
		}
		hull[top++] = P[i];
	}
	
	// 4. 收尾：最后加入的起点与栈底的起点重合，需减去
	if (n > 1) top--;
	hull.resize(top); // 截断有效部分
	return hull;
}

void solve(){
	cin>>n;
	vector<Point>pts(n);
	up(i,0,n-1)
		cin>>pts[i].x>>pts[i].y;
	vector<Point>hull=convex_hull(pts);
	double ans=0;
	double tx=hull.back().x,ty=hull.back().y;
	for(auto const &[x,y]:hull){
		ans+=sqrt((x-tx)*(x-tx)+(y-ty)*(y-ty));
		tx=x;
		ty=y;
	}
	cout << fixed << setprecision(2) << ans << '\n';
}
signed main()
{
	ios::sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	int t = 1;
//	cin >> t;
	while (t--){
		solve();
	}
//	system("x-www-browser https://ys.mihoyo.com/");
//	cout << fixed << setprecision(10) << x << '\n';
	return 0;
}
```

### 8.2 极角排序

**极角排序** *(sort)*

> 【极角排序（sort）】
极角排序模板，按相对于原点的角度排序点集。

核心函数：
  int half(无参数) — 核心算法函数
  long long cross(Point a, Point b) — 叉积运算
  long long dist2(Point a) — 计算距离
  bool polar_cmp(Point a, Point b) — 核心算法函数
  void polar_sort_example(无参数) — 核心算法函数

核心结构体：Point

```cpp
#include <bits/stdc++.h>
using namespace std;
struct Point {
	long long x, y;
	
	// 1. 象限划分 / 半平面划分
	// 规定极角从 x 轴正半轴开始，逆时针方向为正。
	// 我们将平面分为上下两个半区：
	// 上半区 (包含正 x 轴)：y > 0，或者 y == 0 且 x > 0 (返回 0)
	// 下半区 (包含负 x 轴)：y < 0，或者 y == 0 且 x < 0 (返回 1)
	// 原点 (0,0) 通常特殊处理或不参与极角排序，这里默认归为上半区
	int half() const {
		if (y > 0 || (y == 0 && x > 0)) return 0;
		return 1;
	}
};

// 几何意义：以 OA 和 OB 为邻边的平行四边形的有向面积
// 如果结果 > 0，说明从 OA 到 OB 是逆时针方向 (A 的极角小于 B 的极角)
// 如果结果 < 0，说明是顺时针方向
// 如果结果 == 0，说明 A, O, B 三点共线
long long cross(Point a, Point b) {
	return a.x * b.y - a.y * b.x;
}

// 3. 距离平方 (用于共线时的副关键字排序)
long long dist2(Point a) {
	return a.x * a.x + a.y * a.y;
}

// 4. 终极极角排序比较函数 (逆时针排列)
bool polar_cmp(Point a, Point b) {
	// 步骤一：如果两个点在不同的半区，上半区的点一定排在前面
	if (a.half() != b.half()) {
		return a.half() < b.half();
	}
	
	long long cp = cross(a, b);
	if (cp != 0) {
		// cp > 0 表示 a 在 b 的顺时针方向（即 a 的角度更小）
		return cp > 0; 
	}
	
	// 步骤三：如果极角完全相同 (共线)，通常把距离原点更近的点排在前面
	return dist2(a) < dist2(b);
}

// ==========================================
// 5. 实战用法示例
// ==========================================
void polar_sort_example() {
	vector<Point> pts = {
{-2, -2}, {1, 1}, {-1, 1}, {2, 0}, {0, 2}, {1, -1}
};
	
	// 假设以原点 (0,0) 为基准点进行极角排序
	// 如果基准点是其他的点 P，只需要把所有的点先减去 P (平移坐标系) 再排序即可
	sort(pts.begin(), pts.end(), polar_cmp);
	
	// 排序后的 pts 顺序将是严格的逆时针一圈
}
```

### 8.3 计算几何综合

**计算几何大板子** *(Geometry)*

> 【计算几何大板子（Computational Geometry Library）】
▪ eq(x, y) — 浮点/整数判等（abs(x-y)≤eps）
▪ type(x, y) — 判断点 (x,y) 所在象限（用于极角排序）
▪ Point — 二维点/向量结构（模板类型 T，默认 long long 支持整数几何）：
  — +、-、*（点积）、*=（标量乘）运算符重载
  — cross(r) — 叉积 x*ry - y*rx（判断方向、面积）
  — toleft(r) — 判断 r 在当前向量左侧(1)/同向(0)/右侧(-1)
  — arg_cmp(r) — 极角比较器（按象限+叉积排序）
  — operator< — 按 (x,y) 字典序比较
▪ Line — 线段/直线结构
▪ operator<< / operator>> — 输入输出流重载
使用整数几何避免浮点精度问题。适用于凸包、线段相交、点在多边形内判定、最近点对等。

```cpp
namespace Geometry {
using T = ll;
constexpr T eps = 0;

bool eq(const T &x, const T &y) { return abs(x - y) <= eps; }
inline constexpr int type(T x, T y) {
    if(x == 0 and y == 0) return 0;
    if(y < 0 or (y == 0 and x > 0)) return -1;
    return 1;
}
struct Point {
    T x, y;
    constexpr Point(T _x = 0, T _y = 0) : x(_x), y(_y) {}
    constexpr Point operator+() const noexcept { return *this; }
    constexpr Point operator-() const noexcept { return Point(-x, -y); }
    constexpr Point operator+(const Point &p) const { return Point(x + p.x, y + p.y); }
    constexpr Point operator-(const Point &p) const { return Point(x - p.x, y - p.y); }
    constexpr Point &operator+=(const Point &p) { return x += p.x, y += p.y, *this; }
    constexpr Point &operator-=(const Point &p) { return x -= p.x, y -= p.y, *this; }
    constexpr T operator*(const Point &p) const { return x * p.x + y * p.y; }
    constexpr Point &operator*=(const T &k) { return x *= k, y *= k, *this; }
    constexpr Point operator*(const T &k) { return Point(x * k, y * k); }
    constexpr bool operator==(const Point &r) const noexcept { return r.x == x and r.y == y; }
    constexpr T cross(const Point &r) const { return x * r.y - y * r.x; }

    constexpr bool operator<(const Point &r) const { return pair(x, y) < pair(r.x, r.y); }

    // 1 : left, 0 : same, -1 : right
    constexpr int toleft(const Point &r) const {
        auto t = cross(r);
        return t > eps ? 1 : t < -eps ? -1 : 0;
    }

    constexpr bool arg_cmp(const Point &r) const {
        int L = type(x, y), R = type(r.x, r.y);
        if(L != R) return L < R;

        T X = x * r.y, Y = r.x * y;
        if(X != Y) return X > Y;
        return x < r.x;
    }
};
bool arg_cmp(const Point &l, const Point &r) { return l.arg_cmp(r); }
ostream &operator<<(ostream &os, const Point &p) { return os << p.x << " " << p.y; }
istream &operator>>(istream &is, Point &p) {
    is >> p.x >> p.y;
    return is;
}

struct Line {
    Point a, b;
    Line() = default;
    Line(Point a, Point b) : a(a), b(b) {}
    // ax + by = c
    Line(T A, T B, T C) {
        if(A == 0) {
            a = Point(0, C / B), b = Point(1, C / B);
        } else if(B == 0) {
            a = Point(C / A, 0), b = Point(C / A, 1);
        } else {
            a = Point(0, C / B), b = Point(C / A, 0);
        }
    }
    // 1 : left, 0 : same, -1 : right
    constexpr int toleft(const Point &r) const {
        auto t = (b - a).cross(r - a);
        return t > eps ? 1 : t < -eps ? -1 : 0;
    }

    friend std::ostream &operator<<(std::ostream &os, Line &ls) {
        return os << "{"
                  << "(" << ls.a.x << ", " << ls.a.y << "), (" << ls.b.x << ", " << ls.b.y << ")}";
    }
};
istream &operator>>(istream &is, Line &p) { return is >> p.a >> p.b; }

struct Segment : Line {
    Segment() = default;
    Segment(Point a, Point b) : Line(a, b) {}
};

ostream &operator<<(ostream &os, Segment &p) { return os << p.a << " to " << p.b; }
istream &operator>>(istream &is, Segment &p) {
    is >> p.a >> p.b;
    return is;
}

struct Circle {
    Point p;
    T r;
    Circle() = default;
    Circle(Point p, T r) : p(p), r(r) {}
};

using pt = Point;
using Points = vector<pt>;
using Polygon = Points;
T cross(const pt &x, const pt &y) { return x.x * y.y - x.y * y.x; }
T dot(const pt &x, const pt &y) { return x.x * y.x + x.y * y.y; }

T abs2(const pt &x) { return dot(x, x); }
// http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_1_C
// 点の回転方向
int ccw(const Point &a, Point b, Point c) {
    b = b - a, c = c - a;
    if(cross(b, c) > 0) return +1;   // "COUNTER_CLOCKWISE"
    if(cross(b, c) < 0) return -1;   // "CLOCKWISE"
    if(dot(b, c) < 0) return +2;     // "ONLINE_BACK"
    if(abs2(b) < abs2(c)) return -2; // "ONLINE_FRONT"
    return 0;                        // "ON_SEGMENT"
}

// http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_2_A
// 平行判定
bool parallel(const Line &a, const Line &b) { return (cross(a.b - a.a, b.b - b.a) == 0); }

// http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_2_A
// 垂直判定
bool orthogonal(const Line &a, const Line &b) { return (dot(a.a - a.b, b.a - b.b) == 0); }

bool intersect(const Line &l, const Point &p) { return abs(ccw(l.a, l.b, p)) != 1; }

bool intersect(const Line &l, const Line &m) { return !parallel(l, m); }

bool intersect(const Segment &s, const Point &p) { return ccw(s.a, s.b, p) == 0; }

bool intersect(const Line &l, const Segment &s) { return cross(l.b - l.a, s.a - l.a) * cross(l.b - l.a, s.b - l.a) <= 0; }

// http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_2_B
bool intersect(const Segment &s, const Segment &t) { return ccw(s.a, s.b, t.a) * ccw(s.a, s.b, t.b) <= 0 && ccw(t.a, t.b, s.a) * ccw(t.a, t.b, s.b) <= 0; }

bool intersect(const Polygon &ps, const Polygon &qs) {
    int pl = si(ps), ql = si(qs), i = 0, j = 0;
    while((i < pl or j < ql) and (i < 2 * pl) and (j < 2 * ql)) {
        auto ps0 = ps[(i + pl - 1) % pl], ps1 = ps[i % pl];
        auto qs0 = qs[(j + ql - 1) % ql], qs1 = qs[j % ql];
        if(intersect(Segment(ps0, ps1), Segment(qs0, qs1))) return true;
        Point a = ps1 - ps0;
        Point b = qs1 - qs0;
        T v = cross(a, b);
        T va = cross(qs1 - qs0, ps1 - qs0);
        T vb = cross(ps1 - ps0, qs1 - ps0);

        if(!v and va < 0 and vb < 0) return false;
        if(!v and !va and !vb) {
            i += 1;
        } else if(v >= 0) {
            if(vb > 0)
                i += 1;
            else
                j += 1;
        } else {
            if(va > 0)
                j += 1;
            else
                i += 1;
        }
    }
    return false;
}

T norm(const Point &p) { return p.x * p.x + p.y * p.y; }
Point projection(const Segment &l, const Point &p) {
    T t = dot(p - l.a, l.a - l.b) / norm(l.a - l.b);
    return l.a + (l.a - l.b) * t;
}

Point crosspoint(const Line &l, const Line &m) {
    T A = cross(l.b - l.a, m.b - m.a);
    T B = cross(l.b - l.a, l.b - m.a);
    if(A == 0 and B == 0) return m.a;
    return m.a + (m.b - m.a) * (B / A);
}

// http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_2_C
Point crosspoint(const Segment &l, const Segment &m) { return crosspoint(Line(l), Line(m)); }

// http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_3_B
// 凸性判定
bool is_convex(const Points &p) {
    int n = (int)p.size();
    for(int i = 0; i < n; i++) {
        if(ccw(p[(i + n - 1) % n], p[i], p[(i + 1) % n]) == -1) return false;
    }
    return true;
}

Points convex_hull(Points p) {
    int n = p.size(), k = 0;
    if(n <= 2) return p;
    sort(begin(p), end(p), [](pt x, pt y) { return (x.x != y.x ? x.x < y.x : x.y < y.y); });
    Points ch(2 * n);
    for(int i = 0; i < n; ch[k++] = p[i++]) {
        while(k >= 2 && cross(ch[k - 1] - ch[k - 2], p[i] - ch[k - 1]) <= 0) --k;
    }
    for(int i = n - 2, t = k + 1; i >= 0; ch[k++] = p[i--]) {
        while(k >= t && cross(ch[k - 1] - ch[k - 2], p[i] - ch[k - 1]) <= 0) --k;
    }
    ch.resize(k - 1);
    return ch;
}

// 面積の 2 倍
T area2(const Points &p) {
    T res = 0;
    rep(i, si(p)) { res += cross(p[i], p[i == si(p) - 1 ? 0 : i + 1]); }
    return res;
}

enum { _OUT, _ON, _IN };

int contains(const Polygon &Q, const Point &p) {
    bool in = false;
    for(int i = 0; i < Q.size(); i++) {
        Point a = Q[i] - p, b = Q[(i + 1) % Q.size()] - p;
        if(a.y > b.y) swap(a, b);
        if(a.y <= 0 && 0 < b.y && cross(a, b) < 0) in = !in;
        if(cross(a, b) == 0 && dot(a, b) <= 0) return _ON;
    }
    return in ? _IN : _OUT;
}

Polygon Minkowski_sum(const Polygon &P, const Polygon &Q) {
    vector<Segment> e1(P.size()), e2(Q.size()), ed(P.size() + Q.size());
    const auto cmp = [](const Segment &u, const Segment &v) { return (u.b - u.a).arg_cmp(v.b - v.a); };
    rep(i, P.size()) e1[i] = {P[i], P[(i + 1) % P.size()]};
    rep(i, Q.size()) e2[i] = {Q[i], Q[(i + 1) % Q.size()]};
    rotate(begin(e1), min_element(all(e1), cmp), end(e1));
    rotate(begin(e2), min_element(all(e2), cmp), end(e2));
    merge(all(e1), all(e2), begin(ed), cmp);
    const auto check = [](const Points &res, const Point &u) {
        const auto back1 = res.back(), back2 = *prev(end(res), 2);
        return eq(cross(back1 - back2, u - back2), eps) and dot(back1 - back2, u - back1) >= -eps;
    };
    auto u = e1[0].a + e2[0].a;
    Points res{u};
    res.reserve(P.size() + Q.size());
    for(const auto &v : ed) {
        u = u + v.b - v.a;
        while(si(res) >= 2 and check(res, u)) res.pop_back();
        res.eb(u);
    }
    if(res.size() and check(res, res[0])) res.pop_back();
    return res;
}

// -1 : on, 0 : out, 1 : in
// O(log(n))
int is_in(const Polygon &p, const Point &a) {
    if(p.size() == 1) return a == p[0] ? -1 : 0;
    if(p.size() == 2) return intersect(Segment(p[0], p[1]), a);
    if(a == p[0]) return -1;
    if((p[1] - p[0]).toleft(a - p[0]) == -1 || (p.back() - p[0]).toleft(a - p[0]) == 1) return 0;
    const auto cmp = [&](const Point &u, const Point &v) { return (u - p[0]).toleft(v - p[0]) == 1; };
    const size_t i = lower_bound(p.begin() + 1, p.end(), a, cmp) - p.begin();
    if(i == 1) return intersect(Segment(p[0], p[i]), a) ? -1 : 0;
    if(i == p.size() - 1 && intersect(Segment(p[0], p[i]), a)) return -1;
    if(intersect(Segment(p[i - 1], p[i]), a)) return -1;
    return (p[i] - p[i - 1]).toleft(a - p[i - 1]) > 0;
}

Points halfplane_intersection(vector<Line> L, const T inf = 1e9) {
    Point box[4] = {Point(inf, inf), Point(-inf, inf), Point(-inf, -inf), Point(inf, -inf)};
    rep(i, 4) { L.emplace_back(box[i], box[(i + 1) % 4]); }
    sort(all(L), [](const Line &l, const Line &r) { return (l.b - l.a).arg_cmp(r.b - r.a); });
    deque<Line> dq;
    int len = 0;
    auto check = [](const Line &a, const Line &b, const Line &c) { return a.toleft(crosspoint(b, c)) == -1; };
    rep(i, L.size()) {
        while(dq.size() > 1 and check(L[i], *(end(dq) - 2), *(end(dq) - 1))) dq.pop_back();
        while(dq.size() > 1 and check(L[i], dq[0], dq[1])) dq.pop_front();
        // dump(L[i], si(dq));

        if(dq.size() and eq(cross(L[i].b - L[i].a, dq.back().b - dq.back().a), 0)) {
            if(dot(L[i].b - L[i].a, dq.back().b - dq.back().a) < eps) return {};
            if(L[i].toleft(dq.back().a) == -1)
                dq.pop_back();
            else
                continue;
        }
        dq.emplace_back(L[i]);
    }

    while(dq.size() > 2 and check(dq[0], *(end(dq) - 2), *(end(dq) - 1))) dq.pop_back();
    while(dq.size() > 2 and check(dq.back(), dq[0], dq[1])) dq.pop_front();
    if(si(dq) < 3) return {};
    Polygon ret(dq.size());
    rep(i, dq.size()) ret[i] = crosspoint(dq[i], dq[(i + 1) % dq.size()]);
    return ret;
}
} // namespace Geometry

using namespace Geometry;
```

**求凸包直径（旋转卡壳）** *(tubao)*

> 【求凸包直径（旋转卡壳）（tubao）】
旋转卡壳（Rotating Calipers）模板，求凸包直径/最远点对。

核心函数：
  int gcd(int x,int y) — 最大公约数
  int ksm(int a,int n,int p) — 核心算法函数
  int sgn(double x) — SG函数计算
  double cross(const Point& a, const Point& b) — 叉积运算
  double cross(const Point& p0, const Point& p1, const Point& p2) — 叉积运算
  int dist(const Point& p0, const Point& p1) — 计算距离
  vector<Point> convex_hull(vector<Point>& P) — 求凸包
  int hull_diam(vector<Point>& hull) — 核心算法函数

核心结构体：Point

关键配置：
N=1e6+5,mod=998244353,inf=1e9+7，eps=1e-9

适用场景：几何对象的交并关系判定、面积/周长计算

```cpp
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // 包含所有容器（哈希表、树、堆）
#include <ext/pb_ds/tree_policy.hpp>     // 包含树的相关策略（用于实现平衡树）
#include <ext/pb_ds/hash_policy.hpp>     // 包含哈希表的相关策略
//#include <ext/pb_ds/priority_queue.hpp>  // 包含优先级队列（堆）
using namespace std;
using namespace __gnu_pbds;
using ll = long long;
template <typename T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define up(i, a, b) for (int i = (a); i <= (b); ++i)
#define down(i, a, b) for (int i = (a); i >= (b); --i)
#define sm int,vector<int>,greater<int>
#define int long long
mt19937_64 gen(12345);
const int N=1e6+5,mod=998244353,inf=1e9+7;;
int n,m,q,k;
int a[N],b[N],c[N],d[N];
int gcd(int x,int y)
{
	if(y==0)return x;
	return gcd(y,x%y);
}
int ksm(int a,int n,int p)
{
	if(n<0)return 0;
	int res=1;
	while(n)
	{
		if(n&1)res=res*a%p;
		n>>=1;
		a=a*a%p;
	}
	return res;
}
const double eps = 1e-9;
int sgn(double x) {
	if (abs(x) < eps) return 0;
	return x < 0 ? -1 : 1;
}
struct Point {
	double x, y;
	Point(double _x = 0, double _y = 0) : x(_x), y(_y) {}
	
	Point operator - (const Point& b) const {
		return Point(x - b.x, y - b.y);
	}
	
	//优先按 x 排序，x 相同按 y 排序
	bool operator < (const Point& b) const {
		if (sgn(x - b.x) == 0) return sgn(y - b.y) < 0;
		return sgn(x - b.x) < 0;
	}
	
	// 判等（用于去重）
	bool operator == (const Point& b) const {
		return sgn(x - b.x) == 0 && sgn(y - b.y) == 0;
	}
};

double cross(const Point& a, const Point& b) {
	return a.x * b.y - a.y * b.x;
}

// 返回值 > 0：p2 在 p0->p1 的左侧（向左转）
// 返回值 < 0：p2 在 p0->p1 的右侧（向右转）
// 返回值 == 0：三点共线
double cross(const Point& p0, const Point& p1, const Point& p2) {
	return cross(p1 - p0, p2 - p0);
}

int dist(const Point& p0, const Point& p1){
	return (p0.x-p1.x)*(p0.x-p1.x)+(p0.y-p1.y)*(p0.y-p1.y);
}
// 输入点集 P，返回凸包上的点集（逆时针顺序，起点和终点不重合）
vector<Point> convex_hull(vector<Point>& P) {
	int n = P.size();
	if (n <= 2) return P; // 退化情况：点数小于等于2，本身就是凸包
	
	// 1. 排序并去重
	sort(P.begin(), P.end());
	P.erase(unique(P.begin(), P.end()), P.end());
	n = P.size();
	if (n <= 2) return P;
	
	vector<Point> hull(2 * n); // 用数组模拟栈，速度最快
	int top = 0;               // 栈顶指针，表示栈内元素个数
	
	// 2. 求下凸壳
	for (int i = 0; i < n; i++) {
		// 【核心判断】：如果向右转或共线，则弹栈
		// 注意：如果你需要保留凸包边上的共线点，把 <= 改成 < 即可
		while (top >= 2 && sgn(cross(hull[top - 2], hull[top - 1], P[i])) <= 0) {
			top--;
		}
		hull[top++] = P[i];
	}
	
	// 3. 求上凸壳
	int tmp = top; // 记录下凸壳的元素个数，上凸壳弹栈时不能破坏下凸壳
	for (int i = n - 2; i >= 0; i--) {
		while (top > tmp && sgn(cross(hull[top - 2], hull[top - 1], P[i])) <= 0) {
			top--;
		}
		hull[top++] = P[i];
	}
	
	if (n > 1) top--;
	hull.resize(top);
	return hull;
}
int hull_diam(vector<Point>& hull){
	int j=2;
	int ans=0,H=hull.size();
	if (H == 2) {
        return dist(hull[0], hull[1]) ;
    }
    if (H <= 1) {
        return 0;
    }
	up(i,0,H-1){
		int next_i=(i+1)%H;
		while(cross(hull[i],hull[next_i],hull[j])<=cross(hull[i],hull[next_i],hull[(j+1)%H])){
			j=(j+1)%H;
		}
		ans=max(ans,dist(hull[i],hull[j]));
		ans=max(ans,dist(hull[next_i],hull[j]));
	}
	return ans;   
}
void solve(){
	cin>>n;
	vector<Point>pts(n);
	up(i,0,n-1)cin>>pts[i].x>>pts[i].y;
	vector<Point>hull=convex_hull(pts);
	cout<<hull_diam(hull);
}

signed main() 
{
	ios::sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	int t = 1;
	// cin >> t;
	while (t--){
		solve();
	}
//	system("x-www-browser https://ys.mihoyo.com/");
//	cout << fixed << setprecision(10) << x << '\n';
	return 0;
}
/*
1
38133 49107

2 27269


*/
```

**三点坐标解圆方程  (Circle Through Three Points)** *(大暴力)*

> 【三点坐标解圆方程  (Circle Through Three Points)（大暴力）】
计算几何算法模板。

核心函数：
  void CL(无参数) — 核心算法函数
  void calc(Poi a,Poi c) — 计算函数
  void calc_(Poi a,Re K) — 计算函数
  Poi Get_half(Poi a,Poi b) — 获取值
  Poi Get_LPL(Line a,Line b) — 获取值
  LD S(Re a) — 核心算法函数
  LD Get_dis(Poi a,Poi b) — 获取值

核心结构体：Poi, Line

说明：freopen("123.txt","r",stdin);；printf("(x - %.3lf)^2 + (y - %.3lf)^2 = %.3lf^2\n",xin.x,xin.y,R);//��׼ʽ

适用场景：几何对象的交并关系判定、面积/周长计算

```cpp
#include<cstring>
#include<cstdio>
#include<cmath>
#define LD double
#define Re register LD
#define abs(x) (x<0?-x:x)
#define sakura(x) (x<0?'-':'+')
using namespace std;
struct Poi{LD x,y;inline void CL(){x=y=0;}}a1,a2,a3,xin;
struct Line{
	LD k,b;
	inline void CL(){k=b=0;}
	inline void calc(Poi a,Poi c){k=(a.y-c.y)/(a.x-c.x),b=a.y-k*a.x;}// 由两点确定一条直线 
	inline void calc_(Poi a,Re K){k=K,b=a.y-k*a.x;}
}L1,L2,L3,L4;
inline Poi Get_half(Poi a,Poi b){// 求两圆交点 
	Poi c;
	c.x=(a.x+b.x)/2.0,c.y=(a.y+b.y)/2.0;
	return c;
}
inline Poi Get_LPL(Line a,Line b){
	Poi c;
	c.x=(b.b-a.b)/(a.k-b.k),c.y=a.k*c.x+a.b;
	return c;
}
inline LD S(Re a){return a*a;}
inline LD Get_dis(Poi a,Poi b){// 撤销操作� 
	return sqrt(S(a.x-b.x)+S(a.y-b.y));
}
LD R;
int main(){
//	freopen("123.txt","r",stdin); 
	while(scanf("%lf%lf%lf%lf%lf%lf",&a1.x,&a1.y,&a2.x,&a2.y,&a3.x,&a3.y)!=EOF){
		xin.CL(),L1.CL(),L2.CL(),L3.CL(),L4.CL();
		L1.calc(a1,a2),L2.calc(a2,a3);
		L3.calc_(Get_half(a1,a2),-1.0/L1.k);
		L4.calc_(Get_half(a2,a3),-1.0/L2.k);
		xin=Get_LPL(L3,L4);
		R=Get_dis(xin,a1);
		Re a=-xin.x,b=-xin.y,c=R,d=-2.0*xin.x,e=-2.0*xin.y,f=S(xin.x)+S(xin.y)-S(R);
		if(a!=0)printf("(x %c %.3lf)^2 ",sakura(a),abs(a));
        else printf("x^2 ");
        if(b!=0)printf("+ (y %c %.3lf)^2 ",sakura(b),abs(b));
        else printf("+ y^2 ");
        printf("= %.3lf^2\n",c);
        printf("x^2 + y^2");
        if(d!=0)printf(" %c %.3lf%c",sakura(d),abs(d),'x');
        if(e!=0)printf(" %c %.3lf%c",sakura(e),abs(e),'y');
        if(f!=0)printf(" %c %.3lf%c",sakura(f),abs(f),' ');
        printf("= 0\n\n");
	}
}

```

**三点坐标解圆方程  (Circle Through Three Points)** *(解方程)*

> 【三点坐标解圆方程  (Circle Through Three Points)（解方程）】
计算几何算法模板。

核心函数：
  Circle getcircle(Point A,Point B,Point C) — 获取值
  void print(Point O,LD r) — 核心算法函数

核心结构体：Point, Circle

说明：printf("(%.3lf,%.3lf), D=%.3lf E=%.3lf F=%.3lf\n",D/2.0,E/2.0,D,E,F);；freopen("123.txt","r",stdin);

适用场景：几何对象的交并关系判定、面积/周长计算

```cpp
#include<cstdio>
#include<cmath>
#define LD double
#define LL long long
#define Re register int
#define S(a) ((a)*(a))
using namespace std;
struct Point{LD x,y;Point(LD X=0,LD Y=0){x=X,y=Y;}};
struct Circle{Point O;LD r;Circle(Point P,LD R=0){O=P,r=R;}};
inline Circle getcircle(Point A,Point B,Point C){
	LD x1=A.x,y1=A.y,x2=B.x,y2=B.y,x3=C.x,y3=C.y;
	LD D=((S(x2)+S(y2)-S(x3)-S(y3))*(y1-y2)-(S(x1)+S(y1)-S(x2)-S(y2))*(y2-y3))/((x1-x2)*(y2-y3)-(x2-x3)*(y1-y2));
	LD E=(S(x1)+S(y1)-S(x2)-S(y2)+D*(x1-x2))/(y2-y1);
	LD F=-(S(x1)+S(y1)+D*x1+E*y1);
//	printf("(%.3lf,%.3lf), D=%.3lf E=%.3lf F=%.3lf\n",D/2.0,E/2.0,D,E,F);
	return Circle(Point(-D/2.0,-E/2.0),sqrt((S(D)+S(E)-4.0*F)/4.0));
}
#define abs(x) (x<0?-x:x)
#define sakura(x) (x<0?'-':'+')
inline void print(Point O,LD r){
	LD a=-O.x,b=-O.y,c=r,d=-2.0*O.x,e=-2.0*O.y,f=S(O.x)+S(O.y)-S(r);
	if(a!=0)printf("(x %c %.3lf)^2 ",sakura(a),abs(a));
    else printf("x^2 ");
    if(b!=0)printf("+ (y %c %.3lf)^2 ",sakura(b),abs(b));
    else printf("+ y^2 ");
    printf("= %.3lf^2\n",c);
    printf("x^2 + y^2");
    if(d!=0)printf(" %c %.3lf%c",sakura(d),abs(d),'x');
    if(e!=0)printf(" %c %.3lf%c",sakura(e),abs(e),'y');
    if(f!=0)printf(" %c %.3lf%c",sakura(f),abs(f),' ');
    printf("= 0\n\n");
}
int main(){
//	freopen("123.txt","r",stdin);
	LD a,b,c,d,e,f;
	while(scanf("%lf%lf%lf%lf%lf%lf",&a,&b,&c,&d,&e,&f)!=EOF){
		Circle C=getcircle(Point(a,b),Point(c,d),Point(e,f));print(C.O,C.r);
	}
}

```

**三角剖分** *(Hdu4404 多边形与圆的交)*

> 【三角剖分（Hdu4404 多边形与圆的交）】
三角剖分（Triangulation）相关模板。

核心函数：
  int dcmp(LD a) — 核心算法函数
  LD Abs(LD a) — 核心算法函数
  void in(Re &x) — 核心算法函数
  LD LDin(无参数) — 核心算法函数
  void in(无参数) — 核心算法函数
  LD Dot(Vector a,Vector b) — 点积运算
  LD Cro(Vector a,Vector b) — 核心算法函数
  LD Len(Vector a) — 核心算法函数

核心结构体：Point

关键配置：
N=1e5+3

说明：freopen("123.txt","r",stdin);；printf("O=(%.2lf,%.2lf), R=%d\n",O.x,O.y,R);

适用场景：几何对象的交并关系判定、面积/周长计算

```cpp
#include<algorithm>
#include<cstdio>
#include<cmath>
#define LD double
#define LL long long
#define Vector Point
#define Re register int
using namespace std;
const int N=1e5+3;
const LD eps=1e-8,Pi=acos(-1.0);
inline int dcmp(LD a){return a<-eps?-1:(a>eps?1:0);}
inline LD Abs(LD a){return a*dcmp(a);}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline LD LDin(){
    LD X=0,Y=1.0;int f=0;char c=getchar();
    while(c<'0'||c>'9'){f|=c=='-';c=getchar();} 
    while(c>='0'&&c<='9')X=X*10+(c^48),c=getchar(); 
    if(c=='.'){c=getchar();while(c>='0'&&c<='9')X+=(Y/=10)*(c^48),c=getchar();}
    return f?-X:X;
}
struct Point{
    LD x,y;Point(LD X=0,LD Y=0){x=X,y=Y;}
    inline void in(){x=LDin(),y=LDin();}
    inline bool operator<(const Point &O)const{return x!=O.x?x<O.x:y<O.y;}
};
inline LD Dot(Vector a,Vector b){return a.x*b.x+a.y*b.y;}
inline LD Cro(Vector a,Vector b){return a.x*b.y-a.y*b.x;}
inline LD Len(Vector a){return sqrt(Dot(a,a));}
inline LD Angle(Vector a,Vector b){return acos(Dot(a,b)/Len(a)/Len(b));}
inline Vector operator-(Vector a,Vector b){return Vector(a.x-b.x,a.y-b.y);}
inline Vector operator+(Vector a,Vector b){return Vector(a.x+b.x,a.y+b.y);}
inline Vector operator*(Vector a,LD b){return Vector(a.x*b,a.y*b);}
inline bool operator==(Vector a,Vector b){return !dcmp(a.x-b.x)&&!dcmp(a.y-b.y);}
inline Point turn_P(Point a,LD theta){
    LD x=a.x*cos(theta)+a.y*sin(theta);
    LD y=-a.x*sin(theta)+a.y*cos(theta);
    return Point(x,y);
}
inline Point cross_LL(Point a,Point b,Point c,Point d){
    Vector x=b-a,y=d-c,z=a-c;
    return a+x*(Cro(y,z)/Cro(x,y));
}
inline LD dis_PL(Point p,Point a,Point b){
    if(a==b)return Len(p-a);
    Vector x=p-a,y=p-b,z=b-a;
    if(dcmp(Dot(x,z))<0)return Len(x);
    if(dcmp(Dot(y,z))>0)return Len(y);
    return Abs(Cro(x,z)/Len(z));
}
inline Point FootPoint(Point p,Point a,Point b){
    Vector x=p-a,y=p-b,z=b-a;
    LD len1=Dot(x,z)/Len(z),len2=-1.0*Dot(y,z)/Len(z);
    return a+z*(len1/(len1+len2));
}
inline LD calc(Point A,Point B,Point O,LD R){
    if((A==O)||(B==O))return 0;
    Re op=(dcmp(Cro(A-O,B-O))>0)?1:-1;LD ans=0;
    Vector x=A-O,y=B-O;
    Re flag1=(int)(dcmp(Len(x)-R)>0),flag2=(int)(dcmp(Len(y)-R)>0);
    if(!flag1&&!flag2)ans=Abs(Cro(A-O,B-O))/2.0;
    else if(flag1&&flag2){
        if(dcmp(dis_PL(O,A,B)-R)>=0)ans=R*R*Angle(x,y)/2.0;
        else{
            if(dcmp(Cro(A-O,B-O))>0)swap(A,B);
            Point F=FootPoint(O,A,B);LD lenx=Len(F-O),len=sqrt(R*R-lenx*lenx);
            Vector z=turn_P(F-O,Pi/2.0)*(len/lenx);Point B_=F+z,A_=F-z;
            ans=R*R*(Angle(A-O,A_-O)+Angle(B-O,B_-O))/2.0+Cro(B_-O,A_-O)/2.0;
        }
    }
    else{
        if(flag1)swap(A,B);
        Point F=FootPoint(O,A,B);LD lenx=Len(F-O),len=sqrt(R*R-lenx*lenx);
        Vector z=turn_P(F-O,Pi/2.0)*(len/lenx);Point C=(dcmp(Cro(A-O,B-O))>0)?(F-z):(F+z);
        ans=Abs(Cro(A-O,C-O))/2.0+R*R*Angle(C-O,B-O)/2.0;
    }
    return ans*op;
}
Point V,P[N];LD h,t,g,v0,ans,theta;int n;Point O;LD R;
int main(){
//    freopen("123.txt","r",stdin);
    while(~scanf("%lf",&O.x)){
        O.y=LDin(),v0=LDin(),theta=LDin(),t=LDin(),g=LDin(),R=LDin();
        if(!dcmp(O.x)&&!dcmp(O.y)&&!dcmp(v0)&&!dcmp(theta)&&!dcmp(t)&&!dcmp(g)&&!dcmp(R))break;
        theta=theta/180.0*Pi,O.x+=t*v0*cos(theta),O.y+=t*v0*sin(theta)-0.5*g*t*t,ans=0;
//        printf("O=(%.2lf,%.2lf), R=%d\n",O.x,O.y,R);
        in(n);for(Re i=1;i<=n;++i)P[i].in();
        for(Re i=1;i<=n;++i)ans+=calc(P[i],P[i<n?i+1:1],O,R);
        if(!dcmp(ans))puts("0.00");
        else printf("%.2lf\n",Abs(ans));
    }
}

```

**三角形面积并** *(optimize)*

> 【三角形面积并】
计算几何算法模板。

核心函数：
  int dcmp(Rd a) — 核心算法函数
  void in(无参数) — 核心算法函数
  void in(无参数) — 核心算法函数
  bool cmp(Triangle A,Triangle B) — 核心算法函数
  LD F(Rd Y) — 核心算法函数
  LD Simpson(Rd L,Rd R) — 核心算法函数
  LD sakura(Rd L,Rd R,Rd now) — 后缀数组
  int TIT(Triangle A,Triangle B) — 核心算法函数

核心结构体：Point, Segment, Triangle

关键配置：
N=2003

说明：freopen("456.txt","r",stdin);

适用场景：几何对象的交并关系判定、面积/周长计算

```cpp
#pragma GCC optimize(3,"Ofast","inline")
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<map>
#define LD double
#define LL long long
#define Re register int
#define Rd register LD
#define Vector Point
using namespace std;
const int N=2003;
const LD eps=1e-9;
int n,m;map<LD,LD>vis;
inline int dcmp(Rd a){return a<-eps?-1:(a>eps?1:0);}
struct Point{
    LD x,y;Point(LD X=0,LD Y=0){x=X,y=Y;}
    inline void in(){scanf("%lf%lf",&x,&y);}
};
struct Segment{
    LD L,R;Segment(LD l=0,LD r=0){L=l,R=r;}
    inline bool operator<(Segment O)const{return L!=O.L?L<O.L:R<O.R;}
}Seg[N];
struct Triangle{
	LD x,y,m,L,R,D,U;
	inline void in(){scanf("%lf%lf%lf",&x,&y,&m),L=x,R=x+m,D=y,U=y+m;}
}C[N],C_[N];
inline bool cmp(Triangle A,Triangle B){return A.m<B.m;}
inline LD F(Rd Y){
    if(vis[Y])return vis[Y];
    Re t=0;Rd ans=0;
    for(Re i=1;i<=n;++i)
        if(dcmp(Y-C[i].D)>=0&&dcmp(Y-C[i].U)<0){
			Rd tmp=C[i].U-Y;
			if(dcmp(tmp)>0)Seg[++t]=Segment(C[i].x,C[i].x+tmp);
		}
    if(!t)return 0.0;
    sort(Seg+1,Seg+t+1);
    for(Re i=1,j;i<=t;i=j+1){
        Rd L=Seg[i].L,R=Seg[i].R;j=i;
        while(j<t&&Seg[j+1].L<=R)++j,R=max(R,Seg[j].R);
        ans+=R-L;
    }
    return vis[Y]=ans;
}
inline LD Simpson(Rd L,Rd R){return (R-L)*(F(L)+4.0*F((L+R)*0.5)+F(R))/6.0;}
inline LD sakura(Rd L,Rd R,Rd now){
    Rd mid=(L+R)*0.5,FL=Simpson(L,mid),FR=Simpson(mid,R);
    if(!dcmp(now-FL-FR))return now;
    return sakura(L,mid,FL)+sakura(mid,R,FR);
}
inline int TIT(Triangle A,Triangle B){
	return A.L>=B.L&&A.R<=B.R&&A.D>=B.D&&A.U<=B.U&&dcmp(A.R-(B.x+B.U-A.y))<=0;
}
LD ans,YY[N<<1];
int main(){
//	freopen("456.txt","r",stdin);
    scanf("%d",&m);Re t=0;
    for(Re i=1;i<=m;++i)C_[i].in();
    sort(C_+1,C_+m+1,cmp),C[++n]=C_[m];
    for(Re i=m-1;i>=1;--i){
        Re flag=1;
        for(Re j=1;j<=n&&flag;++j)if(TIT(C_[i],C[j]))flag=0;
        if(flag)C[++n]=C_[i];
    }
    for(Re i=1;i<=n;++i)YY[++t]=C[i].D,YY[++t]=C[i].U;
	sort(YY+1,YY+t+1);
    for(Re i=2;i<=t;++i)
		if(dcmp(YY[i]-YY[i-1])>0){
			Rd D=YY[i-1],U=YY[i]-2*eps;
	        ans+=sakura(D,U,Simpson(D,U));
    	}
    printf("%.1lf",ans);
}

```

**二维凸包** *(周长)*

> 【二维凸包（周长）】
计算几何算法模板。

核心函数：
  int dcmp(LD a) — 核心算法函数
  LD Dot(Vector a,Vector b) — 点积运算
  LD Cro(Vector a,Vector b) — 核心算法函数
  LD Len(Vector a) — 核心算法函数
  LD Angle(Vector a,Vector b) — 核心算法函数
  Vector Normal(Vector a) — 核心算法函数
  bool cmp1(Vector a,Vector b) — 核心算法函数
  bool cmp2(Vector a,Vector b) — 核心算法函数

核心结构体：Point

关键配置：
N=1e4+3

说明：freopen("123.txt","r",stdin);

适用场景：几何对象的交并关系判定、面积/周长计算

```cpp
#include<algorithm>
#include<cstdio>
#include<cmath>
#define LD double
#define Vector Point
#define Re register int
using namespace std;
const int N=1e4+3;
const LD eps=1e-8;
inline int dcmp(LD a){return a<-eps?-1:(a>eps?1:0);}
struct Point{LD x,y;Point(LD X=0,LD Y=0):x(X),y(Y){}}Poi[N],cp[N];
inline LD Dot(Vector a,Vector b){return a.x*b.x+a.y*b.y;}
inline LD Cro(Vector a,Vector b){return a.x*b.y-a.y*b.x;}
inline LD Len(Vector a){return sqrt(Dot(a,a));}
inline LD Angle(Vector a,Vector b){return acos(Dot(a,b)/Len(a)/Len(b));}
inline Vector Normal(Vector a){LD L=Len(a);return Vector(-a.y/L,a.x/L);}
inline Vector operator+(Vector a,Vector b){return Vector(a.x+b.x,a.y+b.y);}
inline Vector operator-(Vector a,Vector b){return Vector(a.x-b.x,a.y-b.y);}
inline Vector operator*(Vector a,LD b){return Vector(a.x*b,a.y*b);}
inline Vector operator/(Vector a,LD b){return Vector(a.x/b,a.y/b);}
inline bool cmp1(Vector a,Vector b){return a.x==b.x?a.y<b.y:a.x<b.x;};
inline bool cmp2(Vector a,Vector b){
	LD pan=Cro(a-Poi[0],b-Poi[0]);
	return pan>0||(pan==0&&Len(a-Poi[0])<Len(b-Poi[0]));
};
inline int ConvexHull(Point *P,Re n,Point *cp){
	sort(P+1,P+n+1,cmp1);
	Re t=0;
	for(Re i=1;i<=n;++i){
		while(t>1&&dcmp(Cro(cp[t]-cp[t-1],P[i]-cp[t-1]))<=0)--t;
		cp[++t]=P[i];
	}
	Re St=t;
	for(Re i=n-1;i>=1;--i){
		while(t>St&&dcmp(Cro(cp[t]-cp[t-1],P[i]-cp[t-1]))<=0)--t;
		cp[++t]=P[i];
	}
	return --t;
}
int n;LD ans;
int main(){
//	freopen("123.txt","r",stdin);
	scanf("%d",&n);
	for(Re i=1;i<=n;++i)scanf("%lf%lf",&Poi[i].x,&Poi[i].y);
	Re cnt=ConvexHull(Poi,n,cp);
	for(Re i=1;i<=cnt;++i)ans+=Len(cp[i<cnt?i+1:1]-cp[i]);
	printf("%.2lf\n",ans);
}

```

**动态凸包** *(Professor's task)*

> 【动态凸包（Professor's task）】
计算几何算法模板。

核心函数：
  void in(Re &x) — 核心算法函数
  void In(无参数) — 核心算法函数
  LL Cro(Vector a,Vector b) — 核心算法函数
  int PIP(Point P) — 核心算法函数
  int judge(IT it) — 判定函数
  void insert(Point P) — 插入元素

核心结构体：Point, ConvexHull

说明：freopen("123.txt","r",stdin);

适用场景：几何对象的交并关系判定、面积/周长计算

```cpp
#include<algorithm>
#include<cstdio>
#include<set>
#define LL long long
#define Vector Point
#define Re register int
#define IT set<Point>::iterator
using namespace std;
const int inf=2e9;
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Point{
    LL x,y;Point(LL X=0,LL Y=0){x=X,y=Y;}
    inline void In(){Re X,Y;in(X),in(Y),x=X,y=Y;}
    inline bool operator<(const Point &O)const{return x!=O.x?x<O.x:y<O.y;}
}P;
inline LL Cro(Vector a,Vector b){return a.x*b.y-a.y*b.x;}
inline Vector operator-(Vector a,Vector b){return Vector(a.x-b.x,a.y-b.y);}
struct ConvexHull{
	int op;set<Point>s;
	inline int PIP(Point P){
		IT it=s.lower_bound(Point(P.x,-inf));
		if(it==s.end())return 0;
		if(it->x==P.x)return (P.y-it->y)*op<=0;
		if(it==s.begin())return 0;
		IT j=it,k=it;--j;return Cro(P-*j,*k-*j)*op>=0;
	}
	inline int judge(IT it){
		IT j=it,k=it;
		if(j==s.begin())return 0;--j;
		if(++k==s.end())return 0;
		return Cro(*it-*j,*k-*j)*op>=0;
	}
	inline void insert(Point P){
		if(PIP(P))return;
		IT tmp=s.lower_bound(Point(P.x,-inf));if(tmp!=s.end()&&tmp->x==P.x)s.erase(tmp);
		s.insert(P);IT it=s.find(P),p=it;
		if(p!=s.begin()){--p;while(judge(p)){IT tmp=p--;s.erase(tmp);}}
		if((p=++it)!=s.end())while(judge(p)){IT tmp=p++;s.erase(tmp);}
	}
}up,down;
int x,y,T,op;
int main(){
//	freopen("123.txt","r",stdin);
	in(T),up.op=1,down.op=-1;
	while(T--){
		in(op),P.In();
		if(op<2)up.insert(P),down.insert(P);
		else puts((up.PIP(P)&&down.PIP(P))?"YES":"NO");
	}
}

```

**圆的面积并** *(optimize)*

> #pragma GCC optimize(3,"Ofast","inline")

```cpp
//#pragma GCC optimize(3,"Ofast","inline")
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<map>
#define LD double
#define LL long long
#define Re register int
#define Rd register LD
#define Vector Point
using namespace std;
const int N=2003;
const LD eps=1e-13;
int n,m;map<LD,LD>vis;
inline int dcmp(Rd a){return a<-eps?-1:(a>eps?1:0);}
struct Point{
    LD x,y;Point(LD X=0,LD Y=0){x=X,y=Y;}
    inline void in(){scanf("%lf%lf",&x,&y);}
};
struct Segment{
    LD L,R;Segment(LD l=0,LD r=0){L=l,R=r;}
    inline bool operator<(Segment O)const{return L!=O.L?L<O.L:R<O.R;}
}Seg[N];
struct Circle{
    LD x,y,r,L,R,D,U;
    inline void in(){scanf("%lf%lf%lf",&x,&y,&r),L=x-r,R=x+r,D=y-r,U=y+r;}
    inline bool operator<(Circle B)const{return D<B.D;}
}C[N],C_[N];
inline bool cmp(Circle A,Circle B){return A.r<B.r;}
inline LD dis(Circle A,Circle B){return sqrt((A.x-B.x)*(A.x-B.x)+(A.y-B.y)*(A.y-B.y));}
inline LD SS(Rd x){return x*x;}
inline LD F(Rd Y){
    if(vis[Y])return vis[Y];
    Re t=0;Rd ans=0;
    for(Re i=1;i<=n;++i)
        if(dcmp(Y-C[i].D)>0&&dcmp(Y-C[i].U)<0){
            Rd tmp=sqrt(SS(C[i].r)-SS(C[i].y-Y));
            if(dcmp(tmp)>0)Seg[++t]=Segment(C[i].x-tmp,C[i].x+tmp);
        }
    if(!t)return 0.0;
    sort(Seg+1,Seg+t+1);
    for(Re i=1,j;i<=t;i=j+1){
        Rd L=Seg[i].L,R=Seg[i].R;j=i;
        while(j<t&&Seg[j+1].L<=R)++j,R=max(R,Seg[j].R);
        ans+=R-L;
    }
    return vis[Y]=ans;
}
inline LD Simpson(Rd L,Rd R){return (R-L)*(F(L)+4.0*F((L+R)*0.5)+F(R))/6.0;}
inline LD sakura(Rd L,Rd R,Rd now){
    Rd mid=(L+R)*0.5,FL=Simpson(L,mid),FR=Simpson(mid,R);
    if(!dcmp(now-FL-FR))return now;
    return sakura(L,mid,FL)+sakura(mid,R,FR);
}
LD ans;
int main(){
//    freopen("789.txt","r",stdin);
    scanf("%d",&m);
    for(Re i=1;i<=m;++i)C_[i].in();
    sort(C_+1,C_+m+1,cmp),C[++n]=C_[m];
    for(Re i=m-1;i>=1;--i){
        Re flag=1;
        for(Re j=1;j<=n&&flag;++j)
			if(dcmp(C_[i].r-C[j].r+dis(C_[i],C[j]))<=0)flag=0;
        if(flag)C[++n]=C_[i];
    }
    sort(C+1,C+n+1);
    for(Re i=1,j;i<=n;i=j+1){
        Rd D=C[i].D,U=C[i].U;j=i;
        while(j<n&&C[j+1].D<=U)++j,U=max(U,C[j].U);
        ans+=sakura(D,U,Simpson(D,U));
    }
    printf("%.3lf",ans);
}

```

**旋转卡壳** *(最远点对距离平方)*

> 【旋转卡壳（最远点对距离平方）】
旋转卡壳（Rotating Calipers）模板，求凸包直径/最远点对。

核心函数：
  int dcmp(Rd a) — 核心算法函数
  void in(无参数) — 核心算法函数
  LD Dot(Vector a,Vector b) — 点积运算
  LD Cro(Vector a,Vector b) — 核心算法函数
  LD Len(Vector a) — 核心算法函数
  bool cmp(Point a,Point b) — 核心算法函数
  int ConvexHull(Point *P,Re n,Point *cp) — 核心算法函数

核心结构体：Point

关键配置：
N=50003

说明：freopen("123.txt","r",stdin);

适用场景：几何对象的交并关系判定、面积/周长计算

```cpp
#include<algorithm>
#include<cstdio>
#include<cmath>
#define LD double
#define LL long long
#define Vector Point
#define Rd register LD
#define Re register int
using namespace std;
const int N=50003;
const LD eps=1e-8;
inline int dcmp(Rd a){return a<-eps?-1:(a>eps?1:0);}
struct Point{
    LD x,y;Point(LD X=0,LD Y=0){x=X,y=Y;}
    inline void in(){scanf("%lf%lf",&x,&y);}
}cp[N],Poi[N];
inline LD Dot(Vector a,Vector b){return a.x*b.x+a.y*b.y;}
inline LD Cro(Vector a,Vector b){return a.x*b.y-a.y*b.x;}
inline LD Len(Vector a){return Dot(a,a);}
inline Vector operator-(Point a,Point b){return Vector(a.x-b.x,a.y-b.y);}
inline bool cmp(Point a,Point b){return a.x!=b.x?a.x<b.x:a.y<b.y;}
inline int ConvexHull(Point *P,Re n,Point *cp){
	sort(P+1,P+n+1,cmp);
	Re t=0;
	for(Re i=1;i<=n;++i){
		while(t>1&&dcmp(Cro(cp[t]-cp[t-1],P[i]-cp[t-1]))<=0)--t;
		cp[++t]=P[i];
	}
	Re St=t;
	for(Re i=n-1;i>=1;--i){
		while(t>St&&dcmp(Cro(cp[t]-cp[t-1],P[i]-cp[t-1]))<=0)--t;
		cp[++t]=P[i];
	}
	return --t;
}
int n;
int main(){
//	freopen("123.txt","r",stdin);
	scanf("%d",&n);
	for(Re i=1;i<=n;++i)Poi[i].in();
	Re cnt=ConvexHull(Poi,n,cp);
	Rd Ans=Len(cp[2]-cp[1]);
	for(Re i=1,j=3;i<=cnt;++i){
		while(dcmp(Cro(cp[i+1]-cp[i],cp[j]-cp[i])-Cro(cp[i+1]-cp[i],cp[j+1]-cp[i]))<0)j=j<cnt?j+1:1;
		Ans=max(Ans,max(Len(cp[j]-cp[i]),Len(cp[j]-cp[i+1])));
	}
	printf("%lld\n",(LL)(Ans+0.5));
}

```

**最小圆覆盖** *(随机增量法)*

> 【最小圆覆盖（随机增量法）】
计算几何算法模板。

核心函数：
  int dcmp(LD a) — 核心算法函数
  void in(无参数) — 核心算法函数
  LD Dot(Vector a,Vector b) — 点积运算
  LD Len(Vector a) — 核心算法函数
  Circle getcircle(Point A,Point B,Point C) — 获取值
  int PIC(Circle &C,Point a) — 核心算法函数
  void Random(无参数) — 核心算法函数

核心结构体：Point, Circle

关键配置：
N=1e6+3

说明：freopen("123.txt","r",stdin);；random_shuffle(P+1,P+n+1);

适用场景：几何对象的交并关系判定、面积/周长计算

```cpp
#include<algorithm>
#include<cstdio>
#include<cmath>
#define LD double
#define LL long long
#define Vector Point
#define Re register int
#define S(a) ((a)*(a))
using namespace std;
const int N=1e6+3;
const LD eps=1e-8;
inline int dcmp(LD a){return a<-eps?-1:(a>eps?1:0);}// 撤销操作
int n;
struct Point{
    LD x,y;Point(LD X=0,LD Y=0){x=X,y=Y;}
    inline void in(){scanf("%lf%lf",&x,&y);}
}P[N];
inline LD Dot(Vector a,Vector b){return a.x*b.x+a.y*b.y;}
inline LD Len(Vector a){return sqrt(Dot(a,a));}
inline Vector operator+(Vector a,Vector b){return Vector(a.x+b.x,a.y+b.y);}
inline Vector operator-(Vector a,Vector b){return Vector(a.x-b.x,a.y-b.y);}
inline Vector operator*(Vector a,LD b){return Vector(a.x*b,a.y*b);}
struct Circle{Point O;LD r;Circle(Point P,LD R=0){O=P,r=R;}};
inline Circle getcircle(Point A,Point B,Point C){
	LD x1=A.x,y1=A.y,x2=B.x,y2=B.y,x3=C.x,y3=C.y;
	LD D=((S(x2)+S(y2)-S(x3)-S(y3))*(y1-y2)-(S(x1)+S(y1)-S(x2)-S(y2))*(y2-y3))/((x1-x2)*(y2-y3)-(x2-x3)*(y1-y2));
	LD E=(S(x1)+S(y1)-S(x2)-S(y2)+D*(x1-x2))/(y2-y1);
	LD F=-(S(x1)+S(y1)+D*x1+E*y1);
	return Circle(Point(-D/2.0,-E/2.0),sqrt((S(D)+S(E)-4.0*F)/4.0));
}
inline int PIC(Circle &C,Point a){return dcmp(Len(a-C.O)-C.r)<=0;}
inline void Random(){for(Re i=1;i<=n;++i)swap(P[i],P[rand()%n+1]);}
int main(){
//	freopen("123.txt","r",stdin);
	scanf("%d",&n);
	for(Re i=1;i<=n;++i)P[i].in();
//	random_shuffle(P+1,P+n+1);
	Random();Circle C=Circle(P[1],0);
	for(Re i=2;i<=n;++i)
		if(!PIC(C,P[i])){
			C=Circle(P[i],0);
			for(Re j=1;j<i;++j)
				if(!PIC(C,P[j])){
					C.O=(P[i]+P[j])*0.5,C.r=Len(P[j]-C.O);
					for(Re k=1;k<j;++k)if(!PIC(C,P[k]))C=getcircle(P[i],P[j],P[k]);
				}
		}
	printf("%.2lf %.2lf %.2lf\n",C.O.x,C.O.y,C.r);
}

```

**自适应辛普森积分** *(全局精度)*

> 【自适应辛普森积分（全局精度）】
计算几何算法模板。

核心函数：
  int dcmp(LD a) — 核心算法函数
  LD F(LD x) — 核心算法函数
  LD Simpson(LD L,LD R) — 核心算法函数
  LD sakura(LD L,LD R,LD now) — 后缀数组

说明：freopen("123.txt","r",stdin);

适用场景：几何对象的交并关系判定、面积/周长计算

```cpp
#include<algorithm>
#include<cstdio>
#include<cmath>
#define LD double
#define LL long long
#define Re register int
#define Vector Point
using namespace std;
const LD eps=1e-13;
inline int dcmp(LD a){return a<-eps?-1:(a>eps?1:0);}
LD a,b,c,d,L,R;
inline LD F(LD x){return (c*x+d)/(a*x+b);}
inline LD Simpson(LD L,LD R){return (R-L)*(F(L)+4.0*F((L+R)*0.5)+F(R))/6.0;}
inline LD sakura(LD L,LD R,LD now){
	LD mid=(L+R)*0.5,FL=Simpson(L,mid),FR=Simpson(mid,R);
	if(!dcmp(now-FL-FR))return now;
	return sakura(L,mid,FL)+sakura(mid,R,FR);
}
int main(){
//	freopen("123.txt","r",stdin);
	scanf("%lf%lf%lf%lf%lf%lf",&a,&b,&c,&d,&L,&R);
	printf("%lf\n",sakura(L,R,Simpson(L,R)));
}

```

**自适应辛普森积分** *(局部精度)*

> 【自适应辛普森积分（局部精度）】
计算几何算法模板。

核心函数：
  int dcmp(LD a,LD eps) — 核心算法函数
  LD F(LD x) — 核心算法函数
  LD Simpson(LD L,LD R) — 核心算法函数
  LD sakura(LD L,LD R,LD now,LD eps) — 后缀数组

说明：freopen("123.txt","r",stdin);

适用场景：几何对象的交并关系判定、面积/周长计算

```cpp
#include<algorithm>
#include<cstdio>
#include<cmath>
#define LD double
#define LL long long
#define Re register int
#define Vector Point
using namespace std;
const LD eps=1e-7;
inline int dcmp(LD a,LD eps){return a<-eps?-1:(a>eps?1:0);}
LD a,b,c,d,L,R;
inline LD F(LD x){return (c*x+d)/(a*x+b);}
inline LD Simpson(LD L,LD R){return (R-L)*(F(L)+4.0*F((L+R)*0.5)+F(R))/6.0;}
inline LD sakura(LD L,LD R,LD now,LD eps){
	LD mid=(L+R)*0.5,FL=Simpson(L,mid),FR=Simpson(mid,R);
	if(!dcmp(now-FL-FR,eps))return now;
	return sakura(L,mid,FL,eps/2)+sakura(mid,R,FR,eps/2);
}
int main(){
//	freopen("123.txt","r",stdin);
	scanf("%lf%lf%lf%lf%lf%lf",&a,&b,&c,&d,&L,&R);
	printf("%lf\n",sakura(L,R,Simpson(L,R),eps));
}

```

**计算几何基础** *(全家桶)*

> 【计算几何基础（全家桶）】
计算几何算法模板。

核心函数：
  int dcmp(LD a) — 核心算法函数
  LD Abs(LD a) — 核心算法函数
  void in(无参数) — 核心算法函数
  void out(无参数) — 核心算法函数
  LD Dot(Vector a,Vector b) — 点积运算
  LD Cro(Vector a,Vector b) — 核心算法函数
  LD Len(Vector a) — 核心算法函数
  LD Angle(Vector a,Vector b) — 核心算法函数

核心结构体：Point, Line, Circle

关键配置：
N=262144+3

说明：PA,AB������P��AB֮��(��ʵҲ������len(p-a)+len(p-b)==len(a-b)�жϣ����Ǿ�����ʧ�ϴ�)；�㰴��ʱ�����；random_shuffle(P+1,P+n+1);

适用场景：几何对象的交并关系判定、面积/周长计算

```cpp
#include<algorithm>
#include<cstdio>
#include<cmath>


#define LD double
#define LL long long
#define Re register int
#define Vector Point
using namespace std;
const int N=262144+3;
const LD eps=1e-8,Pi=acos(-1.0);
inline int dcmp(LD a){return a<-eps?-1:(a>eps?1:0);}// 撤销操作
inline LD Abs(LD a){return a*dcmp(a);}
struct Point{
    LD x,y;Point(LD X=0,LD Y=0){x=X,y=Y;}
    inline void in(){scanf("%lf%lf",&x,&y);}
    inline void out(){printf("%.2lf %.2lf\n",x,y);}
};


inline LD Dot(Vector a,Vector b){return a.x*b.x+a.y*b.y;}
inline LD Cro(Vector a,Vector b){return a.x*b.y-a.y*b.x;}
inline LD Len(Vector a){return sqrt(Dot(a,a));}
inline LD Angle(Vector a,Vector b){return acos(Dot(a,b)/Len(a)/Len(b));}// 撤销操作�нǡ�
inline Vector Normal(Vector a){return Vector(-a.y,a.x);}
inline Vector operator+(Vector a,Vector b){return Vector(a.x+b.x,a.y+b.y);}
inline Vector operator-(Vector a,Vector b){return Vector(a.x-b.x,a.y-b.y);}
inline Vector operator*(Vector a,LD b){return Vector(a.x*b,a.y*b);}
inline bool operator==(Point a,Point b){return !dcmp(a.x-b.x)&&!dcmp(a.y-b.y);}



inline Point turn_P(Point a,LD theta){
    LD x=a.x*cos(theta)+a.y*sin(theta);
    LD y=-a.x*sin(theta)+a.y*cos(theta);
    return Point(x,y);
}
inline Point turn_PP(Point a,Point b,LD theta){
    LD x=(a.x-b.x)*cos(theta)+(a.y-b.y)*sin(theta)+b.x;
    LD y=-(a.x-b.x)*sin(theta)+(a.y-b.y)*cos(theta)+b.y;
    return Point(x,y);
}



inline int pan_PL(Point p,Point a,Point b){
    return !dcmp(Cro(p-a,b-a))&&dcmp(Dot(p-a,p-b))<=0;
}
inline LD dis_PL(Point p,Point a,Point b){
    if(a==b)return Len(p-a);//AB�غ�
    Vector x=p-a,y=p-b,z=b-a;
    if(dcmp(Dot(x,z))<0)return Len(x);
    if(dcmp(Dot(y,z))>0)return Len(y);
    return Abs(Cro(x,z)/Len(z));
}

inline int pan_PL_(Point p,Point a,Point b){
    return !dcmp(Cro(p-a,b-a));
}
inline Point FootPoint(Point p,Point a,Point b){
    Vector x=p-a,y=p-b,z=b-a;
    LD len1=Dot(x,z)/Len(z),len2=-1.0*Dot(y,z)/Len(z);
    return a+z*(len1/(len1+len2));
}
inline Point Symmetry_PL(Point p,Point a,Point b){
    return p+(FootPoint(p,a,b)-p)*2;
}

inline Point cross_LL(Point a,Point b,Point c,Point d){
    Vector x=b-a,y=d-c,z=a-c;
    return a+x*(Cro(y,z)/Cro(x,y));
}
inline int pan_cross_L_L(Point a,Point b,Point c,Point d){
    return pan_PL(cross_LL(a,b,c,d),c,d);
}
inline int pan_cross_LL(Point a,Point b,Point c,Point d){
    LD c1=Cro(b-a,c-a),c2=Cro(b-a,d-a);
    LD d1=Cro(d-c,a-c),d2=Cro(d-c,b-c);
    return dcmp(c1)*dcmp(c2)<0&&dcmp(d1)*dcmp(d2)<0;
}

inline int PIP(Point *P,Re n,Point a){
    Re cnt=0;LD tmp;
    for(Re i=1;i<=n;++i){
        Re j=i<n?i+1:1;
        if(pan_PL(a,P[i],P[j]))return 2;
        if(a.y>=min(P[i].y,P[j].y)&&a.y<max(P[i].y,P[j].y))
            tmp=P[i].x+(a.y-P[i].y)/(P[j].y-P[i].y)*(P[j].x-P[i].x),cnt+=dcmp(tmp-a.x)>0;
    }
    return cnt&1;
}
inline int judge(Point a,Point L,Point R){
    return dcmp(Cro(L-a,R-a))>0;
}
inline int PIP_(Point *P,Re n,Point a){
    if(judge(P[1],a,P[2])||judge(P[1],P[n],a))return 0;
    if(pan_PL(a,P[1],P[2])||pan_PL(a,P[1],P[n]))return 2;
    Re l=2,r=n-1;
    while(l<r){
        Re mid=l+r+1>>1;
        if(judge(P[1],P[mid],a))l=mid;
        else r=mid-1;
    }
    if(judge(P[l],a,P[l+1]))return 0;
    if(pan_PL(a,P[l],P[l+1]))return 2;
    return 1;
}


inline int judge_PP(Point *A,Re n,Point *B,Re m){
    for(Re i1=1;i1<=n;++i1){
        Re j1=i1<n?i1+1:1;
        for(Re i2=1;i2<=m;++i2){
            Re j2=i2<m?i2+1:1;
            if(pan_cross_LL(A[i1],A[j1],B[i2],B[j2]))return 0;
            if(PIP(B,m,A[i1])||PIP(A,n,B[i2]))return 0;// 撤销操作�
        }
    }
    return 1;
}



inline LD PolyArea(Point *P,Re n){
    LD S=0;
    for(Re i=1;i<=n;++i)S+=Cro(P[i],P[i<n?i+1:1]);
    return S/2.0;
}





inline bool cmp1(Vector a,Vector b){return a.x==b.x?a.y<b.y:a.x<b.x;};
inline int ConvexHull(Point *P,Re n,Point *cp){
    sort(P+1,P+n+1,cmp1);
    Re t=0;
    for(Re i=1;i<=n;++i){
        while(t>1&&dcmp(Cro(cp[t]-cp[t-1],P[i]-cp[t-1]))<=0)--t;
        cp[++t]=P[i];
    }
    Re St=t;
    for(Re i=n-1;i>=1;--i){
        while(t>St&&dcmp(Cro(cp[t]-cp[t-1],P[i]-cp[t-1]))<=0)--t;
        cp[++t]=P[i];
    }
    return --t;
}

struct Line{
    Point a,b;LD k;Line(Point A=Point(0,0),Point B=Point(0,0)){a=A,b=B,k=atan2(b.y-a.y,b.x-a.x);}
    inline bool operator<(const Line &O)const{return dcmp(k-O.k)?dcmp(k-O.k)<0:judge(O.a,O.b,a);}
}L[N],Q[N];
inline Point cross(Line L1,Line L2){return cross_LL(L1.a,L1.b,L2.a,L2.b);}
inline int judge(Line L,Point a){return dcmp(Cro(a-L.a,L.b-L.a))>0;}
inline int halfcut(Line *L,Re n,Point *P){
    sort(L+1,L+n+1);Re m=n;n=0;
    for(Re i=1;i<=m;++i)if(i==1||dcmp(L[i].k-L[i-1].k))L[++n]=L[i];
    Re h=1,t=0;
    for(Re i=1;i<=n;++i){
        while(h<t&&judge(L[i],cross(Q[t],Q[t-1])))--t;
        while(h<t&&judge(L[i],cross(Q[h],Q[h+1])))++h;
        Q[++t]=L[i];
    }
    while(h<t&&judge(Q[h],cross(Q[t],Q[t-1])))--t;
    while(h<t&&judge(Q[t],cross(Q[h],Q[h+1])))++h;
    n=0;
    for(Re i=h;i<=t;++i)P[++n]=cross(Q[i],Q[i<t?i+1:h]);
    return n;
}

Vector V1[N],V2[N];
inline int Mincowski(Point *P1,Re n,Point *P2,Re m,Vector *V){
    for(Re i=1;i<=n;++i)V1[i]=P1[i<n?i+1:1]-P1[i];
    for(Re i=1;i<=m;++i)V2[i]=P2[i<m?i+1:1]-P2[i];
    Re t=0,i=1,j=1;V[++t]=P1[1]+P2[1];
    while(i<=n&&j<=m)++t,V[t]=V[t-1]+(dcmp(Cro(V1[i],V2[j]))>0?V1[i++]:V2[j++]);
    while(i<=n)++t,V[t]=V[t-1]+V1[i++];
    while(j<=m)++t,V[t]=V[t-1]+V2[j++];
    return t;
}



#define S(a) ((a)*(a))
struct Circle{Point O;LD r;Circle(Point P,LD R=0){O=P,r=R;}};
inline Circle getCircle(Point A,Point B,Point C){
    LD x1=A.x,y1=A.y,x2=B.x,y2=B.y,x3=C.x,y3=C.y;
    LD D=((S(x2)+S(y2)-S(x3)-S(y3))*(y1-y2)-(S(x1)+S(y1)-S(x2)-S(y2))*(y2-y3))/((x1-x2)*(y2-y3)-(x2-x3)*(y1-y2));
    LD E=(S(x1)+S(y1)-S(x2)-S(y2)+D*(x1-x2))/(y2-y1);
    LD F=-(S(x1)+S(y1)+D*x1+E*y1);
    return Circle(Point(-D/2.0,-E/2.0),sqrt((S(D)+S(E)-4.0*F)/4.0));
}
inline Circle getcircle(Point A,Point B,Point C){
    Point P1=(A+B)*0.5,P2=(A+C)*0.5;
    Point O=cross_LL(P1,P1+Normal(B-A),P2,P2+Normal(C-A));
    return Circle(O,Len(A-O));
}

inline int PIC(Circle C,Point a){return dcmp(Len(a-C.O)-C.r)<=0;}
inline void Random(Point *P,Re n){for(Re i=1;i<=n;++i)swap(P[i],P[rand()%n+1]);}
inline Circle Min_Circle(Point *P,Re n){
//  random_shuffle(P+1,P+n+1);
    Random(P,n);Circle C=Circle(P[1],0);
    for(Re i=2;i<=n;++i)if(!PIC(C,P[i])){
        C=Circle(P[i],0);
        for(Re j=1;j<i;++j)if(!PIC(C,P[j])){
            C.O=(P[i]+P[j])*0.5,C.r=Len(P[j]-C.O);
            for(Re k=1;k<j;++k)if(!PIC(C,P[k]))C=getcircle(P[i],P[j],P[k]);
        }
    }
    return C;
}

inline LD calc(Point A,Point B,Point O,LD R){
    if(A==O||B==O)return 0;
    Re op=dcmp(Cro(A-O,B-O))>0?1:-1;LD ans=0;
    Vector x=A-O,y=B-O;
    Re flag1=dcmp(Len(x)-R)>0,flag2=dcmp(Len(y)-R)>0;
    if(!flag1&&!flag2)ans=Abs(Cro(A-O,B-O))/2.0;
    else if(flag1&&flag2){
        if(dcmp(dis_PL(O,A,B)-R)>=0)ans=R*R*Angle(x,y)/2.0;
        else{
            if(dcmp(Cro(A-O,B-O))>0)swap(A,B);
            Point F=FootPoint(O,A,B);LD lenx=Len(F-O),len=sqrt(R*R-lenx*lenx);
            Vector z=turn_P(F-O,Pi/2.0)*(len/lenx);Point B_=F+z,A_=F-z;
            ans=R*R*(Angle(A-O,A_-O)+Angle(B-O,B_-O))/2.0+Cro(B_-O,A_-O)/2.0;
        }
    }
    else{
        if(flag1)swap(A,B);
        Point F=FootPoint(O,A,B);LD lenx=Len(F-O),len=sqrt(R*R-lenx*lenx);
        Vector z=turn_P(F-O,Pi/2.0)*(len/lenx);Point C=dcmp(Cro(A-O,B-O))>0?F-z:F+z;
        ans=Abs(Cro(A-O,C-O))/2.0+R*R*Angle(C-O,B-O)/2.0;
    }
    return ans*op;
}

int main(){}

```

**闵可夫斯基和** *(战争)*

> 【闵可夫斯基和（战争）】
计算几何算法模板。

核心函数：
  int dcmp(LD a) — 核心算法函数
  void in(Re &x) — 核心算法函数
  void in(无参数) — 核心算法函数
  void print(Re op=0) — 核心算法函数
  LD Dot(Vector a,Vector b) — 点积运算
  LD Cro(Vector a,Vector b) — 核心算法函数
  LD Len(Vector a) — 核心算法函数
  bool cmp1(Vector a,Vector b) — 核心算法函数

核心结构体：Point

关键配置：
N=1e5+3,inf=1e8

说明：freopen("123.txt","r",stdin);

适用场景：几何对象的交并关系判定、面积/周长计算

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#define LD double
#define LL long long
#define Vector Point
#define Re register int
using namespace std;
const int N=1e5+3,inf=1e8;
const LD eps=1e-8;
inline int dcmp(LD a){return a<-eps?-1:(a>eps?1:0);}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Point{
	LD x,y;LD k;Point(LD X=0,LD Y=0){x=X,y=Y;}
	inline void in(){scanf("%lf%lf",&x,&y);}
	inline void print(Re op=0){printf("(%.2lf %.2lf) ",x,y);if(op)puts("");}
};
inline LD Dot(Vector a,Vector b){return a.x*b.x+a.y*b.y;}
inline LD Cro(Vector a,Vector b){return a.x*b.y-a.y*b.x;}
inline LD Len(Vector a){return sqrt(Dot(a,a));}
inline Vector operator+(Vector a,Vector b){return Vector(a.x+b.x,a.y+b.y);}
inline Vector operator-(Vector a,Vector b){return Vector(a.x-b.x,a.y-b.y);}
inline Vector operator*(Vector a,LD b){return Vector(a.x*b,a.y*b);}
inline bool cmp1(Vector a,Vector b){return a.x==b.x?a.y<b.y:a.x<b.x;};
inline int ConvexHull(Point *P,Re n,Point *cp){
    sort(P+1,P+n+1,cmp1);
    Re t=0;
    for(Re i=1;i<=n;++i){
        while(t>1&&dcmp(Cro(cp[t]-cp[t-1],P[i]-cp[t-1]))<=0)--t;
        cp[++t]=P[i];
    }
    Re St=t;
    for(Re i=n-1;i>=1;--i){
        while(t>St&&dcmp(Cro(cp[t]-cp[t-1],P[i]-cp[t-1]))<=0)--t;
        cp[++t]=P[i];
    }
    return --t;
}
inline int judge(Point a,Point L,Point R){
	return dcmp(Cro(L-a,R-a))>0;
}
inline int PIL(Point a,Point b,Point p){
	return !dcmp(Cro(p-a,b-a))&&dcmp(Cro(p-a,p-b))<0;
}
inline int PIP(Point *P,Re n,Point a){
	if(judge(P[1],a,P[2])||judge(P[1],P[n],a))return 0;
	if(PIL(P[1],P[2],a)||PIL(P[1],P[n],a))return 1;
	Re l=2,r=n-1;
	while(l<r){
		Re mid=l+r+1>>1;
		if(judge(P[1],P[mid],a))l=mid;
		else r=mid-1;
	}
	if(judge(P[l],a,P[l+1]))return 0;
	if(PIL(P[l],P[l+1],a))return 1;
	return 1;
}
Vector V1[N],V2[N];
inline int Mincowski(Point *P1,Re n,Point *P2,Re m,Vector *V){
	for(Re i=1;i<=n;++i)V1[i]=P1[i<n?i+1:1]-P1[i];
	for(Re i=1;i<=m;++i)V2[i]=P2[i<m?i+1:1]-P2[i];
	Re t=0,i=1,j=1;V[++t]=P1[1]+P2[1];
	while(i<=n&&j<=m)++t,V[t]=V[t-1]+(dcmp(Cro(V1[i],V2[j]))>0?V1[i++]:V2[j++]);
	while(i<=n)++t,V[t]=V[t-1]+V1[i++];
	while(j<=m)++t,V[t]=V[t-1]+V2[j++];
	return t;
}
int n,m,T;Point v,P1[N],P2[N],cp1[N],cp2[N];Vector V[N<<1];
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(m),in(T);
	for(Re i=1;i<=n;++i)P1[i].in();
	for(Re i=1;i<=m;++i)P2[i].in(),P2[i].x=-P2[i].x,P2[i].y=-P2[i].y;
	Re cnt1=ConvexHull(P1,n,cp1),cnt2=ConvexHull(P2,m,cp2);
	Re cnt=Mincowski(cp1,cnt1,cp2,cnt2,V); 
	while(T--)v.in(),printf("%d\n",PIP(V,cnt,v));
}

```

**小凸爱跑步** *(直线不等式转半平面交)*

> 【小凸爱跑步（直线不等式转半平面交）】
计算几何算法模板。

核心函数：
  int dcmp(LD a) — 核心算法函数
  void in(Re &x) — 核心算法函数
  void in(无参数) — 核心算法函数
  LD Dot(Vector a,Vector b) — 点积运算
  LD Cro(Vector a,Vector b) — 核心算法函数
  int judge(Point a,Point L,Point R) — 判定函数
  Point cross(Point a,Point b,Point c,Point d) — 叉积运算
  LD PolyArea(Point *P,Re n) — 核心算法函数

核心结构体：Point, Line

关键配置：
N=1e5+3,inf=2e9

说明：freopen("123.txt","r",stdin);

适用场景：几何对象的交并关系判定、面积/周长计算

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#define LD double
#define LL long long
#define Vector Point
#define Re register int
using namespace std;
const int N=1e5+3,inf=2e9;
const LD eps=1e-8;
inline int dcmp(LD a){return a<-eps?-1:(a>eps?1:0);}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Point{
    LD x,y;Point(LD X=0,LD Y=0){x=X,y=Y;}
    inline void in(){scanf("%lf%lf",&x,&y);}
};
inline LD Dot(Vector a,Vector b){return a.x*b.x+a.y*b.y;}
inline LD Cro(Vector a,Vector b){return a.x*b.y-a.y*b.x;}
inline Vector operator+(Vector a,Vector b){return Vector(a.x+b.x,a.y+b.y);}
inline Vector operator-(Vector a,Vector b){return Vector(a.x-b.x,a.y-b.y);}
inline Vector operator*(Vector a,LD b){return Vector(a.x*b,a.y*b);}
inline int judge(Point a,Point L,Point R){
    return dcmp(Cro(L-a,R-a))>0;
}
inline Point cross(Point a,Point b,Point c,Point d){
    Vector x=b-a,y=d-c,z=a-c;
    return a+x*(Cro(y,z)/Cro(x,y));
}
inline LD PolyArea(Point *P,Re n){
    LD ans=0;
    for(Re i=1;i<=n;++i)ans+=Cro(P[i],P[i<n?i+1:1]);
    return ans/2.0;
}
struct Line{
    Point a,b;LD k;Line(Point A=Point(0,0),Point B=Point(0,0)){a=A,b=B,k=atan2(b.y-a.y,b.x-a.x);}
    inline bool operator<(const Line &O)const{return dcmp(k-O.k)?dcmp(k-O.k)<0:judge(O.a,O.b,b);}
}Q[N<<1];
inline int judge(Point a,Line L){return dcmp(Cro(a-L.a,L.b-L.a))>0;}
inline Point cross(Line L1,Line L2){return cross(L1.a,L1.b,L2.a,L2.b);}
inline int halfcut(Line *L,Re n,Point *P){
    sort(L+1,L+n+1);Re m=0;
    for(Re i=1;i<=n;++i)if(i==1||dcmp(L[i].k-L[i-1].k))L[++m]=L[i];
    Re h=1,t=0;
    for(Re i=1;i<=m;++i){
        while(h<t&&judge(cross(Q[t],Q[t-1]),L[i]))--t;
        while(h<t&&judge(cross(Q[h],Q[h+1]),L[i]))++h;
        Q[++t]=L[i];
    }
    while(h<t&&judge(cross(Q[t],Q[t-1]),Q[h]))--t;
    while(h<t&&judge(cross(Q[h],Q[h+1]),Q[t]))++h;
    m=0;
    for(Re i=h;i<=t;++i)P[++m]=cross(Q[i],Q[i<t?i+1:h]);
    return m;
}
int n,m;Point P[N],PP[N<<1];Line L[N<<1];
int main(){
//    freopen("123.txt","r",stdin);
    in(n);
    for(Re i=1;i<=n;++i)P[i].in();P[n+1]=P[1];
    for(Re i=2;i<=n;++i){
        Point tmp=P[1]-P[2]-P[i]+P[i+1];
        LD a=tmp.y,b=-tmp.x,c=Cro(P[1],P[2])-Cro(P[i],P[i+1]);//ax+by+c<=0
        if(!dcmp(a)&&!dcmp(b)){
            if(dcmp(c)<=0)continue;
            else{puts("0");return 0;}
        }
        if(!dcmp(a)){//by+c<=0
            if(b>0)L[++m]=Line(Point(1,-c/b),Point(0,-c/b));//y<=-c/b
            else L[++m]=Line(Point(0,-c/b),Point(1,-c/b));//y>=-c/b
        }
        else if(!dcmp(b)){//ax+c<=0
            if(a>0)L[++m]=Line(Point(-c/a,0),Point(-c/a,1));//x<=-c/a
            else L[++m]=Line(Point(-c/a,1),Point(-c/a,0));//x>=-c/a
        }
        else if(b>0)L[++m]=Line(Point(1,-a/b-c/b),Point(0,-c/b));//y<=-a/b*x-c/b
        else L[++m]=Line(Point(0,-c/b),Point(1,-a/b-c/b));//y>=-a/b*x-c/b
    }
    for(Re i=1;i<=n;++i)L[++m]=Line(P[i],P[i+1]);
    Re cnt=halfcut(L,m,PP);
    printf("%.4lf\n",PolyArea(PP,cnt)/PolyArea(P,n));
}

```

**逃考** *(半平面交求点管辖区域)*

> 【逃考（半平面交求点管辖区域）】
计算几何算法模板。

核心函数：
  int dcmp(LD a) — 核心算法函数
  void in(无参数) — 核心算法函数
  void print(无参数) — 核心算法函数
  LD Dot(Vector a,Vector b) — 点积运算
  LD Cro(Vector a,Vector b) — 核心算法函数
  LD Len(Vector a) — 核心算法函数
  Point cross(Point a,Point b,Point c,Point d) — 叉积运算
  int judge(Point a,Point L,Point R) — 判定函数

核心结构体：Point, Line, Dijkstra, QAQ, QWQ

关键配置：
N=610

说明：freopen("456.txt","r",stdin);；printf("st=%d\n",st);

适用场景：几何对象的交并关系判定、面积/周长计算

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<queue>
#define LD double
#define LL long long
#define Vector Point
#define Re register int
using namespace std;
const int N=610;
const LD eps=1e-8,Pi=acos(-1);
inline int dcmp(LD a){return a<-eps?-1:(a>eps?1:0);}
struct Point{
	LD x,y;Point(LD X=0,LD Y=0){x=X,y=Y;}
	inline void in(){scanf("%lf%lf",&x,&y);}
	inline void print(){printf("%.2lf %.2lf\n",x,y);}
}P[N];
inline LD Dot(Vector a,Vector b){return a.x*b.x+a.y*b.y;}
inline LD Cro(Vector a,Vector b){return a.x*b.y-a.y*b.x;}
inline LD Len(Vector a){return Dot(a,a);}
inline Vector operator+(Vector a,Vector b){return Vector(a.x+b.x,a.y+b.y);}
inline Vector operator-(Vector a,Vector b){return Vector(a.x-b.x,a.y-b.y);}
inline Vector operator*(Vector a,LD x){return Vector(a.x*x,a.y*x);}
inline Point cross(Point a,Point b,Point c,Point d){
	Vector x=b-a,y=d-c,z=a-c;
	return a+x*(Cro(y,z)/Cro(x,y));
}
inline int judge(Point a,Point L,Point R){
	return dcmp(Cro(L-a,R-a))>0;
}
struct Line{
	Point a,b;LD k;int id;Line(Point A=Point(0,0),Point B=Point(0,0)){id=0,a=A,b=B,k=atan2(b.y-a.y,b.x-a.x);}
	inline bool operator<(const Line &O)const{return dcmp(k-O.k)?dcmp(k-O.k)<0:judge(O.a,O.b,b);}
}Q[N];
inline Point cross(Line L1,Line L2){return cross(L1.a,L1.b,L2.a,L2.b);}
inline int judge(Line L,Point a){return dcmp(Cro(a-L.a,L.b-L.a))>0;}
inline void halfcut(Line *L,Re &n){
	sort(L+1,L+n+1);Re m=n;n=0;
	for(Re i=1;i<=m;++i)if(i==1||dcmp(L[i].k-L[i-1].k))L[++n]=L[i];
	Re h=1,t=0;
	for(Re i=1;i<=n;++i){
		while(h<t&&judge(L[i],cross(Q[t],Q[t-1])))--t;
		while(h<t&&judge(L[i],cross(Q[h],Q[h+1])))++h;
		Q[++t]=L[i];
	}
	while(h<t&&judge(Q[h],cross(Q[t],Q[t-1])))--t;
	while(h<t&&judge(Q[t],cross(Q[h],Q[h+1])))++h;
	n=0;
	for(Re i=h;i<=t;++i)L[++n]=Q[i];
}
inline Point turnP(Point a,LD theta){
	LD x=a.x*cos(theta)+a.y*sin(theta);
	LD y=a.y*cos(theta)-a.x*sin(theta);
	return Point(x,y);
}
inline Line get_midL(Point a,Point b){
	Point M=a+((b-a)*0.5);
	return Line(M,M+turnP(a-b,Pi/2.0));
}
int n,m,T,st,ed;Point a,b,c,d,x0,A[N];Line L[N];
struct Dijkstra{
	int o,dis[N],pan[N],head[N];
	struct QAQ{int w,to,next;}a[N*N];
	inline void add(Re x,Re y,Re z){a[++o].w=z,a[o].to=y,a[o].next=head[x],head[x]=o;}
	struct QWQ{int x,d;inline bool operator<(const QWQ &O)const{return d>O.d;}};
	priority_queue<QWQ>Q;
	inline void CL(){memset(head,0,sizeof(head)),o=0;}
	inline int dijkstra(Re st,Re ed){
		for(Re i=0;i<=n;++i)dis[i]=2e9,pan[i]=0;
		Q.push((QWQ){st,dis[st]=1});
		while(!Q.empty()){
			Re x=Q.top().x;Q.pop();
			if(pan[x])continue;
			pan[x]=1;
			for(Re i=head[x],to;i;i=a[i].next)
				if(dis[to=a[i].to]>dis[x]+a[i].w)
					Q.push((QWQ){to,dis[to]=dis[x]+a[i].w});
		}
		return dis[ed];
	}
}T1;
int main(){
//	freopen("456.txt","r",stdin);
	scanf("%d",&T);
	while(T--){
		scanf("%d",&n),c.in(),x0.in(),T1.CL();
		if(!n){puts("0");continue;}
		a=Point(0,0),b=Point(c.x,0),d=Point(0,c.y);
		for(Re i=1;i<=n;++i){
			A[i].in();
			if(A[i].x>c.x||A[i].y>c.y){--i,--n;continue;}
			if(dcmp(Len(A[i]-x0)-Len(A[st]-x0))<0)st=i;
		}
//		printf("st=%d\n",st);
		for(Re i=1;i<=n;++i){
			Re m=0;
			for(Re j=1;j<=n;++j)
				if(i!=j)L[++m]=get_midL(A[i],A[j]),L[m].id=j;
			L[++m]=Line(a,b),L[++m]=Line(b,c),L[++m]=Line(c,d),L[++m]=Line(d,a);
			halfcut(L,m);
			for(Re j=1;j<=m;++j)T1.add(i,L[j].id,L[j].id>0);
		}
		printf("%d\n",T1.dijkstra(st,ed));
	}
}

```

**防线修建** *(动态凸包 维护周长)*

> 【防线修建（动态凸包 维护周长）】
计算几何算法模板。

核心函数：
  int dcmp(LD a) — 核心算法函数
  LD Abs(LD a) — 核心算法函数
  void in(Re &x) — 核心算法函数
  void In(无参数) — 核心算法函数
  LL Dot(Vector a,Vector b) — 点积运算
  LL Cro(Vector a,Vector b) — 核心算法函数
  LD Len(Vector a) — 核心算法函数
  int which(Re p) — 核心算法函数

核心结构体：Point, Splay, QAQ, ConvexHull

关键配置：
N=1e5+3

说明：freopen("123.txt","r",stdin);

适用场景：几何对象的交并关系判定、面积/周长计算

```cpp
#include<algorithm>
#include<cstdio>
#include<queue>
#include<cmath>
#include<set>
#define LD double
#define LL long long
#define Vector Point
#define Re register int
using namespace std;
const int N=1e5+3;
const LD eps=1e-8,Pi=acos(-1.0);
inline int dcmp(LD a){return a<-eps?-1:(a>eps?1:0);}
inline LD Abs(LD a){return a*dcmp(a);}
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Point{
    LL x,y;Point(LL X=0,LL Y=0){x=X,y=Y;}
    inline void In(){Re X,Y;in(X),in(Y),x=X,y=Y;}
    inline bool operator<(const Point &O)const{return x!=O.x?x<O.x:y<O.y;}
};
inline LL Dot(Vector a,Vector b){return a.x*b.x+a.y*b.y;}
inline LL Cro(Vector a,Vector b){return a.x*b.y-a.y*b.x;}
inline LD Len(Vector a){return sqrt((LD)Dot(a,a));}
inline Vector operator-(Vector a,Vector b){return Vector(a.x-b.x,a.y-b.y);}
inline Vector operator+(Vector a,Vector b){return Vector(a.x+b.x,a.y+b.y);}
inline Vector operator*(Vector a,LD b){return Vector(a.x*b,a.y*b);}
inline bool operator==(Vector a,Vector b){return a.x==b.x&&a.y==b.y;}
struct Splay{
	#define pl tr[p].ps[0]
	#define pr tr[p].ps[1]
	#define pf tr[p].fa
	#define pv tr[p].v
	int O,root;queue<int>Q;LD ans;
	struct QAQ{int fa,ps[2];Point v;}tr[N];
	inline int which(Re p){return tr[pf].ps[1]==p;}
	inline void connect(Re p,Re fa,Re o){tr[pf=fa].ps[o]=p;}
	inline void rotate(Re p){
		Re fa=pf,fas=which(p);
		Re pa=tr[fa].fa,pas=which(fa);
		Re x=tr[p].ps[fas^1];
		connect(x,fa,fas),connect(fa,p,fas^1),connect(p,pa,pas);
	}
	inline void splay(Re p){
		for(Re fa;pf;rotate(p))
			if(tr[fa=pf].fa)rotate(which(p)==which(fa)?fa:p);
		root=p;
	}
	inline void CL(Re p){tr[p].v=Point(),pf=pl=pr=0,p=0;}
	inline int New(){
		Re p;
		if(Q.empty())p=++O;
		else p=Q.front(),Q.pop();
		return p;
	}
	inline void del(Re p){CL(p),Q.push(p);}
	inline int pre(Re p){p=pl;while(pr)p=pr;return p;}
	inline int nex(Re p){p=pr;while(pl)p=pl;return p;}
	inline void insert(Point v){
		Re p=root,fa=0;
		while(p)fa=p,p=tr[p].ps[!(pv<v)];
		p=New(),pv=v,pf=fa;
		if(fa)tr[fa].ps[!(tr[fa].v<v)]=p;
		splay(p);Re p1=0,p2=0;
		if(pl)p1=pre(p);if(pr)p2=nex(p);
		if(p1&&p2)ans-=Len(tr[p2].v-tr[p1].v);
		if(p1)ans+=Len(v-tr[p1].v);
		if(p2)ans+=Len(v-tr[p2].v);
	}
	inline void erase(Point v){
		Re p=root;
		while(!(pv==v))p,p=tr[p].ps[!(pv<v)];
		splay(p);
		Re p1=0,p2=0;
		if(pl)p1=pre(p);if(pr)p2=nex(p);
		if(p1&&p2)ans+=Len(tr[p2].v-tr[p1].v);
		if(p1)ans-=Len(v-tr[p1].v);
		if(p2)ans-=Len(v-tr[p2].v);
		if(!pl&&!pr){root=0,del(p);return;}
		if(!pl||!pr){tr[root=pl+pr].fa=0,del(p);return;}
		splay(pre(p)),tr[root].ps[1]=pr,tr[pr].fa=root,del(p);
	}
};
#define IT set<Point>::iterator
struct ConvexHull{
	int op;set<Point>s;LD ans;//Splay ss;
	inline void Insert(Point P){
		s.insert(P);IT p=s.find(P);
		Re o1=0,o2=0;IT p1=p,p2=p;
		if(p1!=s.begin())o1=1,--p1;if(++p2!=s.end())o2=1;
		if(o1&&o2)ans-=Len(*p2-*p1);
		if(o1)ans+=Len(*p-*p1);
		if(o2)ans+=Len(*p-*p2);
	}
	inline void Erase(IT p){
		Re o1=0,o2=0;IT p1=p,p2=p;
		if(p1!=s.begin())o1=1,--p1;if(++p2!=s.end())o2=1;
		if(o1&&o2)ans+=Len(*p2-*p1);
		if(o1)ans-=Len(*p-*p1);
		if(o2)ans-=Len(*p-*p2);
		s.erase(p);
	}
	inline int PIP(Point P){
		IT it=s.lower_bound(Point(P.x,-2e9));
		if(it==s.end())return 0;
		if(it->x==P.x)return (P.y-it->y)*op<=0;
		if(it==s.begin())return 0;
		IT j=it,k=it;--j;return Cro(P-*j,*k-*j)*op>=0;
	}
	inline int judge(IT it){
		IT j=it,k=it;
		if(j==s.begin())return 0;--j;
		if(++k==s.end())return 0;
		return Cro(*it-*j,*k-*j)*op>=0;
	}
	inline void insert(Point P){
		if(PIP(P))return;
		IT tmp=s.lower_bound(Point(P.x,-2e9));if(tmp!=s.end()&&tmp->x==P.x)Erase(tmp);//ss.erase(*tmp),s.erase(tmp);
		Insert(P);/*s.insert(P),ss.insert(P);*/IT it=s.find(P),p=it;
		if(p!=s.begin()){--p;while(judge(p)){IT tmp=p--;Erase(tmp);/*ss.erase(*tmp),s.erase(tmp);*/}}
		if((p=++it)!=s.end())while(judge(p)){IT tmp=p++;Erase(tmp);/*ss.erase(*tmp),s.erase(tmp);*/}
	}
}up,down;
int n,x,T,X[N],op[N],vis[N];LD Ans[N];Point P[N];
int main(){
//	freopen("123.txt","r",stdin);
	in(x),P[0].In(),up.op=1,down.op=-1;
	up.insert(P[0]),down.insert(P[0]);
	up.insert(Point(0,0)),down.insert(Point(0,0));
	up.insert(Point(x,0)),down.insert(Point(x,0));
	in(n);for(Re i=1;i<=n;++i)P[i].In();
	in(T);for(Re i=1;i<=T;++i){in(op[i]);if(op[i]<2)in(x),vis[X[i]=x]=1;}
	for(Re i=1;i<=n;++i)if(!vis[i])up.insert(P[i]),down.insert(P[i]);
	for(Re i=T;i>=1;--i)
		if(op[i]<2)up.insert(P[X[i]]),down.insert(P[X[i]]);
		else Ans[i]=up.ans+Len(*up.s.begin()-*down.s.begin())+Len(*--up.s.end()-*--down.s.end());
	for(Re i=1;i<=T;++i)if(op[i]>1)printf("%.2lf\n",Ans[i]);
}

```

**扫描线（暴力）** *(周长)*

> 【扫描线（暴力）（周长）】
扫描线（Sweep Line）模板，处理几何对象间的交并关系。

核心函数：
  void in(Re &x) — 核心算法函数

核心结构体：Line

关键配置：
N=1e4

说明：freopen("123.txt","r",stdin);

适用场景：几何对象的交并关系判定、面积/周长计算

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#define y1 ORZ_HYJ_AK_IOI
#define LL long long
#define Re register int
using namespace std;
const int N=1e4;
int a,b,c,d,n,m,pan1[N+5<<1],pan2[N+5<<1];LL ans;
struct Line{int x,y1,y2,k;inline bool operator<(Line O)const{return x==O.x?k>O.k:x<O.x;}}A[N+5<<1],B[N+5<<1];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
int main(){
    // freopen("123.txt","r",stdin);
    in(n);
    for(Re i=1;i<=n;++i){
        in(a),in(b),in(c),in(d);
        A[++m]=(Line){a,b,d,1},B[m]=(Line){b,a,c,1};
        A[++m]=(Line){c,b,d,0},B[m]=(Line){d,a,c,0};
    }
    sort(A+1,A+m+1);
    sort(B+1,B+m+1);
    for(Re i=1;i<=m;++i){
        if(A[i].k)for(Re j=A[i].y1;j<A[i].y2;++j)ans+=(!pan1[j+N]),++pan1[j+N];
        else for(Re j=A[i].y1;j<A[i].y2;++j)--pan1[j+N],ans+=(!pan1[j+N]);
        if(B[i].k)for(Re j=B[i].y1;j<B[i].y2;++j)ans+=(!pan2[j+N]),++pan2[j+N];
        else for(Re j=B[i].y1;j<B[i].y2;++j)--pan2[j+N],ans+=(!pan2[j+N]);
    }
    printf("%lld\n",ans);
}

```

**扫描线（线段树）** *(周长)*

> 【扫描线（线段树）（周长）】
扫描线（Sweep Line）模板，处理几何对象间的交并关系。

核心函数：
  void in(Re &x) — 核心算法函数
  void pushup(Re p,Re L,Re R) — 上推更新节点信息
  void change(Re p,Re L,Re R,Re l,Re r,Re v) — 核心算法函数

核心结构体：Segment_Tree, QAQ, Line

关键配置：
N=5e4+3,M=2e4+3

说明：freopen("123.txt","r",stdin);

适用场景：几何对象的交并关系判定、面积/周长计算

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define y1 yyyy
#define LL long long
#define Re register int
using namespace std;
const int N=5e4+3,M=2e4+3;
int n,m,ans,Max=10000,x1[N],y1[N],x2[N],y2[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Segment_Tree{
	#define pl (p<<1)
	#define pr (p<<1|1)
	#define mid ((L+R)>>1)
	struct QAQ{int S,cnt;}tr[M<<2];
	inline void pushup(Re p,Re L,Re R){
		if(tr[p].cnt)tr[p].S=R-L+1;
		else tr[p].S=(L==R)?0:tr[pl].S+tr[pr].S;
	}
	inline void change(Re p,Re L,Re R,Re l,Re r,Re v){
		if(l<=L&&R<=r){tr[p].cnt+=v,pushup(p,L,R);return;}
		if(l<=mid)change(pl,L,mid,l,r,v);
		if(r>mid)change(pr,mid+1,R,l,r,v);
		pushup(p,L,R);
	}
}TR1,TR2;
struct Line{
	int x,y1,y2,k;Line(Re X=0,Re Y1=0,Re Y2=0,Re K=0){x=X,y1=Y1,y2=Y2,k=K;}
	inline bool operator<(const Line &O)const{return x!=O.x?x<O.x:k>O.k;}
}L1[N<<1],L2[N<<1];
int main(){
//	freopen("123.txt","r",stdin);
	in(n);
	for(Re i=1;i<=n;++i)
		in(x1[i]),in(y1[i]),in(x2[i]),in(y2[i]),x1[i]+=Max,y1[i]+=Max,x2[i]+=Max,y2[i]+=Max,
		L1[++m]=Line(x1[i],y1[i],y2[i],1),L2[m]=Line(y1[i],x1[i],x2[i],1),
		L1[++m]=Line(x2[i],y1[i],y2[i],-1),L2[m]=Line(y2[i],x1[i],x2[i],-1);
	sort(L1+1,L1+m+1),sort(L2+1,L2+m+1);
	for(Re i=1,j=0;i<=m;i=j+1){
		Re last=TR1.tr[1].S;
		++j,TR1.change(1,1,Max<<1,L1[j].y1+1,L1[j].y2,L1[j].k);
		while(j+1<=m&&L1[j].x==L1[j+1].x&&L1[j].k==L1[j+1].k)++j,TR1.change(1,1,Max<<1,L1[j].y1+1,L1[j].y2,L1[j].k);
		ans+=abs(last-TR1.tr[1].S);
	}
	for(Re i=1,j=0;i<=m;i=j+1){
		Re last=TR2.tr[1].S;
		++j,TR2.change(1,1,Max<<1,L2[j].y1+1,L2[j].y2,L2[j].k);
		while(j+1<=m&&L2[j].x==L2[j+1].x&&L2[j].k==L2[j+1].k)++j,TR2.change(1,1,Max<<1,L2[j].y1+1,L2[j].y2,L2[j].k);
		ans+=abs(last-TR2.tr[1].S);
	}
	printf("%d\n",ans);
}

```

**扫描线** *(面积)*

> 【扫描线（面积）】
扫描线（Sweep Line）模板，处理几何对象间的交并关系。

核心函数：
  void in(Re &x) — 核心算法函数
  void pushup(Re p,Re L,Re R) — 上推更新节点信息
  void change(Re p,Re L,Re R,Re l,Re r,Re v) — 核心算法函数

核心结构体：Line, Segment_Tree, QAQ

关键配置：
N=1e5+3

适用场景：几何对象的交并关系判定、面积/周长计算

```cpp
#include<algorithm>
#include<cstring>
#include<cstdio>
#define y1 yyyy
#define LL long long
#define Re register int
using namespace std;
const int N=1e5+3;
int n,m,T,x1,y1,x2,y2,b[N<<1];LL ans;
struct Line{int x,y1,y2,k;inline bool operator<(const Line &O)const{return x<O.x;}}A[N<<1];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct Segment_Tree{
    #define pl (p<<1)
    #define pr (p<<1|1)
    #define mid ((L+R)>>1)
    struct QAQ{int cnt,len;}tr[N<<3];
    inline void pushup(Re p,Re L,Re R){
        if(tr[p].cnt)tr[p].len=b[R+1]-b[L];
        else tr[p].len=(L==R)?0:tr[pl].len+tr[pr].len;
    }
    inline void change(Re p,Re L,Re R,Re l,Re r,Re v){
        if(l<=L&&R<=r){tr[p].cnt+=v,pushup(p,L,R);return;}
        if(l<=mid)change(pl,L,mid,l,r,v);
        if(r>mid)change(pr,mid+1,R,l,r,v);
        pushup(p,L,R);
    }
}TR;
int main(){
    in(T);
    while(T--){
        in(x1),in(y1),in(x2),in(y2);
        A[++n]=(Line){x1,y1,y2,1},A[++n]=(Line){x2,y1,y2,-1};
        b[++m]=y1,b[++m]=y2;
    }
    sort(A+1,A+n+1),sort(b+1,b+m+1),m=unique(b+1,b+m+1)-b-1;
    for(Re i=1;i<n;++i){
        Re y1=lower_bound(b+1,b+m+1,A[i].y1)-b,y2=lower_bound(b+1,b+m+1,A[i].y2)-b;
        TR.change(1,1,m-1,y1,y2-1,A[i].k);
        ans+=(LL)TR.tr[1].len*(A[i+1].x-A[i].x);
    }
    printf("%lld\n",ans);
}

```
