[HDOJ3622]Bomb Game

二分+2SAT验证~

#include <cstdio>
#include <cstring>

 /*

* 2-SAT
* 标号从1开始

 */

#define OO(i) ((i & 1) ? (i + 1) : (i - 1))

class B_SAT
{
private:
    const static int NK = 2;
    const static int MAXV = 16050;
    const static int MAXE = 40100;
    const static int INF = 0x7F7F7F7F;

    int nv;

    int top1;
    int stk1[MAXV];
    int top2;
    int stk2[MAXV];

    int times;
    int npart;
    int low[MAXV];

    int cor[MAXV];

    int belong[MAXV];

    int list[MAXV];
    int queue[MAXV];
    int degree[MAXV];
    bool topovst[MAXV];

    struct List
    {
        int u;
        int v;
        List * next;
    };

    List pool[NK][MAXE];
    List * pp[NK];
    List * head[NK][MAXV];

    List * create(int u,int v,List * * pp,List * next)
    {
        (*pp)->u = u;
        (*pp)->v = v;
        (*pp)->next = next;
        return (*pp)++;
    }
    void dfs(int v);
    void Gabow();
    void Rebuild();
    void Topo();

public:
    void Init(int _nv);
    void addEdge(int u,int v,int idx);
    bool solvable();
    void SAT();
};

void B_SAT::dfs(int v)
{
    low[v] = ++times;
    stk1[++top1] = v;
    stk2[++top2] = v;
    for (List * tp = head[0][v];tp;tp = tp->next)
    {
        int u = tp->v;
        if (low[u] == INF)
            dfs(u);
        else if (belong[u] == INF)
            while (low[stk2[top2]] > low[u])
                --top2;
    }

    if (stk2[top2] == v)
    {
        --top2;
        ++npart;
        do
        {
            belong[stk1[top1]] = npart;
        }
        while (stk1[top1--] != v);
    }
}

void B_SAT::Gabow()
{
    top1 = top2 = times = npart = 0;
    memset(low,0x7F,(nv + 2) * sizeof(low[0]));
    memset(belong,0x7F,(nv + 2) * sizeof(belong[0]));
    for (int i = 1;i <= nv;i++)
        if (low[i] == INF)
            dfs(i);
}

void B_SAT::Rebuild()
{
    memset(degree,0,(nv + 2) * sizeof(degree[0]));

    for (List * tp = pool[0];tp != pp[0];tp++)
    {
        int u = belong[tp->u];
        int v = belong[tp->v];
        if (u != v)
        {
            addEdge(v,u,1);
            degree[u]++;
        }
    }
}

void B_SAT::Topo()
{
    int qh = -1;
    int qe = -1;
    int cnt = 0;

    memset(topovst,false,(nv + 2) * sizeof(topovst[0]));

    for (int i = 1;i <= npart;i++)
        if (degree[i] == 0 && !topovst[i])
        {
            topovst[i] = true;
            list[++cnt] = i;
            queue[++qe] = i;
            while (qh != qe)
            {
                int u = queue[++qh];
                for (List * p = head[1][u];p;p = p->next)
                {
                    degree[p->v]--;
                    if (degree[p->v] == 0 && !topovst[p->v])
                    {
                        list[++cnt] = p->v;
                        queue[++qe] = p->v;
                        topovst[p->v] = true;
                    }
                }
            }
        }

    memset(topovst,true,(npart + 2) * sizeof(topovst[0]));
    for (int i = 1;i <= cnt;i++)
        if (topovst[list[i]])
            topovst[cor[list[i]]] = false;
}

void B_SAT::Init(int _nv)
{
    nv = _nv;

    pp[0] = pool[0];
    pp[1] = pool[1];
    memset(head,0,sizeof(head));
}

void B_SAT::addEdge(int u,int v,int idx)
{
    head[idx][u] = create(u,v,&pp[idx],head[idx][u]);
}

bool B_SAT::solvable()
{
    Gabow();
    int lim = nv / 2;
    for (int i = 1;i <= lim;i++)
    {
        if (belong[2 * i - 1] == belong[2 * i])
            return false;
        cor[belong[2 * i - 1]] = belong[2 * i];
        cor[belong[2 * i]] = belong[2 * i - 1];
    }
    return true;
}

void B_SAT::SAT()
{
    Rebuild();
    Topo();
    for (int i = 1;i <= nv;i++)
        if (topovst[belong[i]])
            printf("%d\n",i);
}

B_SAT sat;

const int SIZE = 128;
const double EPS = 0.0001;

struct PP
{
    int x;
    int y;
};

struct LL
{
    PP a;
    PP b;
};

LL in[SIZE];

bool judge(const PP & a,const PP & b,double mid)
{
    return ((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y)) <= 4 * mid * mid;
}

bool isok(int nv,double mid)
{
    sat.Init(nv << 1);
    for (int i = 1;i <= nv;i++)
        for (int j = i + 1;j <= nv;j++)
        {
            if (judge(in[i].a,in[j].a,mid))
            {
                int a = (i << 1) - 1;
                int b = (j << 1) - 1;
                sat.addEdge(a,OO(b),0);
                sat.addEdge(b,OO(a),0);
            }
            if (judge(in[i].a,in[j].b,mid))
            {
                int a = (i << 1) - 1;
                int b = (j << 1);
                sat.addEdge(a,OO(b),0);
                sat.addEdge(b,OO(a),0);
            }
            if (judge(in[i].b,in[j].a,mid))
            {
                int a = (i << 1);
                int b = (j << 1) - 1;
                sat.addEdge(a,OO(b),0);
                sat.addEdge(b,OO(a),0);
            }
            if (judge(in[i].b,in[j].b,mid))
            {
                int a = (i << 1);
                int b = (j << 1);
                sat.addEdge(a,OO(b),0);
                sat.addEdge(b,OO(a),0);
            }
        }

    return sat.solvable();
}


int main()
{
    int nv;

    while (scanf("%d",&nv) != EOF)
    {
        for (int i = 1;i <= nv;i++)
            scanf("%d %d %d %d",&in[i].a.x,&in[i].a.y,&in[i].b.x,&in[i].b.y);

        double high = 30000;
        double low = 0;
        double mid;
        double ans;

        while (high - low > EPS)
        {
            mid = (low + high) / 2;
            if (isok(nv,mid))
            {
                low = mid;
                ans = mid;
            }
            else high = mid;
        }

        printf("%.2lf\n",ans);
    }
    return 0;
}