[CodeForces510c]Fox And Names

Fox Ciel is going to publish a paper on FOCS (Foxes Operated Computer Systems, pronounce: "Fox"). She heard a rumor: the authors list on the paper is always sorted in the lexicographicalorder.

After checking some examples, she found out that sometimes it wasn't true. On some papers authors' names weren't sorted in lexicographical order in normal sense. But it was always true that after some modification of the order of letters in alphabet, the order of authors becomes lexicographical!

She wants to know, if there exists an order of letters in Latin alphabet such that the names on the paper she is submitting are following in the lexicographical order. If so, you should find out any such order.

Lexicographical order is defined in following way. When we compare s and t, first we find the leftmost position with differing characters: si ≠ ti. If there is no such position (i. e. s is a prefix of t or vice versa) the shortest string is less. Otherwise, we compare characters si and ti according to their order in alphabet.

Input

The first line contains an integer n (1 ≤ n ≤ 100): number of names.

Each of the following n lines contain one string namei (1 ≤ |namei| ≤ 100), the i-th name. Each name contains only lowercase Latin letters. All names are different.

Output

If there exists such order of letters that the given names are sorted lexicographically, output any such order as a permutation of characters 'a'–'z' (i. e. first output the first letter of the modified alphabet, then the second, and so on).

Otherwise output a single word "Impossible" (without quotes).

---

 

题意理解：有N个字符串，要求你给出一个字典序，使它们按字典序排序后的结果和输入顺序一样。

显然对于一个字符串i优先于字符串j，i的第一个和j不同的字母优于j的对应的字母。（若找不到该字母，即i是j的前面一部分则可以直接判断无解）

那么我们可以得到很多对字母之间的优先顺序，要给出26个字母的优先顺序，无非就是拓扑排序。

然后考虑，使用普通BFS的拓扑排序的时候，如果存在没有被拓扑排序所排序到的节点，那么无解（即有环）。

发现没有特殊情况。

因为点少，用邻接矩阵建图。

上代码

#include<cstdio>
#include<cstring>
#include<cmath>
#include<iostream>
#include<queue>
using namespace std;
char s[110][110],ans[30];
int in[110];
bool link[26][26];
queue<int>q;
bool solve()
{
    int cnt=0;
    for(int i=0;i<26;i++)
    {
        if(in[i]==0)
        {
            q.push(i);
            ans[cnt++]='a'+i;
        }
    }
    while(!q.empty())
    {
        int now=q.front();
        q.pop();
        for(int i=0;i<26;i++)
        {
            if(link[now][i])
            {
                in[i]--;
                if(in[i]==0)
                {
                    q.push(i);
                    ans[cnt++]='a'+i;
                }
            }
        }
    }
    ans[26]='\0';
    if(cnt<26)
        return false;
    else
        return true;
}

int main()
{
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
        cin>>s[i];
    bool flag=true;
    for(int i=0;i<n-1&&flag;i++)
    {
        bool ok=false;
        int l1=strlen(s[i]),l2=strlen(s[i+1]);
        for(int j=0;j<l1&&j<l2&&!ok;j++)
        {
            if(s[i][j]!=s[i+1][j])
            {
                ok=true;
                if(!link[s[i][j]-'a'][s[i+1][j]-'a'])
                {
                    in[s[i+1][j]-'a']++;
                    link[s[i][j]-'a'][s[i+1][j]-'a']=true;
                }
            }
        }
        if(!ok&&l1>l2)
            flag=false;
    }
    if(!flag)
    {
        printf("Impossible\n");
    }
    else
    {
        flag=solve();
        if(!flag)
            printf("Impossible\n");
        else
            printf("%s",ans);
    }
    return 0;
}