Split files into folders

Author: fredbr

bit.cpp renamed to data_structures/bit.cpp

@@ -0,0 +1,229 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+typedef long long ll;
+
+const int maxn = 100010;
+const int sqt = 330;
+
+inline int64_t ord(int x, int y, int pow, int rotate) {
+	if (pow == 0) {
+		return 0;
+	}
+	int hpow = 1 << (pow-1);
+	int seg = (x < hpow) ? (
+		(y < hpow) ? 0 : 3
+	) : (
+		(y < hpow) ? 1 : 2
+	);
+	seg = (seg + rotate) & 3;
+	const int rotateDelta[4] = {3, 0, 0, 1};
+	int nx = x & (x ^ hpow), ny = y & (y ^ hpow);
+	int nrot = (rotate + rotateDelta[seg]) & 3;
+	int64_t subSquareSize = int64_t(1) << (2*pow - 2);
+	int64_t ans = seg * subSquareSize;
+	int64_t add = ord(nx, ny, pow-1, nrot);
+	ans += (seg == 1 || seg == 2) ? add : (subSquareSize - add - 1);
+	return ans;
+}
+
+struct query
+{
+	int l, r, id;
+	ll w;
+
+	bool operator<(const query &rhs) const {
+		return w < rhs.w;
+	}
+};
+
+int lim = 0;
+
+struct bit
+{
+	int b[maxn];
+
+	inline void add(int x, int d)
+	{
+		for (int i = x; i <= lim; i += i&-i) b[i] += d;
+	}
+
+	inline int get(int x)
+	{
+		int ans = 0;
+		for (int i = x; i > 0; i -= i&-i) ans += b[i];
+		return ans;
+	}
+};
+
+bit re;
+query qr[maxn];
+int v[maxn], v2[maxn];
+
+ll tot = 0;
+ll sum = 0;
+
+inline void addl(int x)
+{	
+	tot++;
+	re.add(v[x], 1);
+	sum += re.get(v[x]-1);
+}
+
+inline void addr(int x)
+{
+	tot++;
+	re.add(v[x], 1);
+	sum += tot - re.get(v[x]);
+}
+
+inline void reml(int x)
+{
+	tot--;
+	re.add(v[x], -1);
+	sum -= re.get(v[x]-1);
+}
+
+inline void remr(int x)
+{
+	tot--;
+	re.add(v[x], -1);
+	sum -= tot - re.get(v[x]);
+}
+
+ll res[maxn];
+
+
+
+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;
+
+
+
+int main()
+{
+	int n;
+	n = readInt();
+
+	ll nn = 0;
+	while ((1<<nn) < n) nn++;
+	// cerr << nn << "\n";
+	
+	for (int i = 1; i <= n; i++) v[i] = readInt(), v2[i] = v[i];
+
+	sort(v2+1, v2+1+n);
+	lim = unique(v2+1, v2+1+n)-v2;
+	
+	for (int i = 1; i <= n; i++)
+		v[i] = lower_bound(v2+1, v2+lim, v[i])-v2;
+
+	int q;
+	q = readInt();
+
+	for (int i = 0; i < q; i++) {
+		qr[i].l = readInt();
+		qr[i].r = readInt();
+
+		qr[i].w = ord(qr[i].l-1, qr[i].r-1, nn, 0);
+		// qr[i].w = qr[i].l/sqt;
+		qr[i].id = i;
+	}
+
+	sort(qr, qr+q);
+
+	// ll dist = qr[0].l + qr[0].r;
+	// for (int i = 1; i < q; i++)
+	// 	dist += abs(qr[i].l-qr[i-1].l)+abs(qr[i].r-qr[i-1].r);
+
+	// cerr << dist << "\n";
+
+	int cl = 1, cr = 0;
+
+	for (int i = 0; i < q; i++) {
+
+		int l = qr[i].l, r = qr[i].r, id = qr[i].id;
+		
+		while (r > cr) addr(++cr);
+		while (r < cr) remr(cr--);
+		while (l < cl) addl(--cl);
+		while (l > cl) reml(cl++);
+
+		res[id] = sum;
+	}
+
+	for (int i = 0; i < q; i++) writeInt(res[i],'\n');
+
+	return 0;
+}

meldable_heap.cpp renamed to data_structures/meldable_heap.cpp

