Initial commit

Author: ekzhang

aho_corasick.cpp

@@ -0,0 +1,127 @@
+// aho_corasick.cpp
+// Eric K. Zhang; July 15, 2016
+
+// Problem: Given a text string and a dictionary
+// of search strings, find all occurences of a search
+// string in the text (overlap included).
+
+// Bad solution: Run KMP a lot, giving O(N * |S|)
+
+// Good solution: Aho-Corasick gives O(N + sum|S|) by
+// essentially extending KMP, creating a trie with
+// "failure" functions. Basically a FSM.
+
+// Note: The automation generated by Aho-Corasick can
+// also be used as a first step in many problems. This
+// is often how it'll be used (e.g. sparse table) in
+// competitions, since Rabin-Karp is easier to code
+// for the simple version of the problem.
+
+#include <bits/stdc++.h>
+using namespace std;
+
+typedef long long LL;
+
+#define MAXN 100013
+int N; // size of dictionary
+string dict[MAXN];
+string text;
+
+#define MAXM 100013
+int M; // number of states in the automation
+int g[MAXM][26]; // the normal edges in the trie
+int f[MAXM]; // failure function
+LL out[MAXM]; // output function
+
+int aho_corasick() {
+	memset(g, -1, sizeof g);
+	memset(out, 0, sizeof out);
+
+	int nodes = 1;
+
+	// build the trie
+	for (int i = 0; i < N; i++) {
+		string& s = dict[i];
+		int cur = 0;
+
+		for (int j = 0; j < s.size(); j++) {
+			if (g[cur][s[j] - 'a'] == -1) {
+				g[cur][s[j] - 'a'] = nodes++;
+			}
+			cur = g[cur][s[j] - 'a'];
+		}
+		out[cur]++;
+	}
+
+	for (int ch = 0; ch < 26; ch++) {
+		if (g[0][ch] == -1) {
+			g[0][ch] = 0;
+		}
+	}
+
+	// BFS to calculate out and failure functions
+	memset(f, -1, sizeof f);
+	queue<int> q;
+	for (int ch = 0; ch < 26; ch++) {
+		if (g[0][ch] != 0) {
+			f[g[0][ch]] = 0;
+			q.push(g[0][ch]);
+		}
+	}
+
+	while (!q.empty()) {
+		int state = q.front();
+		q.pop();
+
+		for (int ch = 0; ch < 26; ch++) {
+			if (g[state][ch] == -1) continue;
+
+			int fail = f[state];
+			while (g[fail][ch] == -1) {
+				fail = f[fail];
+			}
+
+			f[g[state][ch]] = g[fail][ch];
+			out[g[state][ch]] += out[g[fail][ch]];
+
+			q.push(g[state][ch]);
+		}
+	}
+
+	return nodes;
+}
+
+LL search() {
+	// Using the Aho-Corasick automation, search the text.
+	int state = 0;
+	LL ret = 0;
+	for (char c : text) {
+		while (g[state][c - 'a'] == -1) {
+			state = f[state];
+		}
+		state = g[state][c - 'a'];
+		ret += out[state];
+	}
+	// It's that simple!
+	return ret;
+}
+
+int main() {
+	// make I/O faster
+	ios_base::sync_with_stdio(false);
+	cin.tie(0);
+
+	freopen("aho_corasick.in", "r", stdin);
+
+	cin >> N;
+	for (int i = 0; i < N; i++) {
+		cin >> dict[i];
+	}
+	cin >> text;
+
+	M = aho_corasick();
+	LL result = search();
+
+	cout << result << endl;
+	return 0;
+}

convex_hull_trick.cpp

@@ -0,0 +1,69 @@
+// convex_hull_trick.cpp
+// Eric K. Zhang; Nov. 22, 2017
+
+#include <bits/stdc++.h>
+using namespace std;
+
+typedef pair<int, int> pii;
+#define MAXN 100013
+int N, Q;
+pii ar[MAXN];
+
+vector<pii> envelope;
+vector<double> hull;
+
+double intersect(int m1, int b1, int m2, int b2) {
+	return (b2 - b1) / ((double) m1 - m2);
+}
+
+double intersect(pii y1, pii y2) {
+	return intersect(y1.first, y1.second, y2.first, y2.second);
+}
+
+int main() {
+	// make cin, cout faster
+	ios_base::sync_with_stdio(false);
+	cin.tie(0);
+
+	freopen("cht.in", "r", stdin);
+
+	cin >> N >> Q;
+	for (int i = 0; i < N; i++) {
+		cin >> ar[i].first >> ar[i].second;
+	}
+
+	// Ok, time for the CHT algorithm! We'll find the lower envelope
+	sort(ar, ar + N, [](pii y1, pii y2) {
+		return y1.first != y2.first ? y1.first > y2.first : y1.second < y2.second;
+	});
+
+	for (int i = 0; i < N; i++) {
+		if (i != 0 && ar[i].first == ar[i - 1].first)
+			continue; // repeated slope <-> parallel lines
+
+		int sz;
+		while ((sz = envelope.size()) >= 2) {
+			if (intersect(envelope[sz - 2], ar[i]) <
+					intersect(envelope[sz - 2], envelope[sz - 1])) {
+				envelope.pop_back();
+			}
+			else break;
+		}
+
+		envelope.push_back(ar[i]);
+	}
+
+	for (int i = 0; i < envelope.size() - 1; i++) {
+		hull.push_back(intersect(envelope[i], envelope[i + 1]));
+	}
+
+	for (int i = 0; i < Q; i++) {
+		double x;
+		cin >> x;
+		int idx = lower_bound(begin(hull), end(hull), x) - begin(hull);
+		cout << envelope[idx].first * x + envelope[idx].second << '\n';
+	}
+
+	cout.flush();
+	return 0;
+}

