Grandpa Giuseppe won a professional pizza cutter, the kind of type reel and, to celebrate, baked a rectangle pizza to his grandchildren! He always sliced his pizzas into pieces by making cuts over continuous lines, not necessarily rectilinear, of two types: some begin at the left edge of the pizza, follow continuously to the right and end up in the right edge; other start on lower edge, follow continuously up and end up on the top edge. But Grandpa Giuseppe always followed a property: two cuts of the same type would never intersect. Here is an example with 4 cuts, two of each type, in the left part of the figure, which divide the pizza in 9 pieces.

It turns out that Grandpa Giuseppe simply loves geometry, topology, combinatorics and stuff; so, he decided to show to his grandchildren who could get more pieces with the same number of cuts if cross cuts of the same type were allowed. The right part of the figure shows, for example, that if the two cuts of the type that go from left to right could intercept, the pizza would be divided into 10 pieces.

Grandpa Giuseppe ruled out the property, but will not make random cuts. In addition to being one of the two types, they will comply with the following restrictions:

• Two cuts have at most one intersection point and, if they have, it is because the cuts cross each other at that point;
• Three cuts do not intersect in a single point;
• Two cuts do not intersect at the border of the pizza;
• A cut does not intercept a pizza corner.

Given the start and end points of each cut, your program should compute the number of resulting pieces from the cuts of Grandfather Giuseppe.

The first line of the input contains two integers X

.

3 4
3 2
1 2
2 1
3 3
1 1
2 2

13

5 5
3 3
2 1
3 2
1 3
3 4
4 3
2 2

19

10000 10000
1 2
321 3455
10 2347
543 8765

6

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstdlib>
#include<cstring>
#include<string>
#include<cmath>
#include<map>
#include<set>
#include<vector>
#include<queue>
#include<bitset>
#include<ctime>
#include<deque>
#include<stack>
#include<functional>
#include<sstream>
//#include<cctype>
//#pragma GCC optimize(2)
using namespace std;
#define maxn 1000005
#define inf 0x7fffffff
//#define INF 1e18
#define rdint(x) scanf("%d",&x)
#define rdllt(x) scanf("%lld",&x)
#define rdult(x) scanf("%lu",&x)
#define rdlf(x) scanf("%lf",&x)
#define rdstr(x) scanf("%s",x)
typedef long long  ll;
typedef unsigned long long ull;
typedef unsigned int U;
#define ms(x) memset((x),0,sizeof(x))
const long long int mod = 1e9;
#define Mod 1000000000
#define sq(x) (x)*(x)
#define eps 1e-5
typedef pair<int, int> pii;
#define pi acos(-1.0)
//const int N = 1005;
#define REP(i,n) for(int i=0;i<(n);i++)
typedef pair<int, int> pii;

inline int rd() {
	int x = 0;
	char c = getchar();
	bool f = false;
	while (!isdigit(c)) {
		if (c == ‘-‘) f = true;
		c = getchar();
	}
	while (isdigit(c)) {
		x = (x << 1) + (x << 3) + (c ^ 48);
		c = getchar();
	}
	return f ? -x : x;
}


ll gcd(ll a, ll b) {
	return b == 0 ? a : gcd(b, a%b);
}
int sqr(int x) { return x * x; }



/*ll ans;
ll exgcd(ll a, ll b, ll &x, ll &y) {
	if (!b) {
		x = 1; y = 0; return a;
	}
	ans = exgcd(b, a%b, x, y);
	ll t = x; x = y; y = t - a / b * y;
	return ans;
}
*/

int X, Y;
int H, V;
int c[maxn];
int Tot;
void add(int x) {
	while (x <= maxn) {
		c[x]++; x += x & -x;
	}
}

int query(int x) {
	int ans = 0;
	while (x > 0) {
		ans += c[x]; x -= x & -x;
	}
	return ans;
}
ll ans;
struct node {
	int l, r;
}a[maxn];
bool cmp(node a, node b) {
	return a.l < b.l;
}
int tmpb[maxn];
int tmpc[maxn];
int main()
{
//	ios::sync_with_stdio(0);
	X = rd(); Y = rd();
	H = rd(); V = rd();
	ans = 1ll * (H + 1ll)*(V + 1ll);
	vector<int>vc; int ct = 0;
	for (int i = 1; i <= H; i++) {
		a[i].l = rd(); a[i].r = rd();
		tmpb[++ct] = a[i].r;
	}
	sort(tmpb + 1, tmpb + 1 + ct);
	sort(a + 1, a + 1 + H, cmp);
	for (int i = 1; i <= H; i++) {
		tmpc[i] = lower_bound(tmpb + 1, tmpb + 1 + ct, a[i].r) - tmpb;
	}
	for (int i = 1; i <= H; i++) {
		add(tmpc[i]);
		ans += (ll)(i - query(lower_bound(tmpb + 1, tmpb + 1 + ct, a[i].r + 1) - tmpb - 1));
	}
	ms(c); ms(tmpb); ms(tmpc);
	ct = 0;
	for (int i = 1; i <= V; i++) {
		a[i].l = rd(); a[i].r = rd();
		tmpb[++ct] = a[i].r;
	}
	sort(tmpb + 1, tmpb + 1 + ct);
	sort(a + 1, a + 1 + V, cmp);
	for (int i = 1; i <= V; i++) {
		tmpc[i] = lower_bound(tmpb + 1, tmpb + 1 + ct, a[i].r) - tmpb;
	}
	for (int i = 1; i <= V; i++) {
		add(tmpc[i]);
		ans += (ll)(i - query(lower_bound(tmpb + 1, tmpb + 1 + ct, a[i].r + 1) - tmpb - 1));
	}
	cout << (ll)ans << endl;
	return 0;
}

Gym - 101908C 樹狀數組 逆序對