Loj 6036 「雅礼集训 2017 Day4」编码

题目传送门

　　唯一的传送门

题目大意

　　给定$n$个串，每个串只包含 '0','1','?' ，其中 '?' 至多在每个串中出现1次，它可以被替换为 '0' 或 '1' 。问是否可能任意两个不同的串不满足一个是另一个的前缀。

　　2-sat的是显然的。

　　枚举每个通配符填0还是1，然后插入Trie树。

　　对于Trie的每个点在2-sat中建点。

　　如果其中一个点被选择，那么它祖先和所有后继的结束点都不能选。（然后逆否命题连边）

　　对于一个包含通配符的串，通配符替换为0以及通配符替换为1的否命题等价，同样，通配符替换为1以及通配符替换为0的否命题等价（连双向边）。

　　对于一个不包含通配符的串，直接它到的节点的从否命题节点连一条到它的有向边。

　　于是我们得到边数平方的优秀做法。

　　考虑前缀和优化，新建一个虚点表示Trie树上，它的祖先的命题都是假。但是这样还有点问题，还要建一个点表示Trie上，它的所有后继的命题都是假。

　　建图比较繁杂，见下图：

　　然后再说一下处理多个串在Trie树上共点。

　　于是便有了点数$12n$的优秀做法。再由于代码常数巨大无比，成功Loj最慢榜榜首，sad。。。（一定要去学习一下榜首同学点数$4n$的优质做法）

Code

/**
 * loj.ac
 * Problem#6036
 * Accepted
 * Time: 4346ms
 * Memory: 469852k
 */ 
#include <bits/stdc++.h>
using namespace std;
typedef bool boolean;

const int N = 5e5 + 5;

typedef class TrieNode {
    public:
        int id;
        TrieNode* ch[2];
        vector<int> vs;
}TrieNode;

TrieNode pool[N << 1];
TrieNode* top = pool;

TrieNode* newnode() {
    top->id = 0;
    top->ch[0] = top->ch[1] = NULL;
    return top++;
}

typedef class Trie {
    public:
        TrieNode* rt;
    
        Trie():rt(newnode()) {    }

        int insert(char* str, int id) {
            TrieNode* p = rt;
            for (int i = 0, c; str[i]; i++) {
                c = str[i] - '0';
                if (!p->ch[c])
                    p->ch[c] = newnode();
                p = p->ch[c];
            }
            if (!p->id)
                p->id = id;
            else if ((!p->vs.size() || p->vs[p->vs.size() - 1] != id - 1) && p->id != id - 1) 
                p->vs.push_back(id);
            return p->id;
        }
}Trie;

int n, n2;
char buf1[N], buf2[N];
vector<int> g[N * 12];
// 1 ~ 2 * n2 : Is the node seclected?
// 2 * n2 + 1 ~ 4 * n2: Aren't nodes above seclected?
// 4 * n2 + 1 ~ 6 * n2: Aren't nodes below seclected?
Trie tr;

inline void init() {
    scanf("%d", &n);
    n2 = n << 1;
    for (int i = 1, len, p1, p2; i <= n; i++) {
        scanf("%s", buf1);
        len = strlen(buf1);
        memcpy(buf2, buf1, len + 1);
        for (int j = 0; j < len; j++)
            if (buf1[j] == '?')
                buf1[j] = '0';
        for (int j = 0; j < len; j++)
            if (buf2[j] == '?')
                buf2[j] = '1';
        p1 = tr.insert(buf1, (i << 1) - 1);
        p2 = tr.insert(buf2, i << 1);
        if (p1 == p2) {
            g[(i << 1) - 1 + n2].push_back((i << 1) - 1);
        } else {
            p1 = ((i << 1) - 1), p2 = (i << 1);
            g[p1].push_back(p2 + n2);
            g[p2 + n2].push_back(p1);
            g[p2].push_back(p1 + n2);
            g[p1 + n2].push_back(p2); 
        }
    }
}

#define virt(_x) (_x + n2)
#define upre(_x) (_x + n2 * 2)
#define upvi(_x) (_x + n2 * 3)
#define dore(_x) (_x + n2 * 4)
#define dovi(_x) (_x + n2 * 5)

void dfs(TrieNode* p, int last) {
    if (!p)    return;
    if (p->vs.size()) {
        vector<int> &ve = p->vs;
        for (int i = 0; i < (signed) ve.size(); i++) {
            TrieNode* q = newnode();
            q->id = ve[i];
            q->ch[0] = p->ch[0], q->ch[1] = p->ch[1];
            p->ch[1] = NULL, p->ch[0] = q;
        }
        ve.clear();
    }
    int id = p->id;
    if (id) {
        g[id].push_back(upvi(id));
        g[id].push_back(dovi(id));
        g[upre(id)].push_back(virt(id));
        g[dore(id)].push_back(virt(id));
        if (last) {
            g[id].push_back(upre(last));
            g[upvi(last)].push_back(virt(id));
            g[last].push_back(dore(id));
            g[dovi(id)].push_back(virt(last));

            g[upre(id)].push_back(upre(last));
            g[upvi(last)].push_back(upvi(id));
            g[dore(last)].push_back(dore(id));
            g[dovi(id)].push_back(dovi(last));
        }
    }
    int nid = ((id) ? (id) : (last));
    dfs(p->ch[0], nid);
    dfs(p->ch[1], nid);
}

int dfs_clock = 0;
stack<int> st;
boolean vis[N * 12], ins[N * 12];
int dfn[N * 12], low[N * 12];
void tarjan(int p) {
    vis[p] = true, ins[p] = true;
    dfn[p] = low[p] = ++dfs_clock;
    st.push(p);
    for (int i = 0; i < (signed) g[p].size(); i++) {
        int e = g[p][i];
        if (!vis[e]) {
            tarjan(e);
            low[p] = min(low[p], low[e]);
        } else if (ins[e])
            low[p] = min(low[p], dfn[e]);
    }

    if (dfn[p] == low[p]) {
        int cur;
        do {
            cur = st.top();
            st.pop();
            low[cur] = low[p];
            ins[cur] = false;
        } while (cur != p);
    }
}

void putans(const char* str) {
    puts(str);
    exit(0);
}

inline void solve() {
    dfs(tr.rt, 0);
    for (int i = 1; i <= n2 * 6; i++)
        if (!vis[i])
            tarjan(i);
    for (int i = 1; i <= n2; i++) {
        if (low[i] == low[virt(i)])
            putans("NO");
        if (low[upre(i)] == low[upvi(i)])
            putans("NO");
        if (low[dore(i)] == low[dovi(i)])
            putans("NO");
    }
    putans("YES");
}

int main() {
    init();
    solve();
    return 0;
}