【北京集训测试赛(五)/HDU5299】圆圈游戏(Circles game)-树上删边-圆的扫描线

Problem 遗产

题目大意

一个平面上n个圆，任两个圆只会相离或包含，给出每个圆位置与半径。

alice&&bob轮流取圆，每取一个就可以取出这个圆以及被这个圆包含的圆。

没圆取的人输，alice先取，问谁有必胜策略。

Solution

Method #1

首先我们考虑一个暴力一点的写法：

先将圆半径从小到大排序，然后枚举两个圆，判断是否包含关系。

如果包含的话就将大圆连一条边到小圆。

很容易发现，这样执行完以后得到了一棵树。

我们接下来要做的事情就变成了：

每个人可以轮流从树上删除一条边，所有与根节点不相连的点全都被删除。

谁不能取谁就输。

预备知识：树上删边

叶子节点值为0；

除叶子节点外任意节点值为其所有儿子的值加一的异或和。

根节点值为0则后取者胜。

dfs一遍树即为答案。

 

接下来很高兴啊！这题A掉啦！

但是——这smg？

$O(n^2)$的算法a掉了20000？？还是700ms？？

hdu的数据怎么不上天？

自己的oj交一发，妥妥的30pts tle。

 

Method #2

好了我们来换思路吧。

首先还是对半径进行排序。

 

我们对于每一个圆，从左到右扫描这个圆的范围。

如果在这个范围内找到了点，那么就判断是否包含，若包含则连边。

大致方法与上面一样。

我们对于每一个x坐标开一个vector记录该坐标线上的点。

 

提交hdu，ac100ms。

自己oj，90pts，还是被卡掉了。

仔细思考扫了一下，构造数据的确是可以卡掉这个算法的。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>
using namespace std;
vector<int> f[80010];
int n,T,h[80010],tot=0,t;
//bool cheat;
struct Circle{
    int x,y,r;
    bool inc;
}c[80010];
struct node{
    int next,to;
}a[80010];
bool cmp(Circle a,Circle b){
    return a.r<b.r;
}
void add(int u,int v){
    a[++tot].to=v;
    a[tot].next=h[u];
    h[u]=tot;
}
int dfs_sg(int x,int fa){
    int ret=0;
    for(int i=h[x];~i;i=a[i].next)
        if(a[i].to!=fa)ret^=(dfs_sg(a[i].to,x)+1);
    return ret;
}
int main(){
//  freopen("08b.in","r",stdin);
    scanf("%d",&T);
    while(T--){
        tot=0,cheat=1;
        memset(a,0,sizeof(a));
        memset(c,0,sizeof(c));
        memset(h,-1,sizeof(h));
        for(int i=0;i<=80001;i++)f[i].clear();
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
            scanf("%d%d%d",&c[i].x,&c[i].y,&c[i].r),
            c[i].x+=40000,c[i].y+=40000;
//      for(int i=1;i<=100;i++)
//          if(c[i].r!=1){
//              cheat=0;
//              break;
//          }
//      if(cheat){
//          printf("Bob\n");
//          continue;
//      }
        sort(c+1,c+1+n,cmp);
        for(int i=1;i<=n;i++){
            for(int p=c[i].x-c[i].r+1;p<=c[i].x+c[i].r-1;p++){
                t=0;
                while(t<f[p].size()){
                    if((c[f[p][t]].x-c[i].x)*
                      (c[f[p][t]].x-c[i].x)+
                      (c[f[p][t]].y-c[i].y)*
                      (c[f[p][t]].y-c[i].y)<=
                      (long long)((c[i].r)*(c[i].r))){
                        c[f[p][t]].inc=1;
                        add(i,f[p][t]);
                        f[p][t]=f[p][f[p].size()-1];
                        f[p].pop_back();
                        t--;
                    }
                    t++;
                }
            }
            f[c[i].x].push_back(i);
        }
        int ans=0;
        for(int i=1;i<=n;i++)
            if(!c[i].inc)ans^=(dfs_sg(i,-1)+1);
        if(!ans)printf("Bob\n");
        else printf("Alice\n");
    }
}

 

