Sublime Text Snippets (Competitive Programming)

cpptemplate.sublime-snippet

<snippet>
	<content><![CDATA[
#include <bits/stdc++.h>
using namespace std;
 
// typedef
typedef long long ll;
typedef pair<int,int> ii;
typedef pair<double,double> dd;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<string> vs;
typedef vector<char> vc;
typedef vector<ii> vii;
typedef vector<vi> vvi;
typedef vector<bool> vb;

#define abs(_x) ((_x)<0?-(_x):(_x))
#define REP(_a,_b) for(int (_a)=0;(_a)<(_b);++(_a))
#define mp(_x,_y) make_pair((_x),(_y))
#define PI 3.1415926535897932385
#define EPS 1e-9
#define INF 0x00FFFFFF
#define INFLL 0x00FFFFFFFFFFFFFFLL
#define ceildiv(_a,_b) ((_a)%(_b)==0?(_a)/(_b):((_a)/(_b))+1)
#define fi first
#define se second

int main(int argc, char **argv){
	ios_base::sync_with_stdio(0);
	cin.tie(0);
	
	$1
	
	return 0;
}
]]></content>
	<!-- Optional: Set a tabTrigger to define how to trigger the snippet -->
	<tabTrigger>cpptemplate</tabTrigger>
	<!-- Optional: Set a scope to limit where the snippet will trigger -->
	<scope>source.c++</scope>
</snippet>

edmondkarp-class.sublime-snippet

<snippet>
	<content><![CDATA[
struct Edge {
	int u, v, w;
	Edge(int uu, int vv, int ww) {
		u = uu;
		v = vv;
		w = ww;
	}
};

class EdmondKarp {
private:
	vector<Edge> edge;
	vvi adj;
	int pre[${1:10000}], cap[${1:10000}];
	queue<int> q;
	int u, v, w, mf;

	int augment(int u, int source, int sink) {
		int forward, backward;
		while(u != source) {
			v = pre[u];
			
			for(int i=0;i<adj[v].size();++i)
				if(edge[adj[v][i]].v == u) {
					forward = adj[v][i];
					break;
				}

			backward = forward ^ 1;

			edge[forward].w -= cap[sink];
			edge[backward].w += cap[sink];

			u = v;
		}

		return cap[sink];
	}

public:
	size_t size;

	EdmondKarp() {

	} 

	EdmondKarp(size_t sz) {
		size = sz;
		reset();
	}

	void reset() {
		edge.clear();
		adj.clear();
		adj.resize(size);
	}

	void resize(size_t sz) {
		size = sz;
		reset();
	}

	void addEdge(int from, int to, int cap) {
		adj[from].push_back(edge.size());
		edge.push_back(Edge(from, to, cap));
	}

	void addEdge(int from, int to, int capForward, int capBackward) {
		addEdge(from, to, capForward);
		addEdge(to, from, capBackward);
	}

	int maxflow(int source, int sink){
		int mf = 0;
		while(true) {
			memset(pre,-1,sizeof pre);
			memset(cap,-1,sizeof cap);
			while(!q.empty()) q.pop();
			
			q.push(source);
			cap[source] = INF;

			// BFS
			while(!q.empty()) {
				u = q.front();
					q.pop();

				// Augment
				if(u == sink) {
					mf += augment(u, source, sink);
					break;
				}

				for(int i=0;i<adj[u].size();++i) {
					v = edge[adj[u][i]].v;
					w = edge[adj[u][i]].w;

					if(w > 0 && pre[v] < 0) {
						pre[v] = u;
						cap[v] = min(cap[u], w);
						if(cap[v] > 0) q.push(v);
					}

				}
			}

			if(pre[sink] == -1)
				return mf;
		}
	}

};
]]></content>
	<!-- Optional: Set a tabTrigger to define how to trigger the snippet -->
	<tabTrigger>edmondkarp-class</tabTrigger>
	<!-- Optional: Set a scope to limit where the snippet will trigger -->
	<scope>source.c++</scope>
