lgP1637 三元上升子序列

给定n个整数的序列A，求存在多少个三元上升子序列，即满足i<j<k并且a[i]<a[j]<a[k]。

分析：用平衡树维护两侧元素，然后枚举中间元素即可。

#include <bits/stdc++.h>
using llong = long long;

template <typename TYPE>
struct Treap {
	struct Node {
		TYPE data, sum;
		int rnd, siz, dup, son[2];
		void init(const TYPE & d) {
			data = sum = d;
			rnd = rand();
			siz = dup = 1;
			son[0] = son[1] = 0;
		}
	};
	Treap(size_t sz, bool multi, bool needSum=false):multiple(multi),needsum(needSum) {
		node.resize(sz + 1);
		reset();
	}
	int newnode(const TYPE & d) {
		total += 1;
		node[total].init(d);
		return total;
	}
	void reset() { root = total = 0; }
	void maintain(int x) {
		node[x].siz = node[x].dup;
		if (needsum) node[x].sum = node[x].data * node[x].dup;
		if (node[x].son[0]) {
			node[x].siz += node[node[x].son[0]].siz;
			if (needsum) node[x].sum += node[node[x].son[0]].sum;
		}
		if (node[x].son[1]) {
			node[x].siz += node[node[x].son[1]].siz;
			if (needsum) node[x].sum += node[node[x].son[1]].sum;
		}
	}
	void rotate(int d, int &r) {
		int k = node[r].son[d^1];
		node[r].son[d^1] = node[k].son[d];
		node[k].son[d] = r;
		maintain(r);
		maintain(k);
		r = k;
	}
	void insert(const TYPE &data, int &r, bool &ans) {
		if (r) {
			if (!(data < node[r].data) && !(node[r].data < data)) {
				ans = false;
				if (multiple) {
					node[r].dup += 1;
					maintain(r);
				}
			} else {
				int d = data < node[r].data ? 0 : 1;
				insert(data, node[r].son[d], ans);
				if (node[node[r].son[d]].rnd > node[r].rnd) {
					rotate(d^1, r);
				} else {
					maintain(r);
				}
			}
		} else {
			r = newnode(data);
		}
	}
	void getkth(int k, int r, TYPE& data) {
		int x = node[r].son[0] ? node[node[r].son[0]].siz : 0;
		int y = node[r].dup;
		if (k <= x) {
			getkth(k, node[r].son[0], data);
		} else if (k <= x + y) {
			data = node[r].data;
		} else {
			getkth(k-x-y, node[r].son[1], data);
		}
	}
	TYPE getksum(int k, int r) {
		if (k <= 0 || r == 0) return 0;
		int x = node[r].son[0] ? node[node[r].son[0]].siz : 0;
		int y = node[r].dup;
		if (k <= x) return getksum(k, node[r].son[0]);
		if (k <= x+y) return node[node[r].son[0]].sum + node[r].data * (k-x);
		return node[node[r].son[0]].sum + node[r].data * y + getksum(k-x-y,node[r].son[1]);
	}
	void erase(const TYPE& data, int & r) {
		if (r == 0) return;
		int d = -1;
		if (data < node[r].data) {
			d = 0;
		} else if (node[r].data < data) {
			d = 1;
		}
		if (d == -1) {
			node[r].dup -= 1;
			if (node[r].dup > 0) {
				maintain(r);
			} else {
				if (node[r].son[0] == 0) {
					r = node[r].son[1];
				} else if (node[r].son[1] == 0) {
					r = node[r].son[0];
				} else {
					int dd = node[node[r].son[0]].rnd > node[node[r].son[1]].rnd ? 1 : 0;
					rotate(dd, r);
					erase(data, node[r].son[dd]);
				}
			}
		} else {
			erase(data, node[r].son[d]);
		}
		if (r) maintain(r);
	}
	int ltcnt(const TYPE& data, int r) {
		if (r == 0) return 0;
		int x = node[r].son[0] ? node[node[r].son[0]].siz : 0;
		if (data < node[r].data) {
			return ltcnt(data, node[r].son[0]);
		}
		if (!(data < node[r].data) && !(node[r].data < data)) {
			return x;
		}
		return x + node[r].dup + ltcnt(data, node[r].son[1]);
	}
	int gtcnt(const TYPE& data, int r) {
		if (r == 0) return 0;
		int x = node[r].son[1] ? node[node[r].son[1]].siz : 0;
		if (data > node[r].data) {
			return gtcnt(data, node[r].son[1]);
		}
		if (!(data < node[r].data) && !(node[r].data < data)) {
			return x;
		}
		return x + node[r].dup + gtcnt(data, node[r].son[0]);
	}
	int count(const TYPE& data, int r) {
		if (r == 0) return 0;
		if (data < node[r].data) return count(data, node[r].son[0]);
		if (node[r].data < data) return count(data, node[r].son[1]);
		return node[r].dup;
	}
	void prev(const TYPE& data, int r, TYPE& result, bool& ret) {
		if (r) {
			if (node[r].data < data) {
				if (ret) {
					result = std::max(result, node[r].data);
				} else {
					result = node[r].data;
					ret = true;
				}
				prev(data, node[r].son[1], result, ret);
			} else {
				prev(data, node[r].son[0], result, ret);
			}
		}
	}
	void next(const TYPE& data, int r, TYPE& result, bool& ret) {
		if (r) {
			if (data < node[r].data) {
				if (ret) {
					result = std::min(result, node[r].data);
				} else {
					result = node[r].data;
					ret = true;
				}
				next(data, node[r].son[0], result, ret);
			} else {
				next(data, node[r].son[1], result, ret);
			}
		}
	}
	std::vector<Node> node;
	int root;
	int total;
	bool multiple;
	bool needsum;
	bool insert(const TYPE& data) {
		bool ret = true;
		insert(data, root, ret);
		return ret;
	}
	bool kth(int k, TYPE &data) {
		if (!root || k <= 0 || k >= node[root].siz)
			return false;
		getkth(k, root, data);
		return true;
	}
	TYPE ksum(int k) {
		assert(root && k>0 && k<node[root].siz);
		return getksum(k, root);
	}
	int count(const TYPE &data) {
		return count(data, root);
	}
	int size() const {
		return root ? node[root].siz : 0;
	}
	void erase(const TYPE& data) {
		return erase(data, root);
	}
	int ltcnt(const TYPE& data) {
		return ltcnt(data, root);
	}
	int gtcnt(const TYPE& data) {
		return gtcnt(data, root);
	}
	int lecnt(const TYPE& data) {
		return size() - gtcnt(data, root);
	}
	int gecnt(const TYPE& data) {
		return size() - ltcnt(data, root);
	}
	bool prev(const TYPE& data, TYPE& result) {
		bool ret = false;
		prev(data, root, result, ret);
		return ret;
	}
	bool next(const TYPE& data, TYPE& result) {
		bool ret = false;
		next(data, root, result, ret);
		return ret;
	}
};

void solve() {
	int n;
	std::cin >> n;
	std::vector<int> A(n);
	for (int i = 0; i < n; i++) {
		std::cin >> A[i];
	}
	Treap<int> tr1(n,1,0), tr2(n,1,0);
	for (int i = 0; i < n; i++) {
		tr2.insert(A[i]);
	}
	llong ans = 0;
	for (int i = 0; i < n; i++) {
		tr2.erase(A[i]);
		ans += 1LL * tr1.ltcnt(A[i]) * tr2.gtcnt(A[i]);
		tr1.insert(A[i]);
	}
	std::cout << ans << "\n";
}

int main() {
	std::cin.tie(0)->sync_with_stdio(0);
	int t = 1;
	while (t--) solve();
	return 0;
}