题二 源代码编译：拓扑排序

一、题目

时间限制:10000ms
单点时限:1000ms
内存限制:256MB

描述

在网易游戏的日常工作中，C++ 是一门常用的语言。面对众多的 C++ 代码，等待源文件编译的漫长时间是个令人糟心的时刻,一直以来大家对此怨声载道。终于有一天，大家找到了你，一位优秀的程序员，请你来帮忙分析一下编译速度的瓶颈。

经过一番调查和研究，你发现一些源代码之间是有依赖关系的。例如，某个源文件 a.cpp 编译链接生成了动态链接库 a.dll，而 b.cpp 编译链接生成的 b.dll 依赖于 a.dll。这个时候，必须等待 a.dll 生成之后才能生成 b.dll。为了表达简单，我们这个时候称 b.cpp 依赖于 a.cpp。

网易游戏内部使用了一个分布式并行的编译平台，可以同时编译多个不互相依赖的文件，大大提高了源代码的编译速度。然而当某些依赖链很长的时候，这个编译平台也无能为力，只能按照依赖顺序一个一个完成编译，从而造成了很长的编译时间。

为了验证这个想法，你决定着手通过代码分析这些文件之间的编译顺序。已知这些文件的文件名，以及这些文件所依赖的其他文件，你需要编写一个程序，输出一个可行的编译所有源文件的编译顺序。如果有多种可行的序列，请输出所有文件名序列中字典序最小的那一个（序列 (a1, a2, …, an) 字典序小于序列 (b1, b2, …, bn)，当且仅当存在某个 i ，使得 ai 的字典序小于 bi，并且对于任意 j < i ，都有 aj = bj）。

输入

输入包含多组测试数据。

输入的第一行包含一个整数 T(T ≤ 100)，表示输入中一共包含有 T 组测试数据。

每组测试数据第一行是一个整数 N(N ≤ 1000)，表示一共有 N 个源代码文件。随后一共有 N 行数据，其中第 i(0 ≤ i < N) 行数据包含序号为 i 的源代码文件的依赖信息。每一行开头是一个字符串，表示这一个文件的文件名，随后一个整数 m(0 ≤ m ≤ N)，表示编译这个源文件之前需要先编译 m 个依赖文件。之后是 m 个整数 j0 … jm-1，表示这 m 个依赖文件的序号(0 ≤ j < N) 。所有的文件名仅由小写字母、数字或“.”组成，并且不会超过 10 个字符。保证 n 个源代码文件的文件名互不相同。

输出

对于每一组输入，按照编译先后顺序输出一组可行的编译顺序，一行一个文件名。如果有多种可行的序列，请输出所有文件名序列中字典序最小的那一个。如果不存在可行的编译顺序，输出一行 ERROR。每组测试数据末尾输出一个空行。

样例输入

3
2
a.cpp 0
b.cpp 1 0
2
cb 0
c 0
2
a.cpp 1 1
b.cpp 1 0

样例输出

a.cpp
b.cpp

c
cb

ERROR

二、code

/* 
* 
* function: 源代码编译
* 
* Date:2016-03-18
* 
*    Author: Bill Wang
*/

#include <iostream>
#include <string>
#include <map>
#include <vector>
#define MAXN 1002

using namespace std;

typedef struct myStruct
{
    string name;
    int dependCnt;
    int visited;

    myStruct() {
        visited = 0;
    }
}cppFile;

cppFile cppfile[MAXN];
map<int, vector<int>>  fileDependMap; //文件依赖关系映射表

