Initial commit

Author: fredbr

.gitignore

@@ -0,0 +1,8 @@
+# Ignore all
+*
+# Unignore all with extensions
+!*.*
+# Unignore all dirs
+!*/
+
+*.txt

bit.cpp

@@ -0,0 +1,32 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+// const int maxn = 1010101;
+
+template <typename T, const int maxn>
+struct bit
+{
+	T v[maxn];
+
+	void add(int x, const T& d)
+	{
+		for (int i = x; i < maxn; i += i&-i)
+			v[i] += d;
+	}
+
+	T get(int x)
+	{
+		T ans{};
+		for (int i = x; i > 0; i -= i&-i)
+			ans += v[i];
+		return ans;
+	}
+};
+
+bit<long long, 1010101> b;
+
+int main()
+{
+
+}

choose.cpp

@@ -0,0 +1,42 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+typedef long long ll;
+
+const ll mod = 1e9 + 7;
+const int maxn = 1e6 + 10;	
+
+ll fac[maxn];
+ll inv[maxn];
+ll invfac[maxn];
+
+void init()
+{	
+	fac[0] = 1ll;
+	for (ll i = 1; i < maxn; i++)
+		fac[i] = fac[i-1] * i % mod;
+
+	inv[1] = 1ll;
+	for (ll i = 2; i < maxn; i++)
+		inv[i] = (mod - (mod/i) * inv[mod%i] % mod) % mod;
+
+	invfac[0] = 1ll;
+	for (ll i = 1; i < maxn; i++)
+		invfac[i] = invfac[i-1] * inv[i] % mod;
+}
+
+ll choose(int n, int k)
+{
+	return (fac[n] * invfac[k]) % mod * invfac[n-k] % mod;
+}
+
+int main()
+{
+	init();
+	
+	int n, k;
+	cin >> n >> k;
+
+	cout << choose(n, k) << "\n";
+}

convexhulltrick.cpp

@@ -0,0 +1,117 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+typedef long double ld;
+// double tambem funciona na maioria dos casos
+
+typedef long long ll;
+
+struct line
+{
+	char type;
+	// type = 0 : linha do envelope
+	// type = 1 : query no x (interseccao das linha) no envelope
+
+	ld x;
+	// x das interseccoes
+
+	ll m, b;
+	// m : coeficiente angular
+	// b : constante
+};
+
+bool operator< (const line &a, const line &b)
+{
+	if (a.type + b.type > 0) return a.x < b.x;
+	return a.m > b.m; 
+	// para maximo inverter o  sinal do ultimo return
+}
+
+typedef set<line>::iterator sit;
+set<line> env;
+
+bool has_prev(sit it)
+{
+	return (it != env.begin());
+}
+
+bool has_next(sit it)
+{
+	return (it != env.end() and ++it != env.end());
+}
+
+bool bad(line i, line j, line k)
+{
+	return (k.b-i.b)*(i.m-j.m) < (j.b-i.b)*(i.m-k.m);
+	// para maximo inverter o sinal
+}
+
+ld intersect(sit i, sit j)
+{
+	return (ld)(i->b-j->b)/(j->m-i->m);
+}
+
+void calc_x(sit i)
+{
+	if (has_prev(i)) {
+
+		line l = *i;
+
+		l.x = intersect(prev(i), i);
+		env.erase(i);
+		env.insert(l);
+	}
+}
+
+void add(ll m, ll b)
+{
+	sit it;
+
+	line l = {0, 0, m, b}; 
+
+	it  = env.lower_bound(l);
+
+
+	// checa linhas colineares
+	if (it != env.end() and it->m == m)
+	{
+		if (it->b <= b) env.erase(it);
+		else return;
+	}
+
+	env.insert(l);
+	it = env.find(l);
+
+	// checa se a linha colocada deve ser removida
+	if (has_prev(it) and has_next(it) and bad(*prev(it), *it, *next(it))) {
+
+		env.erase(it);
+		return;
+	}
+
+	// retira linhas da direta irrelevantes
+	while (has_next(it) and has_next(next(it)) and bad(*it, *next(it), *next(next(it))))
+		env.erase(next(it));
+
+	// retira linhas da esquerda irrelevantes
+	while (has_prev(it) and has_prev(prev(it)) and bad(*prev(prev(it)), *prev(it), *it))
+		env.erase(prev(it));
+
+	// salva o x das interseccoes dele com o anterior e o proximo
+	if (has_next(it)) calc_x(next(it));
+	calc_x(it);
+}
+
+ll query(ll x)
+{
+	sit it = env.upper_bound({1, (ld)x, 0, 0});
+	it--;
+
+	return it->m*x + it->b;
+}
+
+int main()
+{
+
+}

