hdu 5299 Circles Game

最新推荐文章于 2020-02-11 15:01:56 发布

原创最新推荐文章于 2020-02-11 15:01:56 发布 · 401 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#多校

ACM 同时被 2 个专栏收录

202 篇文章

订阅专栏

博弈

3 篇文章

订阅专栏

本文深入探讨了游戏开发领域的关键技术，包括游戏引擎、Unity、Cocos2d-X等，以及AI音视频处理的应用，如语义识别、物体检测、语音识别和AR技术，展示了这些技术如何共同推动游戏体验的创新与升级。

http://acm.hdu.edu.cn/showproblem.php?pid=5299

题意：在坐标系中给出一些圆，这些圆可能相互包含和相离，现在两个人玩一个游戏，每个人每次选择去掉一个圆，如果这个圆中有小圆，同时去掉，没有圆可取的人输。

分析：等级制的威佐夫博奕
因为圆与圆有相互包含的关系，那么我们可以建一棵树，虚设一个无穷大的圆作为根节点，那么剩下的圆与大圆建立联系。
如果知道树的删边游戏的话，这道题应该是很好做的。

树的删边游戏规则如下：

1.给出一颗n个结点的树，其中有一个点规定为根。

2.两名游戏者轮流操作，每次从树中删去一条边，删去该边后，不与根节点连通的部分将被移走。

3.无法操作者输。

定理：

1.叶子结点的sg值为0；

2.分支结点的sg值为其所有子节点的sg值加1后的异或和。

有了这些知识以后就可以做了，设0结点为根，求其sg值即可。

建边可以用扫描线，也可以暴力建边

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;

const int N = 11111;
int head[N];
int e;

struct Edge 
{
    int v, next;
} edge[N];

void addEdge( int u, int v )
{
    edge[e].v = v;
    edge[e].next = head[u];
    head[u] = e++;
}

struct Circle 
{
    int x, y, r;
    bool operator < ( const Circle & o ) const 
    {
        return r < o.r;
    }
} circle[N];

int dfs( int u )
{
    int res = 0;
    for ( int i = head[u]; i != -1; i = edge[i].next )
    {
        res ^= ( dfs( edge[i].v ) + 1 );
    }
    return res;
}

bool involve( int i, int j )
{
    int x1 = circle[i].x, x2 = circle[j].x;
    int y1 = circle[i].y, y2 = circle[j].y;
    int r1 = circle[i].r, r2 = circle[j].r;
    return ( x1 - x2 ) * ( x1 - x2 ) + ( y1 - y2 ) * ( y1 - y2 ) < ( r1 - r2 ) * ( r1 - r2 );
}

int main ()
{
    int t;
    scanf("%d", &t);
    while ( t-- )
    {
        int n;
        scanf("%d", &n);
        for ( int i = 1; i <= n; i++ )
        {
            scanf("%d%d%d", &circle[i].x, &circle[i].y, &circle[i].r);
        }
        e = 0;
        memset( head, -1, sizeof(head) );
        sort( circle + 1, circle + 1 + n );
        for ( int i = 1; i <= n; i++ )
        {
            bool flag = false;
            for ( int j = i + 1; j <= n; j++ )
            {
                if ( involve( i, j ) )
                {
                    addEdge( j, i );
                    flag = true;
                    break;
                }
            }
            if ( !flag )
            {
                addEdge( 0, i );
            }
        }
        int ans = dfs(0);
        if ( ans ) puts("Alice");
        else puts("Bob");
    }
    return 0;
}

因为仅要找到每个圆外侧的最内侧的那个，因此用set二分查找左右边界优化，以加边171ms，对比上面是889ms

#include <bits/stdc++.h>
using namespace std;
#define prt(k) cerr<<#k" = "<<k<<endl
typedef long long ll;
const int N = 20003;
double sqr(double x) { return x*x ; }
struct P
{
    int x, y, r; int id;
    P() {}
    P(int _x, int _y, int _r =0) { x=_x, y=_y, r=_r; }
    void out() { printf("%d : (%d, %d) ---%d\n", id, x,y,r); }
    bool operator < (P b) const
    {
            if (x - b.x) return x < b.x;
            if (y - b.y) return y < b.y;
            return r < b.r;
    }
    double dis(P b) {
                return sqrt(sqr(x-b.x) + sqr(y-b.y) );
        }
}p[N];
double dis(P a, P b) { return a.dis(b); }
bool cmp(P a, P b)
{
        return a.r > b.r;
}
bool vis[N];
struct Edge
{
    int v, next;
} e[N<<1] ;
int head[N], mm;
void add(int u, int v)
{
    e[mm].v = v;
    e[mm].next = head[u];
    head[u] = mm++;
}
int n;
const int Root = N - 1;
int fa[N];
int dfs(int u)
{
    int ret=  0;
    for (int i=head[u];~i;i=e[i].next) {
        ret ^= dfs(e[i].v)+1;
    }
    return ret;
}
set<P>::iterator it;
const int inf = 0x3f3f3f3f;
int main()
{
        int re, ca=1;
        cin>>re;
        while (re--)
        {
                memset(head, -1, sizeof head); mm=  0;
                cin>>n;
                set<P> se;
                for (int i=0;i<n;i++) {
                        scanf("%d%d%d", &p[i].x, &p[i].y, &p[i].r);
                }
                se.insert(P(inf, inf));
                sort(p, p+n, cmp);
                for (int i=0;i<n;i++) p[i].id= i ;
                memset(vis, 0, sizeof vis);
                for (int i=n-1;i>=0;i--) {
                        P l = P(p[i].x - p[i].r, p[i].y - p[i].r);
                        P r = P(p[i].x + p[i].r, p[i].y + p[i].r);
                        set<P>::iterator e,f ;
                        e = se.lower_bound(l);
                        f = se.lower_bound(r);
                        for (set<P>::iterator it = e; it!=se.end() && it!=f; it++)
                        {
                                P tmp = *it;
                                double d = dis(tmp, p[i]);
                                if (!vis[it->id] && d < abs(p[i].r - tmp.r))
                                {
                                        add(i , tmp.id);
                                        vis[tmp.id] = 1;
                                }
                        }
                        se.insert(p[i]);
                }
                for (int i=0;i<n;i++) if (!vis[i]) add(Root, i);
                int ans = dfs(Root);
                puts(ans ? "Alice" : "Bob");
        }
}