线段树||树状数组poj2464

Language: Default Brownie Points II Time Limit: 5000MS   Memory Limit: 65536K Total Submissions: 1939   Accepted: 682 Description Stan and Ollie play the game of Odd Brownie Points. Some brownie points are located in the plane, at integer coordinates. Stan plays first and places a vertical line in the plane. The line must go through a brownie point and may cross many (with the same x-coordinate). Then Ollie places a horizontal line that must cross a brownie point already crossed by the vertical line.   Those lines divide the plane into four quadrants. The quadrant containing points with arbitrarily large positive coordinates is the top-right quadrant.   The players score according to the number of brownie points in the quadrants. If a brownie point is crossed by a line, it doesn't count. Stan gets a point for each (uncrossed) brownie point in the top-right and bottom-left quadrants. Ollie gets a point for each (uncrossed) brownie point in the top-left and bottom-right quadrants.   Stan and Ollie each try to maximize his own score. When Stan plays, he considers the responses, and chooses a line which maximizes his smallest-possible score. Input Input contains a number of test cases. The data of each test case appear on a sequence of input lines. The first line of each test case contains a positive odd integer 1 < n < 200000 which is the number of brownie points. Each of the following n lines contains two integers, the horizontal (x) and vertical (y) coordinates of a brownie point. No two brownie points occupy the same place. The input ends with a line containing 0 (instead of the n of a test). Output For each input test, print a line of output in the format shown below. The first number is the largest score which Stan can assure for himself. The remaining numbers are the possible (high) scores of Ollie, in increasing order. Sample Input 11 3 2 3 3 3 4 3 6 2 -2 1 -3 0 0 -3 -3 -3 -2 -3 -4 3 -7 0 Sample Output Stan: 7; Ollie: 2 3;

题意：在平面直角坐标系中给你N个点，stan和ollie玩一个游戏，首先stan在竖直方向上画一条直线，该直线必须要过其中的某个点，然后ollie在水平方向上画一条直线，该直线的要求是要经过一个stan之前画过的点。 这时候平面就被分割成了四块，两个人这时候会有一个得分，stan的得分是平面上第1、3象限内的点的个数，ollie的得分是平面上第2、4象限内的点的个数，在统计的时候在所画线上的点都不计算在内。求最终stan使得自己的最差得分最高，并且输出此时ollie的得分。

思路：需要两个树状数组，分别维护左右两边。对y坐标进行离散化，然后按x进行排序，预先把所有的点加到右边的树状数组中，然后扫一遍，不断更新左右的树状数组和答案

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
const int maxn=200010;
int N;
int l[maxn],r[maxn];
int Y[maxn];
struct P
{
    int x,y;
    bool operator<(const P & a)const
    {
        return x<a.x;
    }
}p[maxn];
int lowbit(int x)
{
    return x&(-x);
}
void update(int *s,int x,int val)
{
    while(x<=N)
    {
        s[x]+=val;
        x+=lowbit(x);
    }
}
int sum(int *s,int x)
{
    int ans=0;
    while(x>0)
    {
        ans+=s[x];
        x-=lowbit(x);
    }
    return ans;
}
int main()
{
    while(scanf("%d",&N)!=EOF,N)
    {
        for(int i=1;i<=N;i++)
        {
            scanf("%d%d",&p[i].x,&p[i].y);
            Y[i]=p[i].y;
        }
        sort(p+1,p+1+N);
        sort(Y+1,Y+1+N);
        int cnt=unique(Y+1,Y+N+1)-Y-1;
        memset(l,0,sizeof(l));
        memset(r,0,sizeof(r));
        for(int i=1;i<=N;i++)
            update(r,lower_bound(Y+1,Y+cnt+1,p[i].y)-Y,1);
        int st=1,Stan=-1;
        vector<int> Ollie;
        for(int i=2;i<=N+1;i++)
        {
            if(i==N+1||p[i-1].x!=p[i].x)
            {
                for(int j=st;j<i;j++)
                    update(r,lower_bound(Y+1,Y+cnt+1,p[j].y)-Y,-1);
                int stan=-1,ollie=-1;
                for(int j=st;j<i;j++)
                {
                    int pos=lower_bound(Y+1,Y+cnt+1,p[j].y)-Y;
                    int a=sum(r,cnt)-sum(r,pos)+sum(l,pos-1);
                    int b=sum(l,cnt)-sum(l,pos)+sum(r,pos-1);
                    if(b==ollie)stan=min(stan,a);
                    else if(b>ollie)stan=a,ollie=b;
                }
                if(stan>Stan)
                {
                    Stan=stan;
                    Ollie.clear();
                }
                if(stan==Stan)Ollie.push_back(ollie);
                for(int j=st;j<i;j++)
                    update(l,lower_bound(Y+1,Y+cnt+1,p[j].y)-Y,1);
                st=i;
            }
        }
        printf("Stan: %d; Ollie:",Stan);
        sort(Ollie.begin(),Ollie.end());
        cnt=unique(Ollie.begin(),Ollie.end())-Ollie.begin();//cout<<cnt;
        for(int j=0;j<cnt;j++)printf(" %d",Ollie[j]);
        printf(";\n");
    }
    return 0;
}