知识点
拓扑排序
结果
菜鸡代码
网友代码
代码
菜鸡代码
//如果有多个答案,则返回任意一个即可?
//一个组可以没有成员
//一个成员可以不属于任何一组
//组和成员从0开始标号
//没有组的-1,不算一组!!!需要重新赋予组
//后继使用set会更好?因为重复的原因?其实没啥关系
class Solution {
private:
//后继集合数组
vector<vector<int>> adj;
//入度数组
vector<int> inDegree;
//组员数组
vector<vector<int>> groupList;
//记录某个组是否被访问
vector<bool> flag;
public:
vector<int> sortItems(int n, int m, vector<int>& group, vector<vector<int>>& beforeItems) {
//初始化长度
adj.assign(n,vector<int>());
inDegree.assign(n,0);
groupList.assign(m,vector<int>());
flag.assign(m,false);
//对组员进行归组
for(int i=0;i<n;i++){
if(group[i] != -1){
groupList[group[i]].push_back(i);
}
}
//遍历beforeItems生成后继集合adj数组,以及更新InDegree
for(int i=0;i<beforeItems.size();i++){
printf("i :%d\n",i);
for(int j=0;j<beforeItems[i].size();j++){
int groupBefore = group[beforeItems[i][j]];
int groupAfter = group[i];
if(groupBefore == -1){ //特判为-1的情况
adj[beforeItems[i][j]].push_back(i);
inDegree[i]++;
}else{
if(groupBefore != groupAfter){ //如果不在同一个组
for(int k=0;k<groupList[groupBefore].size();k++){
if(groupAfter == -1){
adj[groupList[groupBefore][k]].push_back(i);
inDegree[i]++;
printf("%d",groupList[groupBefore][k]);
}else{
for(int l=0;l<groupList[groupAfter].size();l++){
adj[groupList[groupBefore][k]].push_back(groupList[groupAfter][l]);
inDegree[groupList[groupAfter][l]]++;
}
}
}
}else{ //在同一个组
adj[beforeItems[i][j]].push_back(i);
inDegree[i]++;
printf("i,j:%d %d\n",i,beforeItems[i][j]);
}
}
}
}
for(int i=0;i<n;i++){
for(int j=0;j<adj[i].size();j++){
printf("%d ",adj[i][j]);
}
printf("\n");
}
//进行拓扑排序,判断是否是有向无环图
vector<int> list;
list = topoSort(n,group);
return list;
}
vector<int> topoSort(int n, vector<int>& group){
vector<int> list;
//初始化
int cnt = 0;
queue<int> q;
for(int i=0;i<n;i++){
if(inDegree[i] == 0){ //入度为0,则放进去,并且记录它们所在的组
q.push(i);
}
}
int before;
int after;
while(!q.empty()){
before = q.front();
q.pop(); //弹出来
printf("before: %d\n",before);
//对小组内部进行拓扑排序输出
if(group[before] != -1 && flag[group[before]] == false){ //如果属于某一个小组,那么小组成员内部进行拓扑,此时应该只有内部关系了
queue<int> inner;
for(int i=0;i<groupList[group[before]].size();i++){
if(inDegree[groupList[group[before]][i]] == 0){
inner.push(groupList[group[before]][i]);
}
}
while(!inner.empty()){
int a = inner.front();
inner.pop();
list.push_back(a);
cnt++;
for(int i=0;i<adj[a].size();i++){
after = adj[a][i];
inDegree[after]--;
if(inDegree[after] == 0){ //减到0就放进去
if(group[after] != group[before]){ //如果不是内部的
q.push(after);
}else{
inner.push(after);
}
}
}
}
flag[group[before]] = true;
}else if(group[before] == -1 || flag[group[before]] == false){
list.push_back(before); //放进去
cnt++;
for(int i=0;i<adj[before].size();i++){
after = adj[before][i];
inDegree[after]--;
if(inDegree[after] == 0){ //减到0就放进去
q.push(after);
}
}
}
}
for(int i=0;i<list.size();i++){
printf("%d ",list[i]);
}
if(cnt != n){
list.clear();
}
return list;
}
};
网友代码
class Solution {
public:
vector<int> sortItems(int n, int m, vector<int>& group, vector<vector<int>>& beforeItems) {
int maxGroup = m;
for(int i=0;i<group.size();++i){
if(group[i] == -1){
group[i] = maxGroup++;
}
}
//用于存储每个组里面有哪些元素
vector<set<int>> groupItem(maxGroup);
//用于存储每个组的入度
vector<int> groupIndegree(maxGroup,0);
//用于存储组的后继
vector<set<int>> groupGraph(maxGroup);
//用于存储每个Item在组内的入度
vector<int> itemIndegree(n,0);
//用于存储每个Item的后继
vector<set<int>> itemGraph(n);
//group队列,用于拓扑排序
queue<int> qu;
//存储数据到组内
for(int i=0;i<n;i++){
groupItem[group[i]].insert(i); //set是使用insert添加元素的
}
//生成组的后继数组和item的后继数组
//规则是判断两者是否在同一个组
for(int i=0;i<n;i++){
//使用auto!!!需要学习一下
for(auto it : beforeItems[i]){
if(group[i] == group[it]){
//两个在同一个组,那么就修改Item后继
itemIndegree[i]++;
itemGraph[it].insert(i);
}else{
//两个不在同一个组,那么就修改Group后继
if(!groupGraph[group[it]].count(group[i])){ //检查是否已经添加
groupIndegree[group[i]]++;
groupGraph[group[it]].insert(group[i]);
}
}
}
}
//top sort_01,首先是对group进行一次拓扑排序
vector<int> ans;
for(int i=0;i<maxGroup;++i){
if(groupIndegree[i] == 0){
qu.push(i);
}
}
while(!qu.empty()){
int curr = qu.front();
qu.pop();
ans.push_back(curr);
for(auto neg:groupGraph[curr]){
groupIndegree[neg]--;
if(groupIndegree[neg] == 0){
qu.push(neg);
}
}
}
//第一次判断是否为DAG
if(ans.size() != maxGroup){
return vector<int>();
}
//topo sort_02,对组内元素进行拓扑排序
vector<int> res;
for(int i=0;i<ans.size();++i){
for(auto it:groupItem[ans[i]]){
if(itemIndegree[it] == 0){
qu.push(it);
}
}
int count = 0;
while(!qu.empty()){
int curr = qu.front();
count++;
qu.pop();
res.push_back(curr);
for(auto neg:itemGraph[curr]){
itemIndegree[neg]--;
if(itemIndegree[neg] == 0){
qu.push(neg);
}
}
}
//判断是否为DAG
if(count != groupItem[ans[i]].size()){
return vector<int>();
}
}
return res;
}
};
反思
- 网友对没有小组的
item
重新分配了小组; - 虽然菜鸡我意识到了要进行 两层的拓扑排序,但是却没有贯彻到底,像网友那样,为我们的
group
也增加后继数组
和入度
,说明我思考的境界还是不高,数据结构的设计掌握不好! - 像网友这种先对
group
进行拓扑排序,然后判断其是否为DAG,再对每个组内又进行拓扑排序的方法,比我一次拓扑排序要来的清晰很多; - 学会了使用
auto
关键字,只是学到皮毛。。。