euler_tour.cpp

@@ -0,0 +1,44 @@
+// euler_tour.cpp
+// Eric K. Zhang; Dec. 22, 2017
+
+#include <bits/stdc++.h>
+using namespace std;
+
+#define MAXN 100013
+#define MAXM 1000013
+int N, M;
+vector<pair<int, int> > adj[MAXN];
+int cur[MAXN];
+bool used[MAXM];
+vector<int> tour;
+
+void dfs(int n) {
+	while (cur[n] != adj[n].size()) {
+		if (used[adj[n][cur[n]].second]) {
+			++cur[n];
+			continue;
+		}
+		auto p = adj[n][cur[n]++];
+		used[p.second] = true;
+		dfs(p.first);
+	}
+	tour.push_back(n);
+}
+
+int main() {
+	cin >> N >> M;
+	for (int i = 0; i < M; i++) {
+		int u, v;
+		cin >> u >> v;
+		--u; --v;
+		adj[u].emplace_back(v, i);
+		adj[v].emplace_back(u, i);
+	}
+	dfs(0);
+	cout << tour.size() << endl;
+	for (int v : tour) {
+		cout << v + 1 << ' ';
+	}
+	cout << endl;
+	return 0;
+}

fentreap.cpp

@@ -0,0 +1,95 @@
+// fentreap.cpp
+// Eric K. Zhang; Jan. 1, 2018
+
+#include <bits/stdc++.h>
+using namespace std;
+
+#define MAXN 100013
+#define MAXLGN 18
+
+int N;
+
+struct tnode {
+	tnode* l;
+	tnode* r;
+	int x, y;
+	int val, sum;
+	tnode() { y = rand() ^ (rand() << 16); }
+	void update() { sum = val + (l ? l->sum : 0) + (r ? r->sum : 0); }
+} vals[MAXN * MAXLGN];
+int mem = 0;
+tnode* fen[MAXN];
+
+void split(tnode* t, tnode*& l, tnode*& r, int k) {
+	if (!t) {
+		l = r = nullptr;
+		return;
+	}
+	if (t->x < k) {
+		l = t;
+		split(t->r, t->r, r, k);
+	}
+	else {
+		r = t;
+		split(t->l, l, t->l, k);
+	}
+	t->update();
+}
+
+void merge(tnode*& t, tnode* l, tnode* r) {
+	if (!l || !r) {
+		t = l ? l : r;
+		return;
+	}
+	if (l->y < r->y) {
+		t = l;
+		merge(t->r, t->r, r);
+	}
+	else {
+		t = r;
+		merge(t->l, l, t->l);
+	}
+	t->update();
+}
+
+void upd(tnode*& t, int y, int val) {
+	tnode *l, *r;
+	split(t, l, t, y);
+	split(t, t, r, y + 1);
+	if (!t) t = &vals[mem++], t->x = y;
+	t->val += val;
+	t->update();
+	merge(t, l, t);
+	merge(t, t, r);
+}
+
+void update(int x, int y, int val) {
+	for (x++; x < MAXN; x += x & -x) {
+		upd(fen[x], y, val);
+	}
+}
+
+int qry(tnode*& t, int y) {
+	tnode* r;
+	split(t, t, r, y + 1);
+	int ret = t ? t->sum : 0;
+	merge(t, t, r);
+	return ret;
+}
+
+int query(int x, int y) {
+	int ret = 0;
+	for (x++; x; x -= x & -x) {
+		ret += qry(fen[x], y);
+	}
+	return ret;
+}
+
+int main() {
+	N = 100;
+	update(0, 0, 5);
+	update(2, 2, 30);
+	update(3, 1, 10);
+	update(0, 5, 10);
+	cout << query(2, 4) << endl;
+}

fenwick_2d.cpp

@@ -0,0 +1,44 @@
+// fenwick_2d.cpp
+// Eric K. Zhang; Nov. 22, 2017
+
+#include <bits/stdc++.h>
+using namespace std;
+
+#define MAX 1000
+
+int N, M;
+int fenwick[MAX + 1][MAX + 1];
+
+void update(int x, int y, int val) {
+	for (int a = x; a <= MAX; a += a & -a) {
+		for (int b = y; b <= MAX; b += b & -b) {
+			fenwick[a][b] += val;
+		}
+	}
+}
+
+int query(int x, int y) {
+	int ans = 0;
+	for (int a = x; a > 0; a -= a & -a) {
+		for (int b = y; b > 0; b -= b & -b) {
+			ans += fenwick[a][b];
+		}
+	}
+	return ans;
+}
+
+int main() {
+	cin >> N >> M;
+	for (int i = 0; i < N; i++) {
+		int A, B;
+		cin >> A >> B;
+		update(A, B, 1);
+	}
+	for (int i = 0; i < M; i++) {
+		int A, B;
+		cin >> A >> B;
+		cout << query(A, B) << '\n';
+	}
+	cout.flush();
+	return 0;
+}