#### Point板子:
点积dot，叉积cross



``` cpp
#include <bits/stdc++.h>
 
using i64 = long long;
using T = long long;
 
struct Point {
    T x;
    T y;
    Point(T x = 0, T y = 0) : x(x), y(y) {}
    
    Point &operator+=(const Point &p) {
        x += p.x, y += p.y;
        return *this;
    }
    Point &operator-=(const Point &p) {
        x -= p.x, y -= p.y;
        return *this;
    }
    Point &operator*=(const T &v) {
        x *= v, y *= v;
        return *this;
    }
    friend Point operator-(const Point &p) {
        return Point(-p.x, -p.y);
    }
    friend Point operator+(Point lhs, const Point &rhs) {
        return lhs += rhs;
    }
    friend Point operator-(Point lhs, const Point &rhs) {
        return lhs -= rhs;
    }
    friend Point operator*(Point lhs, const T &rhs) {
        return lhs *= rhs;
    }
};
 
T dot(const Point &a, const Point &b) {
    return a.x * b.x + a.y * b.y;
}
 
T cross(const Point &a, const Point &b) {
    return a.x * b.y - a.y * b.x;
}
```
#### 圆的交面积
``` cpp
typedef double db;
struct cir{
    db x,y,r;
    void read(){
        scanf("%lf%lf%lf",&x,&y,&r);
    }
}e[N];
db sq(db x){return x*x;}
db cal(cir a,cir b){
    db sql=sq(a.x-b.x)+sq(a.y-b.y);
    if(sql>=sq(a.r+b.r))return 0;
    if(sql<=sq(a.r-b.r)){
        if(a.r<b.r)return pi*a.r*a.r;
        else return pi*b.r*b.r;
    }
    db l=sqrt(sql),sqa=sq(a.r),sqb=sq(b.r);
    db p=(l+a.r+b.r)/2.0;
    db v=2.0*sqrt(p*(p-l)*(p-a.r)*(p-b.r));
    return acos((sqa+sql-sqb)/(2.0*a.r*l))*sqa+acos((sqb+sql-sqa)/(2.0*b.r*l))*sqb-v;
}
```
#### 三角形
```cpp
struct node{
    double x,y;
};
node a,b,c;
//求两个点之间的长度
double len(node a,node b) {
    double tmp = sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
    return tmp;
}
//给出三个点，求三角形的面积  海伦公式: p=(a+b+c)/2，S=sqrt(p(p-a)(p-b)(p-c))
double Area(node a,node b,node c){
    double lena = len(a,b);
    double lenb = len(b,c);
    double lenc = len(a,c);

    double p = (lena + lenb + lenc) / 2.0;
    double S = sqrt(p * (p - lena) * (p - lenb) * (p - lenc));
    return S;
}
//三角形求每条边对应的圆心角
void Ran() {
    double lena = len(a,b);
    double lenb = len(b,c);
    double lenc = len(a,c);
    double A = acos((lenb * lenb + lenc * lenc - lena * lena) / (2 * lenb * lenc));
    double B = acos((lena * lena + lenc * lenc - lenb * lenb) / (2 * lena * lenc));
    double C = acos((lena * lena + lenb * lenb - lenc * lenc) / (2 * lena * lenb));
}
//求外接圆半径r = a * b * c / 4S 
double R(node a,node b,node c) {
    double lena = len(a,b);
    double lenb = len(b,c);
    double lenc = len(a,c);
    double S = Area(a,b,c);
    double R = lena * lenb * lenc / (4.0 * S);
}
```

计算几何

# 如何使用`fesdrerrand.h`库中的各个组件。


### 1. 随机数生成器
**操作示例：**
```cpp
long long random_int = random(1, 100); // 生成1到100之间的随机整数
double random_real = randomreal(1.0, 100.0); // 生成1.0到100.0之间的随机实数
```

### 2. 基本随机函数（RANDOMBASIC）
**操作示例：**
```cpp
std::vector<int> arr = RandomBasic.random_sequence(10, 1, 100); // 生成10个1到100的随机整数序列
RandomBasic.random_shuffle(arr.begin(), arr.end()); // 随机打乱数组
std::string random_str = RandomBasic.random_string(5); // 生成5个随机字符的字符串
```

### 3. 输出辅助函数（RANDOMPRINT）
**操作示例：**
```cpp
RandomPrint.print_sequence(arr.begin(), arr.end()); // 打印数组
RandomPrint.print_sequence_pair({{1, 2}, {3, 4}, {5, 6}}); // 打印二元组数组
```