</snippet>

edmondkarp.sublime-snippet

<snippet>
	<content><![CDATA[
struct Edge {
	int u, v, w;
	Edge(int uu, int vv, int ww) {
		u = uu;
		v = vv;
		w = ww;
	}
};

vector<Edge> edge;
vvi adj;

int u, v, w, mf;
int pre[${1:1000}], cap[${1:1000}];
queue<int> q;

void initEdmondKarp(int sz) {
	edge.clear();
	adj.clear();
	adj.resize(sz);
}

void addEdge(int from, int to, int cap) {
	adj[from].push_back(edge.size());
	edge.push_back(Edge(from, to, cap));
}

void addDirectedEdge(int from, int to, int cap) {
	addEdge(from, to, cap);
	addEdge(to, from, 0);
}

void addUndirectedEdge(int from, int to, int cap) {
	addEdge(from, to, cap);
	addEdge(to, from, cap);
}

int maxflow(int source, int sink){
	int mf = 0;
	int forward, backward;
	while(true) {
		memset(pre, -1, sizeof pre);
		memset(cap, INF, sizeof pre);
		while(!q.empty()) q.pop();
		
		q.push(source);
		cap[source] = INF;

		while(!q.empty()) {
			u = q.front();
				q.pop();

			if(u == sink) {
				mf += cap[sink];
				while(u != source) {
					v = pre[u];
					
					for(int i=0;i<adj[v].size();++i)
						if(edge[adj[v][i]].v == u) {
							forward = adj[v][i];
							break;
						}

					backward = forward ^ 1;

					edge[forward].w -= cap[sink];
					edge[backward].w += cap[sink];

					u = v;
				}

				break;
			}

			for(int i=0;i<adj[u].size();++i) {
				v = edge[adj[u][i]].v;
				w = edge[adj[u][i]].w;

				if(w > 0 && pre[v] < 0) {
					pre[v] = u;
					cap[v] = min(cap[u], w);
					if(cap[v] > 0) q.push(v);
				}

			}
		}

		if(pre[sink] == -1)
			return mf;
	}
}
]]></content>
	<!-- Optional: Set a tabTrigger to define how to trigger the snippet -->
	<tabTrigger>edmondkarp</tabTrigger>
	<!-- Optional: Set a scope to limit where the snippet will trigger -->
	<scope>source.c++</scope>
</snippet>

fenwicktree-2d.sublime-snippet

<snippet>
	<content><![CDATA[
const int	szx = ${1:1100},
			szy = ${2:1100};

int bit[szx][szy];
int mat[szx][szy];

void reset() { 	memset(bit, 0, sizeof bit),	memset(mat, 0, sizeof mat); }

void update_y(int x, int y, int v) {
	while (y < szy)	bit[x][y] += v, y += y & -y;}

void update(int x, int y, int v) {
	while (x < szx) update_y(x, y, v), x += x & -x;}

int sum_y(int x, int y) {
	int ret = 0;
	while (y) ret += bit[x][y], y -= (y & -y);
	return ret;}

int sum(int x, int y) {
	int ret = 0;
	while (x) ret += sum_y(x, y), x -= x & -x;
	return ret;}

int sum(int x0, int y0, int x1, int y1) {
	return sum(x1,y1) - sum(x0-1,y1) - sum(x1,y0-1) + sum(x0-1,y0-1);}
]]></content>
	<!-- Optional: Set a tabTrigger to define how to trigger the snippet -->
	<tabTrigger>fenwick2d</tabTrigger>
	<!-- Optional: Set a scope to limit where the snippet will trigger -->
	<scope>source.c++</scope>
</snippet>

fenwicktree.sublime-snippet

