LeetCode 1203. Sort Items by Groups Respecting Dependencies

知识点

拓扑排序

结果

菜鸡代码

网友代码

代码

菜鸡代码

//如果有多个答案，则返回任意一个即可？
//一个组可以没有成员
//一个成员可以不属于任何一组
//组和成员从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; 
    }
};

反思

1. 网友对没有小组的item重新分配了小组；
2. 虽然菜鸡我意识到了要进行 两层的拓扑排序，但是却没有贯彻到底，像网友那样，为我们的group也增加后继数组和入度，说明我思考的境界还是不高，数据结构的设计掌握不好！
3. 像网友这种先对group进行拓扑排序，然后判断其是否为DAG，再对每个组内又进行拓扑排序的方法，比我一次拓扑排序要来的清晰很多；
4. 学会了使用auto关键字，只是学到皮毛。。。