清华学堂 LightHouse

灯塔(LightHouse)

---

Description

As shown in the following figure, If another lighthouse is in gray area, they can beacon each other.

For example, in following figure, (B, R) is a pair of lighthouse which can beacon each other, while (B, G), (R, G) are NOT.

Input

1st line: N

2nd ~ (N + 1)th line: each line is X Y, means a lighthouse is on the point (X, Y).

Output

How many pairs of lighthourses can beacon each other

( For every lighthouses, X coordinates won't be the same , Y coordinates won't be the same )

Example

Input

3
2 2
4 3
5 1

Output

1

Restrictions

For 90% test cases: 1 <= n <= 3 * 10⁵

For 95% test cases: 1 <= n <= 10⁶

For all test cases: 1 <= n <= 4 * 10⁶

For every lighthouses, X coordinates won't be the same , Y coordinates won't be the same.

1 <= x, y <= 10^8

Time: 2 sec

Memory: 256 MB

Hints

The range of int is usually [-2³¹, 2³¹ - 1], it may be too small.

视频里有讲解我尽然没看到，醉了。

就是求一下逆序对就行。

 #include <cstdlib>
 #include <iostream>
 #include <cstdio>
 #include <cstring>
 using namespace std;
 #define LL long long
 const int max_size =  * 1e6;
 LL y_val[max_size];
 LL tmp_arry[max_size];
 ///加速代码，why 百度
 const int SZ = <<;
 struct fastio{
     char inbuf[SZ];
     char outbuf[SZ];
     fastio(){
         setvbuf(stdin,inbuf,_IOFBF,SZ);
         setvbuf(stdout,outbuf,_IOFBF,SZ);
     }
 }io;
 struct Point
 {
     LL x, y;
 } p[max_size];

 int cmp(const void *a, const void *b)
 {
     struct Point *c = (Point *)a;
     struct Point *d = (Point *)b;
     if(c->x != d->x)
         return c->x - d->x;
     else
         return d->y - c->y;
 }

 LL Merge(LL *arr, LL beg, LL mid, LL end, LL *tmp_arr)
 {
     memcpy(tmp_arr+beg, arr+beg, sizeof(LL)*(end - beg + ));
     LL i = beg;
     LL j = mid+;
     LL k = beg;
     LL inversion = ;
     while(i <= mid && j <= end)
     {
         if(tmp_arr[i] <= tmp_arr[j])
             arr[k++] = tmp_arr[i++];
         else
         {
             arr[k++] = tmp_arr[j++];
             inversion += mid - i + ;
         }
     }

     while(i <= mid)
         arr[k++] = tmp_arr[i++];
     while(j <= end)
         arr[k++] = tmp_arr[j++];
     return inversion;
 }

 LL MergeInversion(LL *arr, LL beg, LL end, LL *tmp_arr)
 {
     LL inversions = ;
     if(beg < end)
     {
         LL mid = (beg + end) >> ;
         inversions += MergeInversion(arr, beg, mid, tmp_arr);
         inversions += MergeInversion(arr, mid+, end, tmp_arr);
         inversions += Merge(arr, beg, mid, end, tmp_arr);
     }
     return inversions;
 }

 int main()
 {
     LL n;
     cin >> n;
     for(int i = ; i < n; i++)
     {
         cin >> p[i].x >> p[i].y;
     }

     qsort(p, n, sizeof(p[]), cmp);
     for(int i = ; i < n; i++)
     {
         y_val[i] = p[i].y;
     }

     memcpy(tmp_arry, y_val, sizeof(LL)*n);
     cout << n*(n-) / - MergeInversion(y_val, , n-, tmp_arry) << endl;
     return ;
 }

然后再对代码进行优化吧，我的这段过不了最后一个点。因为多做了排序操作，没必要。