概述
在打区域赛的时候,遇到计算几何可能就会望而生畏,因为码量大,细节多,正确率低,这就使大部分计算几何会成为金牌题,出线题,争冠题。但是本次的学习的目的是防止出题人会出一些铜牌银牌的计算几何,从而导致一点没学计算几何的人会吃很大的亏。一般铜牌银牌的计算几何设计的知识点很少,到点,线,多边形就停了,圆都很少涉及。
前置知识
几何知识
中学几何
平面几何
直角坐标系,极坐标系
正弦定理,余弦定理
向量
浮点数与精度问题
f l o a t float float:基本不用
d o u b l e double double:双精度浮点类型
l o n g long long d o u b l e double double:扩展精度浮点类型
结论:
若问题能用整数解决就不用浮点数解决
不用float,视情况用long double
减少数学函数的使用(开方,三角函数)
比较时加入容限,即 e p s eps eps
二维几何
点,线
向量
向量: x , y x,y x,y
支持四则运算:
向量+向量
向量-向量
向量*向量
向量/向量
向量 A B ⃗ \vec{AB} AB可以通过 B ⃗ − A ⃗ \vec{B}-\vec{A} B−A
叉积
c j ( a , b ) = a . x ∗ b . y − a . y ∗ b . x = ∣ a ∣ ∗ ∣ b ∣ ∗ s i n < a , b > cj(a,b)=a.x*b.y-a.y*b.x=|a|*|b|*sin<a,b> cj(a,b)=a.x∗b.y−a.y∗b.x=∣a∣∗∣b∣∗sin<a,b>
作用:三角形的面积,判断点在向量的哪一侧,判平行等等
点积
d j ( a , b ) = a . x ∗ b . x + a . y ∗ b . y = ∣ a ∣ ∗ ∣ b ∣ ∗ c o s < a , b > dj(a,b)=a.x*b.x+a.y*b.y=|a|*|b|*cos<a,b> dj(a,b)=a.x∗b.x+a.y∗b.y=∣a∣∗∣b∣∗cos<a,b>
作用:计算两向量夹角,判断两向量的同向关系,判断垂直等等
旋转
v ′ = ( c o s α ∗ x − s i n α ∗ y , s i n α ∗ x + c o s α ∗ y ) v^{'}=(cos\alpha *x-sin\alpha*y,sin\alpha *x+cos\alpha *y) v′=(cosα∗x−sinα∗y,sinα∗x+cosα∗y)
极角序
极角是在极坐标下的角度,某些题可以按极角序排序,然后顺序做。
多边形
多边形 { ① : 面积 ② : 点包含 ③ : 凸包 ④ : 旋转卡壳 ⑤ : 切多边形 面积: S = 1 2 ∑ i = 0 n P i ∗ P ( i + 1 ) % n 点包含:以要判断的点为起点作一射线,计算该设点与多边形的交点数目 若为偶数,则在多边形外,为奇数,在多边形内 多边形\begin{cases} ①:面积\\ ②:点包含\\ ③:凸包\\ ④:旋转卡壳\\ ⑤:切多边形 \end{cases}\\ 面积:S=\frac 12 \sum_{i=0}^{n}P_i*P_{(i+1)\%n}\\ 点包含:以要判断的点为起点作一射线,计算该设点与多边形的交点数目\\ 若为偶数,则在多边形外,为奇数,在多边形内 多边形⎩ ⎨ ⎧①:面积②:点包含③:凸包④:旋转卡壳⑤:切多边形面积:S=21i=0∑nPi∗P(i+1)%n点包含:以要判断的点为起点作一射线,计算该设点与多边形的交点数目若为偶数,则在多边形外,为奇数,在多边形内
圆
用一个圆心+半径 r r r就能可以代表一个圆
涉及到的内容有:
圆与直线的交点
圆与圆的交点
圆与多边形的面积并
圆的面积并
题目:
Crazy Town
题意:告诉你一条线段(家和学校),再给 n n n条直线,问有多少条直线会和这条线段相交
做法:最基本的几何知识,将坐标带进去比大小即可,代码如下:
/*
coder:sunshine
school:njupt
*/
#include <bits/stdc++.h>
using namespace std;
#define endl '\n' //交互题删掉
#define x first
#define y second
typedef long long ll;
typedef pair<int, int> pii;
constexpr int mod = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int ans = 0;
vector<double> aa(5);
for (int i = 1; i <= 4; i++)
cin >> aa[i];
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int a, b, c;
cin >> a >> b >> c;
double a1 = a * aa[1] + b * aa[2] + c;
double a2 = a * aa[3] + b * aa[4] + c;
if (a1 > a2)
swap(a1, a2);
if (a1 < 0 && a2 > 0)
ans++;
}
cout << ans << endl;
return 0;
}
神秘大三角
题意:给一个三角形和一个点判断位置关系
做法:叉积的基本应用,根据叉积正负在来判断位置,代码如下:
/*
coder:sunshine
school:njupt
*/
#include <bits/stdc++.h>
using namespace std;
#define endl '\n' //交互题删掉
#define x first
#define y second
typedef long long ll;
typedef pair<int, int> pii;
constexpr int mod = 1e9 + 7;
typedef long long db;
const db EPS = 0;
inline int sign(db a) {
return a < -EPS ? -1 : a > EPS;
}
inline int cmp(db a, db b) {
return sign(a - b);
}
struct P {
db x, y;
P() {}
P(db _x, db _y) : x(_x), y(_y) {}
P operator+(P p) { return {x + p.x, y + p.y}; }
P operator-(P p) { return {x - p.x, y - p.y}; }
P operator*(db d) { return {x * d, y * d}; }
bool operator<(P p) const {
int c = cmp(x, p.x);
if (c)
return c == -1;
return cmp(y, p.y) == -1;
}
bool operator==(P o) const { return cmp(x, o.x) == 0 && cmp(y, o.y) == 0; }
db dot(P p) { return x * p.x + y * p.y; }
db det(P p) { return x * p.y - y * p.x; }
void read() { cin >> x >> y; }
int quad() const { return sign(y) == 1 || (sign(y) == 0 && sign(x) >= 0); }
};
P aa[3];
P p;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
for (int i = 0; i < 4; i++) {
char a, b, c;
int e, f;
cin >> a >> e >> b >> f >> c;
if (i != 3) {
aa[i].x = e;
aa[i].y = f;
} else {
p.x = e, p.y = f;
}
}
int l = 0, r = 0;
for (int i = 0; i < 3; i++) {
P a = p - aa[i];
P b = p - aa[(i + 1) % 3];
int d = a.det(b);
if (d < 0)
l++;
if (d > 0)
r++;
}
if (l == 3 || r == 3)
cout << 1 << endl;
else if (r > 0 && l > 0)
cout << 2 << endl;
else if (l + r == 1)
cout << 4 << endl;
else
cout << 3 << endl;
return 0;
}
oil
题意:n条平行的线段,再来一条直线,问最多能和多少线段相交
做法:有个结论:最终最优的直线一定经过某条线段的左端点和一条直线的左端点,所以先按极角序排序,枚举左端点,在枚举其他直线,算每种情况下的答案,取个最大值。
注意:这里可以不算斜率 y / x y/x y/x,而算 x / y x/y x/y,从而避免了竖线的情况
/*
coder:sunshine
school:njupt
*/
#include <bits/stdc++.h>
using namespace std;
#define endl '\n' //交互题删掉
typedef long long ll;
typedef pair<int, int> pii;
constexpr int mod = 1e9 + 7;
#include <bits/stdc++.h>
using namespace std;
typedef long long db;
const db EPS = 0;
inline int sign(db a) {
return a < -EPS ? -1 : a > EPS;
}
inline int cmp(db a, db b) {
return sign(a - b);
}
struct P {
db x, y;
P() {}
P(db _x, db _y) : x(_x), y(_y) {}
P operator+(P p) { return {x + p.x, y + p.y}; }
P operator-(P p) { return {x - p.x, y - p.y}; }
P operator*(db d) { return {x * d, y * d}; }
bool operator<(P p) const {
int c = cmp(x, p.x);
if (c)
return c == -1;
return cmp(y, p.y) == -1;
}
bool operator==(P o) const { return cmp(x, o.x) == 0 && cmp(y, o.y) == 0; }
db dot(P p) { return x * p.x + y * p.y; }
db det(P p) { return x * p.y - y * p.x; }
void read() { cin >> x >> y; }
int quad() const { return sign(y) == 1 || (sign(y) == 0 && sign(x) >= 0); }
};
#define cross(p1, p2, p3) \
((p2.x - p1.x) * (p3.y - p1.y) - (p3.x - p1.x) * (p2.y - p1.y))
#define crossOp(p1, p2, p3) sign(cross(p1, p2, p3))
// 直线 p1p2, q1q2 是否恰有一个交点
bool chkLL(P p1, P p2, P q1, P q2) {
db a1 = cross(q1, q2, p1), a2 = -cross(q1, q2, p2);
return sign(a1 + a2) != 0;
}
// 判断区间 [l1, r1], [l2, r2] 是否相交
bool intersect(db l1, db r1, db l2, db r2) {
if (l1 > r1)
swap(l1, r1);
if (l2 > r2)
swap(l2, r2);
return !(cmp(r1, l2) == -1 || cmp(r2, l1) == -1);
}
// 线段 p1p2, q1q2 相交
bool isSS(P p1, P p2, P q1, P q2) {
return intersect(p1.x, p2.x, q1.x, q2.x) &&
intersect(p1.y, p2.y, q1.y, q2.y) &&
crossOp(p1, p2, q1) * crossOp(p1, p2, q2) <= 0 &&
crossOp(q1, q2, p1) * crossOp(q1, q2, p2) <= 0;
}
// 线段 p1p2, q1q2 严格相交
bool isSS_strict(P p1, P p2, P q1, P q2) {
return crossOp(p1, p2, q1) * crossOp(p1, p2, q2) < 0 &&
crossOp(q1, q2, p1) * crossOp(q1, q2, p2) < 0;
}
// m 在 a 和 b 之间
bool isMiddle(db a, db m, db b) {
/*if (a > b) swap(a, b);
return cmp(a, m) <= 0 && cmp(m, b) <= 0;*/
return sign(a - m) == 0 || sign(b - m) == 0 || (a < m != b < m);
}
bool isMiddle(P a, P m, P b) {
return isMiddle(a.x, m.x, b.x) && isMiddle(a.y, m.y, b.y);
}
// 点 p 在线段 p1p2 上
bool onSeg(P p1, P p2, P q) {
return crossOp(p1, p2, q) == 0 && isMiddle(p1, q, p2);
}
// q1q2 和 p1p2 的交点 在 p1p2 上?
// 点 p 严格在 p1p2 上
bool onSeg_strict(P p1, P p2, P q) {
return crossOp(p1, p2, q) == 0 &&
sign((q - p1).dot(p1 - p2)) * sign((q - p2).dot(p1 - p2)) < 0;
}
int n;
constexpr int N = 2010;
pair<P, int> evt[2 * N];
P p[N][2];
ll solve(P o) {
int t = 0;
for (int i = 0; i < n; i++) {
if (p[i][0].y == o.y)
continue;
P p1 = p[i][0] - o, p2 = p[i][1] - o;
int len = p[i][1].x - p[i][0].x;
if (p[i][1].y > o.y) {
evt[t++] = {p2, len};
evt[t++] = {p1, -len};
} else {
evt[t++] = {p1 * (-1), len};
evt[t++] = {p2 * (-1), -len};
}
}
sort(evt, evt + t, [&](pair<P, int>& a, pair<P, int>& b) {
auto d = a.first.det(b.first);
if (d != 0)
return d > 0;
else
return a.second > b.second;
});
ll ans = 0, cur = 0;
for (int i = 0; i < t; i++) {
cur += evt[i].second;
ans = max(ans, cur);
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n;
for (int i = 0; i < n; i++) {
int x1, x2, y;
cin >> x1 >> x2 >> y;
if (x1 > x2)
swap(x1, x2);
p[i][0] = P(x1, y);
p[i][1] = P(x2, y);
}
ll ans = 0;
for (int i = 0; i < n; i++) {
ans = max(ans,
max(solve(p[i][0]), solve(p[i][1])) + p[i][1].x - p[i][0].x);
}
cout << ans << endl;
return 0;
}
Grass
题意:给定平面上 n 个点,要求选出其中 5 个不同的点,并选定 1 个中心点 A 向其他 4 个点 B, C, D,E 连出 4 条线段,要求 这四条线段任意两条的交点都仅有中心点 A。
做法:把玩样例后,可以发现:选出的 5 个点能构造出可行解,当且仅当 这 5 个点不全共线。所以做法是先判断有没有解,即是否全部共线,是的话就无解,然后找出五个不共线的点,依次判断是否可以作为中心点。
/*
coder:sunshine
school:njupt
*/
#include <bits/stdc++.h>
using namespace std;
#define endl '\n' //交互题删掉
typedef long long ll;
typedef pair<int, int> pii;
constexpr int mod = 1e9 + 7;
typedef long long db;
const db EPS = 0;
inline int sign(db a) {
return a < -EPS ? -1 : a > EPS;
}
inline int cmp(db a, db b) {
return sign(a - b);
}
struct P {
db x, y;
P() {}
P(db _x, db _y) : x(_x), y(_y) {}
P operator+(P p) { return {x + p.x, y + p.y}; }
P operator-(P p) { return {x - p.x, y - p.y}; }
P operator*(db d) { return {x * d, y * d}; }
bool operator<(P p) const {
int c = cmp(x, p.x);
if (c)
return c == -1;
return cmp(y, p.y) == -1;
}
bool operator==(P o) const { return cmp(x, o.x) == 0 && cmp(y, o.y) == 0; }
db dot(P p) { return x * p.x + y * p.y; }
db det(P p) { return x * p.y - y * p.x; }
void read() { cin >> x >> y; }
int quad() const { return sign(y) == 1 || (sign(y) == 0 && sign(x) >= 0); }
};
#define cross(p1, p2, p3) \
((p2.x - p1.x) * (p3.y - p1.y) - (p3.x - p1.x) * (p2.y - p1.y))
#define crossOp(p1, p2, p3) sign(cross(p1, p2, p3))
// 直线 p1p2, q1q2 是否恰有一个交点
bool chkLL(P p1, P p2, P q1, P q2) {
db a1 = cross(q1, q2, p1), a2 = -cross(q1, q2, p2);
return sign(a1 + a2) != 0;
}
// 判断区间 [l1, r1], [l2, r2] 是否相交
bool intersect(db l1, db r1, db l2, db r2) {
if (l1 > r1)
swap(l1, r1);
if (l2 > r2)
swap(l2, r2);
return !(cmp(r1, l2) == -1 || cmp(r2, l1) == -1);
}
// 线段 p1p2, q1q2 相交
bool isSS(P p1, P p2, P q1, P q2) {
return intersect(p1.x, p2.x, q1.x, q2.x) &&
intersect(p1.y, p2.y, q1.y, q2.y) &&
crossOp(p1, p2, q1) * crossOp(p1, p2, q2) <= 0 &&
crossOp(q1, q2, p1) * crossOp(q1, q2, p2) <= 0;
}
// 线段 p1p2, q1q2 严格相交
bool isSS_strict(P p1, P p2, P q1, P q2) {
return crossOp(p1, p2, q1) * crossOp(p1, p2, q2) < 0 &&
crossOp(q1, q2, p1) * crossOp(q1, q2, p2) < 0;
}
// m 在 a 和 b 之间
bool isMiddle(db a, db m, db b) {
/*if (a > b) swap(a, b);
return cmp(a, m) <= 0 && cmp(m, b) <= 0;*/
return sign(a - m) == 0 || sign(b - m) == 0 || (a < m != b < m);
}
bool isMiddle(P a, P m, P b) {
return isMiddle(a.x, m.x, b.x) && isMiddle(a.y, m.y, b.y);
}
// 点 p 在线段 p1p2 上
bool onSeg(P p1, P p2, P q) {
return crossOp(p1, p2, q) == 0 && isMiddle(p1, q, p2);
}
// q1q2 和 p1p2 的交点 在 p1p2 上?
// 点 p 严格在 p1p2 上
bool onSeg_strict(P p1, P p2, P q) {
return crossOp(p1, p2, q) == 0 &&
sign((q - p1).dot(p1 - p2)) * sign((q - p2).dot(p1 - p2)) < 0;
}
constexpr int N = 25010;
P p[N];
int n;
void solve() {
cin >> n;
for (int i = 0; i < n; i++) {
ll a, b;
cin >> a >> b;
p[i] = {a, b};
}
if (n < 5) {
cout << "NO" << endl;
return;
}
vector<P> c;
int idx = -1;
for (int i = 2; i < n; i++) {
if (crossOp(p[0], p[1], p[i]) != 0)
idx = i;
}
if (idx == -1) {
cout << "NO" << endl;
return;
}
c.push_back(p[idx]);
c.push_back(p[0]);
c.push_back(p[1]);
for (int i = 2; i < n; i++) {
if (i != idx && c.size() < 5)
c.push_back(p[i]);
}
cout << "YES" << endl;
for (int i = 0; i < 5; i++) {
bool ok = 1;
for (int j = 0; j < 5; j++) {
for (int k = j + 1; k < 5; k++) {
if (i != j && i != k) {
if (crossOp(c[i], c[j], c[k]) == 0 &&
!onSeg(c[j], c[k], c[i]))
ok = 0;
}
}
}
if (ok) {
cout << c[i].x << " " << c[i].y << endl;
for (int j = 0; j < 5; j++) {
if (i != j)
cout << c[j].x << " " << c[j].y << endl;
}
break;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t = 1;
cin >> t;
while (t--)
solve();
return 0;
}
How Many Triangles
题意:给n个点,求能组成多少个锐角三角形
做法:直接求不好求,于是可以正难则反,用总的三角形个数减去直角三角形,钝角三角形
有
n
个点
则总的三角形数:
C
n
3
对应的锐角
+
直角
+
钝角个数为:
3
C
n
3
假设有
x
个直角
,
y
个钝角
则锐角三角形个数为
:
(
3
C
n
3
−
2
∗
x
−
x
−
2
∗
y
)
/
3
=
C
n
3
−
x
−
y
有n个点\\ 则总的三角形数:C_n^3 对应的锐角+直角+钝角个数为:3C_n^3\\ 假设有x个直角,y个钝角\\ 则锐角三角形个数为:\\ (3C_n^3-2*x-x-2*y)/3=C_n^3-x-y
有n个点则总的三角形数:Cn3对应的锐角+直角+钝角个数为:3Cn3假设有x个直角,y个钝角则锐角三角形个数为:(3Cn3−2∗x−x−2∗y)/3=Cn3−x−y
于是做法就出来了,按照极角序排个序,然后双指针扫一下,统计个数即可。
有些细节需要注意:平角不要被算两次
/*
coder:sunshine
school:njupt
*/
#include <bits/stdc++.h>
using namespace std;
#define endl '\n' //交互题删掉
typedef long long ll;
typedef pair<int, int> pii;
constexpr int mod = 1e9 + 7;
typedef long long db;
const db EPS = 0;
inline int sign(db a) {
return a < -EPS ? -1 : a > EPS;
}
inline int cmp(db a, db b) {
return sign(a - b);
}
struct P {
db x, y;
P() {}
P(db _x, db _y) : x(_x), y(_y) {}
P operator+(P p) { return {x + p.x, y + p.y}; }
P operator-(P p) { return {x - p.x, y - p.y}; }
P operator*(db d) { return {x * d, y * d}; }
bool operator<(P p) const {
int c = cmp(x, p.x);
if (c)
return c == -1;
return cmp(y, p.y) == -1;
}
bool operator==(P o) const { return cmp(x, o.x) == 0 && cmp(y, o.y) == 0; }
db dot(P p) { return x * p.x + y * p.y; }
db det(P p) { return x * p.y - y * p.x; }
void read() { cin >> x >> y; }
int quad() const { return sign(y) == 1 || (sign(y) == 0 && sign(x) >= 0); }
};
#define cross(p1, p2, p3) \
((p2.x - p1.x) * (p3.y - p1.y) - (p3.x - p1.x) * (p2.y - p1.y))
#define crossOp(p1, p2, p3) sign(cross(p1, p2, p3))
// 直线 p1p2, q1q2 是否恰有一个交点
bool chkLL(P p1, P p2, P q1, P q2) {
db a1 = cross(q1, q2, p1), a2 = -cross(q1, q2, p2);
return sign(a1 + a2) != 0;
}
// 判断区间 [l1, r1], [l2, r2] 是否相交
bool intersect(db l1, db r1, db l2, db r2) {
if (l1 > r1)
swap(l1, r1);
if (l2 > r2)
swap(l2, r2);
return !(cmp(r1, l2) == -1 || cmp(r2, l1) == -1);
}
// 线段 p1p2, q1q2 相交
bool isSS(P p1, P p2, P q1, P q2) {
return intersect(p1.x, p2.x, q1.x, q2.x) &&
intersect(p1.y, p2.y, q1.y, q2.y) &&
crossOp(p1, p2, q1) * crossOp(p1, p2, q2) <= 0 &&
crossOp(q1, q2, p1) * crossOp(q1, q2, p2) <= 0;
}
// 线段 p1p2, q1q2 严格相交
bool isSS_strict(P p1, P p2, P q1, P q2) {
return crossOp(p1, p2, q1) * crossOp(p1, p2, q2) < 0 &&
crossOp(q1, q2, p1) * crossOp(q1, q2, p2) < 0;
}
// m 在 a 和 b 之间
bool isMiddle(db a, db m, db b) {
/*if (a > b) swap(a, b);
return cmp(a, m) <= 0 && cmp(m, b) <= 0;*/
return sign(a - m) == 0 || sign(b - m) == 0 || (a < m != b < m);
}
bool isMiddle(P a, P m, P b) {
return isMiddle(a.x, m.x, b.x) && isMiddle(a.y, m.y, b.y);
}
// 点 p 在线段 p1p2 上
bool onSeg(P p1, P p2, P q) {
return crossOp(p1, p2, q) == 0 && isMiddle(p1, q, p2);
}
// q1q2 和 p1p2 的交点 在 p1p2 上?
// 点 p 严格在 p1p2 上
bool onSeg_strict(P p1, P p2, P q) {
return crossOp(p1, p2, q) == 0 &&
sign((q - p1).dot(p1 - p2)) * sign((q - p2).dot(p1 - p2)) < 0;
}
constexpr int N = 2010;
P p[N], q[N * 2];
int n;
void solve() {
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
p[i] = P(x, y);
}
ll ans = (ll)n * (n - 1) * (n - 2) / 6;
for (int i = 0; i < n; i++) {
int t = 0;
for (int j = 0; j < n; j++) {
if (j != i)
q[t++] = p[j] - p[i];
}
sort(q, q + t, [&](P a, P b) {
int qa = a.quad(), qb = b.quad();
if (qa != qb)
return qa < qb;
else
return sign(a.det(b)) > 0;
});
//破环为链
for (int j = 0; j < t; j++)
q[j + t] = q[j];
int l = -1, r = -1;
for (int j = 0; j < t; j++) {
l = max(l, j + 1);
r = max(r, j + 1);
//判断是否小于90度
auto check1 = [&](P a, P b, int idl) {
if (q[j].dot(q[l]) > 0) {
if (q[j].det(q[l]) != 0) {
return q[j].det(q[l]) > 0;
} else
return idl < t;
}
return false;
};
while (l < j + t && check1(q[j], q[l], l))
l++;
//判断 >=pi/2,<=pi
auto check2 = [&](P a, P b, int idr) {
auto d = a.det(b);
if (d != 0)
return d > 0;
return idr < t;
};
while (r < j + t && check2(q[j], q[r], r))
r++;
ans -= r - l;
}
}
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
while (cin >> n)
solve();
return 0;
}
Airport Construction
题意:在一个多边形内,伸出一条线段,求线段最长
做法:有一个比较容易想到的结论,就是线段一定经过多边形的顶点,跟上面的oil结论类似,但不一定两个端点在顶点上(下图是反例)。n是200的范围,可以考虑 n 4 n^4 n4加点剪枝过。即枚举两个顶点,生成的线段计算出与多边形相交的长度。
#include <bits/stdc++.h>
using namespace std;
typedef double db;
#define rep(i, a, n) for (int i = a; i < n; i++)
const db EPS = 1e-9;
inline int sign(db a) {
return a < -EPS ? -1 : a > EPS;
}
inline int cmp(db a, db b) {
return sign(a - b);
}
struct P {
db x, y;
P() {}
P(db _x, db _y) : x(_x), y(_y) {}
P operator+(P p) { return {x + p.x, y + p.y}; }
P operator-(P p) { return {x - p.x, y - p.y}; }
P operator*(db d) { return {x * d, y * d}; }
P operator/(db d) { return {x / d, y / d}; }
bool operator<(P p) const {
int c = cmp(y, p.y);
if (c)
return c == -1;
return cmp(x, p.x) == -1;
}
bool operator==(P o) const { return cmp(x, o.x) == 0 && cmp(y, o.y) == 0; }
db dot(P p) { return x * p.x + y * p.y; }
db det(P p) { return x * p.y - y * p.x; }
db distTo(P p) { return (*this - p).abs(); }
db alpha() { return atan2(y, x); }
void read() {
int x_, y_;
scanf("%d%d", &x_, &y_);
x = x_, y = y_;
}
void write() { cout << "(" << x << "," << y << ")" << endl; }
db abs() { return sqrt(abs2()); }
db abs2() { return x * x + y * y; }
P rot90() { return P(-y, x); }
P unit() { return *this / abs(); }
int quad() const { return sign(y) == 1 || (sign(y) == 0 && sign(x) >= 0); }
P rot(db an) {
return {x * cos(an) - y * sin(an), x * sin(an) + y * cos(an)};
}
};
#define cross(p1, p2, p3) \
((p2.x - p1.x) * (p3.y - p1.y) - (p3.x - p1.x) * (p2.y - p1.y))
#define crossOp(p1, p2, p3) sign(cross(p1, p2, p3))
// 直线 p1p2, q1q2 是否恰有一个交点
bool chkLL(P p1, P p2, P q1, P q2) {
db a1 = cross(q1, q2, p1), a2 = -cross(q1, q2, p2);
return sign(a1 + a2) != 0;
}
// 求直线 p1p2, q1q2 的交点
P isLL(P p1, P p2, P q1, P q2) {
db a1 = cross(q1, q2, p1), a2 = -cross(q1, q2, p2);
return (p1 * a2 + p2 * a1) / (a1 + a2);
}
// 判断区间 [l1, r1], [l2, r2] 是否相交
bool intersect(db l1, db r1, db l2, db r2) {
if (l1 > r1)
swap(l1, r1);
if (l2 > r2)
swap(l2, r2);
return !(cmp(r1, l2) == -1 || cmp(r2, l1) == -1);
}
// 线段 p1p2, q1q2 相交
bool isSS(P p1, P p2, P q1, P q2) {
return intersect(p1.x, p2.x, q1.x, q2.x) &&
intersect(p1.y, p2.y, q1.y, q2.y) &&
crossOp(p1, p2, q1) * crossOp(p1, p2, q2) <= 0 &&
crossOp(q1, q2, p1) * crossOp(q1, q2, p2) <= 0;
}
// 线段 p1p2, q1q2 严格相交
bool isSS_strict(P p1, P p2, P q1, P q2) {
return crossOp(p1, p2, q1) * crossOp(p1, p2, q2) < 0 &&
crossOp(q1, q2, p1) * crossOp(q1, q2, p2) < 0;
}
// m 在 a 和 b 之间
bool isMiddle(db a, db m, db b) {
/*if (a > b) swap(a, b);
return cmp(a, m) <= 0 && cmp(m, b) <= 0;*/
return sign(a - m) == 0 || sign(b - m) == 0 || (a < m != b < m);
}
bool isMiddle(P a, P m, P b) {
return isMiddle(a.x, m.x, b.x) && isMiddle(a.y, m.y, b.y);
}
// 点 p 在线段 p1p2 上
bool onSeg(P p1, P p2, P q) {
return crossOp(p1, p2, q) == 0 && isMiddle(p1, q, p2);
}
// q1q2 和 p1p2 的交点 在 p1p2 上?
// 点 p 严格在 p1p2 上
bool onSeg_strict(P p1, P p2, P q) {
return crossOp(p1, p2, q) == 0 &&
sign((q - p1).dot(p1 - p2)) * sign((q - p2).dot(p1 - p2)) < 0;
}
// 求 q 到 直线p1p2 的投影(垂足) ⚠️ : p1 != p2
P proj(P p1, P p2, P q) {
P dir = p2 - p1;
return p1 + dir * (dir.dot(q - p1) / dir.abs2());
}
// 求 q 以 直线p1p2 为轴的反射
P reflect(P p1, P p2, P q) {
return proj(p1, p2, q) * 2 - q;
}
// 求 q 到 线段p1p2 的最小距离
db nearest(P p1, P p2, P q) {
if (p1 == p2)
return p1.distTo(q);
P h = proj(p1, p2, q);
if (isMiddle(p1, h, p2))
return q.distTo(h);
return min(p1.distTo(q), p2.distTo(q));
}
// 求 线段p1p2 与 线段q1q2 的距离
db disSS(P p1, P p2, P q1, P q2) {
if (isSS(p1, p2, q1, q2))
return 0;
return min(min(nearest(p1, p2, q1), nearest(p1, p2, q2)),
min(nearest(q1, q2, p1), nearest(q1, q2, p2)));
}
db area(vector<P> ps) {
db ret = 0;
rep(i, 0, ps.size()) ret += ps[i].det(ps[(i + 1) % ps.size()]);
return ret / 2;
}
int contain(vector<P> ps, P p) { // 2:inside,1:on_seg,0:outside
int n = ps.size(), ret = 0;
rep(i, 0, n) {
P u = ps[i], v = ps[(i + 1) % n];
if (onSeg(u, v, p))
return 1;
if (cmp(u.y, v.y) <= 0)
swap(u, v);
if (cmp(p.y, u.y) > 0 || cmp(p.y, v.y) <= 0)
continue;
ret ^= crossOp(p, u, v) > 0;
}
return ret * 2;
}
vector<P> convexHull(vector<P> ps) {
int n = ps.size();
if (n <= 1)
return ps;
sort(ps.begin(), ps.end());
vector<P> qs(n * 2);
int k = 0;
for (int i = 0; i < n; qs[k++] = ps[i++])
while (k > 1 && crossOp(qs[k - 2], qs[k - 1], ps[i]) <= 0)
--k;
for (int i = n - 2, t = k; i >= 0; qs[k++] = ps[i--])
while (k > t && crossOp(qs[k - 2], qs[k - 1], ps[i]) <= 0)
--k;
qs.resize(k - 1);
return qs;
}
vector<P> convexHullNonStrict(vector<P> ps) {
// caution: need to unique the Ps first
int n = ps.size();
if (n <= 1)
return ps;
sort(ps.begin(), ps.end());
vector<P> qs(n * 2);
int k = 0;
for (int i = 0; i < n; qs[k++] = ps[i++])
while (k > 1 && crossOp(qs[k - 2], qs[k - 1], ps[i]) < 0)
--k;
for (int i = n - 2, t = k; i >= 0; qs[k++] = ps[i--])
while (k > t && crossOp(qs[k - 2], qs[k - 1], ps[i]) < 0)
--k;
qs.resize(k - 1);
return qs;
}
db convexDiameter(vector<P> ps) {
int n = ps.size();
if (n <= 1)
return 0;
int is = 0, js = 0;
rep(k, 1, n) is = ps[k] < ps[is] ? k : is, js = ps[js] < ps[k] ? k : js;
int i = is, j = js;
db ret = ps[i].distTo(ps[j]);
do {
if ((ps[(i + 1) % n] - ps[i]).det(ps[(j + 1) % n] - ps[j]) >= 0)
(++j) %= n;
else
(++i) %= n;
ret = max(ret, ps[i].distTo(ps[j]));
} while (i != is || j != js);
return ret;
}
vector<P> convexCut(const vector<P>& ps, P q1, P q2) {
vector<P> qs;
int n = ps.size();
rep(i, 0, n) {
P p1 = ps[i], p2 = ps[(i + 1) % n];
int d1 = crossOp(q1, q2, p1), d2 = crossOp(q1, q2, p2);
if (d1 >= 0)
qs.push_back(p1);
if (d1 * d2 < 0)
qs.push_back(isLL(p1, p2, q1, q2));
}
return qs;
}
int n;
vector<P> p;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
p.resize(n);
for (int i = 0; i < n; i++) {
p[i].read();
}
db ans = 0;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) {
vector<P> q;
for (int k = 0; k < n; k++) {
if (crossOp(p[i], p[j], p[k]) == 0)
q.push_back(p[k]);
if (crossOp(p[i], p[j], p[k]) *
crossOp(p[i], p[j], p[(k + 1) % n]) <
0)
q.push_back(isLL(p[i], p[j], p[k], p[(k + 1) % n]));
}
sort(q.begin(), q.end());
q.erase(unique(q.begin(), q.end()), q.end()); //去重一下
int m = q.size();
int s = -1, t = -1;
for (int k = 0; k < m; k++) {
if (p[i] == q[k])
s = k;
if (p[j] == q[k])
t = k;
}
if (s > t)
swap(s, t);
if (q[0].distTo(q[m - 1]) <
ans) //剪枝,如果最大的长度还是比答案小,就跳过
continue;
//还有按照启发式枚举的方式枚举
bool inside = true;
db len = 0;
for (int k = s; k < t; k++) {
int v = contain(p, (q[k] + q[k + 1]) / 2);
if (v == 0) {
inside = false;
break;
} else {
len += q[k].distTo(q[k + 1]);
}
}
if (!inside)
continue;
for (int k = s; k > 0; k--) {
int v = contain(p, (q[k] + q[k - 1]) / 2);
if (v == 0) {
break;
} else {
len += q[k].distTo(q[k - 1]);
}
}
for (int k = t; k + 1 < m; k++) {
int v = contain(p, (q[k] + q[k + 1]) / 2);
if (v == 0) {
break;
} else {
len += q[k].distTo(q[k + 1]);
}
}
ans = max(ans, len);
}
cout << fixed << setprecision(10) << ans << endl;
}
A_Colourful_Prospect
题意:至多三个圆,求这些圆将平面划分为了几个区域
做法:首先可能能分类讨论,但是两个圆的情况已经很多了,三个圆想都不敢想。
所以就有一个公式:欧拉公式: V − E + R = 2 , V 是交点个数, E 是边数, R 是被分割的平面数 V-E+R=2,V是交点个数,E是边数,R是被分割的平面数 V−E+R=2,V是交点个数,E是边数,R是被分割的平面数
但是这道题比较特殊,可以有不连通的圆,所以公式改一下: V − E + R = C + 1 V−E+R=C+1 V−E+R=C+1,C是连通块个数
于是求连通块数量可以用并查集计算,交点个数用圆与圆交计算,然后去个重,边数就统计每个圆上的交点个数,累加即可。
/*
coder:sunshine
school:njupt
*/
#include <bits/stdc++.h>
using namespace std;
#define endl '\n' //交互题删掉
#define x first
#define y second
typedef long long ll;
typedef pair<int, int> pii;
constexpr int mod = 1e9 + 7;
typedef double db;
#define rep(i, a, n) for (int i = a; i < n; i++)
const db EPS = 1e-9;
inline int sign(db a) {
return a < -EPS ? -1 : a > EPS;
}
inline int cmp(db a, db b) {
return sign(a - b);
}
struct P {
db x, y;
P() {}
P(db _x, db _y) : x(_x), y(_y) {}
P operator+(P p) { return {x + p.x, y + p.y}; }
P operator-(P p) { return {x - p.x, y - p.y}; }
P operator*(db d) { return {x * d, y * d}; }
P operator/(db d) { return {x / d, y / d}; }
bool operator<(P p) const {
int c = cmp(y, p.y);
if (c)
return c == -1;
return cmp(x, p.x) == -1;
}
bool operator==(P o) const { return cmp(x, o.x) == 0 && cmp(y, o.y) == 0; }
db dot(P p) { return x * p.x + y * p.y; }
db det(P p) { return x * p.y - y * p.x; }
db distTo(P p) { return (*this - p).abs(); }
db alpha() { return atan2(y, x); }
void read() {
int x_, y_;
scanf("%d%d", &x_, &y_);
x = x_, y = y_;
}
void write() { cout << "(" << x << "," << y << ")" << endl; }
db abs() { return sqrt(abs2()); }
db abs2() { return x * x + y * y; }
P rot90() { return P(-y, x); }
P unit() { return *this / abs(); }
int quad() const { return sign(y) == 1 || (sign(y) == 0 && sign(x) >= 0); }
P rot(db an) {
return {x * cos(an) - y * sin(an), x * sin(an) + y * cos(an)};
}
};
#define cross(p1, p2, p3) \
((p2.x - p1.x) * (p3.y - p1.y) - (p3.x - p1.x) * (p2.y - p1.y))
#define crossOp(p1, p2, p3) sign(cross(p1, p2, p3))
// 直线 p1p2, q1q2 是否恰有一个交点
bool chkLL(P p1, P p2, P q1, P q2) {
db a1 = cross(q1, q2, p1), a2 = -cross(q1, q2, p2);
return sign(a1 + a2) != 0;
}
// 求直线 p1p2, q1q2 的交点
P isLL(P p1, P p2, P q1, P q2) {
db a1 = cross(q1, q2, p1), a2 = -cross(q1, q2, p2);
return (p1 * a2 + p2 * a1) / (a1 + a2);
}
// 判断区间 [l1, r1], [l2, r2] 是否相交
bool intersect(db l1, db r1, db l2, db r2) {
if (l1 > r1)
swap(l1, r1);
if (l2 > r2)
swap(l2, r2);
return !(cmp(r1, l2) == -1 || cmp(r2, l1) == -1);
}
// 线段 p1p2, q1q2 相交
bool isSS(P p1, P p2, P q1, P q2) {
return intersect(p1.x, p2.x, q1.x, q2.x) &&
intersect(p1.y, p2.y, q1.y, q2.y) &&
crossOp(p1, p2, q1) * crossOp(p1, p2, q2) <= 0 &&
crossOp(q1, q2, p1) * crossOp(q1, q2, p2) <= 0;
}
// 线段 p1p2, q1q2 严格相交
bool isSS_strict(P p1, P p2, P q1, P q2) {
return crossOp(p1, p2, q1) * crossOp(p1, p2, q2) < 0 &&
crossOp(q1, q2, p1) * crossOp(q1, q2, p2) < 0;
}
// m 在 a 和 b 之间
bool isMiddle(db a, db m, db b) {
/*if (a > b) swap(a, b);
return cmp(a, m) <= 0 && cmp(m, b) <= 0;*/
return sign(a - m) == 0 || sign(b - m) == 0 || (a < m != b < m);
}
bool isMiddle(P a, P m, P b) {
return isMiddle(a.x, m.x, b.x) && isMiddle(a.y, m.y, b.y);
}
// 点 p 在线段 p1p2 上
bool onSeg(P p1, P p2, P q) {
return crossOp(p1, p2, q) == 0 && isMiddle(p1, q, p2);
}
// q1q2 和 p1p2 的交点 在 p1p2 上?
// 点 p 严格在 p1p2 上
bool onSeg_strict(P p1, P p2, P q) {
return crossOp(p1, p2, q) == 0 &&
sign((q - p1).dot(p1 - p2)) * sign((q - p2).dot(p1 - p2)) < 0;
}
// 求 q 到 直线p1p2 的投影(垂足) ⚠️ : p1 != p2
P proj(P p1, P p2, P q) {
P dir = p2 - p1;
return p1 + dir * (dir.dot(q - p1) / dir.abs2());
}
// 求 q 以 直线p1p2 为轴的反射
P reflect(P p1, P p2, P q) {
return proj(p1, p2, q) * 2 - q;
}
// 求 q 到 线段p1p2 的最小距离
db nearest(P p1, P p2, P q) {
if (p1 == p2)
return p1.distTo(q);
P h = proj(p1, p2, q);
if (isMiddle(p1, h, p2))
return q.distTo(h);
return min(p1.distTo(q), p2.distTo(q));
}
// 求 线段p1p2 与 线段q1q2 的距离
db disSS(P p1, P p2, P q1, P q2) {
if (isSS(p1, p2, q1, q2))
return 0;
return min(min(nearest(p1, p2, q1), nearest(p1, p2, q2)),
min(nearest(q1, q2, p1), nearest(q1, q2, p2)));
}
db area(vector<P> ps) {
db ret = 0;
rep(i, 0, ps.size()) ret += ps[i].det(ps[(i + 1) % ps.size()]);
return ret / 2;
}
int contain(vector<P> ps, P p) { // 2:inside,1:on_seg,0:outside
int n = ps.size(), ret = 0;
rep(i, 0, n) {
P u = ps[i], v = ps[(i + 1) % n];
if (onSeg(u, v, p))
return 1;
if (cmp(u.y, v.y) <= 0)
swap(u, v);
if (cmp(p.y, u.y) > 0 || cmp(p.y, v.y) <= 0)
continue;
ret ^= crossOp(p, u, v) > 0;
}
return ret * 2;
}
vector<P> convexHull(vector<P> ps) {
int n = ps.size();
if (n <= 1)
return ps;
sort(ps.begin(), ps.end());
vector<P> qs(n * 2);
int k = 0;
for (int i = 0; i < n; qs[k++] = ps[i++])
while (k > 1 && crossOp(qs[k - 2], qs[k - 1], ps[i]) <= 0)
--k;
for (int i = n - 2, t = k; i >= 0; qs[k++] = ps[i--])
while (k > t && crossOp(qs[k - 2], qs[k - 1], ps[i]) <= 0)
--k;
qs.resize(k - 1);
return qs;
}
vector<P> convexHullNonStrict(vector<P> ps) {
// caution: need to unique the Ps first
int n = ps.size();
if (n <= 1)
return ps;
sort(ps.begin(), ps.end());
vector<P> qs(n * 2);
int k = 0;
for (int i = 0; i < n; qs[k++] = ps[i++])
while (k > 1 && crossOp(qs[k - 2], qs[k - 1], ps[i]) < 0)
--k;
for (int i = n - 2, t = k; i >= 0; qs[k++] = ps[i--])
while (k > t && crossOp(qs[k - 2], qs[k - 1], ps[i]) < 0)
--k;
qs.resize(k - 1);
return qs;
}
db convexDiameter(vector<P> ps) {
int n = ps.size();
if (n <= 1)
return 0;
int is = 0, js = 0;
rep(k, 1, n) is = ps[k] < ps[is] ? k : is, js = ps[js] < ps[k] ? k : js;
int i = is, j = js;
db ret = ps[i].distTo(ps[j]);
do {
if ((ps[(i + 1) % n] - ps[i]).det(ps[(j + 1) % n] - ps[j]) >= 0)
(++j) %= n;
else
(++i) %= n;
ret = max(ret, ps[i].distTo(ps[j]));
} while (i != is || j != js);
return ret;
}
vector<P> convexCut(const vector<P>& ps, P q1, P q2) {
vector<P> qs;
int n = ps.size();
rep(i, 0, n) {
P p1 = ps[i], p2 = ps[(i + 1) % n];
int d1 = crossOp(q1, q2, p1), d2 = crossOp(q1, q2, p2);
if (d1 >= 0)
qs.push_back(p1);
if (d1 * d2 < 0)
qs.push_back(isLL(p1, p2, q1, q2));
}
return qs;
}
int type(P o1, db r1, P o2, db r2) {
db d = o1.distTo(o2);
if (cmp(d, r1 + r2) == 1)
return 4;
if (cmp(d, r1 + r2) == 0)
return 3;
if (cmp(d, abs(r1 - r2)) == 1)
return 2;
if (cmp(d, abs(r1 - r2)) == 0)
return 1;
return 0;
}
vector<P> isCL(P o, db r, P p1, P p2) {
if (cmp(abs((o - p1).det(p2 - p1) / p1.distTo(p2)), r) > 0)
return {};
db x = (p1 - o).dot(p2 - p1), y = (p2 - p1).abs2(),
d = x * x - y * ((p1 - o).abs2() - r * r);
d = max(d, (db)0.0);
P m = p1 - (p2 - p1) * (x / y), dr = (p2 - p1) * (sqrt(d) / y);
return {m - dr, m + dr}; // along dir: p1->p2
}
vector<P> isCC(P o1,
db r1,
P o2,
db r2) { // need to check whether two circles are the same
db d = o1.distTo(o2);
if (cmp(d, r1 + r2) == 1)
return {};
if (cmp(d, abs(r1 - r2)) == -1)
return {};
d = min(d, r1 + r2);
db y = (r1 * r1 + d * d - r2 * r2) / (2 * d), x = sqrt(r1 * r1 - y * y);
P dr = (o2 - o1).unit();
P q1 = o1 + dr * y, q2 = dr.rot90() * x;
return {q1 - q2, q1 + q2}; // along circle 1
}
// extanCC, intanCC : -r2, tanCP : r2 = 0
vector<pair<P, P>> tanCC(P o1, db r1, P o2, db r2) {
P d = o2 - o1;
db dr = r1 - r2, d2 = d.abs2(), h2 = d2 - dr * dr;
if (sign(d2) == 0 || sign(h2) < 0)
return {};
h2 = max(0.0, h2);
vector<pair<P, P>> ret;
for (db sign : {-1, 1}) {
P v = (d * dr + d.rot90() * sqrt(h2) * sign) / d2;
ret.push_back({o1 + v * r1, o2 + v * r2});
}
if (sign(h2) == 0)
ret.pop_back();
return ret;
}
db rad(P p1, P p2) {
return atan2l(p1.det(p2), p1.dot(p2));
}
db areaCT(db r, P p1, P p2) {
vector<P> is = isCL(P(0, 0), r, p1, p2);
if (is.empty())
return r * r * rad(p1, p2) / 2;
bool b1 = cmp(p1.abs2(), r * r) == 1, b2 = cmp(p2.abs2(), r * r) == 1;
if (b1 && b2) {
if (sign((p1 - is[0]).dot(p2 - is[0])) <= 0 &&
sign((p1 - is[1]).dot(p2 - is[1])) <= 0)
return r * r * (rad(p1, is[0]) + rad(is[1], p2)) / 2 +
is[0].det(is[1]) / 2;
else
return r * r * rad(p1, p2) / 2;
}
if (b1)
return (r * r * rad(p1, is[0]) + is[0].det(p2)) / 2;
if (b2)
return (p1.det(is[1]) + r * r * rad(is[1], p2)) / 2;
return p1.det(p2) / 2;
}
P inCenter(P A, P B, P C) {
double a = (B - C).abs(), b = (C - A).abs(), c = (A - B).abs();
return (A * a + B * b + C * c) / (a + b + c);
}
P circumCenter(P a, P b, P c) {
P bb = b - a, cc = c - a;
double db = bb.abs2(), dc = cc.abs2(), d = 2 * bb.det(cc);
return a - P(bb.y * dc - cc.y * db, cc.x * db - bb.x * dc) / d;
}
P othroCenter(P a, P b, P c) {
P ba = b - a, ca = c - a, bc = b - c;
double Y = ba.y * ca.y * bc.y, A = ca.x * ba.y - ba.x * ca.y,
x0 = (Y + ca.x * ba.y * b.x - ba.x * ca.y * c.x) / A,
y0 = -ba.x * (x0 - c.x) / ba.y + ca.y;
return {x0, y0};
}
pair<P, db> min_circle(vector<P> ps) {
random_device rd;
mt19937 rng(rd());
shuffle(ps.begin(), ps.end(), rng);
// random_shuffle(ps.begin(), ps.end());
int n = ps.size();
P o = ps[0];
db r = 0;
rep(i, 1, n) if (o.distTo(ps[i]) > r + EPS) {
o = ps[i], r = 0;
rep(j, 0, i) if (o.distTo(ps[j]) > r + EPS) {
o = (ps[i] + ps[j]) / 2;
r = o.distTo(ps[i]);
rep(k, 0, j) if (o.distTo(ps[k]) > r + EPS) {
o = circumCenter(ps[i], ps[j], ps[k]);
r = o.distTo(ps[i]);
}
}
}
return {o, r};
}
int n, r[10], f[10];
P o[10];
void solve() {
cin >> n;
for (int i = 0; i < n; i++) {
int x, y, r_;
cin >> x >> y >> r_;
o[i] = P(x, y);
r[i] = r_;
}
vector<P> pt;
vector<vector<P>> pts(n);
for (int i = 0; i < n; i++) {
pts[i].clear();
for (int j = 0; j < n; j++) {
if (i != j) {
auto ps = isCC(o[i], r[i], o[j], r[j]);
for (auto p : ps) {
pts[i].push_back(p);
pt.push_back(p);
}
}
}
if (pts[i].empty()) {
P p = o[i] - P(r[i], 0);
pts[i].push_back(p);
pt.push_back(p);
}
//去重
sort(pts[i].begin(), pts[i].end());
pts[i].erase(unique(pts[i].begin(), pts[i].end()), pts[i].end());
}
//去重
sort(pt.begin(), pt.end());
pt.erase(unique(pt.begin(), pt.end()), pt.end());
int V = pt.size();
int E = 0, C = V;
//并查集
for (int i = 1; i <= V; i++)
f[i] = i;
function<int(int)> find = [&](int x) {
if (x != f[x])
f[x] = find(f[x]);
return f[x];
};
for (int i = 0; i < n; i++) {
E += pts[i].size();
int x = lower_bound(pt.begin(), pt.end(), pts[i][0]) - pt.begin() + 1;
for (auto p : pts[i]) {
int y = lower_bound(pt.begin(), pt.end(), p) - pt.begin() + 1;
if (find(x) != find(y)) {
C--;
f[find(x)] = find(y);
}
}
}
int F = E + C + 1 - V;
cout << F << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t = 1;
// cin >> t;
while (t--)
solve();
return 0;
}
板子
dls 的板子
点线:
#include <bits/stdc++.h>
using namespace std;
typedef double db;
const db EPS = 1e-9;
inline int sign(db a) {
return a < -EPS ? -1 : a > EPS;
}
inline int cmp(db a, db b) {
return sign(a - b);
}
struct P {
db x, y;
P() {}
P(db _x, db _y) : x(_x), y(_y) {}
//重构加减乘除
P operator+(P p) { return {x + p.x, y + p.y}; }
P operator-(P p) { return {x - p.x, y - p.y}; }
P operator*(db d) { return {x * d, y * d}; }
P operator/(db d) { return {x / d, y / d}; }
bool operator<(P p) const {
int c = cmp(x, p.x);
if (c)
return c == -1;
return cmp(y, p.y) == -1;
}
bool operator==(P o) const { return cmp(x, o.x) == 0 && cmp(y, o.y) == 0; }
db dot(P p) { return x * p.x + y * p.y; } //点积
db det(P p) { return x * p.y - y * p.x; } //叉积
db distTo(P p) { return (*this - p).abs(); }
db alpha() { return atan2(y, x); }
void read() { cin >> x >> y; }
void write() { cout << "(" << x << "," << y << ")" << endl; }
db abs() { return sqrt(abs2()); }
db abs2() { return x * x + y * y; }
P rot90() { return P(-y, x); }
P unit() { return *this / abs(); }
int quad() const { return sign(y) == 1 || (sign(y) == 0 && sign(x) >= 0); }
P rot(db an) {
return {x * cos(an) - y * sin(an), x * sin(an) + y * cos(an)};
}
};
#define cross(p1, p2, p3) \
((p2.x - p1.x) * (p3.y - p1.y) - (p3.x - p1.x) * (p2.y - p1.y))
#define crossOp(p1, p2, p3) sign(cross(p1, p2, p3))
// 直线 p1p2, q1q2 是否恰有一个交点
bool chkLL(P p1, P p2, P q1, P q2) {
db a1 = cross(q1, q2, p1), a2 = -cross(q1, q2, p2);
return sign(a1 + a2) != 0;
}
// 求直线 p1p2, q1q2 的交点
P isLL(P p1, P p2, P q1, P q2) {
db a1 = cross(q1, q2, p1), a2 = -cross(q1, q2, p2);
return (p1 * a2 + p2 * a1) / (a1 + a2);
}
// 判断区间 [l1, r1], [l2, r2] 是否相交
bool intersect(db l1, db r1, db l2, db r2) {
if (l1 > r1)
swap(l1, r1);
if (l2 > r2)
swap(l2, r2);
return !(cmp(r1, l2) == -1 || cmp(r2, l1) == -1);
}
// 线段 p1p2, q1q2 相交
bool isSS(P p1, P p2, P q1, P q2) {
return intersect(p1.x, p2.x, q1.x, q2.x) &&
intersect(p1.y, p2.y, q1.y, q2.y) &&
crossOp(p1, p2, q1) * crossOp(p1, p2, q2) <= 0 &&
crossOp(q1, q2, p1) * crossOp(q1, q2, p2) <= 0;
}
// 线段 p1p2, q1q2 严格相交
bool isSS_strict(P p1, P p2, P q1, P q2) {
return crossOp(p1, p2, q1) * crossOp(p1, p2, q2) < 0 &&
crossOp(q1, q2, p1) * crossOp(q1, q2, p2) < 0;
}
// m 在 a 和 b 之间
bool isMiddle(db a, db m, db b) {
/*if (a > b) swap(a, b);
return cmp(a, m) <= 0 && cmp(m, b) <= 0;*/
return sign(a - m) == 0 || sign(b - m) == 0 || (a < m != b < m);
}
bool isMiddle(P a, P m, P b) {
return isMiddle(a.x, m.x, b.x) && isMiddle(a.y, m.y, b.y);
}
// 点 p 在线段 p1p2 上
bool onSeg(P p1, P p2, P q) {
return crossOp(p1, p2, q) == 0 && isMiddle(p1, q, p2);
}
// q1q2 和 p1p2 的交点 在 p1p2 上?
// 点 p 严格在 p1p2 上
bool onSeg_strict(P p1, P p2, P q) {
return crossOp(p1, p2, q) == 0 &&
sign((q - p1).dot(p1 - p2)) * sign((q - p2).dot(p1 - p2)) < 0;
}
// 求 q 到 直线p1p2 的投影(垂足) ⚠️ : p1 != p2
P proj(P p1, P p2, P q) {
P dir = p2 - p1;
return p1 + dir * (dir.dot(q - p1) / dir.abs2());
}
// 求 q 以 直线p1p2 为轴的反射
P reflect(P p1, P p2, P q) {
return proj(p1, p2, q) * 2 - q;
}
// 求 q 到 线段p1p2 的最小距离
db nearest(P p1, P p2, P q) {
if (p1 == p2)
return p1.distTo(q);
P h = proj(p1, p2, q);
if (isMiddle(p1, h, p2))
return q.distTo(h);
return min(p1.distTo(q), p2.distTo(q));
}
// 求 线段p1p2 与 线段q1q2 的距离
db disSS(P p1, P p2, P q1, P q2) {
if (isSS(p1, p2, q1, q2))
return 0;
return min(min(nearest(p1, p2, q1), nearest(p1, p2, q2)),
min(nearest(q1, q2, p1), nearest(q1, q2, p2)));
}
// 极角排序
sort(p, p + n, [&](P a, P b) {
int qa = a.quad(), qb = b.quad();
if (qa != qb)
return qa < qb;
else
return sign(a.det(b)) > 0;
});
多边形
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, n) for (int i = a; i < n; i++)
typedef double db;
const db EPS = 1e-9;
//求多边形面积
db area(vector<P> ps) {
db ret = 0;
rep(i, 0, ps.size()) ret += ps[i].det(ps[(i + 1) % ps.size()]);
return ret / 2;
}
//点包含
int contain(vector<P> ps, P p) { // 2:inside,1:on_seg,0:outside
int n = ps.size(), ret = 0;
rep(i, 0, n) {
P u = ps[i], v = ps[(i + 1) % n];
if (onSeg(u, v, p))
return 1;
if (cmp(u.y, v.y) <= 0)
swap(u, v);
if (cmp(p.y, u.y) > 0 || cmp(p.y, v.y) <= 0)
continue;
ret ^= crossOp(p, u, v) > 0;
}
return ret * 2;
}
//严格凸包
vector<P> convexHull(vector<P> ps) {
int n = ps.size();
if (n <= 1)
return ps;
sort(ps.begin(), ps.end());
vector<P> qs(n * 2);
int k = 0;
for (int i = 0; i < n; qs[k++] = ps[i++])
while (k > 1 && crossOp(qs[k - 2], qs[k - 1], ps[i]) <= 0)
--k;
for (int i = n - 2, t = k; i >= 0; qs[k++] = ps[i--])
while (k > t && crossOp(qs[k - 2], qs[k - 1], ps[i]) <= 0)
--k;
qs.resize(k - 1);
return qs;
}
//不严格凸包
vector<P> convexHullNonStrict(vector<P> ps) {
// caution: need to unique the Ps first
int n = ps.size();
if (n <= 1)
return ps;
sort(ps.begin(), ps.end());
vector<P> qs(n * 2);
int k = 0;
for (int i = 0; i < n; qs[k++] = ps[i++])
while (k > 1 && crossOp(qs[k - 2], qs[k - 1], ps[i]) < 0)
--k;
for (int i = n - 2, t = k; i >= 0; qs[k++] = ps[i--])
while (k > t && crossOp(qs[k - 2], qs[k - 1], ps[i]) < 0)
--k;
qs.resize(k - 1);
return qs;
}
//旋转卡壳
db convexDiameter(vector<P> ps) {
int n = ps.size();
if (n <= 1)
return 0;
int is = 0, js = 0;
rep(k, 1, n) is = ps[k] < ps[is] ? k : is, js = ps[js] < ps[k] ? k : js;
int i = is, j = js;
db ret = ps[i].distTo(ps[j]);
do {
if ((ps[(i + 1) % n] - ps[i]).det(ps[(j + 1) % n] - ps[j]) >= 0)
(++j) %= n;
else
(++i) %= n;
ret = max(ret, ps[i].distTo(ps[j]));
} while (i != is || j != js);
return ret;
}
//切多边形
vector<P> convexCut(const vector<P>& ps, P q1, P q2) {
vector<P> qs;
int n = ps.size();
rep(i, 0, n) {
P p1 = ps[i], p2 = ps[(i + 1) % n];
int d1 = crossOp(q1, q2, p1), d2 = crossOp(q1, q2, p2);
if (d1 >= 0)
qs.push_back(p1);
if (d1 * d2 < 0)
qs.push_back(isLL(p1, p2, q1, q2));
}
return qs;
}
圆
#define rep(i, a, n) for (int i = a; i < n; i++)
const double PI = acos(-1.0);
//判断两个圆的关系
int type(P o1, db r1, P o2, db r2) {
db d = o1.distTo(o2);
if (cmp(d, r1 + r2) == 1)
return 4;
if (cmp(d, r1 + r2) == 0)
return 3;
if (cmp(d, abs(r1 - r2)) == 1)
return 2;
if (cmp(d, abs(r1 - r2)) == 0)
return 1;
return 0;
}
//圆和线相交
vector<P> isCL(P o, db r, P p1, P p2) {
if (cmp(abs((o - p1).det(p2 - p1) / p1.distTo(p2)), r) > 0)
return {};
db x = (p1 - o).dot(p2 - p1), y = (p2 - p1).abs2(),
d = x * x - y * ((p1 - o).abs2() - r * r);
d = max(d, (db)0.0);
P m = p1 - (p2 - p1) * (x / y), dr = (p2 - p1) * (sqrt(d) / y);
return {m - dr, m + dr}; // along dir: p1->p2
}
//两个圆相交的交点
vector<P> isCC(P o1,
db r1,
P o2,
db r2) { // need to check whether two circles are the same
db d = o1.distTo(o2);
if (cmp(d, r1 + r2) == 1)
return {};
if (cmp(d, abs(r1 - r2)) == -1)
return {};
d = min(d, r1 + r2);
db y = (r1 * r1 + d * d - r2 * r2) / (2 * d), x = sqrt(r1 * r1 - y * y);
P dr = (o2 - o1).unit();
P q1 = o1 + dr * y, q2 = dr.rot90() * x;
return {q1 - q2, q1 + q2}; // along circle 1
}
//求切线,默认求外公切线,求内公切线的话,r2改成负数,求点到圆的切线,r2改成0
// extanCC, intanCC : -r2, tanCP : r2 = 0
vector<pair<P, P>> tanCC(P o1, db r1, P o2, db r2) {
P d = o2 - o1;
db dr = r1 - r2, d2 = d.abs2(), h2 = d2 - dr * dr;
if (sign(d2) == 0 || sign(h2) < 0)
return {};
h2 = max((db)0.0, h2);
vector<pair<P, P>> ret;
for (db sign : {-1, 1}) {
P v = (d * dr + d.rot90() * sqrt(h2) * sign) / d2;
ret.push_back({o1 + v * r1, o2 + v * r2});
}
if (sign(h2) == 0)
ret.pop_back();
return ret;
}
db rad(P p1, P p2) {
return atan2l(p1.det(p2), p1.dot(p2));
}
//圆和三角形的面积交
db areaCT(db r, P p1, P p2) {
vector<P> is = isCL(P(0, 0), r, p1, p2);
if (is.empty())
return r * r * rad(p1, p2) / 2;
bool b1 = cmp(p1.abs2(), r * r) == 1, b2 = cmp(p2.abs2(), r * r) == 1;
if (b1 && b2) {
P md = (is[0] + is[1]) / 2;
if (sign((p1 - md).dot(p2 - md)) <= 0)
return r * r * (rad(p1, is[0]) + rad(is[1], p2)) / 2 +
is[0].det(is[1]) / 2;
else
return r * r * rad(p1, p2) / 2;
}
if (b1)
return (r * r * rad(p1, is[0]) + is[0].det(p2)) / 2;
if (b2)
return (p1.det(is[1]) + r * r * rad(is[1], p2)) / 2;
return p1.det(p2) / 2;
}
//内心
P inCenter(P A, P B, P C) {
double a = (B - C).abs(), b = (C - A).abs(), c = (A - B).abs();
return (A * a + B * b + C * c) / (a + b + c);
}
//外心
P circumCenter(P a, P b, P c) {
P bb = b - a, cc = c - a;
double db = bb.abs2(), dc = cc.abs2(), d = 2 * bb.det(cc);
return a - P(bb.y * dc - cc.y * db, cc.x * db - bb.x * dc) / d;
}
//垂心
P othroCenter(P a, P b, P c) {
P ba = b - a, ca = c - a, bc = b - c;
double Y = ba.y * ca.y * bc.y, A = ca.x * ba.y - ba.x * ca.y,
x0 = (Y + ca.x * ba.y * b.x - ba.x * ca.y * c.x) / A,
y0 = -ba.x * (x0 - c.x) / ba.y + ca.y;
return {x0, y0};
}
//最小圆覆盖,随机增量法
pair<P, db> min_circle(vector<P> ps) {
random_device rd;
mt19937 rng(rd());
shuffle(ps.begin(), ps.end(), rng);
// random_shuffle(ps.begin(), ps.end());
int n = ps.size();
P o = ps[0];
db r = 0;
rep(i, 1, n) if (o.distTo(ps[i]) > r + EPS) {
o = ps[i], r = 0;
rep(j, 0, i) if (o.distTo(ps[j]) > r + EPS) {
o = (ps[i] + ps[j]) / 2;
r = o.distTo(ps[i]);
rep(k, 0, j) if (o.distTo(ps[k]) > r + EPS) {
o = circumCenter(ps[i], ps[j], ps[k]);
r = o.distTo(ps[i]);
}
}
}
return {o, r};
}
db intergal(db x, db y, db r, db L, db R) {
return r * r * (R - L) + x * r * (sinl(R) - sinl(L)) +
y * r * (-cosl(R) + cosl(L));
}
db calc_area_circle(P c, db r, db L, db R) {
return intergal(c.x, c.y, r, L, R) / 2;
}
db norm(db x) {
while (x < 0)
x += 2 * PI;
while (x > 2 * PI)
x -= 2 * PI;
return x;
}
//圆面积并
P cs[N];
db rs[N];
void work() {
vector<int> cand = {};
rep(i, 0, n) {
bool ok = 1;
rep(j, 0, n) if (i != j) {
if (rs[j] > rs[i] + EPS &&
rs[i] + cs[i].distTo(cs[j]) <= rs[j] + EPS) {
ok = 0;
break;
}
if (cs[i] == cs[j] && cmp(rs[i], rs[j]) == 0 && j < i) {
ok = 0;
break;
}
}
if (ok)
cand.push_back(i);
}
rep(i, 0, cand.size()) cs[i] = cs[cand[i]], rs[i] = rs[cand[i]];
n = cand.size();
db area = 0;
// work
rep(i, 0, n) {
vector<pair<db, int>> ev = {{0, 0}, {2 * PI, 0}};
int cur = 0;
rep(j, 0, n) if (j != i) {
auto ret = isCC(cs[i], rs[i], cs[j], rs[j]);
if (!ret.empty()) {
db l = (ret[0] - cs[i]).alpha();
db r = (ret[1] - cs[i]).alpha();
l = norm(l);
r = norm(r);
ev.push_back({l, 1});
ev.push_back({r, -1});
if (l > r)
++cur;
}
}
sort(ev.begin(), ev.end());
rep(j, 0, ev.size() - 1) {
cur += ev[j].se;
if (cur == 0) {
area += calc_area_circle(cs[i], rs[i], ev[j].fi, ev[j + 1].fi);
}
}
}
}
牛客
比较全,按需自取
#include <bits/stdc++.h>
using namespace std;
using point_t = long double; //全局数据类型,可修改为 long long 等
constexpr point_t eps = 1e-8;
constexpr long double PI = 3.1415926535897932384l;
// 点与向量
template <typename T>
struct point {
T x, y;
bool operator==(const point& a) const {
return (abs(x - a.x) <= eps && abs(y - a.y) <= eps);
}
bool operator<(const point& a) const {
if (abs(x - a.x) <= eps)
return y < a.y - eps;
return x < a.x - eps;
}
bool operator>(const point& a) const { return !(*this < a || *this == a); }
point operator+(const point& a) const { return {x + a.x, y + a.y}; }
point operator-(const point& a) const { return {x - a.x, y - a.y}; }
point operator-() const { return {-x, -y}; }
point operator*(const T k) const { return {k * x, k * y}; }
point operator/(const T k) const { return {x / k, y / k}; }
T operator*(const point& a) const { return x * a.x + y * a.y; } // 点积
T operator^(const point& a) const {
return x * a.y - y * a.x;
} // 叉积,注意优先级
int toleft(const point& a) const {
const auto t = (*this) ^ a;
return (t > eps) - (t < -eps);
} // to-left 测试
T len2() const { return (*this) * (*this); } // 向量长度的平方
T dis2(const point& a) const {
return (a - (*this)).len2();
} // 两点距离的平方
// 涉及浮点数
long double len() const { return sqrtl(len2()); } // 向量长度
long double dis(const point& a) const {
return sqrtl(dis2(a));
} // 两点距离
long double ang(const point& a) const {
return acosl(max(-1.0l, min(1.0l, ((*this) * a) / (len() * a.len()))));
} // 向量夹角
point rot(const long double rad) const {
return {x * cos(rad) - y * sin(rad), x * sin(rad) + y * cos(rad)};
} // 逆时针旋转(给定角度)
point rot(const long double cosr, const long double sinr) const {
return {x * cosr - y * sinr, x * sinr + y * cosr};
} // 逆时针旋转(给定角度的正弦与余弦)
};
using Point = point<point_t>;
// 极角排序
struct argcmp {
bool operator()(const Point& a, const Point& b) const {
const auto quad = [](const Point& a) {
if (a.y < -eps)
return 1;
if (a.y > eps)
return 4;
if (a.x < -eps)
return 5;
if (a.x > eps)
return 3;
return 2;
};
const int qa = quad(a), qb = quad(b);
if (qa != qb)
return qa < qb;
const auto t = a ^ b;
// if (abs(t)<=eps) return a*a<b*b-eps; // 不同长度的向量需要分开
return t > eps;
}
};
// 直线
template <typename T>
struct line {
point<T> p, v; // p 为直线上一点,v 为方向向量
bool operator==(const line& a) const {
return v.toleft(a.v) == 0 && v.toleft(p - a.p) == 0;
}
int toleft(const point<T>& a) const {
return v.toleft(a - p);
} // to-left 测试
bool operator<(const line& a) const // 半平面交算法定义的排序
{
if (abs(v ^ a.v) <= eps && v * a.v >= -eps)
return toleft(a.p) == -1;
return argcmp()(v, a.v);
}
// 涉及浮点数
point<T> inter(const line& a) const {
return p + v * ((a.v ^ (p - a.p)) / (v ^ a.v));
} // 直线交点
long double dis(const point<T>& a) const {
return abs(v ^ (a - p)) / v.len();
} // 点到直线距离
point<T> proj(const point<T>& a) const {
return p + v * ((v * (a - p)) / (v * v));
} // 点在直线上的投影
};
using Line = line<point_t>;
//线段
template <typename T>
struct segment {
point<T> a, b;
bool operator<(const segment& s) const {
return make_pair(a, b) < make_pair(s.a, s.b);
}
// 判定性函数建议在整数域使用
// 判断点是否在线段上
// -1 点在线段端点 | 0 点不在线段上 | 1 点严格在线段上
int is_on(const point<T>& p) const {
if (p == a || p == b)
return -1;
return (p - a).toleft(p - b) == 0 && (p - a) * (p - b) < -eps;
}
// 判断线段直线是否相交
// -1 直线经过线段端点 | 0 线段和直线不相交 | 1 线段和直线严格相交
int is_inter(const line<T>& l) const {
if (l.toleft(a) == 0 || l.toleft(b) == 0)
return -1;
return l.toleft(a) != l.toleft(b);
}
// 判断两线段是否相交
// -1 在某一线段端点处相交 | 0 两线段不相交 | 1 两线段严格相交
int is_inter(const segment<T>& s) const {
if (is_on(s.a) || is_on(s.b) || s.is_on(a) || s.is_on(b))
return -1;
const line<T> l{a, b - a}, ls{s.a, s.b - s.a};
return l.toleft(s.a) * l.toleft(s.b) == -1 &&
ls.toleft(a) * ls.toleft(b) == -1;
}
// 点到线段距离
long double dis(const point<T>& p) const {
if ((p - a) * (b - a) < -eps || (p - b) * (a - b) < -eps)
return min(p.dis(a), p.dis(b));
const line<T> l{a, b - a};
return l.dis(p);
}
// 两线段间距离
long double dis(const segment<T>& s) const {
if (is_inter(s))
return 0;
return min({dis(s.a), dis(s.b), s.dis(a), s.dis(b)});
}
};
using Segment = segment<point_t>;
// 多边形
template <typename T>
struct polygon {
vector<point<T>> p; // 以逆时针顺序存储
size_t nxt(const size_t i) const { return i == p.size() - 1 ? 0 : i + 1; }
size_t pre(const size_t i) const { return i == 0 ? p.size() - 1 : i - 1; }
// 回转数
// 返回值第一项表示点是否在多边形边上
// 对于狭义多边形,回转数为 0 表示点在多边形外,否则点在多边形内
pair<bool, int> winding(const point<T>& a) const {
int cnt = 0;
for (size_t i = 0; i < p.size(); i++) {
const point<T> u = p[i], v = p[nxt(i)];
if (abs((a - u) ^ (a - v)) <= eps && (a - u) * (a - v) <= eps)
return {true, 0};
if (abs(u.y - v.y) <= eps)
continue;
const Line uv = {u, v - u};
if (u.y < v.y - eps && uv.toleft(a) <= 0)
continue;
if (u.y > v.y + eps && uv.toleft(a) >= 0)
continue;
if (u.y < a.y - eps && v.y >= a.y - eps)
cnt++;
if (u.y >= a.y - eps && v.y < a.y - eps)
cnt--;
}
return {false, cnt};
}
// 多边形面积的两倍
// 可用于判断点的存储顺序是顺时针或逆时针
T area() const {
T sum = 0;
for (size_t i = 0; i < p.size(); i++)
sum += p[i] ^ p[nxt(i)];
return sum;
}
// 多边形的周长
long double circ() const {
long double sum = 0;
for (size_t i = 0; i < p.size(); i++)
sum += p[i].dis(p[nxt(i)]);
return sum;
}
};
using Polygon = polygon<point_t>;
//凸多边形
template <typename T>
struct convex : polygon<T> {
// 闵可夫斯基和
convex operator+(const convex& c) const {
const auto& p = this->p;
vector<Segment> e1(p.size()), e2(c.p.size()),
edge(p.size() + c.p.size());
vector<point<T>> res;
res.reserve(p.size() + c.p.size());
const auto cmp = [](const Segment& u, const Segment& v) {
return argcmp()(u.b - u.a, v.b - v.a);
};
for (size_t i = 0; i < p.size(); i++)
e1[i] = {p[i], p[this->nxt(i)]};
for (size_t i = 0; i < c.p.size(); i++)
e2[i] = {c.p[i], c.p[c.nxt(i)]};
rotate(e1.begin(), min_element(e1.begin(), e1.end(), cmp), e1.end());
rotate(e2.begin(), min_element(e2.begin(), e2.end(), cmp), e2.end());
merge(e1.begin(), e1.end(), e2.begin(), e2.end(), edge.begin(), cmp);
const auto check = [](const vector<point<T>>& res, const point<T>& u) {
const auto back1 = res.back(), back2 = *prev(res.end(), 2);
return (back1 - back2).toleft(u - back1) == 0 &&
(back1 - back2) * (u - back1) >= -eps;
};
auto u = e1[0].a + e2[0].a;
for (const auto& v : edge) {
while (res.size() > 1 && check(res, u))
res.pop_back();
res.push_back(u);
u = u + v.b - v.a;
}
if (res.size() > 1 && check(res, res[0]))
res.pop_back();
return {res};
}
// 旋转卡壳
// func 为更新答案的函数,可以根据题目调整位置
template <typename F>
void rotcaliper(const F& func) const {
const auto& p = this->p;
const auto area = [](const point<T>& u, const point<T>& v,
const point<T>& w) { return (w - u) ^ (w - v); };
for (size_t i = 0, j = 1; i < p.size(); i++) {
const auto nxti = this->nxt(i);
func(p[i], p[nxti], p[j]);
while (area(p[this->nxt(j)], p[i], p[nxti]) >=
area(p[j], p[i], p[nxti])) {
j = this->nxt(j);
func(p[i], p[nxti], p[j]);
}
}
}
// 凸多边形的直径的平方
T diameter2() const {
const auto& p = this->p;
if (p.size() == 1)
return 0;
if (p.size() == 2)
return p[0].dis2(p[1]);
T ans = 0;
auto func = [&](const point<T>& u, const point<T>& v,
const point<T>& w) {
ans = max({ans, w.dis2(u), w.dis2(v)});
};
rotcaliper(func);
return ans;
}
// 判断点是否在凸多边形内
// 复杂度 O(logn)
// -1 点在多边形边上 | 0 点在多边形外 | 1 点在多边形内
int is_in(const point<T>& a) const {
const auto& p = this->p;
if (p.size() == 1)
return a == p[0] ? -1 : 0;
if (p.size() == 2)
return segment<T>{p[0], p[1]}.is_on(a) ? -1 : 0;
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 segment<T>{p[0], p[i]}.is_on(a) ? -1 : 0;
if (i == p.size() - 1 && segment<T>{p[0], p[i]}.is_on(a))
return -1;
if (segment<T>{p[i - 1], p[i]}.is_on(a))
return -1;
return (p[i] - p[i - 1]).toleft(a - p[i - 1]) > 0;
}
// 凸多边形关于某一方向的极点
// 复杂度 O(logn)
// 参考资料:https://codeforces.com/blog/entry/48868
template <typename F>
size_t extreme(const F& dir) const {
const auto& p = this->p;
const auto check = [&](const size_t i) {
return dir(p[i]).toleft(p[this->nxt(i)] - p[i]) >= 0;
};
const auto dir0 = dir(p[0]);
const auto check0 = check(0);
if (!check0 && check(p.size() - 1))
return 0;
const auto cmp = [&](const Point& v) {
const size_t vi = &v - p.data();
if (vi == 0)
return 1;
const auto checkv = check(vi);
const auto t = dir0.toleft(v - p[0]);
if (vi == 1 && checkv == check0 && t == 0)
return 1;
return checkv ^ (checkv == check0 && t <= 0);
};
return partition_point(p.begin(), p.end(), cmp) - p.begin();
}
// 过凸多边形外一点求凸多边形的切线,返回切点下标
// 复杂度 O(logn)
// 必须保证点在多边形外
pair<size_t, size_t> tangent(const point<T>& a) const {
const size_t i = extreme([&](const point<T>& u) { return u - a; });
const size_t j = extreme([&](const point<T>& u) { return a - u; });
return {i, j};
}
// 求平行于给定直线的凸多边形的切线,返回切点下标
// 复杂度 O(logn)
pair<size_t, size_t> tangent(const line<T>& a) const {
const size_t i = extreme([&](...) { return a.v; });
const size_t j = extreme([&](...) { return -a.v; });
return {i, j};
}
};
using Convex = convex<point_t>;
// 圆
struct Circle {
Point c;
long double r;
bool operator==(const Circle& a) const {
return c == a.c && abs(r - a.r) <= eps;
}
long double circ() const { return 2 * PI * r; } // 周长
long double area() const { return PI * r * r; } // 面积
// 点与圆的关系
// -1 圆上 | 0 圆外 | 1 圆内
int is_in(const Point& p) const {
const long double d = p.dis(c);
return abs(d - r) <= eps ? -1 : d < r - eps;
}
// 直线与圆关系
// 0 相离 | 1 相切 | 2 相交
int relation(const Line& l) const {
const long double d = l.dis(c);
if (d > r + eps)
return 0;
if (abs(d - r) <= eps)
return 1;
return 2;
}
// 圆与圆关系
// -1 相同 | 0 相离 | 1 外切 | 2 相交 | 3 内切 | 4 内含
int relation(const Circle& a) const {
if (*this == a)
return -1;
const long double d = c.dis(a.c);
if (d > r + a.r + eps)
return 0;
if (abs(d - r - a.r) <= eps)
return 1;
if (abs(d - abs(r - a.r)) <= eps)
return 3;
if (d < abs(r - a.r) - eps)
return 4;
return 2;
}
// 直线与圆的交点
vector<Point> inter(const Line& l) const {
const long double d = l.dis(c);
const Point p = l.proj(c);
const int t = relation(l);
if (t == 0)
return vector<Point>();
if (t == 1)
return vector<Point>{p};
const long double k = sqrt(r * r - d * d);
return vector<Point>{p - (l.v / l.v.len()) * k,
p + (l.v / l.v.len()) * k};
}
// 圆与圆交点
vector<Point> inter(const Circle& a) const {
const long double d = c.dis(a.c);
const int t = relation(a);
if (t == -1 || t == 0 || t == 4)
return vector<Point>();
Point e = a.c - c;
e = e / e.len() * r;
if (t == 1 || t == 3) {
if (r * r + d * d - a.r * a.r >= -eps)
return vector<Point>{c + e};
return vector<Point>{c - e};
}
const long double costh = (r * r + d * d - a.r * a.r) / (2 * r * d),
sinth = sqrt(1 - costh * costh);
return vector<Point>{c + e.rot(costh, -sinth), c + e.rot(costh, sinth)};
}
// 圆与圆交面积
long double inter_area(const Circle& a) const {
const long double d = c.dis(a.c);
const int t = relation(a);
if (t == -1)
return area();
if (t < 2)
return 0;
if (t > 2)
return min(area(), a.area());
const long double costh1 = (r * r + d * d - a.r * a.r) / (2 * r * d),
costh2 = (a.r * a.r + d * d - r * r) / (2 * a.r * d);
const long double sinth1 = sqrt(1 - costh1 * costh1),
sinth2 = sqrt(1 - costh2 * costh2);
const long double th1 = acos(costh1), th2 = acos(costh2);
return r * r * (th1 - costh1 * sinth1) +
a.r * a.r * (th2 - costh2 * sinth2);
}
// 过圆外一点圆的切线
vector<Line> tangent(const Point& a) const {
const int t = is_in(a);
if (t == 1)
return vector<Line>();
if (t == -1) {
const Point v = {-(a - c).y, (a - c).x};
return vector<Line>{{a, v}};
}
Point e = a - c;
e = e / e.len() * r;
const long double costh = r / c.dis(a), sinth = sqrt(1 - costh * costh);
const Point t1 = c + e.rot(costh, -sinth), t2 = c + e.rot(costh, sinth);
return vector<Line>{{a, t1 - a}, {a, t2 - a}};
}
// 两圆的公切线
vector<Line> tangent(const Circle& a) const {
const int t = relation(a);
vector<Line> lines;
if (t == -1 || t == 4)
return lines;
if (t == 1 || t == 3) {
const Point p = inter(a)[0], v = {-(a.c - c).y, (a.c - c).x};
lines.push_back({p, v});
}
const long double d = c.dis(a.c);
const Point e = (a.c - c) / (a.c - c).len();
if (t <= 2) {
const long double costh = (r - a.r) / d,
sinth = sqrt(1 - costh * costh);
const Point d1 = e.rot(costh, -sinth), d2 = e.rot(costh, sinth);
const Point u1 = c + d1 * r, u2 = c + d2 * r, v1 = a.c + d1 * a.r,
v2 = a.c + d2 * a.r;
lines.push_back({u1, v1 - u1});
lines.push_back({u2, v2 - u2});
}
if (t == 0) {
const long double costh = (r + a.r) / d,
sinth = sqrt(1 - costh * costh);
const Point d1 = e.rot(costh, -sinth), d2 = e.rot(costh, sinth);
const Point u1 = c + d1 * r, u2 = c + d2 * r, v1 = a.c - d1 * a.r,
v2 = a.c - d2 * a.r;
lines.push_back({u1, v1 - u1});
lines.push_back({u2, v2 - u2});
}
return lines;
}
// 圆的反演
tuple<int, Circle, Line> inverse(const Line& l) const {
const Circle null_c = {{0.0, 0.0}, 0.0};
const Line null_l = {{0.0, 0.0}, {0.0, 0.0}};
if (l.toleft(c) == 0)
return {2, null_c, l};
const Point v =
l.toleft(c) == 1 ? Point{l.v.y, -l.v.x} : Point{-l.v.y, l.v.x};
const long double d = r * r / l.dis(c);
const Point p = c + v / v.len() * d;
return {1, {(c + p) / 2, d / 2}, null_l};
}
tuple<int, Circle, Line> inverse(const Circle& a) const {
const Circle null_c = {{0.0, 0.0}, 0.0};
const Line null_l = {{0.0, 0.0}, {0.0, 0.0}};
const Point v = a.c - c;
if (a.is_in(c) == -1) {
const long double d = r * r / (a.r + a.r);
const Point p = c + v / v.len() * d;
return {2, null_c, {p, {-v.y, v.x}}};
}
if (c == a.c)
return {1, {c, r * r / a.r}, null_l};
const long double d1 = r * r / (c.dis(a.c) - a.r),
d2 = r * r / (c.dis(a.c) + a.r);
const Point p = c + v / v.len() * d1, q = c + v / v.len() * d2;
return {1, {(p + q) / 2, p.dis(q) / 2}, null_l};
}
};
// 圆与多边形面积交
long double area_inter(const Circle& circ, const Polygon& poly) {
const auto cal = [](const Circle& circ, const Point& a, const Point& b) {
if ((a - circ.c).toleft(b - circ.c) == 0)
return 0.0l;
const auto ina = circ.is_in(a), inb = circ.is_in(b);
const Line ab = {a, b - a};
if (ina && inb)
return ((a - circ.c) ^ (b - circ.c)) / 2;
if (ina && !inb) {
const auto t = circ.inter(ab);
const Point p = t.size() == 1 ? t[0] : t[1];
const long double ans = ((a - circ.c) ^ (p - circ.c)) / 2;
const long double th = (p - circ.c).ang(b - circ.c);
const long double d = circ.r * circ.r * th / 2;
if ((a - circ.c).toleft(b - circ.c) == 1)
return ans + d;
return ans - d;
}
if (!ina && inb) {
const Point p = circ.inter(ab)[0];
const long double ans = ((p - circ.c) ^ (b - circ.c)) / 2;
const long double th = (a - circ.c).ang(p - circ.c);
const long double d = circ.r * circ.r * th / 2;
if ((a - circ.c).toleft(b - circ.c) == 1)
return ans + d;
return ans - d;
}
const auto p = circ.inter(ab);
if (p.size() == 2 && Segment{a, b}.dis(circ.c) <= circ.r + eps) {
const long double ans = ((p[0] - circ.c) ^ (p[1] - circ.c)) / 2;
const long double th1 = (a - circ.c).ang(p[0] - circ.c),
th2 = (b - circ.c).ang(p[1] - circ.c);
const long double d1 = circ.r * circ.r * th1 / 2,
d2 = circ.r * circ.r * th2 / 2;
if ((a - circ.c).toleft(b - circ.c) == 1)
return ans + d1 + d2;
return ans - d1 - d2;
}
const long double th = (a - circ.c).ang(b - circ.c);
if ((a - circ.c).toleft(b - circ.c) == 1)
return circ.r * circ.r * th / 2;
return -circ.r * circ.r * th / 2;
};
long double ans = 0;
for (size_t i = 0; i < poly.p.size(); i++) {
const Point a = poly.p[i], b = poly.p[poly.nxt(i)];
ans += cal(circ, a, b);
}
return ans;
}
// 点集的凸包
// Andrew 算法,复杂度 O(nlogn)
Convex convexhull(vector<Point> p) {
vector<Point> st;
if (p.empty())
return Convex{st};
sort(p.begin(), p.end());
const auto check = [](const vector<Point>& st, const Point& u) {
const auto back1 = st.back(), back2 = *prev(st.end(), 2);
return (back1 - back2).toleft(u - back1) <= 0;
};
for (const Point& u : p) {
while (st.size() > 1 && check(st, u))
st.pop_back();
st.push_back(u);
}
size_t k = st.size();
p.pop_back();
reverse(p.begin(), p.end());
for (const Point& u : p) {
while (st.size() > k && check(st, u))
st.pop_back();
st.push_back(u);
}
st.pop_back();
return Convex{st};
}
// 半平面交
// 排序增量法,复杂度 O(nlogn)
// 输入与返回值都是用直线表示的半平面集合
vector<Line> halfinter(vector<Line> l, const point_t lim = 1e9) {
const auto check = [](const Line& a, const Line& b, const Line& c) {
return a.toleft(b.inter(c)) < 0;
};
// 无精度误差的方法,但注意取值范围会扩大到三次方
/*const auto check=[](const Line &a,const Line &b,const Line &c)
{
const Point
p=a.v*(b.v^c.v),q=b.p*(b.v^c.v)+b.v*(c.v^(b.p-c.p))-a.p*(b.v^c.v); return
p.toleft(q)<0;
};*/
l.push_back({{-lim, 0}, {0, -1}});
l.push_back({{0, -lim}, {1, 0}});
l.push_back({{lim, 0}, {0, 1}});
l.push_back({{0, lim}, {-1, 0}});
sort(l.begin(), l.end());
deque<Line> q;
for (size_t i = 0; i < l.size(); i++) {
if (i > 0 && l[i - 1].v.toleft(l[i].v) == 0 &&
l[i - 1].v * l[i].v > eps)
continue;
while (q.size() > 1 && check(l[i], q.back(), q[q.size() - 2]))
q.pop_back();
while (q.size() > 1 && check(l[i], q[0], q[1]))
q.pop_front();
if (!q.empty() && q.back().v.toleft(l[i].v) <= 0)
return vector<Line>();
q.push_back(l[i]);
}
while (q.size() > 1 && check(q[0], q.back(), q[q.size() - 2]))
q.pop_back();
while (q.size() > 1 && check(q.back(), q[0], q[1]))
q.pop_front();
return vector<Line>(q.begin(), q.end());
}
// 点集形成的最小最大三角形
// 极角序扫描线,复杂度 O(n^2logn)
// 最大三角形问题可以使用凸包与旋转卡壳做到 O(n^2)
pair<point_t, point_t> minmax_triangle(const vector<Point>& vec) {
if (vec.size() <= 2)
return {0, 0};
vector<pair<int, int>> evt;
evt.reserve(vec.size() * vec.size());
point_t maxans = 0, minans = numeric_limits<point_t>::max();
for (size_t i = 0; i < vec.size(); i++) {
for (size_t j = 0; j < vec.size(); j++) {
if (i == j)
continue;
if (vec[i] == vec[j])
minans = 0;
else
evt.push_back({i, j});
}
}
sort(evt.begin(), evt.end(),
[&](const pair<int, int>& u, const pair<int, int>& v) {
const Point du = vec[u.second] - vec[u.first],
dv = vec[v.second] - vec[v.first];
return argcmp()({du.y, -du.x}, {dv.y, -dv.x});
});
vector<size_t> vx(vec.size()), pos(vec.size());
for (size_t i = 0; i < vec.size(); i++)
vx[i] = i;
sort(vx.begin(), vx.end(), [&](int x, int y) { return vec[x] < vec[y]; });
for (size_t i = 0; i < vx.size(); i++)
pos[vx[i]] = i;
for (auto [u, v] : evt) {
const size_t i = pos[u], j = pos[v];
const size_t l = min(i, j), r = max(i, j);
const Point vecu = vec[u], vecv = vec[v];
if (l > 0)
minans = min(
minans, abs((vec[vx[l - 1]] - vecu) ^ (vec[vx[l - 1]] - vecv)));
if (r < vx.size() - 1)
minans = min(
minans, abs((vec[vx[r + 1]] - vecu) ^ (vec[vx[r + 1]] - vecv)));
maxans = max({maxans, abs((vec[vx[0]] - vecu) ^ (vec[vx[0]] - vecv)),
abs((vec[vx.back()] - vecu) ^ (vec[vx.back()] - vecv))});
if (i < j)
swap(vx[i], vx[j]), pos[u] = j, pos[v] = i;
}
return {minans, maxans};
}
// 判断多条线段是否有交点
// 扫描线,复杂度 O(nlogn)
bool segs_inter(const vector<Segment>& segs) {
if (segs.empty())
return false;
using seq_t = tuple<point_t, int, Segment>;
const auto seqcmp = [](const seq_t& u, const seq_t& v) {
const auto [u0, u1, u2] = u;
const auto [v0, v1, v2] = v;
if (abs(u0 - v0) <= eps)
return make_pair(u1, u2) < make_pair(v1, v2);
return u0 < v0 - eps;
};
vector<seq_t> seq;
for (auto seg : segs) {
if (seg.a.x > seg.b.x + eps)
swap(seg.a, seg.b);
seq.push_back({seg.a.x, 0, seg});
seq.push_back({seg.b.x, 1, seg});
}
sort(seq.begin(), seq.end(), seqcmp);
point_t x_now;
auto cmp = [&](const Segment& u, const Segment& v) {
if (abs(u.a.x - u.b.x) <= eps || abs(v.a.x - v.b.x) <= eps)
return u.a.y < v.a.y - eps;
return ((x_now - u.a.x) * (u.b.y - u.a.y) + u.a.y * (u.b.x - u.a.x)) *
(v.b.x - v.a.x) <
((x_now - v.a.x) * (v.b.y - v.a.y) + v.a.y * (v.b.x - v.a.x)) *
(u.b.x - u.a.x) -
eps;
};
multiset<Segment, decltype(cmp)> s{cmp};
for (const auto [x, o, seg] : seq) {
x_now = x;
const auto it = s.lower_bound(seg);
if (o == 0) {
if (it != s.end() && seg.is_inter(*it))
return true;
if (it != s.begin() && seg.is_inter(*prev(it)))
return true;
s.insert(seg);
} else {
if (next(it) != s.end() && it != s.begin() &&
(*prev(it)).is_inter(*next(it)))
return true;
s.erase(it);
}
}
return false;
}
// 多边形面积并
// 轮廓积分,复杂度 O(n^2logn),n为边数
// ans[i] 表示被至少覆盖了 i+1 次的区域的面积
vector<long double> area_union(const vector<Polygon>& polys) {
const size_t siz = polys.size();
vector<vector<pair<Point, Point>>> segs(siz);
const auto check = [](const Point& u, const Segment& e) {
return !((u < e.a && u < e.b) || (u > e.a && u > e.b));
};
auto cut_edge = [&](const Segment& e, const size_t i) {
const Line le{e.a, e.b - e.a};
vector<pair<Point, int>> evt;
evt.push_back({e.a, 0});
evt.push_back({e.b, 0});
for (size_t j = 0; j < polys.size(); j++) {
if (i == j)
continue;
const auto& pj = polys[j];
for (size_t k = 0; k < pj.p.size(); k++) {
const Segment s = {pj.p[k], pj.p[pj.nxt(k)]};
if (le.toleft(s.a) == 0 && le.toleft(s.b) == 0) {
evt.push_back({s.a, 0});
evt.push_back({s.b, 0});
} else if (s.is_inter(le)) {
const Line ls{s.a, s.b - s.a};
const Point u = le.inter(ls);
if (le.toleft(s.a) < 0 && le.toleft(s.b) >= 0)
evt.push_back({u, -1});
else if (le.toleft(s.a) >= 0 && le.toleft(s.b) < 0)
evt.push_back({u, 1});
}
}
}
sort(evt.begin(), evt.end());
if (e.a > e.b)
reverse(evt.begin(), evt.end());
int sum = 0;
for (size_t i = 0; i < evt.size(); i++) {
sum += evt[i].second;
const Point u = evt[i].first, v = evt[i + 1].first;
if (!(u == v) && check(u, e) && check(v, e))
segs[sum].push_back({u, v});
if (v == e.b)
break;
}
};
for (size_t i = 0; i < polys.size(); i++) {
const auto& pi = polys[i];
for (size_t k = 0; k < pi.p.size(); k++) {
const Segment ei = {pi.p[k], pi.p[pi.nxt(k)]};
cut_edge(ei, i);
}
}
vector<long double> ans(siz);
for (size_t i = 0; i < siz; i++) {
long double sum = 0;
sort(segs[i].begin(), segs[i].end());
int cnt = 0;
for (size_t j = 0; j < segs[i].size(); j++) {
if (j > 0 && segs[i][j] == segs[i][j - 1])
segs[i + (++cnt)].push_back(segs[i][j]);
else
cnt = 0, sum += segs[i][j].first ^ segs[i][j].second;
}
ans[i] = sum / 2;
}
return ans;
}
// 圆面积并
// 轮廓积分,复杂度 O(n^2logn)
// ans[i] 表示被至少覆盖了 i+1 次的区域的面积
vector<long double> area_union(const vector<Circle>& circs) {
const size_t siz = circs.size();
using arc_t = tuple<Point, long double, long double, long double>;
vector<vector<arc_t>> arcs(siz);
const auto eq = [](const arc_t& u, const arc_t& v) {
const auto [u1, u2, u3, u4] = u;
const auto [v1, v2, v3, v4] = v;
return u1 == v1 && abs(u2 - v2) <= eps && abs(u3 - v3) <= eps &&
abs(u4 - v4) <= eps;
};
auto cut_circ = [&](const Circle& ci, const size_t i) {
vector<pair<long double, int>> evt;
evt.push_back({-PI, 0});
evt.push_back({PI, 0});
int init = 0;
for (size_t j = 0; j < circs.size(); j++) {
if (i == j)
continue;
const Circle& cj = circs[j];
if (ci.r < cj.r - eps && ci.relation(cj) >= 3)
init++;
const auto inters = ci.inter(cj);
if (inters.size() == 1)
evt.push_back(
{atan2l((inters[0] - ci.c).y, (inters[0] - ci.c).x), 0});
if (inters.size() == 2) {
const Point dl = inters[0] - ci.c, dr = inters[1] - ci.c;
long double argl = atan2l(dl.y, dl.x),
argr = atan2l(dr.y, dr.x);
if (abs(argl + PI) <= eps)
argl = PI;
if (abs(argr + PI) <= eps)
argr = PI;
if (argl > argr + eps) {
evt.push_back({argl, 1});
evt.push_back({PI, -1});
evt.push_back({-PI, 1});
evt.push_back({argr, -1});
} else {
evt.push_back({argl, 1});
evt.push_back({argr, -1});
}
}
}
sort(evt.begin(), evt.end());
int sum = init;
for (size_t i = 0; i < evt.size(); i++) {
sum += evt[i].second;
if (abs(evt[i].first - evt[i + 1].first) > eps)
arcs[sum].push_back(
{ci.c, ci.r, evt[i].first, evt[i + 1].first});
if (abs(evt[i + 1].first - PI) <= eps)
break;
}
};
const auto oint = [](const arc_t& arc) {
const auto [cc, cr, l, r] = arc;
if (abs(r - l - PI - PI) <= eps)
return 2.0l * PI * cr * cr;
return cr * cr * (r - l) + cc.x * cr * (sin(r) - sin(l)) -
cc.y * cr * (cos(r) - cos(l));
};
for (size_t i = 0; i < circs.size(); i++) {
const auto& ci = circs[i];
cut_circ(ci, i);
}
vector<long double> ans(siz);
for (size_t i = 0; i < siz; i++) {
long double sum = 0;
sort(arcs[i].begin(), arcs[i].end());
int cnt = 0;
for (size_t j = 0; j < arcs[i].size(); j++) {
if (j > 0 && eq(arcs[i][j], arcs[i][j - 1]))
arcs[i + (++cnt)].push_back(arcs[i][j]);
else
cnt = 0, sum += oint(arcs[i][j]);
}
ans[i] = sum / 2;
}
return ans;
}