Method #3

我们将每个圆的左端点&&右端点出现的时间排序。

对于每一个圆的端点来说，左端点sign为+1，表示该圆开始出现，右端点sign为-1，表示该圆结束。

我们开一个set来维护这些圆与扫描线的交点。set的键值为交点的y坐标值，如下计算：

$c_i\cap(x=now)={c_i.y\pm \sqrt{(c_i.r)^2-(c_i.x-now)^2}} $

只要给set开一个operater就可以了。

对于圆$c_i$的起始交点，我们get到它的upper bound

upperbound交点有三种可能，

一种是没有该交点，这说明$c_i$一定是不被其他圆包含的圆。

一种是该交点所属的圆$c_j$包含$c_i$，这说明$c_i$的父亲是圆$c_j$，而且不会有更近的父亲。

还有是圆$c_j$不包含圆$c_i$。这说明$c_i$圆的父亲是圆$c_j$的父亲的儿子。

第三种可能我们需要特判一下，如果圆$c_j$的父亲为0，那么不就不用连边。否则会爆空间。

判断sign为正的时候insert，sign为负的时候erase即可。

建树完毕后dfs即可。

 

hdu 78ms，

oj终于a掉了。

强烈吐槽hdu的数据。

最垃圾的暴力都能a掉，出数据的人可能比较强吧不屑于出这种题目的数据。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <set>
using namespace std;
int n,h[80010],fa[80010],tot=0,now,T,ndtot=0;
struct Node{
    int next,to;
}a[80010];
struct Circle{
    int x,y,r;
}c[80010];
struct Time{
    int x,id;
    friend inline bool operator <(Time x,Time y){
        return x.x<y.x;
    }
}t[80010];
struct node{
    int sign,id;
    inline double y(){
        return c[id].y+sign*sqrt((c[id].r)*(c[id].r)
        -(now-c[id].x)*(now-c[id].x));
    }
    friend inline bool operator <(node x,node y){
        return x.id==y.id?x.sign<y.sign:x.y()<y.y();
    }
};
int dfs_sg(int x,int fa){
    int ret=0;
    for(int i=h[x];~i;i=a[i].next)
        if(a[i].to!=fa)ret^=(dfs_sg(a[i].to,x)+1);
    return ret;
}
void add(int u,int v){
    a[++ndtot].to=v;
    a[ndtot].next=h[u];
    h[u]=ndtot;
}
set<node> S;
int main(){
//  freopen("08b.in","r",stdin);
    scanf("%d",&T);
    while(T--){
        memset(a,0,sizeof(a));
        memset(c,0,sizeof(c));
        memset(t,0,sizeof(t));
        memset(h,-1,sizeof(h));
        memset(fa,0,sizeof(fa));
        S.clear();tot=0;ndtot=0;
        scanf("%d",&n);
        for(int i=1;i<=n;i++)scanf("%d%d%d",&c[i].x,&c[i].y,&c[i].r);
        for(int i=1;i<=n;i++)
            t[++tot]=(Time){c[i].x-c[i].r,i},
            t[++tot]=(Time){c[i].x+c[i].r,-i};
        sort(t+1,t+tot+1);
        for(int i=1;i<=tot;i++){
            now=t[i].x;
            if(t[i].id>0){
                set<node>::iterator it=S.upper_bound((node){+1,t[i].id});
                if(it==S.end()) fa[t[i].id]=0;
                else if(it->sign==1) add(it->id,t[i].id),fa[t[i].id]=it->id;
                else{
                    if(fa[it->id])add(fa[it->id],t[i].id);
                    fa[t[i].id]=fa[it->id];
                }        
                S.insert((node){-1,t[i].id}),S.insert((node){+1,t[i].id});
            }
            else S.erase((node){-1,-t[i].id}),S.erase((node){+1,-t[i].id});
        }
        int ans=0;
        for(int i=1;i<=n;i++)
            if(!fa[i])ans^=(dfs_sg(i,-1)+1);
        if(!ans)printf("Bob\n");
        else printf("Alice\n");
    }
    return 0;
}