### 4. 其他随机函数（RANDOMANOTHER）
**操作示例：**
```cpp
std::vector<int> diff = RandomAnother.random_different(1, 100, 10); // 在1到100之间随机生成10个不同的数
std::vector<std::vector<int>> divided = RandomAnother.random_divide(1, 100, 5); // 将1到100分成5份
```

### 5. 图操作辅助函数（RANDOMGRAPHTOOL）
**操作示例：**
```cpp
std::vector<std::pair<int, int>> graph = RandomGraph.graph(10, 15, true, false, false, false); // 生成有10个节点15条边的无向图
RandomGraphTool.random_vertices(10, graph); // 随机打乱图的节点编号
```

### 6. 随机树生成函数（RANDOMTREE）
**操作示例：**
```cpp
std::vector<std::pair<int, int>> tree = RandomTree.random_tree(10); // 生成有10个节点的随机树
```

### 7. 随机图生成函数（RANDOMGRAPH）
**操作示例：**
```cpp
std::vector<std::pair<int, int>> graph = RandomGraph.graph(10, 15, true, false, false, false); // 生成有10个节点15条边的无向图
```

### 8. 卡 SPFA 生成函数（RANDOMHACKSPFA）
**操作示例：**
```cpp
std::vector<std::pair<std::pair<int, int>, int>> spfa_graph = RandomHackSpfa.hackspfa(10, 1, 100); // 生成用于测试SPFA算法的图
```

### 9. 有向无环图生成函数（RANDOMDAG）
**操作示例：**
```cpp
std::vector<std::pair<int, int>> dag = RandomDag.dag(10, 15, true, false); // 生成有10个节点15条边的有向无环图
```

### 10. 强连通分量生成函数（RANDOMSCC）
**操作示例：**
```cpp
std::vector<std::pair<int, int>> scc_graph = RandomScc.scc(10, 15, 5, spfa_graph, 1.0); // 生成有10个节点15条边5个强连通分量的图
```

### 11. 边双连通分量生成函数（RANDOMEDCC）
**操作示例：**
```cpp
std::vector<std::pair<int, int>> edcc_graph = RandomEdcc.edcc(10, 15, 5, tree, 1.0); // 生成有10个节点15条边5个边双连通分量的图
```

### 12. 点双连通分量生成函数（RANDOMVDCC）
**操作示例：**
```cpp
std::vector<std::pair<int, int>> vdcc_graph = RandomVdcc.vdcc(10, 15, 5, 1.0); // 生成有10个节点15条边5个点双连通分量的图
```

### 13. 检查函数
**操作示例：**
```cpp
std::vector<int> depth = CheckTree.Get_dep(tree); // 获取树中每个节点的深度
std::vector<int> degree = CheckTree.Get_degree(tree); // 获取树中每个节点的度数
std::vector<std::vector<int>> scc = CheckScc.check(10, graph); // 获取强连通分量
```



# 差分约束

给出一组包含 $m$ 个不等式，有 $n$ 个未知数的形如：

