【BZOJ 2646】【NEERC 2011】flight

http://www.lydsy.com/JudgeOnline/problem.php?id=2646
夏令营alpq654321讲课时说这道题很简单但并没有几个人提交，最近想复习一下线段树，脑袋一热就开始写这道题。。。
询问([i,j])内的抛物线在([l,r])上的最大值，最大值只会出现在抛物线的极值处和(l)，(r)处。
对于出现在极值处的最大值我用线段树套平衡树解决（看claris大佬用KDTree做的orzorzorz）
对于出现在(l)，(r)处的最大值，对抛物线的编号建立线段树，线段树每个节点表示这个编号区间内的抛物线的上轮廓线，然后二分一下就可以了。
初始化时不断地归并两个孩子的上轮廓线作为自己的上轮廓线。
求上轮廓线时先找出两个上轮廓线所有的断点，再在两个断点之间讨论两个上轮廓线的交点。
一开始我讨论交点直接用一元二次方程求根公式，但这样会出现非常大的精度问题！（有几个情况精度很严重，比如一个抛物线与另一个抛物线相切）
看了claris大佬的代码，先求第一个交点，讨论一下，再求第二个交点再讨论一下，这样可以避免上述情况orzorzorz
这道题我写挂了好几次，也重写了好几次，出现了好几个错误：

1. 建树套树时依次插入很费时，最好直接递归建树qwq我好蠢啊
2. 归并两个上轮廓线时出现的精度问题qwq
3. 求二次函数时出现的精度问题qwq
4. lower_bound慢？手写二分。。。动态开点慢？手写内存池。。。
5. 加了inline本地AC提交RE？？？还是不加inline吧。。。

时间复杂度(O(nlog^2n+mlog^2n))。
空间复杂度是(O(nlog n))的！
总的来说本题需要卡精度+卡常（只要树套树不依次插入貌似就不会T了？）

#include<cmath>
#include<cstdio>
#include<vector>
#include<cstring>
#include<algorithm>
using namespace std;

inline double max(const double &a, const double &b) {return a > b ? a : b;}

const int N = 50003;
const double eps = 1e-8;

int n, m;

struct nodeL {
	double a, b, c; int p, x, y, pr;
	inline double get_key(double X) {
		return a * X * X + b * X + c;
	}
} L[N];

namespace Splay {
	struct node *null;
	struct node {
		node *ch[2], *fa;
		int pos, num, ma;
		int pl() {return fa->ch[1] == this;}
		void setc(node *r, int c) {ch[c] = r; if (r != null) r->fa = this;}
		void count() {ma = max(num, max(ch[0]->ma, ch[1]->ma));}
	} *root[N << 2], *tt, pool[N * 30];
	int rtn, top = 0;
	
	node *newnode(node *f, int nu1, int nu2, int nu3) {
		node *t = pool + top; ++top;
		t->ch[0] = t->ch[1] = null;
		t->fa = f;
		t->pos = nu1; t->num = nu2; t->ma = nu3;
		return t;
	}
	
	void rotate(node *r) {
		node *f = r->fa;
		int c = r->pl();
		if (f == root[rtn]) r->fa = null, root[rtn] = r;
		else f->fa->setc(r, f->pl());
		f->setc(r->ch[c ^ 1], c);
		r->setc(f, c ^ 1);
		f->count();
	}
	void splay(node *r, node *tar = null) {
		for (; r->fa != tar; rotate(r))
			if (r->fa->fa != tar) rotate(r->pl() == r->fa->pl() ? r->fa : r);
		r->count();
	}
	
	int fornow;
	
	int le(node *r, double tmp) {
		if (r == null) return -0x7fffffff;
		if (r->pos >= tmp) return le(r->ch[0], tmp);
		else if (r->pos > (fornow = le(r->ch[1], tmp))) {tt = r; return r->pos;}
		else return fornow;
	}
	
	int ri(node *r, double tmp) {
		if (r == null) return 0x7fffffff;
		if (r->pos <= tmp) return ri(r->ch[1], tmp);
		else if (r->pos < (fornow = ri(r->ch[0], tmp))) {tt = r; return r->pos;}
		else return fornow;
	}
		
