CF290-C

拓扑排序

给定n个字符串,要求构造一个字母顺序表以至于这n个字符串是按照字典顺序排序好的(两个子串比较大小从最低位开始,字符大的的字符串大,如b>ab)

首先题目只要求构造一个顺序,我们需要只依照给定的n个字符串的字母相对顺序和原字母表的顺序就可以确定新的顺序.这样很容易就想到拓扑排序

我们默认从1~n的字符串已经是有序的了.

依次比较相邻的两个字符串,将不满足大小顺序的字母在拓扑图上表示

如代码中的:indegree[k2]++; graph[k1].push_back(k2);意味着k1顺序应该在k2之前

遍历所有的字符串后意味着顺序已经确定好,输出就可以了

#include <iostream>
#include <string.h>
#include <vector>

int indegree[200];
int use[200];
using namespace std;
vector<int> graph[200];
vector<int> res;
void topsort()
{
    while(true)
    {
        for(int i=0;i<26;i++)
        {
            if(indegree[i]==0&&graph[i].size()==0&&!use[i])
            {
                use[i]=1;
                res.push_back(i);
            }
        }
        int k=0;
        for(;k<26;k++)
        {
            if(indegree[k]==0&&!use[k])
                break;
        }
        if(k<26)
        {
            use[k]=1;
            res.push_back(k);
            for(int i=0;i<graph[k].size();i++)
            {
                indegree[graph[k].at(i)]--;
            }
            graph[k].clear();
        }
        else
        {
            if(res.size()==26)
                break;
            cout<<"Impossible"<<endl;
            return ;
        }
    }
    for(int i=0;i<res.size();i++)
    {
        cout<<char(res.at(i)+‘a‘);
    }
    cout<<endl;
}
int main()
{
    int n;
    memset(use,0,sizeof(use));
    memset(indegree,0,sizeof(indegree));
    char str[200][200];
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        cin>>str[i];
    }
    for(int i=2;i<=n;i++)
    {
        char s1[200];
        char s2[200];
        strcpy(s1,str[i-1]);
        strcpy(s2,str[i]);
        int k1=-1;
        int k2=-1;
        for(int j=0;j<min(strlen(s1),strlen(s2));j++)
        {
            if(s1[j]==s2[j])
            {
                continue;
            }
            else
            {
                k1=s1[j]-‘a‘;
                k2=s2[j]-‘a‘;
                break;
            }
        }
        if(k1==-1)
        {
            if(strlen(s1)>strlen(s2))
            {
                cout<<"Impossible"<<endl;
                return 0;
            }
            else
                continue;
        }
        indegree[k2]++;
        graph[k1].push_back(k2);
    }
    topsort();
    return 0;
}