kth-competitive-programming · ZergTricky · Apr 25, 2024
diff --git a/content/contest/template.cpp b/content/contest/template.cpp
@@ -4,9 +4,9 @@ using namespace std;
 #define rep(i, a, b) for(int i = a; i < (b); ++i)
 #define all(x) begin(x), end(x)
 #define sz(x) (int)(x).size()
-typedef long long ll;
-typedef pair<int, int> pii;
-typedef vector<int> vi;
+using ll = long long;
+using pii = pair<int, int>;
+using vi = vector<int>;
 
 int main() {
 	cin.tie(0)->sync_with_stdio(0);

diff --git a/content/data-structures/Matrix.h b/content/data-structures/Matrix.h
@@ -13,7 +13,7 @@
 #pragma once
 
 template<class T, int N> struct Matrix {
-	typedef Matrix M;
+	using M = Matrix;
 	array<array<T, N>, N> d{};
 	M operator*(const M& m) const {
 		M a;

diff --git a/content/data-structures/SegmentTree.h b/content/data-structures/SegmentTree.h
@@ -11,7 +11,7 @@
 #pragma once
 
 struct Tree {
-	typedef int T;
+	using T = int;
 	static constexpr T unit = INT_MIN;
 	T f(T a, T b) { return max(a, b); } // (any associative fn)
 	vector<T> s; int n;

diff --git a/content/geometry/3dHull.h b/content/geometry/3dHull.h
@@ -12,7 +12,7 @@
 
 #include "Point3D.h"
 
-typedef Point3D<double> P3;
+using P3 = Point3D<double>;
 
 struct PR {
 	void ins(int x) { (a == -1 ? a : b) = x; }

diff --git a/content/geometry/CircleIntersection.h b/content/geometry/CircleIntersection.h
@@ -10,7 +10,7 @@
 
 #include "Point.h"
 
-typedef Point<double> P;
+using P = Point<double>;
 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;

diff --git a/content/geometry/CirclePolygonIntersection.h b/content/geometry/CirclePolygonIntersection.h
@@ -12,7 +12,7 @@
 
 #include "../../content/geometry/Point.h"
 
-typedef Point<double> P;
+using P = Point<double>;
 #define arg(p, q) atan2(p.cross(q), p.dot(q))
 double circlePoly(P c, double r, vector<P> ps) {
 	auto tri = [&](P p, P q) {

diff --git a/content/geometry/ClosestPair.h b/content/geometry/ClosestPair.h
@@ -11,7 +11,7 @@
 
 #include "Point.h"
 
-typedef Point<ll> P;
+using P = Point<ll>;
 pair<P, P> closest(vector<P> v) {
 	assert(sz(v) > 1);
 	set<P> S;

diff --git a/content/geometry/ConvexHull.h b/content/geometry/ConvexHull.h
@@ -20,7 +20,7 @@ Points on the edge of the hull between two other points are not considered part
 
 #include "Point.h"
 
-typedef Point<ll> P;
+using P = Point<ll>;
 vector<P> convexHull(vector<P> pts) {
 	if (sz(pts) <= 1) return pts;
 	sort(all(pts));

diff --git a/content/geometry/FastDelaunay.h b/content/geometry/FastDelaunay.h
@@ -16,9 +16,9 @@
 
 #include "Point.h"
 
-typedef Point<ll> P;
-typedef struct Quad* Q;
-typedef __int128_t lll; // (can be ll if coords are < 2e4)
+using P = Point<ll>;
+using Q = struct Quad*;
+using lll = __int128_t; // (can be ll if coords are < 2e4)
 P arb(LLONG_MAX,LLONG_MAX); // not equal to any other point
 
 struct Quad {

diff --git a/content/geometry/HullDiameter.h b/content/geometry/HullDiameter.h
@@ -11,7 +11,7 @@
 #pragma once
 #include "Point.h"
 
-typedef Point<ll> P;
+using P = Point<ll>;
 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]}});

diff --git a/content/geometry/ManhattanMST.h b/content/geometry/ManhattanMST.h
@@ -13,7 +13,7 @@
 #pragma once
 #include "Point.h"
 
-typedef Point<int> P;
+using P = Point<int>;
 vector<array<int, 3>> manhattanMST(vector<P> ps) {
 	vi id(sz(ps));
 	iota(all(id), 0);

diff --git a/content/geometry/Point.h b/content/geometry/Point.h
@@ -12,7 +12,7 @@
 template <class T> int sgn(T x) { return (x > 0) - (x < 0); }
 template<class T>
 struct Point {
-	typedef Point P;
+	using P = Point;
 	T x, y;
 	explicit Point(T x=0, T y=0) : x(x), y(y) {}
 	bool operator<(P p) const { return tie(x,y) < tie(p.x,p.y); }

diff --git a/content/geometry/Point3D.h b/content/geometry/Point3D.h
@@ -11,8 +11,8 @@
 #pragma once
 
 template<class T> struct Point3D {
-	typedef Point3D P;
-	typedef const P& R;
+	using P = Point3D;
+	using R = const P&;
 	T x, y, z;
 	explicit Point3D(T x=0, T y=0, T z=0) : x(x), y(y), z(z) {}
 	bool operator<(R p) const {

diff --git a/content/geometry/PointInsideHull.h b/content/geometry/PointInsideHull.h
@@ -16,7 +16,7 @@
 #include "sideOf.h"
 #include "OnSegment.h"
 
-typedef Point<ll> P;
+using P = Point<ll>;
 
 bool inHull(const vector<P>& l, P p, bool strict = true) {
 	int a = 1, b = sz(l) - 1, r = !strict;

diff --git a/content/geometry/PolygonCenter.h b/content/geometry/PolygonCenter.h
@@ -11,7 +11,7 @@
 
 #include "Point.h"
 
-typedef Point<double> P;
+using P = Point<double>;
 P polygonCenter(const vector<P>& v) {
 	P res(0, 0); double A = 0;
 	for (int i = 0, j = sz(v) - 1; i < sz(v); j = i++) {

diff --git a/content/geometry/PolygonCut.h b/content/geometry/PolygonCut.h
@@ -22,7 +22,7 @@
 #include "Point.h"
 #include "lineIntersection.h"
 
-typedef Point<double> P;
+using P = Point<double>;
 vector<P> polygonCut(const vector<P>& poly, P s, P e) {
 	vector<P> res;
 	rep(i,0,sz(poly)) {

diff --git a/content/geometry/PolygonUnion.h b/content/geometry/PolygonUnion.h
@@ -14,7 +14,7 @@
 #include "Point.h"
 #include "sideOf.h"
 
-typedef Point<double> P;
+using P = Point<double>;
 double rat(P a, P b) { return sgn(b.x) ? a.x/b.x : a.y/b.y; }
 double polyUnion(vector<vector<P>>& poly) {
 	double ret = 0;

diff --git a/content/geometry/SegmentDistance.h b/content/geometry/SegmentDistance.h
@@ -20,7 +20,7 @@ Returns the shortest distance between point p and the line segment from point s
 
 #include "Point.h"
 
-typedef Point<double> P;
+using P = Point<double>;
 double segDist(P& s, P& e, P& p) {
 	if (s==e) return (p-s).dist();
 	auto d = (e-s).dist2(), t = min(d,max(.0,(p-s).dot(e-s)));

diff --git a/content/geometry/circumcircle.h b/content/geometry/circumcircle.h
@@ -17,7 +17,7 @@ The circumcirle of a triangle is the circle intersecting all three vertices. ccR
 
 #include "Point.h"
 
-typedef Point<double> P;
+using P = Point<double>;
 double ccRadius(const P& A, const P& B, const P& C) {
 	return (B-A).dist()*(C-B).dist()*(A-C).dist()/
 			abs((B-A).cross(C-A))/2;

diff --git a/content/geometry/kdTree.h b/content/geometry/kdTree.h
@@ -9,8 +9,8 @@
 
 #include "Point.h"
 
-typedef long long T;
-typedef Point<T> P;
+using T = long long;
+using P = Point<T>;
 const T INF = numeric_limits<T>::max();
 
 bool on_x(const P& a, const P& b) { return a.x < b.x; }

diff --git a/content/geometry/linearTransformation.h b/content/geometry/linearTransformation.h
@@ -18,7 +18,7 @@
 
 #include "Point.h"
 
-typedef Point<double> P;
+using P = Point<double>;
 P linearTransformation(const P& p0, const P& p1,
 		const P& q0, const P& q1, const P& r) {
 	P dp = p1-p0, dq = q1-q0, num(dp.cross(dq), dp.dot(dq));

diff --git a/content/graph/CompressTree.h b/content/graph/CompressTree.h
@@ -14,7 +14,7 @@
 
 #include "LCA.h"
 
-typedef vector<pair<int, int>> vpi;
+using vpi = vector<pair<int, int>>;
 vpi compressTree(LCA& lca, const vi& subset) {
 	static vi rev; rev.resize(sz(lca.time));
 	vi li = subset, &T = lca.time;

diff --git a/content/graph/GomoryHu.h b/content/graph/GomoryHu.h
@@ -18,7 +18,7 @@
 
 #include "PushRelabel.h"
 
-typedef array<ll, 3> Edge;
+using Edge = array<ll, 3>;
 vector<Edge> gomoryHu(int N, vector<Edge> ed) {
 	vector<Edge> tree;
 	vi par(N);

diff --git a/content/graph/MaximalCliques.h b/content/graph/MaximalCliques.h
@@ -15,7 +15,7 @@
 /// degree, where degrees go down as nodes are removed.
 /// (mostly irrelevant given MaximumClique)
 
-typedef bitset<128> B;
+using B = bitset<128>;
 template<class F>
 void cliques(vector<B>& eds, F f, B P = ~B(), B X={}, B R={}) {
 	if (!P.any()) { if (!X.any()) f(R); return; }

diff --git a/content/graph/MaximumClique.h b/content/graph/MaximumClique.h
@@ -10,11 +10,11 @@
  * faster for sparse graphs.
  * Status: stress-tested
  */
-typedef vector<bitset<200>> vb;
+using vb = vector<bitset<200>>;
 struct Maxclique {
 	double limit=0.025, pk=0;
 	struct Vertex { int i, d=0; };
-	typedef vector<Vertex> vv;
+	using vv = vector<Vertex>;
 	vb e;
 	vv V;
 	vector<vi> C;

diff --git a/content/number-theory/ContinuedFractions.h b/content/number-theory/ContinuedFractions.h
@@ -14,7 +14,7 @@
  * Status: stress-tested for n <= 300
  */
 
-typedef double d; // for N ~ 1e7; long double for N ~ 1e9
+using d = double; // for N ~ 1e7; long double for N ~ 1e9
 pair<ll, ll> approximate(d x, ll N) {
 	ll LP = 0, LQ = 1, P = 1, Q = 0, inf = LLONG_MAX; d y = x;
 	for (;;) {

diff --git a/content/number-theory/ModMulLL.h b/content/number-theory/ModMulLL.h
@@ -16,7 +16,7 @@
  */
 #pragma once
 
-typedef unsigned long long ull;
+using ull = unsigned long long;
 ull modmul(ull a, ull b, ull M) {
 	ll ret = a * b - M * ull(1.L / M * a * b);
 	return ret + M * (ret < 0) - M * (ret >= (ll)M);

diff --git a/content/number-theory/ModSum.h b/content/number-theory/ModSum.h
@@ -12,7 +12,7 @@
  */
 #pragma once
 
-typedef unsigned long long ull;
+using ull = unsigned long long;
 ull sumsq(ull to) { return to / 2 * ((to-1) | 1); }
 /// ^ written in a weird way to deal with overflows correctly
 

diff --git a/content/numerical/FastFourierTransform.h b/content/numerical/FastFourierTransform.h
@@ -19,8 +19,8 @@
  */
 #pragma once
 
-typedef complex<double> C;
-typedef vector<double> vd;
+using C = complex<double>;
+using vd = vector<double>;
 void fft(vector<C>& a) {
 	int n = sz(a), L = 31 - __builtin_clz(n);
 	static vector<complex<long double>> R(2, 1);

diff --git a/content/numerical/FastFourierTransformMod.h b/content/numerical/FastFourierTransformMod.h
@@ -15,7 +15,7 @@
 
 #include "FastFourierTransform.h"
 
-typedef vector<ll> vl;
+using vl = vector<ll>;
 template<int M> vl convMod(const vl &a, const vl &b) {
 	if (a.empty() || b.empty()) return {};
 	vl res(sz(a) + sz(b) - 1);

diff --git a/content/numerical/HillClimbing.h b/content/numerical/HillClimbing.h
@@ -8,7 +8,7 @@
  */
 #pragma once
 
-typedef array<double, 2> P;
+using P = array<double, 2>;
 
 template<class F> pair<double, P> hillClimb(P start, F f) {
 	pair<double, P> cur(f(start), start);

diff --git a/content/numerical/IntegrateAdaptive.h b/content/numerical/IntegrateAdaptive.h
@@ -13,7 +13,7 @@
  */
 #pragma once
 
-typedef double d;
+using d = double;
 #define S(a,b) (f(a) + 4*f((a+b) / 2) + f(b)) * (b-a) / 6
 
 template <class F>

diff --git a/content/numerical/LinearRecurrence.h b/content/numerical/LinearRecurrence.h
@@ -16,7 +16,7 @@
 
 const ll mod = 5; /** exclude-line */
 
-typedef vector<ll> Poly;
+using Poly = vector<ll>;
 ll linearRec(Poly S, Poly tr, ll k) {
 	int n = sz(tr);
 

diff --git a/content/numerical/NumberTheoreticTransform.h b/content/numerical/NumberTheoreticTransform.h
@@ -21,7 +21,7 @@
 const ll mod = (119 << 23) + 1, root = 62; // = 998244353
 // For p < 2^30 there is also e.g. 5 << 25, 7 << 26, 479 << 21
 // and 483 << 21 (same root). The last two are > 10^9.
-typedef vector<ll> vl;
+using vl = vector<ll>;
 void ntt(vl &a) {
 	int n = sz(a), L = 31 - __builtin_clz(n);
 	static vl rt(2, 1);

diff --git a/content/numerical/PolyInterpolate.h b/content/numerical/PolyInterpolate.h
@@ -10,7 +10,7 @@
  */
 #pragma once
 
-typedef vector<double> vd;
+using vd = vector<double>;
 vd interpolate(vd x, vd y, int n) {
 	vd res(n), temp(n);
 	rep(k,0,n-1) rep(i,k+1,n)

diff --git a/content/numerical/Simplex.h b/content/numerical/Simplex.h
@@ -15,9 +15,9 @@
  */
 #pragma once
 
-typedef double T; // long double, Rational, double + mod<P>...
-typedef vector<T> vd;
-typedef vector<vd> vvd;
+using T = double; // long double, Rational, double + mod<P>...
+using vd = vector<T>;
+using vvd = vector<vd>;
 
 const T eps = 1e-8, inf = 1/.0;
 #define MP make_pair

diff --git a/content/numerical/SolveLinear.h b/content/numerical/SolveLinear.h
@@ -9,7 +9,7 @@
  */
 #pragma once
 
-typedef vector<double> vd;
+using vd = vector<double>;
 const double eps = 1e-12;
 
 int solveLinear(vector<vd>& A, vd& b, vd& x) {

diff --git a/content/numerical/SolveLinearBinary.h b/content/numerical/SolveLinearBinary.h
@@ -10,7 +10,7 @@
  */
 #pragma once
 
-typedef bitset<1000> bs;
+using bs = bitset<1000>;
 
 int solveLinear(vector<bs>& A, vi& b, bs& x, int m) {
 	int n = sz(A), rank = 0, br;

diff --git a/content/numerical/Tridiagonal.h b/content/numerical/Tridiagonal.h
@@ -33,7 +33,7 @@ the algorithm is numerically stable and neither \texttt{tr} nor the check for \t
  */
 #pragma once
 
-typedef double T;
+using T = double;
 vector<T> tridiagonal(vector<T> diag, const vector<T>& super,
 		const vector<T>& sub, vector<T> b) {
 	int n = sz(b); vi tr(n);

diff --git a/content/strings/Hashing-codeforces.h b/content/strings/Hashing-codeforces.h
@@ -9,11 +9,11 @@
  */
 #pragma once
 
-typedef uint64_t ull;
+using ull = uint64_t;
 static int C; // initialized below
 
 // Arithmetic mod two primes and 2^32 simultaneously.
-// "typedef uint64_t H;" instead if Thue-Morse does not apply.
+// "using H = uint64_t;" instead if Thue-Morse does not apply.
 template<int M, class B>
 struct A {
 	int x; B b; A(int x=0) : x(x), b(x) {}
@@ -25,7 +25,7 @@ struct A {
 	bool operator==(A o) const { return (ull)*this == (ull)o; }
 	bool operator<(A o) const { return (ull)*this < (ull)o; }
 };
-typedef A<1000000007, A<1000000009, unsigned>> H;
+using H = A<1000000007, A<1000000009, unsigned>>;
 
 struct HashInterval {
 	vector<H> ha, pw;