	int get_max(double l, double r) {
		node *tl, *tr;
		le(root[rtn], l); tl = tt;
		ri(root[rtn], r); tr = tt;
		splay(tl); splay(tr, root[rtn]);
		return root[rtn]->ch[1]->ch[0]->ma;
	}
		
	void initnull() {null = newnode(null, 0, 0, 0); null->fa = null->ch[0] = null->ch[1] = null;}
	
	int id[N], cnt;
	bool cmp(int x, int y) {return L[x].x == L[y].x ? L[x].y < L[y].y : L[x].x < L[y].x;}
	
	node *BuildTree(int l, int r, node *f) {
		if (l > r) return null;
		int mid = (l + r) >> 1;
		node *t = newnode(f, L[id[mid]].x, L[id[mid]].y, L[id[mid]].y);
		if (mid == 0) t->pos = -1, t->num = t->ma = 0;
		if (mid == cnt + 1) t->pos = N, t->num = t->ma = 0;
		t->ch[0] = BuildTree(l, mid - 1, t);
		t->ch[1] = BuildTree(mid + 1, r, t);
		t->count();
		return t;
	}
	
	void init(int rt_num, int l, int r) {
		cnt = 0;
		for (int i = l; i <= r; ++i) id[++cnt] = i;
		stable_sort(id + 1, id + cnt + 1, cmp);
		root[rt_num] = BuildTree(0, cnt + 1, null);
		if (l == r) return;
		int mid = (l + r) >> 1;
		init(rt_num << 1, l, mid);
		init(rt_num << 1 | 1, mid + 1, r);
	}
	
	int query(int rt_num, int l, int r, int L, int R, double keyl, double keyr) {
		if (L <= l && r <= R) {
			rtn = rt_num;
			return get_max(keyl, keyr);
		}
		int mid = (l + r) >> 1, ans = 0;
		if (L <= mid) ans = max(ans, query(rt_num << 1, l, mid, L, R, keyl, keyr));
		if (R > mid) ans = max(ans, query(rt_num << 1 | 1, mid + 1, r, L, R, keyl, keyr));
		return ans;
	}
}

namespace SegmentTree {
	struct node {
		int id; double l, r;
		node (int _id = 0, double _l = 0, double _r = 0) : id(_id), l(_l), r(_r) {}
		double get(double X) {return L[id].a * X * X + L[id].b * X + L[id].c;}
		bool operator < (const node &A) const {
			return r < A.r;
		}
	};
	vector <node> T[N << 2], c;
	vector <double> q;
	
	double pos, tl, tr;
	int id[N], cnt = 0, tot;
	
	double cal(int x, int y, double l, double r) {
		double a = L[x].a - L[y].a, b = L[x].b - L[y].b, c = L[x].c - L[y].c;
		double delta = b * b - 4 * a * c, po;
		if (1.0 * (L[x].x - L[x].p) * L[y].y == 1.0 * L[x].y * (L[y].x - L[y].p)) {
			if (fabs(b) < eps) return r;
			else if ((po = -c / b) > l + eps && po < r) return po;
			else return r;
		}
		if (delta < -eps) return r;
		delta = sqrt(delta);
		tl = (-b + delta) / 2 / a;
		tr = (-b - delta) / 2 / a;
		if (tl < l + eps || tl > r - eps) tl = -1;
		if (tr < l + eps || tr > r - eps) tr = -1;
		po = r;
		if (tl != -1) po = min(po, tl);
		if (tr != -1) po = min(po, tr);
		return po;
	}
	
