LeetCode 1203 项目管理 HERODING的LeetCode之路

公司共有 n 个项目和 m 个小组，每个项目要不无人接手，要不就由 m 个小组之一负责。

group[i] 表示第 i 个项目所属的小组，如果这个项目目前无人接手，那么 group[i] 就等于 -1。（项目和小组都是从零开始编号的）小组可能存在没有接手任何项目的情况。

请你帮忙按要求安排这些项目的进度，并返回排序后的项目列表：

同一小组的项目，排序后在列表中彼此相邻。
项目之间存在一定的依赖关系，我们用一个列表 beforeItems 来表示，其中 beforeItems[i] 表示在进行第 i 个项目前（位于第 i 个项目左侧）应该完成的所有项目。

如果存在多个解决方案，只需要返回其中任意一个即可。如果没有合适的解决方案，就请返回一个 空列表 。

示例 1：

输入：n = 8, m = 2, group = [-1,-1,1,0,0,1,0,-1], beforeItems = [[],[6],[5],[6],[3,6],[],[],[]]
输出：[6,3,4,1,5,2,0,7]

示例 2：

输入：n = 8, m = 2, group = [-1,-1,1,0,0,1,0,-1], beforeItems = [[],[6],[5],[6],[3],[],[4],[]]
输出：[]
解释：与示例 1 大致相同，但是在排序后的列表中，4 必须放在 6 的前面。

提示：

1 <= m <= n <= 3 * 104
group.length == beforeItems.length == n
-1 <= group[i] <= m - 1
0 <= beforeItems[i].length <= n - 1
0 <= beforeItems[i][j] <= n - 1
i != beforeItems[i][j]
beforeItems[i] 不含重复元素

解题思路：
构造小组的依赖关系和组内项目的依赖关系。
判断小组间是否有冲突，没冲突计算出小组的拓扑排序。
判断每个小组内项目是否有冲突，没冲突计算出小组内项目的拓扑排序
这是参考一位大佬的做法，老实说这道题目真的很有难度，不认真钻研也是不行的，代码如下：

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);
        vector<int> itemIndegree(n,0);
        vector<set<int>> itemGraph(n);
        queue<int> qu;
        
        for(int i = 0;i < group.size(); ++i){
    
    
            groupItem[group[i]].insert(i);
        }
        for(int i = 0;i < beforeItems.size(); ++i){
    
    
            for(auto it : beforeItems[i]){
    
    
                if(group[i] == group[it]){
    
    
                    itemIndegree[i]++;
                    itemGraph[it].insert(i);
                }else{
    
    
                    if(!groupGraph[group[it]].count(group[i])){
    
    
                        groupIndegree[group[i]]++;
                        groupGraph[group[it]].insert(group[i]);
                    }
                }
            }
        }
        
        /*top sort*/
        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);
                }
            }
        }
        
        if(ans.size() != maxGroup){
    
    
            return vector<int>();
        }
        
        /*top sort*/
        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);
                    }
                }
            }
            
            if(count != groupItem[ans[i]].size()){
    
    
                return vector<int>();
            }
            
        }
        
        return res;
    }
};