尚未完整测试，务必留意模板 bug！

  1. /* Clearink */
  3. #include <cmath>
  4. #include <queue>
  5. #include <cstdio>
  6. #include <vector>
  7. #include <algorithm>
  9. namespace PCG {
  11. const double PI = acos ( -1. ), EPS = 1e-9, INF = 2e9;
  12. /* treat x as 0 <=> -EPS < x < EPS */
  14. inline double dabs ( const double x ) { return x < 0 ? -x : x; }
  15. inline double dmin ( const double a, const double b ) { return a < b ? a : b; }
  16. inline double dmax ( const double a, const double b ) { return b < a ? a : b; }
  17. inline int dcmp ( const double x, const double y = 0 ) {
  18. 	return dabs ( x - y ) < EPS ? 0 : x < y ? -1 : 1;
  19. }
  21. struct Point {
  22. 	double x, y;
  23. 	inline Point ( const double tx = 0, const double ty = 0 ):
  24. 		x ( tx ), y ( ty ) {}
  25. 	inline Point operator + ( const Point& p ) const {
  26. 		return Point ( x + p.x, y + p.y );
  27. 	}
  28. 	inline Point operator - ( const Point& p ) const {
  29. 		return Point ( x - p.x, y - p.y );
  30. 	}
  31. 	inline Point operator - () const {
  32. 		return Point ( -x, -y );
  33. 	}
  34. 	inline Point operator * ( const double v ) const {
  35. 		return Point ( x * v, y * v );
  36. 	}
  37. 	inline Point operator / ( const double v ) const {
  38. 		return Point ( x / v, y / v );
  39. 	}
  40. 	inline double operator * ( const Point& p ) const { // dot.
  41. 		return x * p.x + y * p.y;
  42. 	}
  43. 	inline double operator ^ ( const Point& p ) const { // cross.
  44. 		return x * p.y - y * p.x;
  45. 	}
  46. 	inline bool operator == ( const Point& p ) const {
  47. 		return !dcmp ( x, p.x ) && !dcmp ( y, p.y );
  48. 	}
  49. 	inline bool operator != ( const Point& p ) const {
  50. 		return !( *this == p );
  51. 	}
  52. 	inline bool operator < ( const Point& p ) const { // as a pair (x,y).
  53. 		return dcmp ( x, p.x ) ? x < p.x : y < p.y;
  54. 	}
  55. 	inline double length () const { return sqrt ( *this * *this ); }
  56. 	inline Point unit () const { return *this / this->length (); }
  57. 	inline Point normal () const { return Point ( y, -x ); }
  58. 	inline double angle () const { // [0,2pi).
  59. 		double t = atan2 ( y, x );
  60. 		return t < 0 ? t + 2 * PI : t;
  61. 	}
  62. 	inline Point rotate ( const double alpha ) const {
  63. 		double c = cos ( alpha ), s = sin ( alpha );
  64. 		return Point ( x * c - y * s, y * c + x * s );
  65. 	}
  66. 	friend inline double angle ( const Point& p, const Point& q ) { // [0,pi).
  67. 		double t = atan2 ( p ^ q, p * q );
  68. 		t < 0 && ( t += 2 * PI, 0 );
  69. 		return t < PI ? t : 2 * PI - t;
  70. 	}
  71. 	friend inline double dist ( const Point& p, const Point& q ) {
  72. 		return ( p - q ).length ();
  73. 	}
  74. 	friend inline double slope ( const Point& p, const Point& q ) {
  75. 		return dcmp ( p.x, q.x ) ?
  76. 			( p.y - q.y ) / ( p.x - q.x ) : p.y < q.y ? INF : -INF;
  77. 	}
  78. 	inline void read () { scanf ( "%lf %lf", &x, &y ); }
  79. 	inline void _show ( const char ch = '\n' ) const {
  80. 		#ifdef RYBY
  81. 			printf ( "(%f, %f)%c", x, y, ch );
  82. 		#endif
  83. 	}
  84. };
  85. typedef Point Vector;
  87. struct Line {
  88. 	Point p, v;
  89. 	inline Line (): p (), v () {}
  90. 	inline Line ( Point a, Point b, const bool type = false ):
  91. 		p ( a ), v ( type ? b - a : b ) {}
  92. 	inline Line ( const double a, const double b, const double c ):
  93. 		p ( dcmp ( a ) ? Point ( -c / a, 0 ) : Point ( 0, -c / b ) ),
  94. 		v ( -b, a ) {}
  95. 	inline Point A () const { return p; }
  96. 	inline Point B () const { return p + v; }
  97. 	inline bool operator < ( const Line& l ) const {
  98. 		return dcmp ( atan2 ( v.y, v.x ), atan2 ( l.v.y, l.v.x ) ) < 0;
  99. 	}
  100. 	inline bool onLeft ( const Point& q ) const {
  101. 		return dcmp ( v ^ ( q - p ) ) > 0;
  102. 	}
  103. 	inline bool onLine ( const Point& q ) const {
  104. 		return !dcmp ( ( q - p ) ^ v );
  105. 	}
  106. 	inline bool onRay ( const Point& q ) const {
  107. 		return onLine ( q ) && dcmp ( ( q - p ) * v ) >= 0;
  108. 	}
  109. 	inline bool onSegment ( const Point& q ) const {
  110. 		if ( !onLine ( q ) ) return false;
  111. 		return dcmp ( ( A () - q ) * ( B () - q ) ) <= 0;
  112. 	}
  113. 	friend inline bool sameSide ( const Line& l,
  114. 		const Point& p, const Point& q ) {
  115. 		return dcmp ( ( ( p - l.p ) ^ ( p - l.B () ) )
  116. 			* ( ( q - l.p ) ^ ( q - l.B () ) ) ) > 0;
  117. 	}
  118. 	friend inline bool interSegment ( const Line& l1, const Line& l2 ) {
  119. 		return ( !sameSide ( l1, l2.p, l2.B () ) )
  120. 			&& ( !sameSide ( l2, l1.p, l1.B () ) );
  121. 	}
  122. 	friend inline bool interRay ( const Line& l1, const Line& l2 ) {
  123. 		return dcmp ( ( ( l2.p - l1.p ) ^ l2.v ) / ( l1.v ^ l2.v ) ) > 0
  124. 			&& dcmp ( ( ( l1.p - l2.p ) ^ l1.v ) / ( l2.v ^ l1.v ) ) > 0;
  125. 	}
  126. 	friend inline Point lineInter ( const Line& l1, const Line& l2 ) {
  127. 		return l1.p + l1.v * ( ( l2.p - l1.p ) ^ l2.v ) / ( l1.v ^ l2.v );
  128. 	}
  129. };
  131. inline std::vector<Point> getConvex ( std::vector<Point> vec,
  132. 	const bool allowCol ) {
  133. 	static std::vector<Point> ret;
  134. 	ret.resize ( vec.size () << 1 );
  135. 	std::sort ( vec.begin (), vec.end () );
  136. 	int n = ( int ) vec.size (), top = 0;
  137. 	for ( int i = 0; i < n; ++i ) {
  138. 		for ( int d; top > 1; --top ) {
  139. 			d = dcmp ( ( ret[top - 1] - ret[top - 2] )
  140. 				^ ( vec[i] - ret[top - 2] ) );
  141. 			if ( !( ( !allowCol && d <= 0 ) || ( allowCol && d < 0 ) ) ) break;
  142. 		}
  143. 		ret[top++] = vec[i];
  144. 	}
  145. 	for ( int tmp = top, i = n - 2; ~i; --i ) {
  146. 		for ( int d; top > tmp; --top ) {
  147. 			d = dcmp ( ( ret[top - 1] - ret[top - 2] )
  148. 				^ ( vec[i] - ret[top - 2] ) );
  149. 			if ( !( ( !allowCol && d <= 0 ) || ( allowCol && d < 0 ) ) ) break;
  150. 		}
  151. 		ret[top++] = vec[i];
  152. 	}
  153. 	if ( n > 1 ) --top;
  154. 	return ret.resize ( top ), ret;
  155. }
  157. inline bool poleCmp ( const Point& p, const Point& q ) {
  158. 	static int t;
  159. 	return ( t = dcmp ( p ^ q ) ) > 0
  160. 		|| ( !t && dcmp ( p.length (), q.length () ) < 0 );
  161. }
  163. inline Point polyCentroid ( const std::vector<Point>& poly ) {
  164. 	double area = 0; Point ret;
  165. 	int n = ( int ) poly.size ();
  166. 	for ( int i = 0; i ^ poly.size (); ++i ) {
  167. 		double s = poly[i] ^ poly[( i + 1 ) % n];
  168. 		area += s;
  169. 		ret.x += ( poly[i].x + poly[( i + 1 ) % n].x ) * s;
  170. 		ret.y += ( poly[i].y + poly[( i + 1 ) % n].y ) * s;
  171. 	}
  172. 	ret.x /= 3, ret.y /= 3; // triangle's centroid.
  173. 	ret.x /= area, ret.y /= area; // average.
  174. 	return ret;
  175. }
  177. inline double polyArea ( const std::vector<Point>& poly ) {
  178. 	double ret = 0; int n = ( int ) poly.size ();
  179. 	for ( int i = 0; i < n; ++i ) {
  180. 		ret += poly[i] ^ poly[( i + 1 ) % n];
  181. 	}
  182. 	return dabs ( ret / 2 );
  183. }
  185. inline std::vector<Point> halfPlaneInter ( std::vector<Line> lvec ) {
  186. 	static std::vector<std::pair<double, int> > ord;
  187. 	static std::deque<Line> que; que.clear ();
  188. 	static std::deque<Point> ret; ret.clear ();
  189. 	lvec.push_back ( Line ( Point ( -INF, -INF ), Point ( 1, 0 ) ) );
  190. 	lvec.push_back ( Line ( Point ( -INF, INF ), Point ( 0, -1 ) ) );
  191. 	lvec.push_back ( Line ( Point ( INF, -INF ), Point ( 0, 1 ) ) );
  192. 	lvec.push_back ( Line ( Point ( INF, INF ), Point ( -1, 0 ) ) );
  193. 	int n = ( int ) lvec.size (); ord.resize ( n );
  194. 	for ( int i = 0; i < n; ++i ) {
  195. 		ord[i].first = atan2 ( lvec[i].v.y, lvec[i].v.x );
  196. 		ord[i].second = i;
  197. 	}
  198. 	std::sort ( ord.begin (), ord.end () );
  199. 	que.push_back ( lvec[ord[0].second] );
  200. 	for ( int i = 1; i < n; ++i ) {
  201. 		const Line& l ( lvec[ord[i].second] );
  202. 		for ( ; que.size () > 1 && !l.onLeft ( ret.back () );
  203. 			que.pop_back (), ret.pop_back () );
  204. 		for ( ; que.size () > 1 && !l.onLeft ( ret[0] );
  205. 			que.pop_front (), ret.pop_front () );
  206. 		if ( dcmp ( l.v ^ que.back ().v ) ) {
  207. 			que.push_back ( l );
  208. 			if ( que.size () > 1 ) {
  209. 				ret.push_back (
  210. 					lineInter ( que[que.size () - 2], que.back () ) );
  211. 			}
  212. 		} else if ( que.back ().onLeft ( l.p ) ) {
  213. 			que.back () = l;
  214. 			if ( que.size () > 1 ) {
  215. 				ret.back () = lineInter ( que[que.size () - 2], que.back () );
  216. 			}
  217. 		}
  218. 	}
  219. 	for ( ; que.size () > 1 && !que[0].onLeft ( ret.back () );
  220. 		que.pop_back (), ret.pop_back () );
  221. 	if ( que.size () <= 2 ) return {};
  222. 	if ( que.size () > 1 ) ret.push_back ( lineInter ( que[0], que.back () ) );
  223. 	return std::vector<Point> ( ret.begin (), ret.end () );
  224. }
  226. inline double convexDiameter ( const std::vector<Point>& conv ) {
  227. 	int n = ( int ) conv.size ();
  228. 	if ( n == 1 ) return 0;
  229. 	if ( n == 2 ) return dist ( conv[0], conv[1] );
  230. 	double ret = 0;
  231. 	for ( int i = 0, j = 2; i < n; ++i ) {
  232. 		for ( ; dabs ( ( conv[j] - conv[i] )
  233. 				^ ( conv[( i + 1 ) % n] - conv[i] ) )
  234. 			< dabs ( ( conv[( j + 1 ) % n] - conv[i] )
  235. 				^ ( conv[( i + 1 ) % n] - conv[i] ) ); j = ( j + 1 ) % n );
  236. 		ret = dmax ( ret, dmax ( dist ( conv[i], conv[j] ),
  237. 			dist ( conv[( i + 1 ) % n], conv[j] ) ) );
  238. 	}
  239. 	return ret;
  240. }
  242. inline int findPole ( const std::vector<Point>& vec ) {
  243. 	int ret = -1, n = ( int ) vec.size ();
  244. 	for ( int i = 0; i < n; ++i ) {
  245. 		if ( !~ret || dcmp ( vec[ret].y, vec[i].y ) > 0
  246. 		|| ( !dcmp ( vec[ret].y, vec[i].y )
  247. 			&& dcmp ( vec[ret].x, vec[i].x ) > 0 ) ) {
  248. 			ret = i;
  249. 		}
  250. 	}
  251. 	return ret;
  252. }
  254. inline void getPoleOrdered ( std::vector<Point>& conv ) {
  255. 	int pid = findPole ( conv ), n = ( int ) conv.size ();
  256. 	pid = n - pid - 1; // reversed.
  257. 	std::reverse ( conv.begin (), conv.end () );
  258. 	std::reverse ( conv.begin (), conv.begin () + pid + 1 );
  259. 	std::reverse ( conv.begin () + pid + 1, conv.end () );
  260. }
  262. inline std::vector<Point> convexSum ( std::vector<Point> A,
  263. 	std::vector<Point> B ) {
  264. 	static std::vector<Point> ret; ret.clear ();
  265. 	getPoleOrdered ( A ), getPoleOrdered ( B );
  266. 	// if use `getConvexG`, there's no need to `getPoleOrdered`.
  267. 	int n = ( int ) A.size (), m = ( int ) B.size ();
  268. 	Point ap ( A[0] ), bp ( B[0] );
  269. 	ret.push_back ( ap + bp );
  270. 	for ( int i = 0; i < n - 1; ++i ) A[i] = A[i + 1] - A[i];
  271. 	A[n - 1] = ap - A[n - 1];
  272. 	for ( int i = 0; i < m - 1; ++i ) B[i] = B[i + 1] - B[i];
  273. 	B[m - 1] = bp - B[m - 1];
  274. 	int i = 0, j = 0;
  275. 	while ( i < n && j < m ) {
  276. 		ret.push_back ( ret.back ()
  277. 			+ ( dcmp ( A[i] ^ B[j] ) >= 0 ? A[i++] : B[j++] ) );
  278. 	}
  279. 	for ( ; i < n; ret.push_back ( ret.back () + A[i++] ) );
  280. 	for ( ; j < m; ret.push_back ( ret.back () + B[j++] ) );
  281. 	return ret;
  282. }
  284. } using namespace PCG;
  286. int n;
  287. std::vector<Point> pos, cnv;
  289. int main () {
  290. 	/*
  291. 		example: https://www.luogu.com.cn/problem/P2742
  292. 	*/
  293. 	scanf ( "%d", &n ), pos.resize ( n );
  294. 	for ( int i = 0; i < n; ++i ) pos[i].readn ();
  295. 	cnv = getConvex ( pos, true ); // also, it could be `getConvex ( pos, false )`.
  296. 	#ifdef RYBY
  297. 		for ( auto p: cnv ) p._show ( ' ' );
  298. 		putchar ( '\n' );
  299. 	#endif
  300. 	int s = cnv.size ();
  301. 	double ans = 0;
  302. 	for ( int i = 0; i < s; ++i ) {
  303. 		ans += dist ( cnv[i], cnv[( i + 1 ) % s] );
  304. 	}
  305. 	printf ( "%.2f\n", ans );
  306. 	return 0;
  307. }
  309. /*
  310. try this data:
  311. 5
  312. 0 0
  313. 0 3
  314. 1 2
  315. 2 1
  316. 3 0
  317. */

  大概是壬寅年新版本。（

  1. /*+Rainybunny+*/
  3. // #include <bits/stdc++.h>
  4. #include <cmath>
  5. #include <queue>
  6. #include <cstdio>
  7. #include <vector>
  8. #include <cassert>
  9. #include <iostream>
  10. #include <algorithm>
  12. #define rep(i, l, r) for (int i = l, rep##i = r; i <= rep##i; ++i)
  13. #define per(i, r, l) for (int i = r, per##i = l; i >= per##i; --i)
  15. namespace ComputingGeometry {
  17. const double EPS = 1e-9, PI = acos(-1.), DINF = 1e18;
  19. template <typename Tp>
  20. inline void chkmin(Tp& u, const Tp& v) { v < u && (u = v, 0); }
  21. template <typename Tp>
  22. inline void chkmax(Tp& u, const Tp& v) { u < v && (u = v, 0); }
  23. template <typename Tp>
  24. inline Tp imin(const Tp& u, const Tp& v) { return u < v ? u : v; }
  25. template <typename Tp>
  26. inline Tp imax(const Tp& u, const Tp& v) { return u < v ? v : u; }
  27. template <typename Tp>
  28. inline Tp iabs(const Tp& u) { return u < 0 ? -u : u; }
  29. inline int sign(const double x) { return iabs(x) <= EPS ? 0 : x < 0 ? -1 : 1; }
  31. struct Point {
  32.     double x, y;
  33.     Point(): x(0.), y(0.) {}
  34.     Point(const double u, const double v): x(u), y(v) {}
  36.     inline void read() { scanf("%lf %lf", &x, &y); }
  38.     inline Point operator + (const Point& p) const {
  39.         return { x + p.x, y + p.y };
  40.     }
  41.     inline Point operator - () const { return { -x, -y }; }
  42.     inline Point operator - (const Point& p) const {
  43.         return { x - p.x, y - p.y };
  44.     }
  45.     inline Point operator * (const double k) const {
  46.         return { k * x, k * y };
  47.     }
  48.     inline Point operator / (const double k) const {
  49.         return { x / k, y / k };
  50.     }
  51.     inline bool operator == (const Point& p) const {
  52.         return !sign(x - p.x) && !sign(y - p.y);
  53.     }
  54.     inline bool operator != (const Point& p) const {
  55.         return !(*this == p);
  56.     }
  57.     inline double operator * (const Point& p) const {
  58.         return x * p.x + y * p.y;
  59.     }
  60.     inline double operator ^ (const Point& p) const {
  61.         return x * p.y - y * p.x;
  62.     }
  64.     inline double leng() const { return sqrt(*this * *this); }
  65.     friend inline double dist(const Point& u, const Point& v) {
  66.         return (u - v).leng();
  67.     }
  68.     inline Point norm() const { return { -y, x }; }
  69.     inline double angle() const {
  70.         double ret = atan2(y, x);
  71.         if (ret < 0) ret += 2 * PI;
  72.         return ret;
  73.     }
  74.     friend inline double angle(const Point& u, const Point& v) {
  75.         double ret = v.angle() - u.angle();
  76.         if (ret > PI) ret -= 2 * PI;
  77.         if (ret < -PI) ret += 2 * PI;
  78.         return ret;
  79.     }
  80.     inline Point rotate(const double alp) const {
  81.         double ca = cos(alp), sa = sin(alp);
  82.         return { x * ca - y * sa, x * sa + y * ca };
  83.     }
  84.     inline bool operator < (const Point& p) const {
  85.         return !sign(x - p.x) ? y < p.y : x < p.x;
  86.     }
  87. };
  88. typedef Point Vector;
  89. typedef std::vector<Point> Polygon;
  90. typedef Polygon Convex;
  92. struct Ray {
  93.     Point p, v;
  94.     Ray() {}
  95.     Ray(const Point& a, const Point& b, const bool type = true) {
  96.         if (type) p = a, v = b - a;
  97.         else p = a, v = b;
  98.     }
  99.     Ray(const double a, const double b, const double c):
  100.         p(sign(a) ? Point(-c / a, 0) : Point(0, -c / b)), v(-b, a) {}
  102.     inline Point st() const { return p; }
  103.     inline Point ed() const { return p + v; }
  104.     inline void readSeg() {
  105.         scanf("%lf %lf %lf %lf", &p.x, &p.y, &v.x, &v.y);
  106.         v = v - p;
  107.     }
  108.     friend inline bool isInterSeg(const Ray& a, const Ray& b) { // *
  109.         return imin(a.st().x, a.ed().x) <= imax(b.st().x, b.ed().x)
  110.           && imax(a.st().x, a.ed().x) <= imin(b.st().x, b.ed().x)
  111.           && imin(a.st().y, a.ed().y) <= imax(b.st().y, b.ed().y)
  112.           && imax(a.st().y, a.ed().y) <= imin(b.st().y, b.ed().y)
  113.           && sign(a.v ^ (b.st() - a.st())) * sign(a.v ^ (b.ed() - a.st())) <=0
  114.           && sign(b.v ^ (a.st() - b.st())) * sign(b.v ^ (a.ed() - b.st())) <=0;
  115.     }
  116.     friend inline Point lineInter(const Ray& a, const Ray& b) {
  117.         return a.p + a.v * ((b.p - a.p) ^ b.v) / (a.v ^ b.v);
  118.     }
  119.     friend inline double pSegDist(const Point& p, const Ray& s) {
  120.         if (sign(s.v * (p - s.p)) < 0) return dist(p, s.p);
  121.         if (sign(-s.v * (p - s.ed())) < 0) return dist(p, s.ed());
  122.         return iabs(s.v ^ (p - s.p)) / s.v.leng();
  123.     }
  124.     friend inline double sSegDist(const Ray& s, const Ray& t) {
  125.         return imin(imin(pSegDist(s.st(), t), pSegDist(s.ed(), t)),
  126.           imin(pSegDist(t.st(), s), pSegDist(t.ed(), s)));
  127.     }
  128. };
  129. typedef Ray Line;
  130. typedef Ray Segment;
  131. typedef std::vector<Line> PlaneCut;
  133. inline Convex getConvex(Polygon P, const bool allw = false) {
  134.     int n = int(P.size()), top = 0, tmp; Convex ret(n << 1);
  135.     std::sort(P.begin(), P.end());
  136.     for (Point& p: P) {
  137.         for (int s; top > 1; --top) {
  138.             s = sign((ret[top - 1] - ret[top - 2]) ^ (p - ret[top - 2]));
  139.             if (s - !allw >= 0) break;
  140.         }
  141.         ret[top++] = p;
  142.     }
  143.     std::reverse(P.begin(), P.end()), tmp = top;
  144.     for (Point& p: P) {
  145.         for (int s; top > tmp; --top) {
  146.             s = sign((ret[top - 1] - ret[top - 2]) ^ (p - ret[top - 2]));
  147.             if (s - !allw >= 0) break;
  148.         }
  149.         ret[top++] = p;
  150.     }
  151.     if (n > 1) --top;
  152.     return ret.resize(top), ret;
  153. }
  155. inline double getArea(const Polygon& P) {
  156.     double ret = 0.; int n = int(P.size());
  157.     rep (i, 0, n - 1) ret += P[i] ^ P[(i + 1) % n];
  158.     return iabs(ret) * 0.5;
  159. }
  161. inline std::pair<Point, Point> convexDiameter(const Convex& C) {
  162.     int n = int(C.size());
  163.     if (n == 1) return { C[0], C[0] };
  164.     if (n == 2) return { C[0], C[1] };
  165.     double dia = 0.; std::pair<Point, Point> ans;
  166.     for (int i = 0, j = 1; i < n; ++i) {
  167.         while (((C[(i + 1) % n] - C[i]) ^ (C[j] - C[i]))
  168.           < ((C[(i + 1) % n] - C[i]) ^ (C[(j + 1) % n] - C[i])))
  169.             j = (j + 1) % n;
  170.         double d1 = dist(C[i], C[j]), d2 = dist(C[(i + 1) % n], C[j]);
  171.         if (d1 > dia) dia = d1, ans = { C[i], C[j] };
  172.         if (d2 > dia) dia = d2, ans = { C[(i + 1) % n], C[j] };
  173.     }
  174.     return ans;
  175. }
  177. inline double convicesDist(const Convex& A, const Convex& B) {
  178.     int n = int(A.size()), m = int(B.size()), p = 0, q = 0;
  179.     rep (i, 1, n - 1) if (A[i].y < A[p].y) p = i;
  180.     rep (i, 1, m - 1) if (B[i].y > B[q].y) q = i;
  181.     double ret = 1e100;
  182.     rep (i, 0, n - 1) {
  183.         while (sign((A[(p + 1) % n] - A[p]) ^ (B[(q + 1) % m] - B[q])) > 0)
  184.             q = (q + 1) % m;
  185.         chkmin(ret, sSegDist(Ray(A[p], A[(p + 1) % n]),
  186.           Ray(B[q], B[(q + 1) % m])));
  187.         p = (p + 1) % n;
  188.     }
  189.     return ret;
  190. }
  192. inline Convex halfPlaneInter(PlaneCut& vec, const bool apd = false) {
  193.     if (apd) {
  194.         vec.push_back(Ray(Point(-DINF, -DINF), Point(1, 0), 0));
  195.         vec.push_back(Ray(Point(DINF, -DINF), Point(0, 1), 0));
  196.         vec.push_back(Ray(Point(DINF, DINF), Point(-1, 0), 0));
  197.         vec.push_back(Ray(Point(-DINF, DINF), Point(0, -1), 0));
  198.     }
  200.     int n = int(vec.size());
  201.     std::vector<double> pol(n); std::vector<int> ord(n);
  202.     rep (i, 0, n - 1) ord[i] = i, pol[i] = atan2(vec[i].v.y, vec[i].v.x);
  203.     std::sort(ord.begin(), ord.end(),
  204.         [&](const int u, const int v)->bool {
  205.             return sign(pol[u] - pol[v]) ? pol[u] < pol[v]
  206.               : (vec[v].v ^ (vec[u].p - vec[v].p)) > 0;
  207.         }
  208.     );
  209.     std::vector<int> tmp; tmp.push_back(ord[0]);
  210.     rep (i, 1, n - 1) {
  211.         if (sign(pol[ord[i]] - pol[ord[i - 1]])) {
  212.             tmp.push_back(ord[i]);
  213.         }
  214.     }
  215.     ord.swap(tmp), n = ord.size();
  217.     std::deque<Line> deq;
  218.     deq.push_back(vec[ord[0]]), deq.push_back(vec[ord[1]]);
  219.     std::deque<Point> pnt;
  220.     pnt.push_back(lineInter(deq.front(), deq.back()));
  221.     rep (i, 2, n - 1) {
  222.         Line& l(vec[ord[i]]);
  223.         while (deq.size() > 1 && sign(l.v ^ (pnt.back() - l.p)) <= 0)
  224.             deq.pop_back(), pnt.pop_back();
  225.         while (deq.size() > 1 && sign(l.v ^ (pnt.front() - l.p)) <= 0)
  226.             deq.pop_front(), pnt.pop_front();
  227.         pnt.push_back(lineInter(deq.back(), l));
  228.         deq.push_back(l);
  229.     }
  230.     while (deq.size() > 1
  231.       && sign(deq.front().v ^ (pnt.back() - deq.front().p)) < 0)
  232.         deq.pop_back(), pnt.pop_back();
  233.     while (deq.size() > 1
  234.       && sign(deq.back().v ^ (pnt.front() - deq.back().p)) < 0)
  235.         deq.pop_front(), pnt.pop_front();
  237.     if (apd) rep (i, 0, 3) vec.pop_back();
  238.     if (deq.size() <= 2) return Convex();
  240.     pnt.push_back(lineInter(deq.front(), deq.back()));
  241.     while (pnt.size() > 1 && pnt.front() == pnt.back()) pnt.pop_back();
  242.     std::vector<Point> ret; ret.push_back(pnt[0]);
  243.     rep (i, 1, int(pnt.size()) - 1) {
  244.         if (pnt[i] != pnt[i - 1]) {
  245.             ret.push_back(pnt[i]);
  246.         }
  247.     }
  248.     return ret;
  249. }
  251. } using namespace ComputingGeometry;
  253. int main() {
  254.     int n; scanf("%d", &n);
  255.     PlaneCut L;
  256.     while (n--) {
  257.         int m; scanf("%d", &m); Polygon P(m);
  258.         for (auto& p: P) p.read();
  259.         rep (i, 0, m - 1) L.push_back(Ray(P[i], P[(i + 1) % m]));
  260.     }
  261.     printf("%.3f\n", getArea(halfPlaneInter(L)));
  262.     return 0;
  263. }

