树状数组

Circle

Description

You are given n points and two circles. The radius of the circle will be dynamical. Your task is to find how many points are under both circles at each time.

A point is under a circle iff the point is strictly inside the circle or on the border of the circle.

Input Description

The first line of the input contains an integer T(1<=T<=20) which means the number of test cases.
For each case, the first line contains two integers n, m.(1 <= n, m <= 100000) Means the number of points and the number of queries.
Next n lines each contains two integer x, y(0 <= x, y <= 80000), describe a point.
Next line contains four integers x1, y1, x2, y2 (0 <= x1, y1, x2, y2 <= 80000), describe the center of two circles.
Next m lines each line contains two integers R1, R2, describe the radius of two circles.(1 <= R1, R2 <= 100000)

Output Description

For each query, output the number of points under both circles.

Sample Input

1
4 4
0 0
0 1
1 0
1 1
0 0 2 2
1 1
1 10
10 1
10 10

Sample Output

0
3
0
4
碰见很多这样的题目了，哎，以为是几何题，题解出来了才发现是树状数组，多做做，多总结

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
#include<string>
#include<queue>
#include<cmath>
#include<vector>

using namespace std;

#define mnx 104000
#define ll long long
#define inf 0x3f3f3f3f
#define lson l, m, rt << 1
#define rson m+1, r, rt << 1 | 1

const int N = mnx;
struct point{
    int x, y;
    point( int x = 0, int y = 0 ) : x(x), y(y) {}
    point operator - ( const point &b ) const {
        return point( x - b.x, y - b.y );
    }
    int length(){
        ll len = (ll)x * x + (ll)y * y;
        ll pt = sqrt( len );
        if( pt * pt < len ) pt++;
        return (int)pt;
    }
    bool operator < ( const point & b ) const{
        return x < b.x; 
    }
}p[mnx], A, B;
struct rad{
    int r1, r2, id;
    bool operator < ( const rad & b ) const{
        return r1 < b.r1;
    }
}query[mnx];
int bit[mnx];
int sum( int x ){
    int ret = 0;
    while( x > 0 ){
        ret += bit[x]; x -= x & -x;
    }
    return ret;
}
void add( int i, int x ){
    while( i <= N ){
        bit[i] += x;
        i += i & -i;
    }
}
int ans[mnx];
int main(){
    int cas;
    scanf( "%d", &cas );
    while( cas-- ){
        memset( bit, 0, sizeof(bit) );
        int n, m;
        scanf( "%d %d", &n, &m );
        for( int i = 0; i < n; i++ ){
            scanf( "%d %d", &p[i].x, &p[i].y );
        }
        scanf( "%d %d %d %d", &A.x, &A.y, &B.x, &B.y );
        for( int i = 0; i < n; i++ ){
            int dis1 = ( p[i] - A ).length();
            int dis2 = ( p[i] - B ).length();
            p[i] = point( dis1, dis2 );
        }
        sort( p, p + n );
        for( int i = 0; i < m; i++ ){
            scanf( "%d %d", &query[i].r1, &query[i].r2 );
            query[i].id = i;
        }
        sort( query, query + m );
        int j = 0;
        for( int i = 0; i < m; i++ ){
            while( j < n && p[j].x <= query[i].r1 ){
                add( p[j].y, 1 );
                j++;
            }
            ans[query[i].id] = sum( query[i].r2 );
        }
        for( int i = 0; i < m; i++ ){
            printf( "%d
", ans[i] );
        }
    }
    return 0;
}

http://acm.hdu.edu.cn/showproblem.php?pid=4417  hdu 4417 Super Mario

题意：给定一段区间每个点有个高度。在m次询问中每次给出左右端点和可以到达的高度，统计有多少个是小于到达高度

做法：离线排序+树状数组。。把输入的每个点的按高度排序，再把询问保存起来，按照高度排序，然后一边插入树状数组一边统计。。

其实还可以在线做，用主席树做