Hong Kong Regional Contest 2016 [Kattis - taboo]

/*
项目名称：Kattis taboo
创建者：  westwood
创建时间：  2017/9/15 21:45:13
CLR：  4.0.30319.42000
解题方法：题意:给出n个01串,要构造一个最长的串使得这个串不包含所有出现过的串,无解输出-1.

首先把所有的点扔进自动机,因为出现过的串不能在我们构造的串中出现,所以事先把某些”坏点”标记,
坏点指的就是每个串的结束节点以及沿着结束节点fail指针走下去的节点. 
如果剩下的图中能够沿着根走出一个环那么必然就无解了, 判环可以用一遍拓扑确定. 
排除无解情况剩下就是一个DAG了, 最后按照最长路打印方案即可.
*/
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<queue>
#include<cstring>
#include<stack>
#include<vector>
#pragma warning(disable : 4996)
using namespace std;
const static int MAXN = 500010;
char str[200000 + 10];
struct Tire
{
    int root, rcnt;
    int next[MAXN][2], fail[MAXN], end[MAXN];
    int newnode()
    {
        for (int i = 0; i < 2; i++)
            next[rcnt][i] = -1;
        end[rcnt++] = 0;
        return rcnt - 1;
    }
    void init()
    {
        rcnt = 0;
        root = newnode();
    }
    void insert(char buf[])
    {
        int len = strlen(buf);
        int now = root;
        for (int i = 0; i < len; i++)
        {
            if (next[now][buf[i] - '0'] == -1)
                next[now][buf[i] - '0'] = newnode();
            now = next[now][buf[i] - '0'];
        }
        end[now]++;
    }
    void build()
    {
        queue<int> que;
        fail[root] = root;
        for (int i = 0; i < 2; i++)
            if (next[root][i] == -1)
                next[root][i] = root;
            else
            {
                fail[next[root][i]] = root;
                que.push(next[root][i]);
            }
        while (que.size())
        {
            int now = que.front();
            end[now] += end[fail[now]];//这个是包含字串，如果失配跳转的地方是一个字符串结束的位置，那么其实就是说，这个now串包含另一个字符串，匹配到这个位置也是非法的
            que.pop();
            for (int i = 0; i < 2; i++)
            {
                if (next[now][i] == -1)
                    next[now][i] = next[fail[now]][i];
                else
                {
                    fail[next[now][i]] = next[fail[now]][i];
                    que.push(next[now][i]);
                }
            }
        }
    }
}tire;//其他的是ac自动机模板
int deg[MAXN];
bool vis[MAXN];
int dp[MAXN];
void getdeg()
{
    for (int u = 0; u < tire.rcnt; u++)
    {
        if (tire.end[u]) continue;
        for (int i = 0; i < 2; i++)
        {
            int v = tire.next[u][i];
            if (tire.end[v]) continue;
            deg[v]++;
        }
    }
}
int loop()
{
    memset(dp, 0, sizeof dp);
    queue<int> que;
    for (int i = 0; i < tire.rcnt; i++)
        if (deg[i] == 0)
        {
            if (tire.end[i]) continue;
            que.push(i), dp[i] = 1;
        }
    while (que.size())
    {
        int u = que.front(); que.pop();
        for (int i = 0; i < 2; i++)
        {
            int v = tire.next[u][i];
            if (tire.end[v]) continue;
            else if (dp[v] < dp[u] + 1)
            {
                dp[v] = dp[u] + 1;
            }
            if (--deg[v] == 0) que.push(v);
        }
    }
    int longest = 0,node;
    for (int i = 0; i < tire.rcnt; i++)
    {
        if (deg[i]) return -1;
        if (longest < dp[i])
        {
            longest = dp[i];
            node = i;
        }
    }
    return longest;
}
int longest;
vector<int> path;//用外部vector保存路径
bool findpath(int u)//寻找字典序最小的路径
{
    if (dp[u] == longest)
    {
        for (int i = 0; i < path.size(); i++)
            printf("%d", path[i]);
        exit(0);
    }
    for (int i = 0; i < 2; i++)
    {
        int v = tire.next[u][i];
        if (dp[v] == dp[u] + 1)
        {
            path.push_back(i);
            findpath(v);
            path.pop_back();
        }
    }
}
void work()
{
    memset(vis, false, sizeof vis);
    getdeg();
    longest = loop();
    if (longest == -1)
    {
        puts("-1");
    }
    else
    {
        findpath(0);
    }
}

int main()
{
    if (fopen("in.txt", "r"))
    {
        freopen("in.txt", "r", stdin);
        freopen("out.txt", "w", stdout);
    }
    int n;
    cin >> n;
    tire.init();
    for (int i = 0; i < n; i++)
    {
        scanf("%s", str);
        tire.insert(str);
    }
    tire.build();
    work();
    return 0;
}