[HDU - 3015] Disharmony Trees (树状数组+离散化)

链接

http://acm.hdu.edu.cn/showproblem.php?pid=3015

题意

给你$n$棵树，每棵树有两个属性$x$坐标，及$h$高度，现在定义$F=|x_i-x_j|$，其中$x_i$及$x_j$均是$x$的排名，如5、8、7、7，排名为1、4、2、2，定义$S=\min (h_i,h_j)$，其中$h_i$及$h_j$也是排名；现在需要你求出$\sum _{i,j}F\ast S$，即所有任意两棵树的$F\ast S$的和；

分析

  这里考虑使用树状数组，首先，$S$是一个求最小值的操作，我们考虑将所有树按$h$值从大到小排序，这样，当我们遍历到第$i$棵树时，那么$h_i$就是当前的$S$，即第$i$棵树与$i$之前的任意一棵树的$S$;
  
  之后$S$相同，我们考虑把$i$与$i$之前的$i-1$棵树的$F$的和求出来，关键就是怎么求$F$了，对于第$i$棵树来说，它与之前所有树的$F=|x_i-x_1|+|x_i-x_2|+\cdot \cdot \cdot +|x_i-x_{i-1}|$;
  
  在第$i$棵树之前的树有两类，一类的排名$x>x_i$，一类$x\le x_i$；之后我们使用两个树状数组，分别保存个数与和，即一个树状数组用来求$[1,i-1]$中，$x$小于$x_i$的个数(至于大于$x_i$的个数，用$i$直接减即可)，另一个树状数组用来求$x$小于$x_i$的$x$的和(至于大于$x_i$的$x$的和，直接拿当前总和减即可)，我们就可以把两类给分开来了，分别求和即可，最后还要乘以一个当前树的$h_i$，最后$i$枚举到第$n$棵树累加结果就可以了；
  
  存结果的变量注意开$longlong$，不然会爆；

代码

#include <functional>
#include <algorithm>
#include <iostream>
#include <cstring>
#include <string>
#include <cstdio>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <set>
#include <map>

#define INF 0x7f7f7f7f
#define MAXN 100005
#define N 200005
#define P 2
#define MOD 99991

typedef long long ll;

namespace fastIO {
	//#define getchar() (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1<<22, stdin), p1 == p2) ? EOF : *p1++)
	//char buf[(1 << 22)], *p1 = buf, *p2 = buf;
	inline int read() {
		char c = getchar(); int x = 0, f = 1;
		while (c < '0' || c > '9') { if (c == '-') f = -1; c = getchar(); }
		while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
		return x * f;
	}
}

using namespace fastIO;
using namespace std;

/*namespace segment_Tree {
	struct Tree {
		int l, r, max;
	} tree[4 * MAXN];

	inline void push_up(int x) {
		tree[x].max = max(tree[x << 1].max, tree[x << 1 | 1].max);
	}

	inline void build(int x, int l, int r) {
		tree[x].l = l, tree[x].r = r;
		if (l == r) {
			tree[x].max = 0;
			return;
		}
		int mid = (l + r) >> 1;
		build(x << 1, l, mid);
		build(x << 1 | 1, mid + 1, r);
		push_up(x);
	}

	inline void update(int x, int pos, int val) {
		int l = tree[x].l, r = tree[x].r;
		if (l == r) {
			tree[x].max = max(tree[x].max, val);
			return;
		}
		int mid = (l + r) >> 1;
		if (pos <= mid)update(x << 1, pos, val);
		else update(x << 1 | 1, pos, val);
		push_up(x);
	}

	inline int query(int x, int l, int r) {
		int le = tree[x].l, ri = tree[x].r;
		if (l <= le && ri <= r) {
			return tree[x].max;
		}
		int mid = (le + ri) >> 1;
		int maxm = 0;
		if (l <= mid) maxm = max(maxm, query(x << 1, l, r));
		if (r > mid) maxm = max(maxm, query(x << 1 | 1, l, r));
		return maxm;
	}
}*/
struct tree {
	int h, x;
	bool operator<(const tree &a)const {
		return h > a.h;
	}
}t[MAXN];

int n, a[MAXN], b[MAXN], c1[MAXN], c2[MAXN];

void insert(int x, int val, int c[]) {
	for (int i = x; i <= n; i += i & -i)
		c[i] += val;
}

int sum(int x, int c[]) {
	int res = 0;
	for (int i = x; i > 0; i -= i & -i)
		res += c[i];
	return res;
}


int main() {
	while (scanf("%d", &n)!=EOF) {
		memset(c1, 0, sizeof(c1));
		memset(c2, 0, sizeof(c2));
		for (int i = 1; i <= n; i++)
			a[i] = t[i].x = read(), b[i] = t[i].h = read();
		sort(a + 1, a + 1 + n);
		sort(b + 1, b + 1 + n);
		sort(t + 1, t + 1 + n);
		//这里不需要unique去重
		ll res = 0;
		for (int i = 1; i <= n; i++) {
			int pos1 = lower_bound(a + 1, a + 1 + n, t[i].x) - a;
			int rk = lower_bound(b + 1, b + 1 + n, t[i].h) - b;
			//cout << rk << endl;
			int sum1 = sum(pos1, c1);
			int sum2 = sum(pos1, c2);
			res += 1ll * rk * (1ll * sum1 * pos1 - sum2 + (sum(n, c2) - sum2) - 1ll * (i - sum1 - 1) * pos1);
			insert(pos1, 1, c1);
			insert(pos1, pos1, c2);
			//cout << sum1 <<" " << sum2 <<" " <<res << endl;
		}
		cout << res << endl;
	}
}