@@ -0,0 +1,79 @@
+#include <bits/stdc++.h>
+
+#define ff first
+#define ss second
+
+using namespace std;
+
+typedef pair<int, int> ii;
+
+struct minqueue
+{
+	deque<ii> dq;
+
+	int l, r, sum;
+
+	void clear()
+	{
+		l = r = sum = 0;
+		dq.clear();
+	}
+
+	void push(int x)
+	{
+		while (!dq.empty() and dq.back().ff > x-sum) dq.pop_back();
+		dq.push_back({x-sum,r});
+		r++;
+	}
+
+	void pop()
+	{
+		if (!dq.empty() and dq.front().ss == l) dq.pop_front();
+		l++;
+	}
+
+	void add(int x)	{sum += x;}
+
+	int getmin() {return dq[0].ff+sum;}
+
+	int size() {return r-l;}
+};
+
+const int maxn = 1000;
+const int maxm = 100000;
+const int inf = 0x3f3f3f;
+
+minqueue q[maxm];
+
+int d[maxm];
+int w[maxn], e[maxn], c[maxn];
+
+int main()
+{
+	int n, m;
+	cin >> n >> m;
+
+	for (int i = 1; i <= n; i++) cin >> w[i] >> e[i] >> c[i];
+
+	for (int i = 1; i <= m; i++) d[i] = inf;
+
+	for (int i = 1; i <= n; i++) {
+
+		for (int j = 0; j < w[i]; j++) q[j].clear();
+
+		for (int j = 0; j <= m; j++) {
+
+			minqueue& mq = q[j%w[i]];
+
+			if (mq.size() > e[i]) mq.pop();
+
+			mq.add(c[i]);
+			mq.push(d[j]);
+
+			d[j] = mq.getmin();
+		}
+	}
+
+	for (int i = 0; i <= m; i++) cout << d[i] << " ";
+	cout << "\n";
+}

merge_sort_tree.cpp renamed to data_structures/merge_sort_tree.cpp

@@ -0,0 +1,84 @@
+#include <bits/stdc++.h>
+
+#define REP(i, n) for(int i = 0; i < int(n); ++i)
+#define REP2(i, ini, fim) for (int i = int(ini); i <= int(fim); ++i)
+
+using namespace std;
+
+const int maxn = 101010;
+
+namespace sarray
+{
+	string s;
+	int n, gap;
+	int sa[maxn], pos[maxn], tmp[maxn], lcp[maxn];
+
+	bool suf_comp(int i, int j)
+	{
+		if (pos[i] != pos[j]) return pos[i] < pos[j];
+
+		i += gap, j += gap;
+
+		return (i < n and j < n)? pos[i] < pos[j] : i > j;
+	}
+
+	void build()
+	{
+		n = s.size();
+
+		REP(i, n) sa[i] = i, pos[i] = s[i];
+
+		for (gap=1;; gap <<= 1) {
+
+			sort(sa, sa+n, suf_comp);
+
+			REP(i, n-1) tmp[i+1] = tmp[i] + suf_comp(sa[i], sa[i+1]);
+			REP(i, n) pos[sa[i]] = tmp[i];
+
+			if (tmp[n-1] == n-1) break;
+		}
+	}
+
+	void buildLCP()
+	{
+		for (int i = 0, k = 0; i < n; ++i) if (pos[i] != n - 1)
+		{
+			for (int j = sa[pos[i] + 1]; s[i + k] == s[j + k]; ++k);
+			lcp[pos[i]] = k;
+			if (k)--k;
+		}
+	}
+
+	int ds()
+	{
+		int result = n - sa[0];
+ 
+	    for (int i = 1; i < n; i++)
+	        result += (n - sa[i]) - lcp[i - 1];
+ 
+	    result++;
+	    return result;
+	}
+} // namespace sarray
+
+int main()
+{
+	ios_base::sync_with_stdio(false);
+	cin.tie(0);
+
+	// int t;
+	// cin >> t;
+	
+	// while (t--) {
+	
+		cin >> sarray::s;
+
+		sarray::build();
+		sarray::buildLCP();
+		REP(i, sarray::n) cout << sarray::lcp[i] << " ";
+		cout << "\n";
+		// sarray::buildLCP();
+
+		// cout << sarray::ds() << "\n";
+	// }
+}