[BZOJ2391]Cirno的忧郁-三角剖分

Cirno的忧郁

Description

Cirno闲着无事的时候喜欢冰冻青蛙。
Cirno每次从雾之湖中固定的n个结点中选出一些点构成一个简单多边形，Cirno运用自己的能力能将此多边形内所有青蛙冰冻。
雾之湖生活着m只青蛙,青蛙有大有小，所以每只青蛙的价值为一个不大于10000的正整数。
Cirno很想知道每次冻住的青蛙的价值总和。因为智商有限，Cirno将这个问题交给完美算术教室里的你。
因为爱护动物，所以每次冻结的青蛙会被放生。也就是说一只青蛙可以被多次统计。

Input

第一行2个正整数 n,m。
以下n行，每行2个整数xi,yi,表示第i个结点的坐标。
再以下m行，每行3个整数xj,yj,vj，表示第j个青蛙的坐标和价值。
第n+m+1行一个整数q，表示有q组询问。
每组询问有2行，第一行一个整数s（3<=s<=n），表示简单多边形的结点数。第二行s个正整数，顺时针或逆时针给出多边形的结点的编号(1–n)

Output

q行。
对于每个询问，每行输出一个整数表示冻结的青蛙的价值之和

Sample Input

4 3
2 2
3 5
7 4
5 1
3 4 2
4 3 7
6 3 90
2
3
1 2 3
4
1 4 3 2

Sample Output

9
99

HINT

对于30%的数据，n,m<=100; q<=100
对于60%的数据，n,m<=100; q<=10000
对于100%的数据，n,m<=1000; q<=10000
-10000<=x,y<=10000; 0 < v<=10000

---

受到了题面感染，感觉整个人都充满了“智慧与力量”……
于是就各种迷之小错误WA了一晚上……
是谁出的这么恶心的题啊啊啊

(╯‵□′)╯︵┻━┻

---

思路:
三角剖分.jpg【生无可恋】
第一次写被严重地恶心到了……

所谓三角剖分呢，就是把整张图分割成一个个小三角形。
在这题，可以采用在剖分后，以每个三角形内部的点的权值和为面积，采用叉积算多边形一样的方法回答询问。

以下为具体剖分过程:
首先，新建一个点p[0]，坐标为(-INF,-INF)。
然后用这个点对其他点进行一次极角排序。
然后按极角序依次对于每个点建立一棵平衡树，平衡树内部采用以当前点为原点的极角序作为比较关键字。
每次对于一个点i，将极角序在它之后的点依次插入它的平衡树，在插入一个点j后，三角形(0,i,j)内部所有点的权值和，即为此时j在平衡树中的所有排名在它之前的点的点权和。

咱可以通过此预处理出所有形如(0,x,y)的三角形的答案。
那么在得到这些以后，只需要按照叉积算多边形面积一样的方法，即顺时针加上，逆时针减去即可，O(n)回答询问~

那么剩下的就是实现了~
这里的平衡树使用了treap~

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>

using namespace std;

inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0' || '9'<ch){if(ch=='-')f=-1;ch=getchar();}
    while('0'<=ch && ch<='9')x=x*10+(ch^48),ch=getchar();
    return x*f;
}

const int N=2009;

struct point
{
    int x,y,v,id;
    point operator - (point b)
    {
        return (point){x-b.x,y-b.y,0,0};
    }
}p[N<<1];

int n,m,q,tot;
int f[N][N],rid[N];
int root,ch[N][2],pool;
int sum[N],key[N],fa[N];
int qu[N];

inline int sqr(int x){return x*x;}
inline int cross(point a,point b){return a.x*b.y-a.y*b.x;}
inline int dist(point a,point b){return sqr(a.x-b.x)+sqr(a.y-b.y);} 

inline bool cmps(point a,point b)
{
    if(cross(b-p[0],a-p[0])==0)
        return dist(p[0],a)<dist(p[0],b);
    return cross(b-a,p[0]-a)>0;
}

inline void init()
{
    root=0;
    memset(ch,0,sizeof(ch));
    memset(fa,0,sizeof(fa));
}

inline void update(int x)
{
    sum[x]=sum[ch[x][0]]+sum[ch[x][1]]+p[x].v;
}

inline void rotate(int x)
{
    int y=fa[x],z=fa[y];
    int l=(ch[y][1]==x);
    if(z){ch[z][ch[z][1]==y]=x;}
    fa[x]=z;fa[y]=x;fa[ch[x][l^1]]=y;
    ch[y][l]=ch[x][l^1],ch[x][l^1]=y;
    update(y);update(x);
}

inline int insert(int base,int now)
{
    sum[now]=p[now].v;
    ch[now][0]=ch[now][1]=0;
    key[now]=rand();
    int ret=0;
    if(!root)
    {
        root=now;
        return ret;
    }

    int pos=root,fat=0,son=0;
    while(pos)
    {
        fat=pos;
        sum[pos]+=p[now].v;
        if(cross(p[now]-p[base],p[pos]-p[base])>0)
            pos=ch[pos][son=0];
        else
        {
            ret+=sum[ch[pos][0]]+p[pos].v;
            pos=ch[pos][son=1];
        }
    }

    fa[now]=fat;
    ch[fat][son]=now;

    while(key[now]<key[fa[now]])
        rotate(now);
    if(!fa[now])
        root=now;
    return ret;
}

int main()
{
    n=read();
    m=read();
    for(int i=1;i<=n;i++)
    {
        p[++tot].x=read();
        p[tot].y=read();
        p[tot].id=tot;
    }
    for(int i=1;i<=m;i++)
    {
        p[++tot].x=read();
        p[tot].y=read();
        p[tot].v=read();
        p[tot].id=tot;
    }

    p[0].x=-12345;
    p[0].y=-15432;
    sort(p+1,p+tot+1,cmps);
    for(int i=1;i<=tot;i++)
        rid[p[i].id]=i;
    for(int i=1;i<tot;i++)
    {
        init();
        for(int j=i+1;j<=tot;j++)
            f[i][j]=f[j][i]=insert(i,j);
    }

    q=read();
    while(q--)
    {
        int cnt=read();
        for(int i=1;i<=cnt;i++)
            qu[i]=rid[read()];
        qu[cnt+1]=qu[1];

        int ans=0;
        for(int i=1;i<=cnt;i++)
            if(cross(p[qu[i+1]]-p[0],p[qu[i]]-p[0])>0)
                ans+=f[qu[i]][qu[i+1]];
            else
                ans-=f[qu[i]][qu[i+1]];
        printf("%d\n",abs(ans));
    }

    return 0;
}