An open API service indexing awesome lists of open source software.

https://github.com/glebegor/competitive-template

Competitive programming template
https://github.com/glebegor/competitive-template

algo competitive-programming cpp

Last synced: 7 months ago
JSON representation

Competitive programming template

Awesome Lists containing this project

README

          

# Competitive Template

## Description

This is the template I use for competitive programming. Below is a detailed description of the main functions and utilities included.

## Imports

```cpp
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
```

## Types

```cpp
using ll = long long;
using ld = long double;
using l128 = __int128_t;
using u32 = unsigned;
using u64 = unsigned long long;
using lli = long long int;
using Com = std::complex; // Complex numbers
#define ComX real()
#define ComY imag()
```

## Constants

```cpp
#define INF 1e12 + 7
#define MOD7 1e9 + 7
#define MOD9 1e12 + 9
#define MIN 0
#define EU exp(1.0)
const ld PI = acos((ld)-1);
const int maxNum = 111111111;
```

## Vectors

```cpp
template
using V = std::vector;
typedef V vi;
typedef V> vii;
typedef V vs;
typedef V vb;
typedef V vl;
typedef V vd;
typedef V vli;
typedef V> vvi;
typedef V> vvl;

#define sz(x) int(size(x))
#define bg(x) begin(x)
#define all(x) bg(x), end(x)
#define rall(x) rbegin(x), rend(x)
#define sor(x) sort(all(x))
#define rsz resize
#define ins insert
#define pb push_back
#define eb emplace_back
#define ft front()
#define bk back()
```

## Basic Functions

```cpp
template
ll cdiv(T a, T b) {
return a / b + ((a ^ b) > 0 && a % b);
} // Divide a by b rounded up

template
ll fdiv(T a, T b) {
return a / b - ((a ^ b) < 0 && a % b);
} // Divide a by b rounded down

template
bool ckmin(T &a, const T &b) {
return b < a ? a = b, 1 : 0;
} // Set a = min(a, b)

template
bool ckmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
} // Set a = max(a, b)

template
void remDup(V &v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
} // Remove duplicates

template
T gcd_euclid(T a, T b) {
while (b > 0) {
ll temp = a / b;
a -= temp * b;
std::swap(a, b);
}
return a;
} // Greatest common divisor

template
T lcd(T a, T b) {
return a / gcd_euclid(a, b) * b;
} // Least common denominator

template
T lcm(T a, T b) {
return abs(a * b) / gcd_euclid(a, b);
} // Least common multiple

template
T factorial(T a) {
if (a == 0) {
return 1;
}
return factorial(a - 1) * a;
} // Factorial

template
std::vector divisors(T n) {
std::vector res;
for (T d = 1; d * d <= n; ++d) {
if (n % d == 0) {
res.pb(d);
if (d * d != n) {
res.pb(n / d);
}
}
}
sort(all(res));
return res;
} // Find all divisors

std::vector seive_count(int n) {
std::vector is_prime(n + 1, true);
is_prime[0] = is_prime[1] = false;
for (int i = 2; i <= n; i++) {
if (is_prime[i] && (long long)i * i <= n) {
for (int j = i * i; j <= n; j += i)
is_prime[j] = false;
}
}
return is_prime;
} // Prime numbers

bool is_prime_number(int n) {
if (n < 2) {
return false;
}
for (int x = 2; x * x <= n; x++) {
if (n % x == 0) {
return false;
}
}
return true;
} // Check if prime

struct pair_hash {
template
std::size_t operator()(const std::pair &pair) const {
auto h1 = std::hash{}(pair.first);
auto h2 = std::hash{}(pair.second);
return h1 ^ h2;
}
}; // Pair hash
```

## Pairs

```cpp
#define f first
#define s second
#define mkp make_pair
typedef std::pair pii;
```

## Loops

```cpp
#define FOR(i, a, b) for (int _n(b), i(a); i <= _n; i++)
#define FORD(i, b, a) for (int _n(b), i(a); i <= _n; i--)
#define REP(i, n) for (int i = 0; i < n; i++)
#define trav(a, x) for (auto &a : x)
```

## Files

```cpp
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
```