int main() 
{
    int t;
    cin>>t;

    while (t--) {

        int n;
        cin>>n;

        //init
        fileDependMap.clear();
        for (int i=0;i<n;++i) {
            cppfile[i].dependCnt=0;
            cppfile[i].visited = 0;
        }

        //输入数据
        for (int i=0;i<n;++i) {
            cin>>cppfile[i].name;
            cin>>cppfile[i].dependCnt;

            for (int j=0;j<cppfile[i].dependCnt;++j) {
                int tmpDepend;
                cin>>tmpDepend;

                if(fileDependMap.count(tmpDepend)>0) {
                    vector<int > tmpV = fileDependMap[tmpDepend];
                    tmpV.push_back(i);
                }else {
                    vector<int > tmpV;
                    tmpV.push_back(i);
                    fileDependMap[tmpDepend] = tmpV;
                }
            }
        }

        //字典序排序
        for (int i=0;i<n-1;++i) {
            for(int j=i+1;j<n;++j) {
                if( cppfile[i].name > cppfile[j].name ) {
                    cppFile tmp = cppfile[i];
                    cppfile[i] = cppfile[j];
                    cppfile[j] = tmp;
                }
            }
        }

        while (1) {
            int flag = 0; //判断有没有改变
            int errorFlag = 0;
            for (int i=0;i<n;++i) {

                if(cppfile[i].dependCnt == 1)
                    errorFlag = 1;

                if( cppfile[i].visited == 0 && cppfile[i].dependCnt == 0 ) {
                    //如果为0，以该文件为基础的文件都减1
                    for (int j=0;j<fileDependMap[i].size();++j) {
                        cppfile[fileDependMap[i][j]].dependCnt--;
                    }
                    cppfile[i].visited = 1;
                    flag = 1;
                    cout<<cppfile[i].name<<endl;
                }
            }

            if(flag == 0 && errorFlag == 1) {
                cout<<"ERROR"<<endl<<endl;
                break;
            }

            else if(flag == 0 && errorFlag == 0) { //已经没有可改变的
                cout<<endl;
                break;
            }
        }

    }

    return 0; 
}

附上大牛代码：

#include <iostream>
#include <stdio.h>
#include <cstring>
#include <vector>
#include <cmath>
#include <algorithm>
#include <set>
#include <cassert>
#include <time.h>
#include <queue>
#include <map>
#include <stack>
#include <bitset>
#include <string>

using namespace std;

template<class T>
T m_max(T a, T b) { return a > b ? a : b; }

template<class T, class ... Ts>
T m_max(T a, Ts ... ts) {
    return max(a, m_max(ts...));
}

//=================================================================
const int maxn = 1000 + 5;
int n;
vector<int> G[maxn];
int inDegree[maxn];
map<string, int> id;
string cppName[maxn];

void input()
{
    //init
    memset(inDegree, 0, sizeof(inDegree));
    for (int i = 0; i < maxn; ++i) {
        G[i].clear();
    }
    id.clear();
    scanf("%d", &n);
    for (int u = 0; u < n; ++u) {
        cin >> cppName[u];
        id[cppName[u]] = u;
        int m;
        scanf("%d", &m);
        while (m--) {
            int v;
            scanf("%d", &v);
            G[v].push_back(u);
            ++inDegree[u];
        }
    }
}

struct QueNode
{
    int id;
    QueNode(int _id)
        : id(_id) { }
    friend bool operator < (const QueNode & n1, const QueNode & n2)
    {
        return cppName[n1.id] > cppName[n2.id];
    }
};


void solve()
{
    priority_queue<QueNode> que;
    for (int i = 0; i < n; ++i) if (!inDegree[i]) {
        que.push(QueNode(i));
    }

    vector<int> ans;
    while (!que.empty()) {
        int u = que.top().id; que.pop();
        ans.push_back(u);
        for (int i = 0; i < G[u].size(); ++i) {
            int v = G[u][i];
            if (--inDegree[v] == 0) que.push(QueNode(v));
        }
    }

    if (ans.size() != n) {
        puts("ERROR");
    } else {
        for (int i = 0; i < ans.size(); ++i) {
            printf("%s\n", cppName[ans[i]].c_str());
        }
    }
}

int main()
{
    int T; cin >> T;
    while (T--) {
        input();
        solve();
        puts("");
    }
}