fast_input.cpp

@@ -0,0 +1,98 @@
+inline int scan () {
+	int result = 0;
+	char ch;
+	bool minus = false;
+	ch = getchar_unlocked();
+	while (true) {
+		if (ch == '-') break;
+		if (ch >= '0' && ch <= '9') break;
+		ch = getchar_unlocked();
+	}
+	if (ch == '-') minus = true; else result = ch-'0';
+	while (true) {
+		ch = getchar_unlocked();
+		if (ch < '0' || ch > '9') break;
+		result = result*10 + (ch - '0');
+	}
+	if (minus) return -result;
+	return result;
+}
+
+
+/*------------------------------------------*/
+/*-----------FUDEROSAMENTE RAPIDO-----------*/
+/*------------------------------------------*/
+
+inline int readChar();
+template <class T = int> inline T readInt(); 
+template <class T> inline void writeInt( T x, char end = 0 );
+inline void writeChar( int x ); 
+inline void writeWord( const char *s );
+
+/** Read */
+
+static const int buf_size = 4096;
+
+inline int getChar() {
+	static char buf[buf_size];
+	static int len = 0, pos = 0;
+	if (pos == len)
+		pos = 0, len = fread(buf, 1, buf_size, stdin);
+	if (pos == len)
+		return -1;
+	return buf[pos++];
+}
+
+inline int readChar() {
+	int c = getChar();
+	while (c <= 32)
+		c = getChar();
+	return c;
+}
+
+template <class T>
+inline T readInt() {
+	char c = readChar();
+	T x = 0;
+	while ('0' <= c && c <= '9')
+		x = x * 10 + c - '0', c = getChar();
+	return x;
+}
+
+/** Write */
+
+static int write_pos = 0;
+static char write_buf[buf_size];
+
+inline void writeChar( int x ) {
+	if (write_pos == buf_size)
+		fwrite(write_buf, 1, buf_size, stdout), write_pos = 0;
+	write_buf[write_pos++] = x;
+}
+
+template <class T> 
+inline void writeInt( T x, char end ) {
+	if (x < 0)
+		writeChar('-'), x = -x;
+
+	char s[24];
+	int n = 0;
+	while (x || !n)
+		s[n++] = '0' + x % 10, x /= 10;
+	while (n--)
+		writeChar(s[n]);
+	if (end)
+		writeChar(end);
+}
+
+inline void writeWord( const char *s ) {
+	while (*s)
+		writeChar(*s++);
+}
+
+struct Flusher {
+	~Flusher() {
+		if (write_pos)
+			fwrite(write_buf, 1, write_pos, stdout), write_pos = 0;
+	}
+} flusher;

gitignore

@@ -0,0 +1,6 @@
+# Ignore all
+*
+# Unignore all with extensions
+!*.*
+# Unignore all dirs
+!*/

meldable_heap.cpp

@@ -0,0 +1,62 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+struct node
+{
+	int val;
+
+	node *l, *r;
+
+	node(int val)
+		: val(val), l(nullptr), r(nullptr) {};
+};
+
+mt19937 rd;
+uniform_int_distribution<int> toss(0, 1);
+
+node* meld(node *&l, node *&r)
+{
+	if (!l) return r;
+	if (!r) return l;
+
+	if (l->val > r->val) swap(l, r);
+
+	if (toss(rd)) l->l = meld(l->l, r);
+	else l->r = meld(l->r, r);
+
+	return l;
+}
+
+void insert(node *&t, int x)
+{
+	node *aux = new node(x);
+
+	t = meld(t, aux);
+}
+
+void pop(node *&t)
+{
+	if (!t) return;
+
+	t = meld(t->l, t->r);
+}
+
+int min(node *t)
+{
+	return t? t->val: 0;
+}
+
+node *t = nullptr;
+
+int main()
+{
+	insert(t, 2);
+	insert(t, 3);
+	insert(t, 4);
+	print(t);
+	cout << "\n";
+	cout << min(t) << "\n";
+	pop(t);
+	cout << min(t) << "\n";
+}