POJ 3648

题目大意：

有N对男女参加一场婚礼。其中一对是新郎和新娘（也就是本次婚礼的主角），其他N－1对都是已婚的夫妇。

设X为0 ~ N－1之间的整数，用Xh和Xw表示一对男女，Xh为男性，Xw为女性。特别地，0h和0w表示新郎和新娘。

这些人中有M对婚外情关系（也就是原文的adulterous relationships），婚外情可能是同性恋或者异性恋。

现要将这N对男女安排在一张长桌子的两侧，要求：

①每一对男女都不能坐在同一侧；

②如果两个人有婚外情，那么他们不能同时坐在新娘的另一侧。

求应该安排哪些人与新娘坐在同一侧，如果有多种方案，输出任意一种；如果不存在方案，输出"bad luck"（输出时不带引号）。

N<=30。

这道题简直各种神坑：

①诡异的题意！我读了好几遍题一直以为是N对男女的集体婚礼，后来结合讨论区和别人的博客才把题意搞懂……

②恶心的输入！！输入M对婚外情关系时，Xh和Yw之间可能没有空格！也就是说，用scanf读入时，"%s%s"是错误的，必须用"%d%c%d%c"。然而这点题面中并没有交代清楚……

③新郎和新娘也可能有婚外情！！如果忘了处理这种情况就很容易WA。（我的妈呀贵圈到底有多乱）

不过模型很好建立。按照以下关系建图，然后跑一遍2-SAT。

对于每个新郎和新娘以外的人，记他/她的编号为X，在图中相应建立两个节点：X表示该人与新娘坐在同侧，X'表示该人与新娘坐在异侧。

对于要求①：设丈夫编号为X，妻子编号为Y，连4条边：X→Y'，Y→X'，X'→Y，Y'→X。其含义是：如果其中一人坐在新娘同侧，那么另一人必须坐在新娘异侧，反之亦然。

对于要求②：设有婚外情的二人编号分别为X，Y。

（1）如果其中某一人是新娘，不用处理；

（2）如果X为新郎，连一条边Y'→Y，表示Y不能坐在新娘异侧。如果Y为新郎，则连一条边X'→X。

（3）否则，连两条边：X'→Y，Y'→X。其含义是：如果其中一人坐在新娘异侧，那么另一人必须坐在新娘同侧。

AC代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <cctype>
#include <utility>

#define FILLC(arr, ch) memset(arr, ch, sizeof(arr))

struct EListNode
{
    int to, next;
    void assign(int t, int n) { to = t; next = n; }
};

template <int maxV, int maxE>
struct EList
{
    EListNode node[maxE + 1];
    int head[maxV + 1];
    int ecnt;

    void init()
    {
        FILLC(head, 0);
        ecnt = 0;
    }

    void access(int v, int& e, int& to)
    {
        e = head[v];
        to = node[e].to;
    }
    void access(int& e, int& to)
    {
        e = node[e].next;
        to = node[e].to;
    }
    bool isEnd(int e)
    {
        return e == 0;
    }

    void addEdge(int u, int v)
    {
        node[++ecnt].assign(v, head[u]);
        head[u] = ecnt;
    }
};

EList<128, 12800> elist;
EList<128, 12800> compElist; //Graph after compressing SCCs
int N, M;

inline int getId(int x, char c)
{
    return 2 * x - (c == 'h');
}