Note -「计算几何」模板的更多相关文章

  1. Note -「多项式」基础模板（FFT/NTT/多模 NTT）光速入门

      进阶篇戳这里. 目录 何为「多项式」 基本概念 系数表示法 & 点值表示法 傅里叶(Fourier)变换 概述 前置知识 - 复数 单位根 快速傅里叶正变换(FFT) 快速傅里叶逆变换(I ...

  2. 「BJWC2010」模板严格次小生成树

    题目描述 小 \(C\) 最近学了很多最小生成树的算法,\(Prim\) 算法.\(Kruskal\) 算法.消圈算法等等.正当小\(C\)洋洋得意之时,小\(P\)又来泼小\(C\)冷水了.小\(P ...

  3. Note -「群论」学习笔记

    目录 前置知识 群 置换 Burnside 引理与 Pólya 定理 概念引入 引例 轨道-稳定子(Orbit-Stabilizer)定理 证明 Burnside 引理 证明 Pólya 定理 证明 ...

  4. Note -「线性规划」学习笔记

    \(\mathcal{Definition}\)   线性规划(Linear Programming, LP)形式上是对如下问题的描述: \[\operatorname{maximize}~~~~z= ...

  5. Solution -「LOCAL」模板

    \(\mathcal{Description}\)   OurOJ.   给定一棵 \(n\) 个结点树,\(1\) 为根,每个 \(u\) 结点有容量 \(k_u\).\(m\) 次操作,每次操作 ...

  6. Note -「模拟退火」

    随机化算法属于省选芝士体系 0x01 前置芝士 你只需要会 rand 就可以啦! 当然如果你想理解的更透彻也可以先看看 爬山算法 0x02 关于退火 退火是一种金属热处理工艺,指的是将金属缓慢加热到一 ...

  7. 「luogu3380」【模板】二逼平衡树（树套树）

    「luogu3380」[模板]二逼平衡树(树套树) 传送门 我写的树套树--线段树套平衡树. 线段树上的每一个节点都是一棵 \(\text{FHQ Treap}\) ,然后我们就可以根据平衡树的基本操 ...

  8. 「luogu3402」【模板】可持久化并查集

    「luogu3402」[模板]可持久化并查集 传送门 我们可以用一个可持久化数组来存每个节点的父亲. 单点信息更新和查询就用主席树多花 一个 \(\log\) 的代价来搞. 然后考虑如何合并两个点. ...

  9. SpringBoot图文教程10—模板导出|百万数据Excel导出|图片导出「easypoi」

    有天上飞的概念,就要有落地的实现 概念十遍不如代码一遍,朋友,希望你把文中所有的代码案例都敲一遍 先赞后看,养成习惯 SpringBoot 图文教程系列文章目录 SpringBoot图文教程1「概念+ ...

随机推荐

  1. Java 私有接口 【类中嵌套接口】

    1.前言 接口十分常用,能规范实现类的命名 和 实现多个实现类的向上转型成统一类型 ,但是接口的修饰符只能是 public吗? 当然不是,可以是private , 难道是像这样? 显然不可以,已经报错 ...

  2. 访问 远程 tomcat 的管理页面 /manager/html 提示 403 的具体解决操作

    1.前言 我在阿里云服务器放了个tomcat ,启动后 ,访问 /manager/html提示403无权访问 原因是 tomcat默认仅仅允许本地的浏览器访问,有ip限制 需要将ip限制去除 顺便把账 ...

  3. JAVA自定义连接池原理设计(一)

    一,概述 本人认为在开发过程中,需要挑战更高的阶段和更优的代码,虽然在真正开发工作中,代码质量和按时交付项目功能相比总是无足轻重.但是个人认为开发是一条任重而道远的路.现在本人在网上找到一个自定义连接 ...

  4. 【Java】代码块

    代码块 代码块的作用:用来初始化类.对象 代码块如果有修饰的话,只能使用static 分类:静态代码块.非静态代码块 静态代码块 static{ } 内部可以有输出语句 随着类的加载而执行,而且只执行 ...

  5. 《剑指offer》面试题60. n个骰子的点数

    问题描述 把n个骰子扔在地上,所有骰子朝上一面的点数之和为s.输入n,打印出s的所有可能的值出现的概率. 你需要用一个浮点数数组返回答案,其中第 i 个元素代表这 n 个骰子所能掷出的点数集合中第 i ...

  6. Solon Web 开发，五、数据访问、事务与缓存应用

    Solon Web 开发 一.开始 二.开发知识准备 三.打包与运行 四.请求上下文 五.数据访问.事务与缓存应用 六.过滤器.处理.拦截器 七.视图模板与Mvc注解 八.校验.及定制与扩展 九.跨域 ...

  7. 多种语言tcp编程

    再次强调,最好socket编程 c#的tcpclient等封装无法对接android的socket服务器 c#的tcpclient等封装可对接java的socket服务器 python socket服 ...

  8. gin源码解读2-揭开gin的神秘面纱

    数据如何在gin中流转 func main() { gin.SetMode(gin.DebugMode) // 设置为开发模式 router := gin.Default() _ = router.S ...

  9. java匿名内部类-细节

    1 package face_09; 2 3 public class InnerClassDemo50 { 4 static class Inner{ 5 6 } 7 public static v ...

  10. python 统计工作簿中每个人名出现的次数

    工作簿 需求:统计人名出现的次数 代码: # coding=gbk import pandas as pd import re def extract_chinese(txt): pattern = ...