<snippet>
	<content><![CDATA[
const int sz = ${1:200005};
int bit[sz];
void reset() {
	memset(bit, 0, sizeof bit);}
void update(int x, int v) {
	while (x < sz) bit[x] += v, x += x & -x;}
int sum(int x) {
	int ret = 0;
	while (x) ret += bit[x], x -= x & -x;
	return ret;}
int sum(int x, int y) {
	return sum(y) - sum(x - 1);}
]]></content>
	<!-- Optional: Set a tabTrigger to define how to trigger the snippet -->
	<tabTrigger>fenwick</tabTrigger>
	<!-- Optional: Set a scope to limit where the snippet will trigger -->
	<scope>source.c++</scope>
</snippet>

treap.sublime-snippet

<snippet>
	<content><![CDATA[
struct Treap{
	typedef struct _Node {
		int x,y,c;
		_Node *l, *r;
		_Node(int _x): x(_x), y(rand()), c(1), l(NULL), r(NULL) {}
		~_Node() { delete l; delete r; }
		void recalc() { c = 1 + (l?l->c:0) + (r?r->c:0); }
	} *Node;

	int count(Node v) { return v?v->c:0; }	

	Node root;
	Treap(): root(0) { srand(time(NULL)); }
	~Treap() { delete root; }

	Node merge(Node l, Node r) {
		if(!l | !r) return l?l:r;
		if(l->y > r->y) {
			l->r = merge(l->r,r);
			l->recalc();
			return l;
		} else {
			r->l = merge(l,r->l);
			r->recalc();
			return r;
		}
	}

	void split(Node v, int x, Node &l, Node &r) {
		l = r = NULL;
		if(!v)
			return;
		if(v->x < x) {
			split(v->r, x, v->r, r);
			l = v;
		} else {
			split(v->l, x, l, v->l);
			r = v;
		}

		v->recalc();
	}

	Node search(Node v, int x) {
		if(!v || v->x == x) return v;
		else if(x < v->x) return search(v->l,x);
		else return search(v->r,x);
	}

	Node search(int x) { return search(root,x); }

	void insert(int x) {
		if (search(x)) return;

		Node l,r;
		split(root,x,l,r);
		root = merge(merge(l,new _Node(x)),r);
	}

	void erase(int x) {
		if (!search(x)) return;

		Node l,m,r;
		split(root,x,l,m);
		split(m,x+1,m,r);
		delete m;
		root = merge(l,r);
	}

	int kth(Node v, int k) {
		int num_l = count(v->l);
		if(k <= num_l)
			return kth(v->l, k);
		else if(k > num_l + 1)
			return kth(v->r, k-num_l-1);
		else
			return v->x;
	}

	int kth(int k) { return kth(root, k); }

	int lt(Node v, int x) {
		if(!v)
			return 0;

		if(x == v->x)
			return count(v->l);
		else if(x < v->x)
			return lt(v->l, x);
		else
			return count(v->l)+1+lt(v->r, x);
	}

	int lt(int x) { return lt(root, x); }

	size_t size() { return count(root); }
};
]]></content>
	<!-- Optional: Set a tabTrigger to define how to trigger the snippet -->
	<tabTrigger>treap</tabTrigger>
	<!-- Optional: Set a scope to limit where the snippet will trigger -->
	<scope>source.c++</scope>
</snippet>

ufds.sublime-snippet

<snippet>
	<content><![CDATA[
vi p;
int disjoint;

void init_ufds(int n) {
	disjoint = n;
	p.resize(n);
	for(int i=0;i<n;++i) p[i] = i;
}

int find(int u) { return p[u]==u? u : p[u]=find(p[u]); }
bool same(int u, int v) { return find(u) == find(v); }
void merge(int u, int v) { p[find(p[u])] = find(v), --disjoint; }
]]></content>
	<!-- Optional: Set a tabTrigger to define how to trigger the snippet -->
	<tabTrigger>ufds</tabTrigger>
	<!-- Optional: Set a scope to limit where the snippet will trigger -->
	<scope>source.c++</scope>
</snippet>