bool inputAndBuildGraph()
{
    if (scanf("%d%d", &N, &M), N == 0)
        return false;

    elist.init();
    //char s1[5], s2[5];
    char cu, cv;
    for (int u, v, i = 0; i < M; i++)
    {
        //scanf("%s%s", s1, s2);
        scanf("%d%c%d%c", &u, &cu, &v, &cv);
        u = getId(u, cu);
        v = getId(v, cv);
        if (u > v)
            std::swap(u, v);
        if (u > 0) //not groom or bride
        {
            elist.addEdge(u + 2 * N, v);
            elist.addEdge(v + 2 * N, u); //adulterous pairs should not be both opposite the bride
        }
        else if (u == -1) //broom
            elist.addEdge(v + 2 * N, v);
    }

    for (int ih, iw, i = 1; i < N; i++)
    {
        ih = 2 * i - 1;
        iw = 2 * i;
        elist.addEdge(ih, iw + 2 * N);
        elist.addEdge(iw, ih + 2 * N); //husband and wife should not be on the same side
        elist.addEdge(ih + 2 * N, iw);
        elist.addEdge(iw + 2 * N, ih);
    }

    return true;
}

int dfn[128];
int low[128];
int sccId[128];
bool inStack[128];
int lastDfn;
std::stack<int> stack;

void initDfs()
{
    FILLC(dfn, -1);
    lastDfn = 0;
}

inline void pushToStack(int v)
{
    stack.push(v);
    inStack[v] = true;
}

inline int popFromStack()
{
    int v = stack.top();
    stack.pop();
    inStack[v] = false;
    return v;
}

void tarjanDfs(int cur)
{
    dfn[cur] = low[cur] = (++lastDfn);
    pushToStack(cur);

    int e, to;
    for (elist.access(cur, e, to); !elist.isEnd(e); elist.access(e, to))
    {
        if (dfn[to] == -1)
        {
            tarjanDfs(to);
            low[cur] = std::min(low[cur], low[to]);
        }
        else if (inStack[to])
            low[cur] = std::min(low[cur], dfn[to]);
    }
    if (dfn[cur] == low[cur])
        for (int v = popFromStack(); ; v = popFromStack())
        {
            sccId[v] = cur;
            if (v == cur)
                break;
        }
}

bool check2SAT()
{
    for (int i = 1; i <= (N - 1) * 2; i++)
        if (sccId[i] == sccId[i + N * 2])
            return false;
    return true;
}

int inDeg[128];
int contra[128];
bool chosen[128];

void compressGraph()
{
    compElist.init();
    FILLC(inDeg, 0);

    for (int v, e, i = 1; i <= (2 * N - 1) * 2; i++)
        for (elist.access(i, e, v); !elist.isEnd(e); elist.access(e, v))
        {
            if (sccId[i] == sccId[v])
                continue;
            compElist.addEdge(sccId[v], sccId[i]);
            inDeg[sccId[i]] += 1;
        }

    for (int i = 1; i <= (N - 1) * 2; i++)
    {
        contra[sccId[i]] = sccId[i + 2 * N];
        contra[sccId[i + 2 * N]] = sccId[i];
    }
}

void chooseNodes()
{
    std::queue<int> que;
    FILLC(chosen, 1);

    for (int i = 1; i <= (2 * N - 1) * 2; i++)
        if (sccId[i] == i && inDeg[i] == 0)
            que.push(i);

    while (!que.empty())
    {
        int cur = que.front();
        que.pop();

        int e, to;
        if (chosen[cur])
            chosen[contra[cur]] = false;

        for (compElist.access(cur, e, to); !compElist.isEnd(e); compElist.access(e, to))
        {
            inDeg[to] -= 1;
            if (inDeg[to] == 0)
                que.push(to);
        }
    }
}

void solve()
{
    initDfs();
    for (int i = 1; i <= (2 * N - 1) * 2; i++)
        if (dfn[i] == -1)
            tarjanDfs(i);

    if (!check2SAT())
    {
        printf("bad luck
");
        return;
    }
    compressGraph();
    chooseNodes();

    for (int i = 1; i <= (N - 1) * 2; i++)
    {
        if (chosen[sccId[i]])
            printf("%d%c ", (i + 1) / 2, i & 1 ? 'h' : 'w');
    }
    putchar('
');
}

int main()
{
    while (inputAndBuildGraph())
        solve();
    return 0;
}