ZOJ 3717 Balloon (二分+2-sat)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3717

2-sat版题

对半径R进行二分，将二分得到的R用2-sat判，如果2R<dis(i,j)，则建边add_and_zero(i,j)，然后看是否有解

// #pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <iostream>
#include <cstring>
#include <string>
#include <cmath>
#include <set>
#include <list>
#include <map>
#include <iterator>
#include <cstdlib>
#include <vector>
#include <queue>
#include <stack>
#include <algorithm>
#include <functional>
using namespace std;
typedef long long LL;
#define ROUND(x) round(x)
#define FLOOR(x) floor(x)
#define CEIL(x) ceil(x)
const int maxn = 410;
const int maxm = 410 * 410;
const int inf = 0x3f3f3f3f;
const LL inf64 = 0x3f3f3f3f3f3f3f3fLL;
const double INF = 1e30;
const double eps = 1e-8;
const int P[4] = {0, 0, -1, 1};
const int Q[4] = {1, -1, 0, 0};
const int PP[8] = { -1, -1, -1, 0, 0, 1, 1, 1};
const int QQ[8] = { -1, 0, 1, -1, 1, -1, 0, 1};
/**
*2-SAT模板: 按字典序排列结果
*输入：按照法则添加边(参数为2*i或者2*i+1)
*运行：先init(n),再add(),再solve()
*注意：add(2*i,2*j)才行
*输出：vis[](1表示选中),solve()(是否有解)
*/
// const int maxn = 0;
// const int maxm = 0;
struct Edge
{
    int u, v;
    int next;
};
struct TwoSAT
{
    int n, en;
    Edge edge[maxm];
    int head[maxn];
    int vis[maxn], S[maxn];
    int cnt;

    void init(int _n = 0)
    {
        n = _n;
        memset(head, -1, sizeof(head));
        en = 0;
        memset(vis, 0, sizeof(vis));
    }

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

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

    bool solve()
    {
        for (int i = 0; i < 2 * n; i += 2)
        {
            if (vis[i] || vis[i ^ 1])continue;
            cnt = 0;
            if (!dfs(i))
            {
                while (cnt)vis[S[--cnt]] = 0;
                if (!dfs(i ^ 1))return 0;
            }
        }
        return 1;
    }

    /// x AND y = 1
    void add_and_one(int x, int y)
    {
        addse(x ^ 1, y);
        addse(y ^ 1, x);
        addse(x, y);
        addse(y ^ 1, x ^ 1);
        addse(y, x);
        addse(x ^ 1, y ^ 1);
    }

    /// x AND y = 0
    void add_and_zero(int x, int y)
    {
        addse(x, y ^ 1);
        addse(y, x ^ 1);
    }

    /// x OR y = 1
    void add_or_one(int x, int y)
    {
        addse(x ^ 1, y);
        addse(y ^ 1, x);
    }

    /// x OR y = 0
    void add_or_zero(int x, int y)
    {
        addse(x, y ^ 1);
        addse(y, x ^ 1);
        addse(x, y);
        addse(y ^ 1, x ^ 1);
        addse(x ^ 1, y ^ 1);
        addse(y, x);
    }

    /// x XOR y = 1
    void add_xor_one(int x, int y)
    {
        addse(x ^ 1, y);
        addse(y ^ 1, x);
        addse(x, y ^ 1);
        addse(y, x ^ 1);
    }

    /// x XOR y = 0
    void add_xor_zero(int x, int y)
    {
        addse(x ^ 1, y ^ 1);
        addse(y, x);
        addse(x, y);
        addse(y ^ 1, x ^ 1);
    }

    /// x -> y
    void add_to(int x, int y)
    {
        addse(x, y);
        addse(y ^ 1, x ^ 1);
    }
} sat;

int n;
struct Node
{
    int x, y, z;
    Node(int _x = -1, int _y = -1, int _z = -1): x(_x), y(_y), z(_z) {}
} node[maxn];
void init()
{
    //
}
void input()
{
    for (int i = 0; i < 2 * n; i++)
    {
        scanf("%d%d%d", &node[i].x, &node[i].y, &node[i].z);
    }
}
void debug()
{
    //
}
double dis(int a, int b)
{
    return sqrt((node[a].x - node[b].x) * (node[a].x - node[b].x) + (node[a].y - node[b].y) * (node[a].y - node[b].y) + (node[a].z - node[b].z) * (node[a].z - node[b].z));
}
bool test(double r)
{
    sat.init(n);
    // for (int i = 0; i < n; i++)
    // {
    //     sat.add_xor_one(2 * i, 2 * i + 1);
    // }
    for (int i = 0; i < 2 * n; i++)
    {
        for (int j = i + 1; j < 2 * n; j++)
        {
            if (2 * r > dis(i, j))
                sat.add_and_zero(i, j);
        }
    }
    return sat.solve();
}
void solve()
{
    double L = 0, R = 20000;
    while (L + eps < R)
    {
        double M = (L + R) / 2;
        if (test(M)) L = M;
        else R = M;
    }
    printf("%f
", L);
}
void output()
{
    //
}
int main()
{
    // std::ios_base::sync_with_stdio(false);
// #ifndef ONLINE_JUDGE
//     freopen("in.cpp", "r", stdin);
// #endif

    while (~scanf("%d", &n))
    {
        init();
        input();
        solve();
        output();
    }
    return 0;
}