LeetCode - 1203. 项目管理

描述

公司共有 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] 不含重复元素

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/sort-items-by-groups-respecting-dependencies/
 

求解（自己没做出来，该求解参考官方题解https://leetcode-cn.com/problems/sort-items-by-groups-respecting-dependencies/solution/xiang-mu-guan-li-by-leetcode-solution-3e7j/）

    class Solution {
    public:
        // 两次拓扑排序
        vector<int> sortItems(int n, int m, vector<int> &group, vector<vector<int>> &beforeItems) {
            // 组的顶点入度和图
            vector<int> groupInDegree(n + m, 0); // 记录顶点的入度
            vector<vector<int>> groupGraph(n + m, vector<int>()); // 图，邻接表存储

            // 点的顶点入度和图
            vector<int> itemInDegree(n + m, 0); // 记录顶点的入度
            vector<vector<int>> itemGraph(n + m, vector<int>()); // 图，邻接表存储

            // 数据预处理，给不属于任何项目组的项目编一个唯一号
            std::unordered_map<int, vector<int>> groupItemsMap; // 每个项目组下面的项目集合
            int groupId = m;
            for (int i = 0; i < n; ++i) {
                if (group[i] == -1) {
                    // 给不属于任何项目组的项目编一个唯一号
                    group[i] = groupId++;
                }
                groupItemsMap[group[i]].emplace_back(i);
            }

            // 项目组，项目组内项目图数据构造
            for (int i = 0; i < n; ++i) {
                int curGroupId = group[i];
                for (auto item : beforeItems[i]) {
                    int beforeGroupId = group[item];
                    if (curGroupId == beforeGroupId) {
                        // 前驱项目和当前项目是属于同一项目组，则不进行组的图数据构造，否则可能形成环
                        // 进行同组内的项目图数据构造，注意，一定要是同组内的项目才进行图数据构造
                        itemGraph[item].emplace_back(i);
                        ++itemInDegree[i];
                    } else {
                        // 前驱项目和当前项目不属于同一个项目组
                        groupGraph[beforeGroupId].emplace_back(curGroupId);
                        ++groupInDegree[curGroupId];
                    }
                }
            }

            // 对项目组进行拓扑排序
            vector<int> id;
            for (int i = 0; i < n + m; ++i) {
                id.emplace_back(i);
            }
            auto groupSortRes = topSort(groupGraph, groupInDegree, id);
            if (groupInDegree.empty()) {
                return vector<int>();
            }

            // 按照项目组的拓扑排序，对每个项目组内的所有项目进行拓扑排序
            vector<int> res;
            for (auto g : groupSortRes) {
                // 项目组内无项目，不进行排序
                if (groupItemsMap[g].empty()) {
                    continue;
                }

                auto itemSortRes = topSort(itemGraph, itemInDegree, groupItemsMap[g]);
                if (itemSortRes.empty()) {
                    // 项目组内无项目，不进行排序
                    return vector<int>();
                }
                // 调用区间成员函数将项目组内项目拓扑排序结果插入最终结果
                res.insert(res.end(), itemSortRes.cbegin(), itemSortRes.cend());
            }
            return res;
        }

    private:
        /*!
*
* @param graph 图，邻接表
* @param inDegree 顶点入度
* @param items 待排序顶点
* @return  拓扑排序结果
*/
        vector<int>
        topSort(const vector<vector<int>> &graph, vector<int> &inDegree, const vector<int> &items) {
            // 找出入度为0的点开始遍历
            std::stack<int> s;
            for (auto i : items) {
                if (inDegree[i] == 0) {
                    s.push(i); // 顶点入度为0，入栈
                }
            }

            // 拓扑排序
            vector<int> res;
            while (!s.empty()) {
                int v = s.top();
                res.emplace_back(v); // 保存拓扑排序结果
                s.pop();
                for (auto w  : graph[v]) {
                    if (--inDegree[w] == 0) {
                        s.push(w);
                    }
                }
            }

            // 满足拓扑排序返回排序结果，否则返回空数组
            return res.size() == items.size() ? res : vector<int>();
        }
    };