merged

Author: Chillee

content/contest/template.cpp

@@ -3,7 +3,7 @@ using namespace std;
 
 #define rep(i, a, b) for(int i = a; i < (b); ++i)
 #define trav(a, x) for(auto& a : x)
-#define all(x) x.begin(), x.end()
+#define all(x) begin(x), end(x)
 #define sz(x) (int)(x).size()
 typedef long long ll;
 typedef pair<int, int> pii;

content/data-structures/OrderStatisticTree.h

@@ -15,7 +15,7 @@ using namespace __gnu_pbds;
 
 template<class T>
 using Tree = tree<T, null_type, less<T>, rb_tree_tag,
-	  tree_order_statistics_node_update>;
+    tree_order_statistics_node_update>;
 
 void example() {
 	Tree<int> t, t2; t.insert(8);

content/data-structures/SegmentTree.h

@@ -3,24 +3,24 @@
  * Date: 2017-10-31
  * License: CC0
  * Source: folklore
- * Description: Zero-indexed max-tree. Bounds are inclusive to the left and exclusive to the right. Can be changed by modifying T, LOW and f.
+ * Description: Zero-indexed max-tree. Bounds are inclusive to the left and exclusive to the right. Can be changed by modifying T, f and unit.
  * Time: O(\log N)
  * Status: fuzz-tested
  */
 #pragma once
 
 struct Tree {
 	typedef int T;
-	static const T LOW = INT_MIN;
+	static constexpr T unit = INT_MIN;
 	T f(T a, T b) { return max(a, b); } // (any associative fn)
 	vector<T> s; int n;
-	Tree(int n = 0, T def = 0) : s(2*n, def), n(n) {}
+	Tree(int n = 0, T def = unit) : s(2*n, def), n(n) {}
 	void update(int pos, T val) {
-		for (s[pos += n] = val; pos > 1; pos /= 2)
-			s[pos / 2] = f(s[pos & ~1], s[pos | 1]);
+		for (s[pos += n] = val; pos /= 2;)
+			s[pos] = f(s[pos * 2], s[pos * 2 + 1]);
 	}
 	T query(int b, int e) { // query [b, e)
-		T ra = LOW, rb = LOW;
+		T ra = unit, rb = unit;
 		for (b += n, e += n; b < e; b /= 2, e /= 2) {
 			if (b % 2) ra = f(ra, s[b++]);
 			if (e % 2) rb = f(s[--e], rb);

content/data-structures/Treap.h

@@ -25,13 +25,13 @@ template<class F> void each(Node* n, F f) {
 
 pair<Node*, Node*> split(Node* n, int k) {
 	if (!n) return {};
-	if (cnt(n->l) >= k) { // "n->val >= v" for lower_bound(v)
+	if (cnt(n->l) >= k) { // "n->val >= k" for lower_bound(k)
 		auto pa = split(n->l, k);
 		n->l = pa.second;
 		n->recalc();
 		return {pa.first, n};
 	} else {
-		auto pa = split(n->r, k - cnt(n->l) - 1);
+		auto pa = split(n->r, k - cnt(n->l) - 1); // and just "k"
 		n->r = pa.first;
 		n->recalc();
 		return {n, pa.second};

content/data-structures/UnionFind.h

@@ -14,10 +14,11 @@ struct UF {
 	bool same_set(int a, int b) { return find(a) == find(b); }
 	int size(int x) { return -e[find(x)]; }
 	int find(int x) { return e[x] < 0 ? x : e[x] = find(e[x]); }
-	void join(int a, int b) {
+	bool join(int a, int b) {
 		a = find(a), b = find(b);
-		if (a == b) return;
+		if (a == b) return false;
 		if (e[a] > e[b]) swap(a, b);
 		e[a] += e[b]; e[b] = a;
+		return true;
 	}
 };

content/geometry/Angle.h

@@ -2,7 +2,7 @@
  * Author: Simon Lindholm
  * Date: 2015-01-31
  * License: CC0
- * Source:
+ * Source: me
  * Description: A class for ordering angles (as represented by int points and
  *  a number of rotations around the origin). Useful for rotational sweeping.
  *  Sometimes also represents points or vectors.
@@ -19,20 +19,18 @@ struct Angle {
 	int t;
 	Angle(int x, int y, int t=0) : x(x), y(y), t(t) {}
 	Angle operator-(Angle b) const { return {x-b.x, y-b.y, t}; }
-	int quad() const {
+	int half() const {
 		assert(x || y);
-		if (y < 0) return (x >= 0) + 2;
-		if (y > 0) return (x <= 0);
-		return (x <= 0) * 2;
+		return y < 0 || (y == 0 && x < 0);
 	}
-	Angle t90() const { return {-y, x, t + (quad() == 3)}; }
-	Angle t180() const { return {-x, -y, t + (quad() >= 2)}; }
+	Angle t90() const { return {-y, x, t + (half() && x >= 0)}; }
+	Angle t180() const { return {-x, -y, t + half()}; }
 	Angle t360() const { return {x, y, t + 1}; }
 };
 bool operator<(Angle a, Angle b) {
 	// add a.dist2() and b.dist2() to also compare distances
-	return make_tuple(a.t, a.quad(), a.y * (ll)b.x) <
-	       make_tuple(b.t, b.quad(), a.x * (ll)b.y);
+	return make_tuple(a.t, a.half(), a.y * (ll)b.x) <
+	       make_tuple(b.t, b.half(), a.x * (ll)b.y);
 }
 
 // Given two points, this calculates the smallest angle between

content/geometry/CircleIntersection.h

@@ -2,24 +2,21 @@
  * Author: Simon Lindholm
  * Date: 2015-09-01
  * License: CC0
- * Description: Computes a pair of points at which two circles intersect. Returns false in case of no intersection.
- * Status: somewhat tested
+ * Description: Computes the pair of points at which two circles intersect. Returns false in case of no intersection.
+ * Status: fuzz-tested
  */
 #pragma once
 
 #include "Point.h"
 
 typedef Point<double> P;
-bool circleIntersection(P a, P b, double r1, double r2,
-		pair<P, P>* out) {
-	P delta = b - a;
-	assert(delta.x || delta.y || r1 != r2);
-	if (!delta.x && !delta.y) return false;
-	double r = r1 + r2, d2 = delta.dist2();
-	double p = (d2 + r1*r1 - r2*r2) / (2.0 * d2);
-	double h2 = r1*r1 - p*p*d2;
-	if (d2 > r*r || h2 < 0) return false;
-	P mid = a + delta*p, per = delta.perp() * sqrt(h2 / d2);
+bool circleInter(P a,P b,double r1,double r2,pair<P, P>* out) {
+	if (a == b) { assert(r1 != r2); return false; }
+	P vec = b - a;
+	double d2 = vec.dist2(), sum = r1+r2, dif = r1-r2,
+	       p = (d2 + r1*r1 - r2*r2)/(d2*2), h2 = r1*r1 - p*p*d2;
+	if (sum*sum < d2 || dif*dif > d2) return false;
+	P mid = a + vec*p, per = vec.perp() * sqrt(fmax(0, h2) / d2);
 	*out = {mid + per, mid - per};
 	return true;
 }

content/geometry/ConvexHull.h

@@ -1,8 +1,8 @@
 /**
- * Author: Johan Sannemo
- * Date: 2017-04-16
- * License: CC0
- * Source: Basic algorithm knowledge
+ * Author: Stjepan Glavina, chilli
+ * Date: 2019-05-05
+ * License: Unlicense
+ * Source: https://github.com/stjepang/snippets/blob/master/convex_hull.cpp
  * Description:
 \\\begin{minipage}{75mm}
 Returns a vector of indices of the convex hull in counter-clockwise order.
@@ -14,32 +14,22 @@ Points on the edge of the hull between two other points are not considered part
 \vspace{-6mm}
 \end{minipage}
  * Status: tested with Kattis problems convexhull
- * Usage:
- * 	vector<P> ps, hull;
- *  trav(i, convexHull(ps)) hull.push_back(ps[i]);
  * Time: O(n \log n)
 */
 #pragma once
 
 #include "Point.h"
 
 typedef Point<ll> P;
-pair<vi, vi> ulHull(const vector<P>& S) {
-	vi Q(sz(S)), U, L;
-	iota(all(Q), 0);                                                                                                                                                                         
-	sort(all(Q), [&S](int a, int b){ return S[a] < S[b]; }); 
-	trav(it, Q) {
-#define ADDP(C, cmp) while (sz(C) > 1 && S[C[sz(C)-2]].cross(\
-	S[it], S[C.back()]) cmp 0) C.pop_back(); C.push_back(it);
-		ADDP(U, <=); ADDP(L, >=);
-	}   
-	return {U, L}; 
-}
-
-vi convexHull(const vector<P>& S) {
-	vi u, l; tie(u, l) = ulHull(S);
-	if (sz(S) <= 1) return u;
-	if (S[u[0]] == S[u[1]]) return {0};
-	l.insert(l.end(), u.rbegin()+1, u.rend()-1);
-	return l;
+vector<P> convexHull(vector<P> pts) {
+	if (sz(pts) <= 1) return pts;
+	sort(all(pts));
+	vector<P> h(sz(pts)+1);
+	int s = 0, t = 0;
+	for (int it = 2; it--; s = --t, reverse(all(pts)))
+		trav(p, pts) {
+			while (t >= s + 2 && h[t-2].cross(h[t-1], p) <= 0) t--;
+			h[t++] = p;
+		}
+	return {h.begin(), h.begin() + t - (t == 2 && h[0] == h[1])};
 }

content/geometry/HullDiameter.h

@@ -0,0 +1,23 @@
+/**
+ * Author: Oleksandr Bacherikov, chilli
+ * Date: 2019-05-05
+ * License: Boost Software License
+ * Source: https://codeforces.com/blog/entry/48868
+ * Description: Returns the two points with max distance on a convex hull (ccw,
+ * no duplicate/colinear points).
+ * Status: Fuzz-tested, submitted on kattis roberthood
+ */
+#pragma once
+
+typedef Point<ll> P;
+array<P, 2> hullDiameter(vector<P> S) {
+	int n = sz(S), j = n < 2 ? 0 : 1;
+	pair<ll, array<P, 2>> res({0, {S[0], S[0]}});
+	rep(i,0,j)
+		for (;; j = (j + 1) % n) {
+			res = max(res, {(S[i] - S[j]).dist2(), {S[i], S[j]}});
+			if ((S[(j + 1) % n] - S[j]).cross(S[i + 1] - S[i]) >= 0)
+				break;
+		}
+	return res.second;
+}

content/geometry/InsidePolygon.h

@@ -0,0 +1,31 @@
+/**
+ * Author: Victor Lecomte, chilli
+ * Date: 2019-04-26
+ * License: CC0
+ * Source: https://vlecomte.github.io/cp-geo.pdf
+ * Description: Returns true if p lies within the polygon. If strict is true,
+ * it returns false for points on the boundary. The algorithm uses
+ * products in intermediate steps so watch out for overflow.
+ * Time: O(n)
+ * Status: fuzz-tested and Kattis problem pointinpolygon
+ * Usage:
+ * vector<P> v = {P{4,4}, P{1,2}, P{2,1}};
+ * bool in = inPolygon(v, P{3, 3}, false);
+ */
+#pragma once
+
+#include "Point.h"
+#include "OnSegment.h"
+#include "SegmentDistance.h"
+
+template<class P>
+bool inPolygon(vector<P> &p, P a, bool strict = true) {
+	int cnt = 0, n = sz(p);
+	rep(i,0,n) {
+		P q = p[(i + 1) % n];
+		if (onSegment(p[i], q, a)) return !strict;
+		//or: if (segDist(p[i], q, a) <= eps) return !strict;
+		cnt ^= ((a.y<p[i].y) - (a.y<q.y)) * a.cross(p[i], q) > 0;
+	}
+	return cnt;
+}