校内训练题 20170916

t1 gcd 求[1, n]内满足gcd(i, j) == (i xor j)的无序对的对数

推得j−i=gcd(i,j)=ixorj，枚举gcd即可

（代码太傻逼，不贴了

t2 path 求最小路径长∈[S, E]

树分治，不会，水50分

（@OwenOwl撒点撒了80分，看来我还是要学习

t3 raid 求有多少个区间[l, r]满足mx - mn == r - l（每个元素互不相同）

考虑分治，对于当前分治区间[L,R]，记区间中点为mid。当前区间的答案就是Ans[L..mid]+Ans[mid+1..R]+跨过中点的合法区间数，然后就分为两种情况了：

1.最小值和最大值在同侧。

2.最小值和最大值在异侧。

下面只考虑最值同在左，和最小值在左，最大值在右的情况。其余两种是对称的。

对于最值同在左侧的情况，我们枚举左边界在哪，然后可以计算出右边界的位置，在判断是否合法，统计答案。时间复杂度：O(N).

对于最小值在左侧，最大值在右侧的情况，如果一个区间满足我们所要求的关系的话，就一定有：

j - i = mx[j] - mn[i]

 移项可得

j - mx[j] = i - mn[i]

 然后可以用单调栈+桶来完成这个任务。时间复杂度：O(N).

如果加一些黑科技可以大大减少代码量，但是复杂度会多一个log。

总的时间复杂度：O(NlogN)/O(NlogN^2)

#include<map>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

inline int read() {
	int x = 0, flag = 1; char ch = getchar();
	while (ch > '9' || ch < '0') { if (ch == '-') flag = -1; ch = getchar(); }
	while (ch <= '9' && ch >= '0') { x = x * 10 + ch - '0'; ch = getchar(); }
	return x * flag;
}

#define N 50001
#define rep(ii, aa, bb) for (int ii = aa; ii <= bb; ii++)
#define drp(ii, aa, bb) for (int ii = aa; ii >= bb; ii--)
#define ll long long

int a[N];
int mn[N], mx[N];

ll divide(int l, int r) {
	if (l == r) return 1;
	int mid = l + r >> 1;
	ll ans = 0;
	mn[mid] = mx[mid] = a[mid];
	mn[mid + 1] = mx[mid + 1] = a[mid + 1];
	drp(i, mid - 1, l)
		mn[i] = min(mn[i + 1], a[i]),
		mx[i] = max(mx[i + 1], a[i]);
	rep(i, mid + 2, r)
		mn[i] = min(mn[i - 1], a[i]),
		mx[i] = max(mx[i - 1], a[i]);

	//min in left, max in right
	rep(i, l, mid) {
		int len = mx[i] - mn[i] + 1;
		int pos = i + len - 1;
		ans += (pos <= r && pos > mid && mx[pos] < mx[i] && mn[pos] > mn[i]);
	}
	//another
	rep(i, mid + 1, r) {
		int len = mx[i] - mn[i] + 1;
		int pos = i - len + 1;
		ans += (pos >= l && pos <= mid && mx[pos] < mx[i] && mn[pos] > mn[i]);
	}

	//min in left, max in right
	//[i, j]
	//j - i = mx[j] - mn[i]
	//j - mx[j] = i - mn[i]
	{
		map<int, int> cc;
		int lb = mid + 1, rb = mid;
		drp(i, mid, l) {
			while (rb < r && mn[i] < mn[rb + 1]) {
				++rb;
				++cc[rb - mx[rb]];
			}
			while (mx[i] >= mx[lb]) {
				--cc[lb - mx[lb]];
				++lb;
				if (lb > r) goto nxt1;
			}
			if (lb <= rb) ans += cc[i - mn[i]];
		nxt1:;
		}
	}

	//min in right, max in left
	//[j, i]
	//i - j = mx[j] - mn[i]
	//j + mx[j] = i + mn[i]
	{
		map<int, int> cc;
		int lb = mid + 1, rb = mid;
		rep(i, mid + 1, r) {
			while (lb - 1 >= l && mn[lb - 1] > mn[i]) {
				--lb;
				++cc[lb + mx[lb]];
			}
			while (mx[rb] <= mx[i]) {
				--cc[rb + mx[rb]];
				--rb;
				if (rb < l) goto nxt2;
			}
			if (lb <= rb) ans += cc[i + mn[i]];
		nxt2:;
		}
	}
	return ans + divide(l, mid) + divide(mid + 1, r);
}

int main() {
	int n = read();
	rep(i, 1, n) {
		int x = read(), y = read();
		a[x] = y;
	}
	printf("%lld", divide(1, n));
	return 0;
}