ightOJ 1103 - Castle Walls

 

1103 - Castle Walls
 	 PDF (English)	 Statistics	 Forum
Time Limit: 2 second(s)	 Memory Limit: 64 MB
In medieval times, knights commanded big armies of peasants. When they had to storm a castle they would line up neatly in front of the castle's wall and throw their grappling hooks over the walls. If one does not throw straight it can easily happen that two hooks cross, making it impossible for the two peasants to climb the wall. That's why every knight made his peasants practice a lot so that this would not happen in combat.

Due to the recent Sir Arthur-Madam Claire Marriage (ACM), two peasant armies have to be merged. Traditionally Sir Arthur's peasants wear blue and Madame Claire's peasants wear red. When practicing together, both armies mix up in front of a castle's wall. On Sir Arthur's command, they all throw their grappling hooks. Due to their perfect training the hooks will never cross within an army, however it can happen that a hook thrown by a blue peasant crosses one thrown by a peasant of the red army.

For statistical purposes, Sir Arthur now needs to find out how many grappling hooks have crossed so that he can measure how well their armies have already been merged. Given the positions of blue and red peasants as well as the positions they threw their grappling hooks at, determine how many distinct pairs of blue and red peasants crossed their hooks.

If there are n blue and m red peasants, the positions in the line where the peasants are standing are numbered from 1 to n + m. The positions on the castle's wall are numbered from 1 to n + m as well, where position i is directly opposite of position i on the line the peasants are standing on. A grappling hook thrown from position i to j is said to cross another hook thrown from p to q if and only if

(i < p and j ≥ q) or (i > p and j ≤ q)

Grappling hooks of the same color will never cross each other, nor will two peasants occupy the same position on the line. However, two hooks (of different color) can be thrown to the same position in which case they are said to cross each other as well.

Input
Input starts with an integer T (≤ 8), denoting the number of test cases.

Each case starts with a line containing two integers n and m, the number of blue and red peasants, respectively (1 ≤ n, m ≤ 105). The next n lines describe the blue peasants followed by m more lines for the red peasants. Each line consists of two integer i and j separated by a space, indicating the peasant's position i and the position j he threw his grappling hook to (1 ≤ i, j ≤ n + m).

Output
For each test case, print the case number and the number of distinct pairs of peasants whose grappling hooks are crossed.

Sample Input
Output for Sample Input
2
2 2
1 2
3 4
2 1
4 3
2 3
1 3
2 5
5 3
3 1
4 2
Case 1: 2
Case 2: 6
 

题意：说白了，就是，给你n+m对数(a,b)；问，相交的有多少对。

A grappling hook thrown from position i to j is said to cross another hook thrown from p to q if and only if (i < p and j ≥ q) or (i > p and j ≤ q) 

然后嘛，线段树还是树状数组就随便上了，我是用树状数组。（注意用long long ，我WA了一次）。

树状数组是一种能在logn复杂度完成单点修改，区间查询或者区间修改，单点查询的神器，由于代码简单，可拓展性高，用过的都说好！

关于树状数组的具体实现原理，这里就不多说了，请读者自行百度之。我记得POJ和HDU上有喝多这样的入门题。

 

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

#define N 200010

long long BIT[N];
int maxn;
struct node{
    int x,y;
}p[N];

bool cmp(const node &a,const node &b){
    if(a.x!=b.x) return a.x>b.x;
    return a.y>b.y;
}

int lowbit(int x){
    return x&(-x);
}

void update(int key){
    for(int i=key;i<=maxn;i+=lowbit(i)) BIT[i]++;
}

int query(int key){
    int res=0;
    for(int i=key;i>0;i-=lowbit(i)) res+=BIT[i];
    return res;
}

int main(){
    int t,cas=1;
    cin>>t;
    while(t--){
        int n,m;
        cin>>n>>m;
        for(int i=0;i<n+m;i++) scanf("%d%d",&p[i].x,&p[i].y);
        sort(p,p+m+n,cmp);
        memset(BIT,0,sizeof(BIT));
        maxn=n+m;
        long long res=0;
        for(int i=0;i<n+m;i++){
            res+=query(p[i].y);
            update(p[i].y);
        }
        printf("Case %d: %lld\n",cas++,res);
    }
    return 0;
}