[NOI2017]游戏【2-SAT（Tarjan+拓扑）+状态压缩二进制枚举】

题目链接

  有N个场地，每个场地有不适应的赛车，这些场地不能派对应的赛车参赛，又有适合所有赛车的图（不超过8个），并且有的车有怪癖，i图使用col[i]车，则要求j图使用col[j]车。问，是否存在一种方案满足以上条件？并且输出，否则为-1。

  很明显的，对于适合所有赛车的图，我们可以使用二进制枚举它是哪种图——假设它不适合'A'车、'B'车。

  那么，对于剩下的图，我们可以直接进行构造，如果在第i个场地开col[i]车（u），需要让第j个场地开col[j]车（v），我们就让" u -> v "，同理，根据2—SAT的原则，其逆否命题显然成立" v' -> u' "。

  然后，我们先Tarjan缩点来看合法性，再如果合法的话，可以从底向上拓扑来选出一种方案。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
#include <unordered_map>
#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
#define pii pair<int, int>
#define MP(a, b) make_pair(a, b)
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 1e5 + 10, maxM = 2e5 + 10;
int N, M, D, dth[10], head[maxN << 1], cnt, id[maxN][3] = {0}, col[maxN][3], all;
struct Eddge
{
    int nex, to;
    Eddge(int a=-1, int b=0):nex(a), to(b) {}
} edge[maxM << 1];
inline void addEddge(int u, int v)
{
    edge[cnt] = Eddge(head[u], v);
    head[u] = cnt++;
}
char s[maxN];
inline void init()
{
    cnt = 0;
    for(int i = 0; i <= all; i ++) head[i] = -1;
}
struct save_edge
{
    int u, v;
    char s0, s1;
    save_edge(int a=0, char _a=0, int b=0, char _b=0):u(a), s0(_a), v(b), s1(_b) {}
} se[maxM];
void build_Graph()
{
    init();
    char s0, s1;
    for(int i = 1, u, v; i <= M; i ++)
    {
        u = se[i].u; v = se[i].v;
        s0 = se[i].s0; s1 = se[i].s1;
        if(s0 + 32 == s[u]) continue;
        if(s1 + 32 == s[v])
        {
            if(col[u][0] == s0) addEddge(id[u][0], id[u][1]);
            else addEddge(id[u][1], id[u][0]);
        }
        else
        {
            int iu = 0, iv = 0;
            if(col[u][iu] != s0) iu ++;
            if(col[v][iv] != s1) iv ++;
            addEddge(id[u][iu], id[v][iv]);
            addEddge(id[v][iv ^ 1], id[u][iu ^ 1]);
        }
    }
}
int dfn[maxN << 1], low[maxN << 1], tot, Stap[maxN << 1], Stop, Belong[maxN << 1], Bcnt;
bool instack[maxN << 1];
void Tarjan(int u)
{
    dfn[u] = low[u] = ++tot;
    Stap[++Stop] = u;
    instack[u] = true;
    for(int i = head[u], v; ~i; i = edge[i].nex)
    {
        v = edge[i].to;
        if(!dfn[v])
        {
            Tarjan(v);
            low[u] = min(low[u], low[v]);
        }
        else if(instack[v]) low[u] = min(low[u], dfn[v]);
    }
    if(low[u] == dfn[u])
    {
        int v; Bcnt++;
        do
        {
            v = Stap[Stop --];
            instack[v] = false;
            Belong[v] = Bcnt;
        } while(u ^ v);
    }
}
queue<int> Q;
int du[maxN << 1], tp_id[maxN << 1], tp_tot;
vector<int> to[maxN << 1];
void tp_sort()
{
    while(!Q.empty()) Q.pop();
    for(int i = 1; i <= Bcnt; i ++) if(!du[i]) Q.push(i);
    tp_tot = 0;
    while(!Q.empty())
    {
        int u = Q.front(); Q.pop();
        tp_id[u] = ++tp_tot;
        for(int v : to[u])
        {
            du[v] --;
            if(!du[v]) Q.push(v);
        }
    }
}
bool Solve()
{
    tot = Stop = Bcnt = 0;
    for(int i = 1; i <= all; i ++) { dfn[i] = low[i] = 0; instack[i] = false; }
    for(int i = 1; i <= all; i ++) if(!dfn[i]) Tarjan(i);
    for(int i = 1; i <= N; i ++)
    {
        if(Belong[id[i][0]] == Belong[id[i][1]]) return false;
    }
    for(int i = 1; i <= Bcnt; i ++) { to[i].clear(); du[i] = 0; }
    for(int u = 1; u <= all; u ++)
    {
        for(int i = head[u], v; ~i; i = edge[i].nex)
        {
            v = edge[i].to;
            if(Belong[u] == Belong[v]) continue;
            to[Belong[v]].push_back(Belong[u]);
            du[Belong[u]] ++;
        }
    }
    tp_sort();
    for(int i = 1; i <= N; i ++)
    {
        if(tp_id[Belong[id[i][0]]] < tp_id[Belong[id[i][1]]]) printf("%c", col[i][0]);
        else printf("%c", col[i][1]);
    }
    printf("
");
    return true;
}
int main()
{
    scanf("%d%d", &N, &D);
    scanf("%s", s + 1);
    all = 0; int kd = 0;
    for(int i = 1; i <= N; i ++)
    {
        id[i][0] = ++all;
        id[i][1] = ++all;
        switch (s[i])
        {
            case 'a': { col[i][0] = 'B'; col[i][1] = 'C'; break; }
            case 'b': { col[i][0] = 'A'; col[i][1] = 'C'; break; }
            case 'c': { col[i][0] = 'A'; col[i][1] = 'B'; break; }
            default: { dth[kd ++] = i; break; }
        }
    }
    scanf("%d", &M);
    char s0[3], s1[3];
    for(int i = 1, u, v; i <= M; i ++)
    {
        scanf("%d%s%d%s", &u, s0, &v, s1);
        se[i] = save_edge(u, s0[0], v, s1[0]);
    }
    bool ok = false;
    for(int Sta = 0; !ok && Sta < (1 << D); Sta ++)
    {
        for(int i = 0; i < D; i ++)
        {
            if((Sta >> i) & 1)
            {
                s[dth[i]] = 'b';
                col[dth[i]][0] = 'A';
                col[dth[i]][1] = 'C';
            }
            else
            {
                s[dth[i]] = 'a';
                col[dth[i]][0] = 'B';
                col[dth[i]][1] = 'C';
            }
        }
        build_Graph();
        ok = Solve();
    }
    if(!ok) printf("-1
");
    return 0;
}
/*
4 0
abac
3
1 B 2 A
2 C 3 B
3 B 4 C
*/