POJ 3207 Ikki's Story IV

http://poj.org/problem?id=3207

两条边不能相交->两条边仅能存1->两条边XOR=1

明显的2-SAT

如果扫描到两条边可能相交就按XOR=1的规则加边，然后用2-SAT判可行性即可

可能相交条件：

bool check(int i,int j)
{
    return (node[i].x<node[j].x&&node[j].x<node[i].y&&node[i].y<node[j].y)||(node[j].x<node[i].x&&node[i].x<node[j].y&&node[j].y<node[i].y);
}

源代码：

//#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=1010;
const int maxm=510;
const int inf=0x3f3f3f3f;
const LL inf64=0x3f3f3f3f3f3f3f3fLL;
const double INF=1e30;
const double eps=1e-6;

/**
*2-SAT模板，Modified Edition of LRJ 按字典序排列结果
*输入：按照法则添加边(参数为2*i或者2*i+1)
*运行：先init(n),再add(),再solve()
*注意：add(2*i,2*j)才行
*输出：mark[](1表示选中),solve()(是否有解)
*/
//const int maxn = 0;
struct TwoSAT
{
    int n;
    vector<int> G[1010];
    bool mark[1010];
    int S[1010], c;

    bool dfs(int x)
    {
        if (mark[x^1]) return false;
        if (mark[x]) return true;
        mark[x] = true;
        S[c++] = x;
        for (int i = 0; i < G[x].size(); i++)
            if (!dfs(G[x][i])) return false;
        return true;
    }

    void init(int n)
    {
        this->n = n;
        for (int i = 0; i < n*2; i++) G[i].clear();
        memset(mark, 0, sizeof(mark));
    }

    /// x AND y = 1
    void add_and_one(int x,int y)
    {
        G[x^1].push_back(y);
        G[y^1].push_back(x);
        G[x].push_back(y);
        G[y^1].push_back(x^1);
        G[y].push_back(x);
        G[x^1].push_back(y^1);
    }

    /// x AND y = 0
    void add_and_zero(int x,int y)
    {
        G[x].push_back(y^1);
        G[y].push_back(x^1);
    }

    /// x OR y = 1
    void add_or_one(int x,int y)
    {
        G[x^1].push_back(y);
        G[y^1].push_back(x);
    }

    /// x OR y = 0
    void add_or_zero(int x,int y)
    {
        G[x].push_back(y^1);
        G[y].push_back(x^1);
        G[x].push_back(y);
        G[y^1].push_back(x^1);
        G[x^1].push_back(y^1);
        G[y].push_back(x);
    }

    /// x XOR y = 1
    void add_xor_one(int x,int y)
    {
        G[x^1].push_back(y);
        G[y^1].push_back(x);
        G[x].push_back(y^1);
        G[y].push_back(x^1);
    }

    /// x XOR y = 0
    void add_xor_zero(int x,int y)
    {
        G[x^1].push_back(y^1);
        G[y].push_back(x);
        G[x].push_back(y);
        G[y^1].push_back(x^1);
    }

    /// x -> y
    void add_to(int x,int y)
    {
        G[x].push_back(y);
        G[y^1].push_back(x^1);
    }

    bool solve()
    {
        for(int i = 0; i < n*2; i += 2)
            if(!mark[i] && !mark[i+1])
            {
                c = 0;
                if(!dfs(i))
                {
                    while(c > 0) mark[S[--c]] = false;
                    if(!dfs(i+1)) return false;
                }
            }
        return true;
    }
} sat;

struct Node
{
    int x,y;
}node[maxm];
int n,m;
void init()
{
    //
}
void input()
{
    if(scanf("%d%d",&n,&m)==EOF) exit(0);
    for(int i=0;i<m;i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        if(x>y) swap(x,y);
        node[i].x=x;
        node[i].y=y;
    }
}
bool check(int i,int j)
{
    return (node[i].x<node[j].x&&node[j].x<node[i].y&&node[i].y<node[j].y)||(node[j].x<node[i].x&&node[i].x<node[j].y&&node[j].y<node[i].y);
}
void solve()
{
    sat.init(m);
    for(int i=0;i<m;i++)
    {
        for(int j=i+1;j<m;j++)
        {
            if(check(i,j))
            {
                sat.add_xor_one(2*i,2*j);
            }
        }
    }
    if(sat.solve()) puts("panda is telling the truth...");
    else puts("the evil panda is lying again");
}
void output()
{
    //
}
int main()
{
//    std::ios_base::sync_with_stdio(false);
//    freopen("in.cpp","r",stdin);
    while(1)
    {
        init();
        input();
        solve();
        output();
    }
    return 0;
}