题目
一个应用启动时,会有多个初始化任务需要执行,并且任务之间有依赖关系,例如A任务依赖B任务,那么必须在B任务执行完成之后,才能开始执行A任务。
现在给出多条任务依赖关系的规则,请输入任务的顺序执行序列,规则采用贪婪策略,即一个任务如果没有依赖的任务,则立刻开始执行,如果同时有多个任务要执行,则根据任务名称字母顺序排序。
例如:B任务依赖A任务,C任务依赖A任务,D任务依赖B任务和C任务,同时,D任务还依赖E任务。那么执行任务的顺序由先到后是:
A任务,E任务,B任务,C任务,D任务
这里A和E任务都是没有依赖的,立即执行。
题目输入
输入参数每个元素都表示任意两个任务之间的依赖关系,输入参数中符号"->"表示依赖方向,例如:
A->B:表示A依赖B
多个依赖之间用单个空格分隔
题目输出
输出排序后的启动任务列表,多个任务之间用单个空格分隔
实例
|----|-------------|
| 输入 | A->B C->B |
| 输出 | B A C |
| 说明 | 无 |
题目解析
题目
题目代码
cpp
//部分通过
#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
#include <set>
#include <map>
using namespace std;
int main() {
string s;
getline(cin, s);
vector<string> nums;
int pos = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == ' ') {
nums.push_back(s.substr(pos, i - pos));
pos = i + 1;
}
}
nums.push_back(s.substr(pos));
set<char> setEl;
for(auto num:nums){
setEl.insert(num[0]);//统计到底有哪些课程
setEl.insert(num[3]);
}
//记录每个课程的前置课程数量;例如a1的前置课程(b、c、d)有3个,前置课程数量为0,本门课程才可以学。{课程:前置课程}={a1:3}
map<char, int> frontNum;
//记录每门课程是哪些课程的前置课程;例如b是a1、a2、a3的前置课程,学完b才可以学a1、a2、a3。{课程:后置课程}={b:a1,a2,a3}
map<char, vector<char>> backGraph;
//赋值初始
for(auto se:setEl){
frontNum[se] = 0;
backGraph[se];
}
//遍历输入,统计依赖关系
for(auto num:nums){
frontNum[num[0]]++;
backGraph[num[3]].push_back(num[0]);
}
//初始化
//优先级队列 递增弹出
std::priority_queue<char, std::vector<char>, std::greater<char>> pq;
for(auto se:setEl){
if(frontNum[se] == 0){
pq.push(se);
}
}
vector<char> result;
while(!pq.empty()){
char ele= pq.top();
result.push_back(ele);
pq.pop();
for(auto az:backGraph[ele]){
frontNum[az]--;
if(frontNum[az] == 0){
pq.push(az);
}
}
}
for(auto ele:result){
cout << ele << " ";
}
cout << endl;
return 0;
}
cpp
//100%通过
#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;
int main() {
string s;
getline(cin, s);
vector<string> rules;
int pos = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == ' ') {
rules.push_back(s.substr(pos, i - pos));
pos = i + 1;
}
}
rules.push_back(s.substr(pos));
int n = rules.size();
vector<int> inDegree(26, 0);
vector<bool> vis(26, false);
vector<vector<int>> graph(26);
for (auto rule : rules) {
int a = rule[0] - 'A';
int b = rule[3] - 'A';
inDegree[a]++;
graph[b].push_back(a);
vis[a] = vis[b] = true;
}
queue<int> q;
vector<int> res;
vector<int> tmp;
for (int i = 0; i < 26; i++) {
if (inDegree[i] == 0 && vis[i]) {
q.push(i);
tmp.push_back(i);
}
}
while (!q.empty()) {
sort(tmp.begin(), tmp.end());
res.insert(res.end(), tmp.begin(), tmp.end());
tmp.clear();
for (int sz = q.size(); sz > 0; sz--) {
int task = q.front();
q.pop();
for (int nxt : graph[task]) {
inDegree[nxt]--;
if (inDegree[nxt] == 0) {
q.push(nxt);
tmp.push_back(nxt);
}
}
}
}
for (int x : res) {
char c = x + 'A';
cout << c << " ";
}
return 0;
}