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

一、题目

时间限制: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("");
}
}