	void merge(vector <node> &A, vector <node> &B, vector <node> &C) {
		q.clear(); c.clear();
		double l, r, mid;
		int lena = A.size(), lenb = B.size(), tmpa = 0, tmpb = 0, tot = 0;
		q.push_back(-N);
		while (tmpa < lena && tmpb < lenb) {
			if (A[tmpa].r < B[tmpb].r) {
				if (A[tmpa].r > q[tot] + eps) q.push_back(A[tmpa].r), ++tot;
				++tmpa;
			} else {
				if (B[tmpb].r > q[tot] + eps) q.push_back(B[tmpb].r), ++tot;
				++tmpb;
			}
		}
		
		while (tmpa < lena) {if (A[tmpa].r > q[tot] + eps) q.push_back(A[tmpa].r), ++tot; ++tmpa;}
		while (tmpb < lenb) {if (B[tmpb].r > q[tot] + eps) q.push_back(B[tmpb].r), ++tot; ++tmpb;}
		tmpa = tmpb = 0;
		for (int i = 0; i < tot; ++i) {
			l = q[i]; r = q[i + 1];
			while (tmpa < lena && A[tmpa].r + eps < r) ++tmpa;
			while (tmpb < lenb && B[tmpb].r + eps < r) ++tmpb;
			if (tmpa == lena || A[tmpa].l > l + eps) {c.push_back(node(B[tmpb].id, l, r)); continue;}
			if (tmpb == lenb || B[tmpb].l > l + eps) {c.push_back(node(A[tmpa].id, l, r)); continue;}
			if (A[tmpa].id == 0 || B[tmpb].id == 0) {c.push_back(node(A[tmpa].id + B[tmpb].id, l, r)); continue;}
			
			while (r - l > eps) {
				pos = cal(A[tmpa].id, B[tmpb].id, l, r);
				mid = (l + pos) / 2;
				if (A[tmpa].get(mid) > B[tmpb].get(mid))
					c.push_back(node(A[tmpa].id, l, pos));
				else
					c.push_back(node(B[tmpb].id, l, pos));
				l = pos;
			}
		}
		
		int tt = c.size();
		for (int i, j, k = 0; k < tt; k = j) {
			for (i = k, j = k + 1; j < tt && c[i].id == c[j].id; ++j);
			C.push_back(node(c[i].id, c[i].l, c[j - 1].r));
		}
	}
	
	void BuildTree(int rt, int l, int r) {
		if (l == r) {
			T[rt].push_back(node(0, -N, L[l].p));
			T[rt].push_back(node(l, L[l].p, L[l].pr));
			T[rt].push_back(node(0, L[l].pr, N));
			return;
		}
		int mid = (l + r) >> 1;
		BuildTree(rt << 1, l, mid);
		BuildTree(rt << 1 | 1, mid + 1, r);
		
		merge(T[rt << 1], T[rt << 1 | 1], T[rt]);
	}
	
	int left, right, mid;
	double query(int rt, int l, int r, int L, int R, double q1, double q2) {
		if (L <= l && r <= R) {
			double ans = 0;
			left = 0; right = T[rt].size();
			while (left < right) {
				mid = (left + right) >> 1;
				if (T[rt][mid].r + eps < q1) left = mid + 1;
				else right = mid;
			}
			if (left != T[rt].size() && T[rt][left].l <= q1)
				ans = max(ans, T[rt][left].get(q1));
			left = 0; right = T[rt].size();
			while (left < right) {
				mid = (left + right) >> 1;
				if (T[rt][mid].r + eps < q2) left = mid + 1;
				else right = mid;
			}
			if (left != T[rt].size() && T[rt][left].l <= q2)
				ans = max(ans, T[rt][left].get(q2));
			return ans;
		}
		
		double ans = 0;
		int mid = (l + r) >> 1;
		if (L <= mid) ans = max(ans, query(rt << 1, l, mid, L, R, q1, q2));
		if (R > mid) ans = max(ans, query(rt << 1 | 1, mid + 1, r, L, R, q1, q2));
		return ans;
	}
}

int main() {
	scanf("%d", &n);
	double p, x, y;
	Splay::initnull();
	for (int i = 1; i <= n; ++i) {
		scanf("%lf%lf%lf", &p, &x, &y);
		L[i].p = p; L[i].x = x; L[i].y = y; L[i].pr = 2 * x - p;
		L[i].a = -y / ((x - p) * (x - p));
		L[i].b = -2 * x * L[i].a;
		L[i].c = y + L[i].a * x * x;
	}
	Splay::init(1, 1, n);
	SegmentTree::BuildTree(1, 1, n);
	
	scanf("%d", &m);
	int idl, idr;
	double ans, l, r;
	for (int i = 1; i <= m; ++i) {
		scanf("%d%d%lf%lf", &idl, &idr, &l, &r);
		ans = Splay::query(1, 1, n, idl, idr, l, r);
		ans = max(ans, SegmentTree::query(1, 1, n, idl, idr, l, r));
		printf("%.5lf
", ans);
	}
	
	return 0;
}