MangataのACM模板
文章目录
- 数据结构
-
- 并查集
- 树状数组
-
- 二维单点修改，区间查询
- 线段树
-
- 单点修改,区间查询
- 区间更新、区间查询
- 主席树（区间第k小数模板）
- 单调栈
- 单调队列
- Trie树
- 01Trie树
- 图论
-
- 最短路
-
- 迪杰斯特拉(堆优化+链式前向星)
- 最短路径计数
- 最小生成树
-
- kruskal
- prim
- 次小生成树
-
- 非严格次小生成树
-
- prime+dp O(V^2)
- 方法二：倍增+kruskal O(MlogN)
- 严格次小生成树
-
- 倍增：O(mlogm)
- LCA
-
- 倍增模板:O(nlogn)
- tarjan模板:0(n+m)
- 二分图
-
- 匈牙利算法： O ( n × m ) O(n\times m) O(n×m)
- KM()算法,求二分图的带权最大匹配，O(n^3)
- 差分约束
- 求树的重心
- 无向图割点和割边
-
- Tarjan 算法求割点
- Tarjan 算法求桥
- Tarjan算法之割边
-
- 定义
- 算法
- 例题：
- code
- 树的直径
- 数论
-
- 数论常见公式
-
- 卡特兰数
- 错排公式
- 常用前n项和公式
- GCD
- 拓展GCD
- 素数判断
-
- 朴素素数判断
- 埃式筛
- 欧拉筛
- 快速幂&龟速乘
- 组合数模板
- SG函数
- 高斯消元
-
- 不带模数的求行列式
- 带模数的求行列式
- 字符串
-
- Manacher模板
- KMP模板
- 字符串hash(自然溢出)
- AC自动机
- DP动态规划
-
- 背包模板
-
- 01背包
- 完全背包
- 多重背包
- 单调队列优化的背包：
- 超大背包问题
- 数位DP
-
- 例一
- 例二
- STL
-
- vector
- priority_queue优先队列（默认为大根堆）
- set（二叉搜索树）
- map
- pair
- algorithm常用函数
-
- unique（）去重函数
- sort()函数
- 求第k小数
- 二分函数：
- 计算几何
-
- 计算几何基本模板
- 半平面交
-
- 点向式求半平面交
- 两点式求半平面交一
- 两点式求半平面交模板二
- N圆面积并&&交
- 凸包&判凸包相交
- 其他
-
- 快读快输模板
- _int128模板
- 二分模板
- 排序
-
- 快速排序
- 归并排序
- 归并排序求逆序对
- JAVA高精度
- 坐标离散化
-
- 例一
-
- 步骤
- code
本篇文章主要是Mangata平时写代码所用到的代码模板库，如有不对请在评论区指出
先放一个我的 常数优化的博客: 传送门
再放一个我的 代码格式博客: 传送门
数据结构
并查集
并查集是一种集合数据结构，通过并查集我们可以快速查询两个元素是否是一个集合，下面是Mangata常用的板子
/*
作者:Mangata
路径压缩并查集
*/
#include树状数组
二维单点修改，区间查询
例题：传送门
Code:
#include线段树
单点修改,区间查询
例题:HDU1754
#include区间更新、区间查询
#include
主席树（区间第k小数模板）
#include单调栈
//单调栈：输出左边第一个比它小的数，如果没有输出-1
int s[N];
int top;
int main(){
int n,i,j,a;
cin>>n;
for(i = 1;i<=n;i++){
cin>>a;
while(top > 0 && s[top] >= a)
top--;
if(top == 0) cout<<"-1 ";
else cout<<s[top]<<" ";
s[++top] = a;
}
return 0;
}
单调队列
//滑动窗口维护区间的最小值
int q[N];
int l,r;
int main(){
int i,j;
int k;//滑动窗口大小
cin>>n>>k;
for(i =1;i<=n;i++) cin>>a[i];
for(i = 1;i<=n;i++){
if(l<r && i-q[l+1] >= k) l++;
while(l<r && a[q[r]]>a[i]) r--;
q[++r]=i;
if(i>=k)
cout<<a[q[l+1]]<<" ";
}
return 0;
}
Trie树
#include01Trie树
#include图论
最短路
迪杰斯特拉(堆优化+链式前向星)
#include最短路径计数
dijkstra拆点最短次短路计数
（只对最短路径计数时，不需要拆点，正常bfs或者dijkstra就可以了）
（注意，一定要先更新次短路点的信息，因为最短路没有更新的时候，次最短路可能更新；而次最短路更新的时候，最短路一定会更新；）
#define x first
#define y second
typedef pair<pair<int,int>,int> PII;
int n, m, S, F;
const int N=1010,M=20010;
int h[N], e[M], w[M], ne[M], idx;
int dis[N][2], cnt[N][2];//0表示最短路状态，1表示次短路状态
bool st[N][2];
void add(int a, int b, int c)
{
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}
int dijkstra(int root)
{
memset(dis,0x3f,sizeof dis);
memset(st,false,sizeof st);
memset(cnt,0,sizeof cnt);
dis[root][0]=0,cnt[root][0]=1;
priority_queue<PII,vector<PII>,greater<PII> > heap;
heap.push({
{
0,0},root});//依次存放最短距离，状态类型，点的id，注意，第一个一定要放最短距离
while(!heap.empty())
{
auto t=heap.top();
heap.pop();
int ver=t.y,type=t.x.y,distance=t.x.x,res=cnt[ver][type];
if(st[ver][type]) continue;
st[ver][type] = true;
for(int i=h[ver];i!=-1;i=ne[i])
{
int j=e[i];
if(dis[j][0]>distance+w[i])
{
dis[j][1]=dis[j][0],cnt[j][1]=cnt[j][0];
heap.push({
{
dis[j][1],1},j});
dis[j][0]=distance+w[i],cnt[j][0]=res;
heap.push({
{
dis[j][0],0},j});
}
else if(dis[j][0]==distance + w[i]) cnt[j][0]+=res;
else if(dis[j][1]>distance+w[i])
{
dis[j][1]=distance+w[i];
cnt[j][1]=res;
heap.push({
{
dis[j][1],1},j});
}
else if(dis[j][1]==distance + w[i])
{
cnt[j][1]+=res;
}
}
}
//dijkstra处理之后，要对终点的状态进行判断
int ans = cnt[F][0];
if (dis[F][0] + 1 == dis[F][1]) ans += cnt[F][1];
return ans;
}
最小生成树
kruskal
最小生成数基于并查集的写法
#includeprim
最小生成树基于prim的写法
#include次小生成树
非严格次小生成树
prime+dp O(V^2)
#include 方法二：倍增+kruskal O(MlogN)
#include 严格次小生成树
倍增：O(mlogm)
#include LCA
倍增模板:O(nlogn)
#includetarjan模板:0(n+m)
#include二分图
匈牙利算法： O ( n × m ) O(n\times m) O(n×m)
int main(){
for(i = 1;i<=n1;i++){
memset(vis,0,sizeof vis);
//如果匹配成功，则匹配总数+1
if(find(i))ans++;
}
printf("%d",ans);
return 0;
}
//对于第x个，能够匹配返回true，不能匹配返回false
bool find(int x){
for(int i = h[x];i!=-1;i = e[i].ne){
int v = e[i].v;
//如果曾经查找过第v个点，但是没有成功
if(vis[v] == 0){
vis[v] = 1;
//第v个没有匹配或者第v个的匹配对象可以匹配成功
if(match[v] == 0 || find(match[v])){
match[v] = x; return true;
}
}
}
return false;
}
KM()算法,求二分图的带权最大匹配，O(n^3)
using namespace std;
typedef long long ll;
typedef pair<ll,ll> PII;
const int N = 605;
const int inf = 0x3f3f3f3f;
PII a[N];
ll n,b[N],c[N];
ll w[N][N], lx[N],ly[N];
ll linker[N], slack[N];
bool visy[N];
ll pre[N];
void bfs(ll k){
int i,j;
ll x,y = 0,yy = 0,delta;
memset(pre,0,sizeof(pre));
for(i =1;i<=n;i++) slack[i] = inf;
linker[y] = k;
while(1){
x = linker[y];delta = inf;visy[y] = true;
for(i=1;i<=n;i++){
if(!visy[i]){
if(slack[i] > lx[x] + ly[i] - w[x][i] ){
slack[i] = lx[x] + ly[i] - w[x][i];
pre[i] = y;
}
if(slack[i] < delta) delta = slack[i], yy = i;
}
}
for(i = 0;i <= n;i++){
if(visy[i]) lx[linker[i]] -= delta , ly[i] += delta;
else slack[i] -= delta;
}
y = yy ;
if(linker[y] == -1) break;
}
while(y) linker[y] = linker[pre[y]], y = pre[y];
}
ll KM(){
int i,j;
memset(lx,0,sizeof(lx));
memset(ly,0,sizeof(ly));
memset(linker,-1,sizeof(linker));
for(i = 1;i<=n;i++){
memset(visy,false, sizeof(visy));
bfs(i);
}
ll res = 0 ;
for(i = 1;i<=n;i++){
if(linker[i]!=-1){
res += w[linker[i]][i];
}
}
return res;
}
int main(){
int i,j;
while(cin>>n){
for(i = 1;i<=n;i++){
for(j = 1;j<=n;j++){
scanf("%d",&w[i][j]);
}
}
cout<<KM()<<endl;
}
return 0;
}
差分约束
解题步骤：
-
先将每个不等式xi<=xj+ck，转化成一条从点j到点i，长度为ck的一条边。
-
找一个超级源点，使得该源点一定可以遍历到所有边。
-
从源点求一遍单源最短路
结果一：如果存在负环，则原不等式组一定无解
结果二：如果没有负环，则d[i]就是原不等式组的一个可行解对于解得最大值和最小值如何求解：
- 当求解得最大值得时候，则应该将所有条件转化为：xi<=xj+ck，然后求最短路就是解得最大值。
- 当求解得最小值得时候，则应该将所有条件转化为：xi>=xj+ck，然后求最长路就是解得最小值。
求树的重心
int ans = inf;
//ans表示将重心删除后，剩余各个连通块中点数的最大值
//返回以u为跟的子树中点的数量
方法一：
int dfs(int u){
vis[u] = 1;
int size = 1,sum = 1;
for(int i = h[u];i!=-1;i = e[i].ne){
int v = e[i].v;
if(vis[v] == 0){
int a = dfs(e[i].v);
size = max(a,size);
sum +=a;
}
}
size = max(size,n-sum);
ans = min(ans,size);
return sum;
}
//方法二：
int dfs(int x,int last){
int i,j;
int size = 0,sum = 1;//以该点为跟的连通块的最大值
for(i = h[x];i!=-1;i = e[i].ne){
int v = e[i].v;
if(v == last) continue;
int t = dfs(v,x);
size = max(size,t);
sum+=t;
}
size = max(size,n-sum);
ans = min(ans,size);
return sum;
}
无向图割点和割边
Tarjan 算法求割点
vector<gg> graph[MAX];
// dfn表示每个结点的搜索次序
gg dfn[MAX], low[MAX];
bool visit[MAX], ans[MAX]; // ans标记该结点是否为割点
gg cnt = 0; // cnt表示搜索次序
void dfs(gg v, gg fa) {
visit[v] = true;
low[v] = dfn[v] = ++cnt;
gg child = 0;
for (gg i : graph[v]) {
if (not visit[i]) {
++child;
dfs(i, v);
low[v] = min(low[v], low[i]);
if (fa != v and low[i] >= dfn[v] and not ans[v]) {
ans[v] = true;
}
} else if (i != fa) {
low[v] = min(low[v], dfn[i]);
}
}
if (fa == v and child >= 2 and not ans[v]) {
ans[v] = true;
}
}
void tarjan() {
for (gg i = 1; i <= ni; ++i) {
if (not visit[i]) {
cnt = 0;
dfs(i, i);
}
}
}
Tarjan 算法求桥
vector<gg> graph[MAX];
// dfn表示每个结点的搜索次序
gg dfn[MAX], low[MAX], father[MAX];
bool ans[MAX]; // 如果ans[i]为true，则表示(father[x],x)为割边
gg cnt = 0; // cnt表示搜索次序
void dfs(gg v, gg fa) {
father[v] = fa;
low[v] = dfn[v] = ++cnt;
for (gg i : graph[v]) {
if (dfn[i] == 0) {
dfs(i, v);
low[v] = min(low[v], low[i]);
if (low[i] > dfn[v]) {
ans[i] = true;
}
} else if (dfn[i] < dfn[v] and i != fa) {
low[v] = min(low[v], dfn[i]);
}
}
}
void tarjan() {
for (gg i = 1; i <= ni; ++i) {
if (dfn[i] == 0) {
cnt = 0;
dfs(i, i);
}
}
}
Tarjan算法之割边
定义
(在无向图中):在一个连通图中,如果删去其中一条边后,连通块的数量会增多,那么我们称这条边为桥或者是割边.
算法
tarjan，只需要判定low[v]>dfn[u]即可(u为父，v为子)
解释：如果子节点在不走原路情况下到不了父节点或父节点之前的点，那么子节点只能走原路回到父节点及之前节点，原路为必经之路，断掉就会产生新的个联通块，符合割边定义。
例题：
HDU4738
code
#include树的直径
const int N = 10000 + 10;
int n, c, d[N];
vector<int> E[N];
void dfs(int u, int fa) {
for (int v : E[u]) {
if (v == fa) continue;
d[v] = d[u] + 1;
if (d[v] > d[c]) c = v;
dfs(v, u);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d %d", &u, &v);
E[u].push_back(v), E[v].push_back(u);
}
dfs(1, 0);
d[c] = 0, dfs(c, 0);
printf("%d\n", d[c]);
return 0;
}
数论
数论常见公式
卡特兰数
错排公式
假设有n个元素，n个位置，每个元素都有自己唯一的正确位置，问，所有元素都处在错误位置有多少可能？
D(n)=(n-1)*( D(n-1) + D(n-2) )，易得 D(1)=0 , D(2)=1。
常用前n项和公式
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iMNNyG8o-1636962675515)(D:\Typora\data\nh.png)]
GCD
GCD的四种方式，辗转相除法和更相减损法的循环写法和递归写法，但是一般来说要用gcd，直接调用__gcd函数就可
/*
作者:Mangata
GCD的四种写法
*/
#include
拓展GCD
关于拓展GCD，我觉得比较核心的是贝祖定理，ax+by=gcd(a,b)，方便我们求解不定方程,板子选取的题目是青蛙的约会
//青蛙的约会
#include
素数判断
朴素素数判断
/*
作者:Mangata
朴素素数判断模板
*/
#include埃式筛
/*
作者:Mangata
埃式筛模板
*/
//时间复杂度 :O(n*log(log(n)))
#include欧拉筛
/*
作者:Mangata
欧拉筛模板
*/
//时间复杂度为 O(n)
#include
快速幂&龟速乘
#include
组合数模板
ll qpow(ll a,ll b,ll c) {
ll ans = 1;
while(b) {
if(b & 1) ans = (ans * a) % c;
b >>= 1;
a = (a * a) % c;
}
return ans;
}
ll inv(ll x,ll c) {
//逆元
return qpow(x,c-2,c);
}
ll C(ll a,ll b, ll c) {
//组合数C(b,a) a>=b
ll ans = 1;
for(int i = 1;i <= b; ++i) {
ans = ans * (a-i+1) % c;
ans = ans * inv(i,c) % c;
}
return ans;
}
SG函数
题目大意：给定nn堆石子，两位玩家轮流操作，每次操作可以取走其中的一堆石子，然后放入两堆规模更小的石子（新堆规模可以为0，且两个新堆的石子总数可以大于取走的那堆石子数），最后无法进行操作的人视为失败。
问如果两人都采用最优策略，先手是否必胜
#include高斯消元
不带模数的求行列式
void det() {
const double EPS = 1E-9;
int n;
vector<vector<double> > a(n, vector<double>(n));
double det = 1;
for (int i = 0; i < n; ++i) {
int k = i;
for (int j = i + 1; j < n; ++j)
if (abs(a[j][i]) > abs(a[k][i])) k = j;
if (abs(a[k][i]) < EPS) {
det = 0;
break;
}
swap(a[i], a[k]);
if (i != k) det = -det;
det *= a[i][i];
for (int j = i + 1; j < n; ++j) a[i][j] /= a[i][i];
for (int j = 0; j < n; ++j)
if (j != i && abs(a[j][i]) > EPS)
for (int k = i + 1; k < n; ++k) a[j][k] -= a[i][k] * a[j][i];
}
cout << det;
}
带模数的求行列式
#include字符串
Manacher模板
Manacher算法主要应用于回文字符串上面，通过字符串翻倍我们能很轻松的通过对称的关系找到子字符串的回文长度。
/*
作者:Mangata
manacger模板
*/
#include
KMP模板
KMP是一个字符串匹配算法，通过此算法能达到线性的匹配时间复杂度，通过对字串求next数组，让我们字符串不回溯(或者说是减少步骤)
/*
作者:Mangata
manacger模板
*/
#include
字符串hash(自然溢出)
ull base = 131,hash[100008],p[100008]; string s;
//求每个前缀的hash
void get_hashs(ull hashs[]){
p[0] = 1;
for(int i = 1;i<=n;i++){
hashs[i] = hashs[i-1]*base+s[i]-'a'+1;
p[i] = p[i-1]*base;
}
}
//得到每个子串的hash
ull get_hash(int l,int r,ull hashs[]){
return hashs[r]-hashs[l-1]*p[r-l+1];
}
AC自动机
求模式串在文本串里面匹配的次数
#includeDP动态规划
背包模板
目前只写三种常用的背包模板(01、完全、多重)，主要也是其他的背包都比较抽象，不好直接写代码。
01背包
/*
作者:Mangata
01背包问题模板 滚动数组优化
*/
#include完全背包
/*
作者:Mangata
完全背包问题模板 滚动数组优化
*/
#include多重背包
/*
作者:Mangata
多重背包问题模板 二进制枚举优化
*/
#include
单调队列优化的背包：
const int N = 1005;
const int M = 20005;
int v[N],w[N],s[N];//体积，价值，数量
int dp[M],g[M], q[M],n,m;
int main(){
int i,j,k;
cin>>n>>m;
for(i = 1;i<=n;i++){
cin>>v[i]>>w[i]>>s[i];
}
for(i = 1;i<=n;i++){
//枚举v[i]的每个余数
memcpy(g,dp,sizeof g);//滚动数组优化
//g表示dp[i-1][],dp表示dp[i][];
for(j = 0;j<v[i];j++){
int l = 0,r = 0;
for(k = j;k<=m;k+=v[i]){
//维护队列中k到k-s[i]*v[i]的最大值的体积
//单调队列中最大值存储物品i的数量大于s[i],出队
if(l<r && (k-q[l+1])/v[i] > s[i]) l++;
//除去比当前小的元素
while(l<r&&g[k]>=g[q[l+1]]+(k-q[l+1])/v[i]*w[i]) r--;
q[++r]=k;
dp[k] = g[q[l+1]]+(k-q[l+1])/v[i]*w[i];
}
}
}
cout<<dp[m]<<endl;
return 0;
}
超大背包问题
#include数位DP
例一
给定两个正整数 aa 和 bb，求在 [a,b][a,b] 中的所有整数中，每个数码(digit)各出现了多少次。
#include例二
1 到 N 中有多少个数满足其二进制表示中恰好有 K 个 1。
#includeSTL
vector
v.push_back(item):向v后加一个元素O(1)
v.pop_back():删除v最后一个元素O(1)
v.size():获取v中元素个数O(1)
v.resize(n):把v的长度重新设定为n个元素O(|n-size|)
v.empty():判断v是否为空O(1)
v.clear():清空v中的元素O(size)
v[index]:获取v中下标为index的元素O(1)
v.begin();返回指向第一个元素的迭代器
v.end();返回指向vector末尾(最后一个元素之后的那个位置)的迭代器
v.front();返回第一个元素
v.back();返回最后一个元素
v.erase(iterator loc);删除loc所指元素并返回下一元素迭代器
v.erase(iterator start, iterator end);删除[start, end)之间的元素，并返回最后一个被删除元素的下个元素的迭代器
去重操作：vt.erase(unique(vt.begin(), vt.end()), vt.end());
v.insert(v.begin()+4,3); 在第五个元素前插入一个元素
priority_queue优先队列（默认为大根堆）
pq.push(item):添加元素 O(logn)
pq.pop():使优先级最高的出队O(logn)
pq.top():获取优先级最高的元素O(1)
pq.size():获取元素个数O(1)
pq.empty():是否为空O(1)
优先队列的定义：
priority_queue<int> q1; //默认从大到小，大顶堆
priority_queue<int ,vector<int>,less<int> > q2; //降序队列，大顶堆
priority_queue<int ,vector<int>,greater<int> > q3; //升序队列，小顶堆
对于结构体定义：
struct T1{
//法一 强烈推荐
int x,y;
friend bool operator < (T1 a,T1 b){
return a.x<b.x;
}
};
priority_queue<T1> q1;
struct T1{
//法二
int x,y;
bool operator < (const T1 &a) const{
return x<a.x; //大顶堆
}
};
priority_queue<T1> q1;
struct T2{
int x,y;};//法三
bool operator <(T2 a,T2 b){
return a.x>b.x;
}
priority_queue<T2> q2;
struct T3{
int x,y;};//法四
struct tmp{
//重写仿函数
bool operator() (T3 a,T3 b){
return a.x<b.x; //大顶堆
}
};
priority_queue<T3, vector<T3>,tmp> q3
set（二叉搜索树）
s.insert(item): 插入元素O(logn)
s.size():获取元素的个数O(1)
s.empty():判断是否为空O(1)
s.clear():清空s O(n)
s.find(item):在s中查找item并返回其iterator(迭代器)，找不到的话返回s.end()O(logn)
s.count(item):返回s中item的数量，因为集合中的元素不能重复，因此只能返回0或1 O(logn)
s.erase(it):删除s中it指向位置的元素
s.erase(item):删除s中值为item的元素
s.earse(it1,it2);删除[it1,it2) 这个区间（迭代器）对应位置的元素
iterator lower_bound( const key_type &key ); 返回一个迭代器，指向键值 >= key的第一个元素。
iterator upper_bound( const key_type &key ); 返回一个迭代器，指向键值 > key的第一个元素。
Set的定义：
struct T1{
int key,value;
bool operator < (const T1 &a) const {
return key<a.key;//按照升序排列
}
};
struct T2{
int key,value;
};
struct T2cmp{
bool operator () (const int &a,const int &b){
if(abs(a-b)<=k)
return false;
return a<b;
}
};
int main(){
int i,j;
set<T1> s1;
set<T2,T2cmp> s2;
set<string> ss1;//等于set > ss1;从小到大
set<string,greater<string> > ss2;//从大到小
set<string,greater<string> > ::iterator itsey;
//set的遍历
set<string> :: iterator it;
for(it = ss1.begin();it!=ss1.end();it++){
cout<<*it<<endl;
}
return 0;
}
Multiset
c.erase(elem) 删除与elem相等的所有元素，返回被移除的元素个数。
c.erase(pos) 移除迭代器pos所指位置元素，无返回值。
map
mp.size():获取元素个数O(1)
mp.empty():判断是否为空O(1)
mp.clear():清空mp O(1)
mp.find(key):在map中查找key并返回其iterator,找不到的话返回mp.end() O(logn)
mp.count(key):在map中找key的数量，由于每个key都是唯一的，只会返回0或1
mp[key] 可以直接访问到键值队key---value中的value，如果不存在这样的键值对，那么mp[key]返回的是value类型默认构造器所构造的值，并将该键值对插入到map中
mp[key]=tmp:可以把键值对key---value中的value赋值为tmp,如果没有对应的键值对,则将该键值对插入到map中复杂度： O(logn)
mp.insert(make_pair(key,value)):在mp中插入键值对key----value。一般不这样用，想要插入键值对的话直接使用mp[key]=value即可，map已经对[]运算符重载过了.
哈希表：
#include pair
#include algorithm常用函数
unique（）去重函数
功能：”删除”序列中所有相邻的重复元素(只保留一个)。此处的删除，并不是真的删除，而是指重复元素的位置被不重复的元素给占领了（它并没有将重复的元素删除，而是把重复的元素放到数组的最后面藏起来了）由于它”删除”的是相邻的重复元素，所以在使用unique函数之前，一般都会将目标序列进行排序。对于数组而言返回去重后最后一个元素的指针，而其他容器则是返回去重后最后一个元素的迭代器。
iterator unique(iterator it_1,iterator it_2);
其中这两个参数表示对容器中[it_1，it_2)范围的元素进行去重,返回值是一个迭代器，它指向的是去重后容器中不重复序列的最后一个元素的下一个元素。
使用：
sort(vt.begin(), vt.end());
vt.erase(unique(vt.begin(), vt.end()), vt.end());
sort()函数
降序排列sort(s+1,s+1+n,greater());
求第k小数
nth_element(a,a+k,a+n)，函数只是把下标为k的元素放在了正确位置，对其它元素并没有排序，当然k左边元素都小于等于它，右边元素都大于等于它，所以可以利用这个函数快速定位某个元素
二分函数：
lower_bound(起始地址，结束地址，要查找的数值) 返回的是>=x的第一个数的地址。
upper_bound(起始地址，结束地址，要查找的数值) 返回的是>x的第一个数的地址
binary_search(起始地址，结束地址，要查找的数值) 返回的是是否存在这么一个数，是一个bool值。
在从小到大的排序数组中：
lower_bound( begin,end,num)：从数组的begin位置到end-1位置二分查找第一个大于或等于num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。upper_bound( begin,end,num)：从数组的begin位置到end-1位置二分查找第一个大于num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。
在从大到小的排序数组中，重载lower_bound()和upper_bound()lower_bound( begin,end,num,greater()):从数组的begin位置到end-1位置二分查找第一个小于或等于num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。upper_bound( begin,end,num,greater()):从数组的begin位置到end-1位置二分查找第一个小于num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标
注意一点这个lower_bound和upper_bound只能用于非降序列，如果要用于非升序列的那要加一个greater
计算几何
计算几何基本模板
#include
Line(Point p,double angle){
p1 = p;
if(sgn(angle - pi/2) == 0){
p2 = (p1 + Point(0,1));}
else{
p2 = (p1 + Point(1,tan(angle)));}
}
//ax+by+c=0
Line(double a,double b,double c){
if(sgn(a) == 0){
p1 = Point(0,-c/b);
p2 = Point(1,-c/b);
}
else if(sgn(b) == 0){
p1 = Point(-c/a,0);
p2 = Point(-c/a,1);
}
else{
p1 = Point(0,-c/b);
p2 = Point(1,(-c-a)/b);
}
}
};
typedef Line Segment; //定义线段，两端点是Point p1,p2
//返回直线倾斜角 0<=angle
double Line_angle(Line v){
double k = atan2(v.p2.y-v.p1.y, v.p2.x-v.p1.x);
if(sgn(k) < 0)k += pi;
if(sgn(k-pi) == 0)k -= pi;
return k;
}
//点和直线关系:1 在左侧;2 在右侧;0 在直线上
int Point_line_relation(Point p,Line v){
int c = sgn(Cross(p-v.p1,v.p2-v.p1));
if(c < 0)return 1; //1：p在v的左边
if(c > 0)return 2; //2：p在v的右边
return 0; //0：p在v上
}
// 点和线段的关系：0 点p不在线段v上；1 点p在线段v上。
bool Point_on_seg(Point p, Line v){
return sgn(Cross(p-v.p1, v.p2-v.p1)) == 0 && sgn(Dot(p - v.p1,p- v.p2)) <= 0;
}
//两直线关系:0 平行,1 重合,2 相交
int Line_relation(Line v1, Line v2){
if(sgn(Cross(v1.p2-v1.p1,v2.p2-v2.p1)) == 0){
if(Point_line_relation(v1.p1,v2)==0) return 1;//1 重合
else return 0;//0 平行
}
return 2; //2 相交
}
//点到直线的距离
double Dis_point_line(Point p, Line v){
return fabs(Cross(p-v.p1,v.p2-v.p1))/Distance(v.p1,v.p2);
}
//求在直线上的投影点
Point Point_line_proj(Point p, Line v){
double k=Dot(v.p2-v.p1,p-v.p1)/Len2(v.p2-v.p1);
return v.p1+(v.p2-v.p1)*k;
}
//点p对直线v的对称点
Point Point_line_symmetry(Point p, Line v){
Point q = Point_line_proj(p,v);//先求点p在直线v的投影点
return Point(2*q.x-p.x,2*q.y-p.y);
}
//点到线段的距离
double Dis_point_seg(Point p, Segment v){
if(sgn(Dot(p- v.p1,v.p2-v.p1))<0 || sgn(Dot(p- v.p2,v.p1-v.p2))<0) //点的投影不在线段上
return min(Distance(p,v.p1),Distance(p,v.p2));//到两端点的距离取最小值
return Dis_point_line(p,v); //点的投影在线段上
}
//求两直线ab和cd的交点
//**调用前要保证两直线不平行或重合，先判断两直线是否平行
Point Cross_point(Point a,Point b,Point c,Point d){
//Line1:ab, Line2:cd
double s1 = Cross(b-a,c-a);
double s2 = Cross(b-a,d-a); //叉积有正负
return Point(c.x*s2-d.x*s1,c.y*s2-d.y*s1)/(s2-s1);
}
//两线段是否相交：1 相交，0不相交
//如果求两线段交点，先判断两线段是否相交，相交则转化成两直线求交点
bool Cross_segment(Point a,Point b,Point c,Point d){
//Line1:ab, Line2:cd
double c1=Cross(b-a,c-a),c2=Cross(b-a,d-a);
double d1=Cross(d-c,a-c),d2=Cross(d-c,b-c);
return sgn(c1)*sgn(c2)<0 && sgn(d1)*sgn(d2)<0;//注意交点是端点的情况不算在内
}
//---------------平面几何：多边形----------------
struct Polygon{
int n; //多边形的顶点数
Point p[maxp]; //多边形的点
Line v[maxp]; //多边形的边
};
//判断点和任意多边形的关系: 3 点上; 2 边上; 1 内部; 0 外部
//点pt，多边形的点Point *p，多边形点的数量n，多边形顶点按照顺时针或者逆时针方向排列
int Point_in_polygon(Point pt,Point *p,int n){
for(int i = 0;i < n;i++){
//点在多边形的顶点上,下标从0开始
if(p[i] == pt)return 3;
}
for(int i = 0;i < n;i++){
//点在多边形的边上
Line v=Line(p[i],p[(i+1)%n]);
if(Point_on_seg(pt,v)) return 2;
}
int num = 0;
for(int i = 0;i < n;i++){
int j = (i+1)% n;
int c = sgn(Cross(pt-p[j],p[i]-p[j]));
int u = sgn(p[i].y - pt.y);
int v = sgn(p[j].y - pt.y);
if(c > 0 && u < 0 && v >=0) num++;
if(c < 0 && u >=0 && v < 0) num--;
}
return num != 0; //1 内部; 0 外部
}
//求多边形的面积，从原点开始划分三角形，顶点按照顺时针或者逆时针方向排列
double Polygon_area(Point *p, int n){
//Point *p表示多边形。
double area = 0;
for(int i = 0;i < n;i++)
area += Cross(p[i],p[(i+1)%n]);
return area/2; //面积有正负，不能简单地取绝对值
}
//求多边形重心。Point *p表示多边形。
Point Polygon_center(Point *p, int n){
Point ans(0,0);
if(Polygon_area(p,n)==0) return ans;
for(int i = 0;i < n;i++)
ans = ans + (p[i]+p[(i+1)%n]) * Cross(p[i],p[(i+1)%n]); //面积有正负
return ans/Polygon_area(p,n)/6.;
}
//Convex_hull()求凸包。凸包顶点放在ch中，返回值是凸包的顶点数
int Convex_hull(Point *p,int n,Point *ch){
sort(p,p+n); //对点排序：按x从小到大排序，如果x相同，按y排序
n=unique(p,p+n)-p; //去除重复点
int v=0;
//求下凸包。如果p[i]是右拐弯的，这个点不在凸包上，往回退
for(int i=0;i<n;i++){
while(v>1 && sgn(Cross(ch[v-1]-ch[v-2],p[i]-ch[v-2]))<=0)
v--;
ch[v++]=p[i];
}
int j=v;
//求上凸包
for(int i=n-2;i>=0;i--){
while(v>j && sgn(Cross(ch[v-1]-ch[v-2],p[i]-ch[v-2]))<=0)
v--;
ch[v++]=p[i];
}
if(n>1) v--;
return v; //返回值v是凸包的顶点数
}
//---------------平面几何：圆----------------
struct Circle{
Point c;//圆心
double r;//半径
Circle(){
}
Circle(Point c,double r):c(c),r(r){
}
Circle(double x,double y,double _r){
c=Point(x,y);r = _r;}
};
//点和圆的关系: 0 点在圆内, 1 圆上, 2 圆外.
int Point_circle_relation(Point p, Circle C){
double dst = Distance(p,C.c);
if(sgn(dst - C.r) < 0) return 0; //点在圆内
if(sgn(dst - C.r) ==0) return 1; //圆上
return 2; //圆外
}
//直线和圆的关系：0 直线在圆内, 1 直线和圆相切, 2 直线在圆外
int Line_circle_relation(Line v,Circle C){
double dst = Dis_point_line(C.c,v);
if(sgn(dst-C.r) < 0) return 0; //直线在圆内
if(sgn(dst-C.r) ==0) return 1; //直线和圆相切
return 2; //直线在圆外
}
//线段和圆的关系：0 线段在圆内, 1 线段和圆相切, 2 线段在圆外
int Seg_circle_relation(Segment v,Circle C){
double dst = Dis_point_seg(C.c,v);
if(sgn(dst-C.r) < 0) return 0; //线段在圆内
if(sgn(dst-C.r) ==0) return 1; //线段和圆相切
return 2; //线段在圆外
}
//直线和圆的交点，pa, pb是交点。返回值是交点个数
int Line_cross_circle(Line v,Circle C,Point &pa,Point &pb){
if(Line_circle_relation(v, C)==2) return 0;//无交点
Point q = Point_line_proj(C.c,v); //圆心在直线上的投影点
double d = Dis_point_line(C.c,v); //圆心到直线的距离
double k = sqrt(C.r*C.r-d*d); //
if(sgn(k) == 0){
//1个交点，直线和圆相切
pa = q;
pb = q;
return 1;
}
Point n=(v.p2-v.p1)/ Len(v.p2-v.p1); //单位向量
pa = q + n*k;
pb = q - n*k;
return 2;//2个交点
}
//-------------------三维几何----------------
//三维：点
struct Point3{
double x,y,z;
Point3(){
}
Point3(double x,double y,double z):x(x),y(y),z(z){
}
Point3 operator + (Point3 B){
return Point3(x+B.x,y+B.y,z+B.z);}
Point3 operator - (Point3 B){
return Point3(x-B.x,y-B.y,z-B.z);}
Point3 operator * (double k){
return Point3(x*k,y*k,z*k);}
Point3 operator / (double k){
return Point3(x/k,y/k,z/k);}
bool operator == (Point3 B){
return sgn(x-B.x)==0 && sgn(y-B.y)==0 && sgn(z-B.z)==0;}
};
typedef Point3 Vector3;
//点积。和二维点积函数同名。C++允许函数同名。
double Dot(Vector3 A,Vector3 B){
return A.x*B.x+A.y*B.y+A.z*B.z;}
//叉积
Vector3 Cross(Vector3 A,Vector3 B){
return Point3(A.y*B.z-A.z*B.y,A.z*B.x-A.x*B.z,A.x*B.y-A.y*B.x);}
double Len(Vector3 A){
return sqrt(Dot(A,A));} //向量的长度
double Len2(Vector3 A){
return Dot(A,A);} //向量长度的平方
double Distance(Point3 A,Point3 B){
return sqrt((A.x-B.x)*(A.x-B.x)+(A.y-B.y)*(A.y-B.y)+(A.z-B.z)*(A.z-B.z));
}
double Angle(Vector3 A,Vector3 B){
return acos(Dot(A,B)/Len(A)/Len(B));} //A与B的夹角
//三维：线
struct Line3{
Point3 p1,p2;
Line3(){
}
Line3(Point3 p1,Point3 p2):p1(p1),p2(p2){
}
};
typedef Line3 Segment3; //定义线段，两端点是Point p1,p2
//三角形面积的2倍
double Area2(Point3 A,Point3 B,Point3 C){
return Len(Cross(B-A, C-A));}
//三维：点到直线距离
double Dis_point_line(Point3 p, Line3 v){
return Len(Cross(v.p2-v.p1,p-v.p1))/Distance(v.p1,v.p2);
}
//三维：点在直线上
bool Point_line_relation(Point3 p,Line3 v){
return sgn( Len(Cross(v.p1-p,v.p2-p))) == 0 && sgn(Dot(v.p1-p,v.p2-p))== 0;
}
//三维：点到线段距离。
double Dis_point_seg(Point3 p, Segment3 v){
if(sgn(Dot(p- v.p1,v.p2-v.p1)) < 0 || sgn(Dot(p- v.p2,v.p1-v.p2)) < 0)
return min(Distance(p,v.p1),Distance(p,v.p2));
return Dis_point_line(p,v);
}
//三维：点 p 在直线上的投影
Point3 Point_line_proj(Point3 p, Line3 v){
double k=Dot(v.p2-v.p1,p-v.p1)/Len2(v.p2-v.p1);
return v.p1+(v.p2-v.p1)*k;
}
//三维：平面
struct Plane{
Point3 p1,p2,p3;//平面上的三个点
Plane(){
}
Plane(Point3 p1,Point3 p2,Point3 p3):p1(p1),p2(p2),p3(p3){
}
};
//平面法向量
Point3 Pvec(Point3 A,Point3 B,Point3 C){
return Cross(B-A,C-A);}
Point3 Pvec(Plane f){
return Cross(f.p2-f.p1,f.p3-f.p1);}
//四点共平面
bool Point_on_plane(Point3 A,Point3 B,Point3 C,Point3 D){
return sgn(Dot(Pvec(A,B,C),D-A)) == 0;
}
//两平面平行
int Parallel(Plane f1, Plane f2){
return Len(Cross(Pvec(f1),Pvec(f2))) < eps;
}
//两平面垂直
int Vertical (Plane f1, Plane f2){
return sgn(Dot(Pvec(f1),Pvec(f2)))==0;
}
//直线与平面的交点p，返回值是交点个数
int Line_cross_plane(Line3 u,Plane f,Point3 &p){
Point3 v = Pvec(f);
double x = Dot(v, u.p2-f.p1);
double y = Dot(v, u.p1-f.p1);
double d = x-y;
if(sgn(x) == 0 && sgn(y) == 0) return -1;//-1：v在f上
if(sgn(d) == 0)return 0; //0：v与f平行
p = ((u.p1 * x)-(u.p2 * y))/d; //v与f相交
return 1;
}
//四面体有向体积*6
double volume4(Point3 A,Point3 B,Point3 C,Point3 D){
return Dot(Cross(B-A,C-A),D-A);}
int main(){
Point a(0,1),b(0,0),c(1,1),d(1,2),p(1.5,1);
double a1=5,b1=6,c1=1;
Line k(a,b),k2(c,d);
Point pr(1,1),cr(1,1); double r=1; Circle C(cr,r);
cout<<endl<<"Line_circle_relation="<<Line_circle_relation(k,C);
cout<<endl<<"Seg_circle_relation="<<Seg_circle_relation(k,C);
cout<<endl<<"Point_circle_relation="<<Point_circle_relation(pr,C);
cout<<endl<<"parallel="<<Parallel(a,b)<<endl;
cout<<"dot="<<Dot(a,b)<<endl<<" angle="<<Angle(a,b)<<endl;
cout<<"90:"<<sgn(Rotate(a, -pi/2).x)<<endl<<Rotate(a, -pi/2).y;
cout<<endl<<"line angle="<<Line_angle(k)*4;
cout<<endl<<"line place="<<Point_line_relation(p,k);
cout<<endl<<"point_on_seg="<<Point_on_seg(p,k);
cout<<endl<<"dis_point_line="<<Dis_point_line(p,k);
cout<<endl<<"dis_point_line="<<Dis_point_seg(p,k);
Point pp=Cross_point(a,b,c,d);
cout<<endl<<"crosspoint="<<pp.x<<" "<<pp.y;
cout<<endl<<"cross seg="<<Cross_segment(a,b,c,d);
cout<<endl<<"distance="<<Distance(a,b);
cout<<endl<<"line_relation="<<Line_relation(k,k2);
Point g[4];
g[0]=a;g[1]=b;g[2]=c;g[3]=d;
cout<<endl<<"Point_in_polygon="<<Point_in_polygon(p,g,4);
cout<<endl<<"Polygon_area="<<Polygon_area(g,4);
cout<<endl<<endl;
return 0;
}
半平面交
点向式求半平面交
#include 两点式求半平面交一
const double INF = 1e12;
const double eps = 1e-8;
int n,m;
int sgn(double x){
//判断x是否等于0
if(fabs(x) < eps) return 0;
else return x<0?-1:1;
}
struct Point{
//定义点和基本运算
double x,y;
Point(){
}
Point(double x,double y):x(x),y(y){
}
Point operator + (Point B){
return Point(x+B.x,y+B.y);}
Point operator - (Point B){
return Point(x-B.x,y-B.y);}
Point operator * (double k){
return Point(x*k,y*k);} //长度增大k倍
Point operator / (double k){
return Point(x/k,y/k);} //长度缩小k倍
};
typedef Point Vector; //定义向量
//点积
double Dot(Vector A,Vector B){
return A.x*B.x + A.y*B.y;}
double Dist(Point A,Point B){
return sqrt((A.x-B.x)*(A.x-B.x) + (A.y-B.y)*(A.y-B.y));}
double Cross(Vector A,Vector B){
return A.x*B.y - A.y*B.x;}
double Area2(Point A, Point B, Point C){
return Cross(B-A, C-A);}
struct Line{
Point p1,p2;//线上的两个点
Line(){
}
Line(Point p1,Point p2):p1(p1),p2(p2){
}
};
//得到极角角度
double get_angle(Line a) {
return atan2(a.p2.y-a.p1.y,a.p2.x-a.p1.x);
}
//排序：极角小的排前面，极角相同时，最左边的排在最后面，以便去重
bool cmp(Line a, Line b) {
double A = get_angle(a), B = get_angle(b);
if (fabs(A - B) < eps) return Area2(a.p1,a.p2,b.p2)<0;
return A < B;
}
//点和直线关系:1 在左侧;2 在右侧;0 在直线上
int Point_line_relation(Point p,Line v){
int c = sgn(Cross(p-v.p1,v.p2-v.p1));
if(c < 0)return 1; //1：p在v的左边
if(c > 0)return 2; //2：p在v的右边
return 0; //0：p在v上
}
//求两直线的交点
Point Cross_point(Point a,Point b,Point c,Point d){
//Line1:ab, Line2:cd
double s1 = Cross(b-a,c-a);
double s2 = Cross(b-a,d-a); //叉积有正负
return Point(c.x*s2-d.x*s1,c.y*s2-d.y*s1)/(s2-s1);
}
//两直线交点
Point Cross_point(Line a,Line b){
return Cross_point(a.p1,a.p2,b.p1,b.p2);
}
bool OnLeft(Line l,Point p){
if(Point_line_relation(p,l) == 1) return true;
return false;
}
//求半平面交，返回图多边形
vector<Point> HPI(vector<Line> L){
int n=L.size();
sort(L.begin(),L.end(),cmp);//将所有半平面按照极角排序。
int l,r; //指向双端队列的第一个和最后一个元素
vector<Point> p(n); //两个相邻半平面的交点
vector<Point> ans; //半平面交形成的凸包
vector<Line> q(n); //双端队列
q[l=r=0]=L[0];
for(int i=1;i<n;i++){
//情况1：删除尾部的半平面
while(l<r && !OnLeft(L[i], p[r-1])) r--;
//情况2：删除首部的半平面：
while(l<r && !OnLeft(L[i], p[l])) l++;
q[++r]=L[i]; //将当前的半平面加入双端队列尾部
//极角相同的两个半平面，保留左边：
if(fabs(Cross(q[r].p2-q[r].p1,q[r-1].p2-q[r-1].p1)) < eps){
r--;
if(OnLeft(q[r],L[i].p1)) q[r]=L[i];
}
//计算队列尾部半平面交点：
if(l<r) p[r-1]=Cross_point(q[r-1],q[r]);
}
//情况3：删除队列尾部的无用半平面
while(l<r && !OnLeft(q[l],p[r-1])) r--;
if(r-l<=1) return ans; //空集
p[r]=Cross_point(q[r],q[l]); //计算队列首尾部的交点。
for(int i=l;i<=r;i++) ans.push_back(p[i]); //复制
return ans; //返回凸多边形
}
vector<Line> L;
vector<Point> ans;
int main(){
int i,j,T;
cin>>T;
while(T--){
int n;
L.clear();
cin>>n;
for(i = 1;i<=n;i++){
double p,v;
scanf("%lf %lf",&p,&v);
Line l(Point(0,p),Point(1,v+p));
L.push_back(l);
}
//加入两个边界的直线
L.push_back(Line(Point(0,0),Point(0,-1)));
L.push_back(Line(Point(0,INF),Point(-1,INF)));
vector<Point> ans = HPI(L);
cout<<ans.size()-2<<endl;
}
return 0;
}
两点式求半平面交模板二
typedef long long ll;
typedef long double LD;
typedef pair<int,int> PII;
const double inf = 1e12;
const int N = 100005;
const LD eps = 1e-18;
int n,m;
int sgn(double x){
//判断x是否等于0
if(fabs(x) < eps) return 0;
else return x<0?-1:1;
}
int Dcmp(double x, double y){
//比较两个浮点数：0 相等；-1 小于；1 大于
if(fabs(x - y) < eps) return 0;
else return x<y ?-1:1;
}
struct Point{
//定义点和基本运算
double x,y;
Point(){
}
Point(double x,double y):x(x),y(y){
}
Point operator + (Point B){
return Point(x+B.x,y+B.y);}
Point operator - (Point B){
return Point(x-B.x,y-B.y);}
Point operator * (double k){
return Point(x*k,y*k);} //长度增大k倍
Point operator / (double k){
return Point(x/k,y/k);} //长度缩小k倍
bool operator == (Point B){
return sgn(x-B.x)==0 && sgn(y-B.y)==0;}
bool operator < (Point B){
return sgn(x-B.x)<0 || (sgn(x-B.x)==0 && sgn(y-B.y)<0);} //用于凸包
};
typedef Point Vector; //定义向量
double Cross(Vector A,Vector B){
return A.x*B.y - A.y*B.x;}
double Area2(Point A, Point B, Point C){
return Cross(B-A, C-A);}
struct Line{
Point p1,p2;//线上的两个点
Line(){
}
Line(Point p1,Point p2):p1(p1),p2(p2){
}
};
Line line[N];
int cnt;
int q[N];//定义双端队列
double get_angle(Line a) {
return atan2(a.p2.y-a.p1.y,a.p2.x-a.p1.x);
}
//排序：极角小的排前面，极角相同时，最左边的排在最后面，以便去重
bool cmp(Line a, Line b) {
double A = get_angle(a), B = get_angle(b);
if (fabs(A - B) < eps) return Area2(a.p1,a.p2,b.p2)<0;
return A < B;
}
Point Cross_point(Point a,Point b,Point c,Point d){
//Line1:ab, Line2:cd
double s1 = Cross(b-a,c-a);
double s2 = Cross(b-a,d-a); //叉积有正负
return Point(c.x*s2-d.x*s1,c.y*s2-d.y*s1)/(s2-s1);
}
//两直线交点
Point Cross_point(Line a,Line b){
return Cross_point(a.p1,a.p2,b.p1,b.p2);
}
// 判断bc的交点是否在a的右侧
bool on_right(Line a, Line b, Line c){
Point o = Cross_point(b, c);
//如果删除重合的点加上等号
return Area2(a.p1, a.p2, o) <= 0;
}
vector<Point> HPI(vector<Line> L){
int cnt = L.size();
sort(L.begin(),L.end(), cmp);
int l = 0, r = -1;//头部和尾部
for (int i = 0; i < cnt; i ++ ){
if (i && !Dcmp(get_angle(L[i - 1]), get_angle(L[i]))) continue;
while (l + 1 <= r && on_right(L[i], L[q[r - 1]], L[q[r]])) r -- ;
while (l + 1 <= r && on_right(L[i], L[q[l]], L[q[l + 1]])) l ++ ;
q[ ++ r] = i;
}
while (l + 1 <= r && on_right(L[q[l]], L[q[r - 1]], L[q[r]])) r -- ;
while (l + 1 <= r && on_right(L[q[r]], L[q[l]], L[q[l + 1]])) l ++ ;
int k = 0;
vector<Point> ans;
if(r - l <= 1) return ans;//返回空集
q[++r] = q[l];//将头部的直线加入尾部
for(int i = l;i<r;i++){
ans.push_back(Cross_point(L[q[i]],L[q[i+1]]));
}
return ans;
}
double Polygon_area(vector<Point> p){
//Point *p表示多边形。
double area = 0;
int n = p.size();
for(int i = 0;i < n;i++)
area += Cross(p[i],p[(i+1)%n]);
return area/2; //面积有正负，不能简单地取绝对值
}
vector<Line> L;
vector<Point> ans;
Point pg[N];
int main(){
int i,j,T;
cin>>T;
while(T--){
int n;
L.clear();
cin>>n;
for(i = 1;i<=n;i++){
double p,v;
scanf("%lf %lf",&p,&v);
Line l(Point(0,p),Point(1,v+p));
L.push_back(l);
}
//加入两个边界的直线
L.push_back(Line(Point(0,0),Point(0,-1)));
L.push_back(Line(Point(0,inf),Point(-1,inf)));
vector<Point> ans = HPI(L);
cout<<ans.size()-2<<endl;
}
return 0;
}
N圆面积并&&交
#include
printf("%f\n", tot); //这句就是求总面积
}
int main(){
solve();
return 0;
}
/*
in
3
1 0 2
-1 0 2
0 1 2
Out
4.20324 相交面积
//22.929505 相并面积
*/
凸包&判凸包相交
#include其他
快读快输模板
有些题目可能会丧心病狂的卡常，这个时候我们可以使用快读快输这种方法优化我们程序的常数。
/*
作者:Mangata
int的快读快输
*/
#include
_int128模板
能够存储128位2进制的数(算是微大数)
#include
二分模板
二分的模板有很多，最好记住并使用一种二分模板就行，这是Mangata最爱的二分模板
/*
作者:Mangata
二分模板返回大于x的第一个位置
*/
#include
排序
快速排序
void quick_sort(int l,int r){
if(l == r) return;
int x = a[(l+r)/2];
int l1 = l-1,r1 = r+1;
while(l1<r1){
do l1++;
while(a[l1]<x);
do r1--;
while(a[r1]>x);
if(l1<r1) swap(a[l1],a[r1]);
}
quick_sort(l,r1);
quick_sort(r1+1,r);
}
归并排序
void merge_sort(int l,int r){
if(l==r)return;
int m = (l+r)/2;
merge_sort(l,m);
merge_sort(m+1,r);
int i = l,j = m+1;
int k = i;
while(i<=m&&j<=r){
if(a[i]<a[j]) tmp[k++] = a[i++];
else tmp[k++] = a[j++];
}
while(i<=m)tmp[k++] = a[i++];
while(j<=r)tmp[k++] = a[j++];
for(i = l;i<=r;i++)
a[i] = tmp[i];
}
归并排序求逆序对
#includeJAVA高精度
import java.util.*;
import java.io.BufferedInputStream;
import java.math.*;
public class Main {
static int N = 2005;
static BigInteger mod = new BigInteger("1000000007");
static int n;
static BigInteger[] a = new BigInteger[N];
static BigInteger[] dp = new BigInteger[N];
public static void main(String args[]) {
Scanner cin = new Scanner(System.in);
int T;
BigInteger a = new BigInteger("123456789") ; // 声明BigInteger对象
BigInteger b = new BigInteger("987654321") ; // 声明BigInteger对象
System.out.println("加法操作：" + b.add(a)) ; // 加法操作
System.out.println("减法操作：" + b.subtract(a)) ; // 减法操作
System.out.println("乘法操作：" + b.multiply(a)) ; // 乘法操作
System.out.println("除法操作：" + b.divide(a)) ; // 除法操作
System.out.println("最大数：" + b.max(a)) ; // 求出最大数
System.out.println("最小数：" + b.min(a)) ; // 求出最小数
System.out.println("商："+b.divide(a));//求商
System.out.println("余数"+b.mod(a));//求余数
BigInteger result[] = b.divideAndRemainder(a) ; // 求出余数的除法操作
System.out.println("商是：" + result[0] +
"；余数是：" + result[1]) ;
//比较函数
if( a.compareTo(b) == 0 ) System.out.println("a == b"); //大整数a==b
else if( a.compareTo(b) > 0 ) System.out.println("a >