$$ \begin{cases} x_{c_1}-x_{c'_1}\leq y_1 \\x_{c_2}-x_{c'_2} \leq y_2 \\ \cdots\\ x_{c_m} - x_{c'_m}\leq y_m\end{cases}$$

的不等式组，求任意一组满足这个不等式组的解。

可以观察到该形式与单源最短路时的(dis[u] + w $$\leq$$ dis[v])很像,故可以将每一个$$x_i$$看成一个节点i，对余每个$$x_i \leq x_j + y_w$$可以看成有一条$$x_j$$到$$x_i$$权值为$$y_w$$的有向边,对该图跑一遍最短路，dis[i]即为$$x_i$$的解，若出现负环则说明该方程无解.
### 过程
建立超级原点$$x_0$$，对所有i<=n建立一条$$x_0$$到$$x_i$$权值为0的边，对$$x_0$$跑一边最短路即可.
### 代码
``` cpp
struct edge{
	int v,w;
};
vector<edge> qwq[maxn];
bool vis[maxn];
int dis[maxn],cnt[maxn];
queue<int> q;
int n,m;
bool spfa(int s)
{
	memset(dis,0x3f,sizeof(dis));
	q.push(s);
	vis[s] = 1;
	dis[s] = 0;
	while(!q.empty())
	{
		int u = q.front();
		q.pop();
		vis[u] = false;
		for(auto [v,w]:qwq[u])
		{
			if(dis[v] > dis[u] + w)
			{
				dis[v] = dis[u]+w;
				cnt[v] = cnt[u] + 1;
				if(cnt[v] > n)
				{
					return false;
				}
				q.push(v);
			}

		}
	}
	return true;
}
void solve(){
	cin>>n>>m;
	for(int i = 0; i < m; i++)
	{
		int u,v,w;scanf("%lld%lld%lld",&v,&u,&w);
		qwq[u].push_back({v,w});
	}
	for(int i = 1; i<= n; i++)
	{
		qwq[0].push_back({i,0});
	}
	if(spfa(0))
	{
		for(int i = 0; i< n; i++)
		{
			cout<<dis[i+1]<<" ";
		}
	}else
	{
		cout<<"NO"<<endl;
	}
}
```

差分约束

# 最短路

### Dijkstra 求解非负权图上单源最短路径
n个点m条边
时间复杂度 *O(mlogm)* 

``` cpp
struct edge//边
{
	int v,w;//端点和权值
};
struct node//点
{
	int dis,u;//到原点的估计最小值和端点
	bool operator > (const node &a) const {return dis > a.dis;}
};
vector<edge> qwq[maxn];
int dis[maxn];
bitset<maxn> vis;
priority_queue<node,vector<node>,greater<>> p;
void dij(int s)
{
	memset(dis,0x3f,sizeof(dis));
	vis.reset();
	dis[s] = 0;
	p.push({0,s});
	while(!p.empty())
	{
		auto [d,u] = p.top();
		p.pop();
		if(vis[u])
			continue;
		vis[u] = 1;
		for(auto [v,w]:qwq[u])
		{
			if(dis[v] > dis[u] + w)
			{
				dis[v] = dis[u] + w;
				p.push({dis[v],v});
			}
		}
	}
}
```
### 分层图Dijkstra求解单源最短路
用于求解图中可以使用k次特殊通行的最短路（如可以k次免费从v地到i地）
(可能存在i<k使得dis[i][t]为0，故最后答案将所有dis[i][t](i<=k)遍历一遍更新最小值)
``` cpp
struct edge//边
{
	int v,w;//端点和权值
};
struct node//点
{
	int dis,u,cnt;//到原点的估计最小值和端点以及使用特殊通行的次数
	bool operator > (const node &a) const {return dis > a.dis;}
};
vector<edge> qwq[maxn];
int dis[maxk][maxn];
bool vis[maxk][maxn];
priority_queue<node,vector<node>,greater<>> p;
void dij(int s,int k)
{
	memset(dis,0x3f,sizeof(dis));
	memset(vis,0,sizeof(vis));
	dis[0][s] = 0;
	p.push({0,s,0});
	while(!p.empty())
	{
		auto [d,u,cnt] = p.top();
		p.pop();
		if(vis[cnt][u])
			continue;
		vis[cnt][u] = 1;
		for(auto [v,w]:qwq[u])
		{
			if(cnt < k && dis[cnt][u] < dis[cnt+1][v])//使用特殊次数免费到达
			{
				dis[cnt+1][v] = dis[cnt][u];
				p.push({dis[cnt+1][v],v,cnt+1});
			}
			if(dis[cnt][v] > dis[cnt][u] + w)
			{
				dis[cnt][v] = dis[cnt][u] + w;
				p.push({dis[cnt][v],v,cnt});
			}
		}
	}
}
```
### SPFA求出有负权的图的最短路
时间复杂度最坏情况下*O(nm)*
``` cpp
struct edge
{
	int v,w;
};
vector<edge> e[maxn];
int dis[maxn],cnt[maxn];
bitset<maxn> vis;//标记在队列中的点
queue<int> q;
bool spfa(int n,int s)
{
	memset(dis,0x3f,sizeof(dis));
	dis[s] = 0;
	vis[s] = 1;
	q.push(s);
	while(!q.empty())
	{
		int u = q.front();
		q.pop();
		vis[u] = 0;
		for(auto [v,w]:e[u])
		{
			if(dis[v] > dis[u] + w)
			{
				dis[v] = dis[u] + w;
				cnt[v] = cnt[u] + 1;
				//cnt数组记录最短路经过的边数
				if(cnt[v] >= n)//多余n条边时说明一定出现了负环
					return false;
				if(!vis[v])
				{
					q.push(v);
					vis[v] = 1;
				}
			}
		}
	}
	return true;
}
```

バイナンスはアメリカでも機能しますか

コインベースは安全に送信しますセクヤ交換2ステップのコインベースを更新する

グローバルアンチ詐欺暗号ログイン

稲作交流

ソーペイ交換