[NOI2017]游戏

经典2-sat。

题意：有n个变量，每个变量有三个取值。但是有的变量的一个取值被限制为不能取。

只有不超过8个变量的取值未被限制，即三个都能取。

有m个约束条件，形如：若第i个变量取了a则第j个变量必须取b。

输出一种取值方案。无解输出-1。

n<=50000,m<=100000

好，假装是3-sat的东西.......

一个朴素想法是枚举未被限制的变量的取值，150000*3^8，超时。

然而正解就这样从TLE中浮出水面：假设未被限制的变量都被限制了，那么枚举限制了哪一个，两次即可覆盖所有情况。

时间复杂度150000*2^8，AC。

(在UOJ上面会97)

#include <cstdio>
#include <algorithm>
#include <cstring>

const int N = 50010;

struct Edge {
    int nex, v;
}edge[N << 2]; int top;

struct ORDER {
    int a, b, c, d;
}ask[N << 1];

int e[N * 3], dfn[N * 3], low[N * 3], tot, stk[N * 3], t, space[10], sp;
int scc_cnt, fr[N * 3], use[N], m, n;
bool in_stk[N * 3];
char s[N], bb[2], dd[2];

inline void add(int x, int y) {
    top++;
    edge[top].nex = e[x];
    edge[top].v = y;
    e[x] = top;
    return;
}

void tarjan(int x) {
    dfn[x] = low[x] = ++tot;
    in_stk[x] = 1;
    stk[++t] = x;
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(!dfn[y]) {
            tarjan(y);
            low[x] = std::min(low[x], low[y]);
        }
        else if(in_stk[y]) {
            low[x] = std::min(low[x], dfn[y]);
        }
    }
    if(low[x] == dfn[x]) {
        scc_cnt++;
        int y;
        do {
            y = stk[t--];
            in_stk[y] = 0;
            fr[y] = scc_cnt;
        } while(y != x);
    }
    return;
}

inline int _(int x) { // opposite
    int i = x;
    while(i > n) {
        i -= n;
    }
    for(int j = 0; j < 3; j++) {
        if(i + j * n != x && use[i] != j + 1) {
            return i + j * n;
        }
    }
    return -0x3f3f3f3f;
}

inline void out() {
    for(int i = 1; i <= n; i++) {
        int x = use[i] == 1 ? i + n : i;
        int y = _(x);
        x = (fr[x] < fr[y]) ? x : y;
        putchar('A' + ((x - 1) / n));
    }
    return;
}

inline bool solve() {
    for(int i = 1; i <= m; i++) {  //  a.b -> c.d
        int x = ask[i].a + (ask[i].b - 1) * n;
        int y = ask[i].c + (ask[i].d - 1) * n;
        if(use[ask[i].a] == ask[i].b) {
            continue;
        }
        if(use[ask[i].c] == ask[i].d) {
            add(x, _(x));
        }
        else {
            add(x, y);
            add(_(y), _(x));
        }
    }

    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= 3; j++) {
            if(use[i] != j && !dfn[i + (j - 1) * n]) {
                tarjan(i + (j - 1) * n);
            }
        }
    }

    for(int i = 1; i <= n; i++) {
        int x = use[i] == 1 ? i + n : i;
        int y = _(x);
        if(fr[x] == fr[y]) {
            return 0;
        }
    }
    return 1;
}

inline void clear() {
    top = 0;
    tot = 0;
    scc_cnt = 0;
    memset(dfn, 0, sizeof(dfn));
    memset(low, 0, sizeof(low));
    memset(e, 0, sizeof(e));
    return;
}

int main() {
    int d;
    scanf("%d%d", &n, &d);
    scanf("%s", s + 1);
    for(int i = 1; i <= n; i++) {
        if(s[i] == 'x') {
            space[++sp] = i;
        }
        else {
            use[i] = (s[i] - 'a') + 1;
        }
    }
    scanf("%d", &m);
    for(int i = 1; i <= m; i++) {
        scanf("%d%s%d%s", &ask[i].a, bb, &ask[i].c, dd);
        ask[i].b = bb[0] - 'A' + 1;
        ask[i].d = dd[0] - 'A' + 1;
    }

    int lm = (1 << d);
    for(int i = 0; i < lm; i++) {
        if(i) {
            clear();
        }
        for(int j = 0; j < d; j++) {
            use[space[j + 1]] = ((i >> j) & 1) + 1;
        }
        if(solve()) {
            out();
            return 0;
        }
    }
    printf("-1");
    return 0;
}