https://leetcode-cn.com/problems/sort-items-by-groups-respecting-dependencies/
公司共有 n 个项目和 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*10^4
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]
解答：
这道题，一个思路，先按照组排序(同一小组的项目，排序后在列表中彼此相邻)，再把组内的数据排序。
所以我们不能不把那些没有组的数据，创建组，并且存放起来
然后再判断哪些组需要在哪些组之前
代码：
public int[] sortItems(int n, int m, int[] group, List<List<Integer>> beforeItems) {
//每个组有哪些项目
Map<Integer, List<Integer>> map = new HashMap<>();
for (int i = 0; i < group.length; i++) {
if (group[i] == -1) {
//如果原本不属于某个组，先假装有个组，就自己
group[i] = m++;
}
List<Integer> lis = map.get(group[i]);
if (lis == null) {
lis = new ArrayList<>();
map.put(group[i], lis);
}
lis.add(i);
}
//用于存储各个组的关联
Set<Integer>[] beforeGroup = new Set[m];
//是否组内需要排序，如果需要，就记录一下
boolean[] containsSelf = new boolean[m];
for (int i = 0; i < n; i++) {
int gro = group[i];
if (beforeGroup[gro] == null) {
beforeGroup[gro] = new HashSet<>();
}
List<Integer> befores = beforeItems.get(i);
for (Integer before : befores) {
if (group[before] != gro) {
//将组与组的前后关系确定起来
beforeGroup[gro].add(group[before]);
} else {
//组内需要排序
containsSelf[gro] = true;
}
}
}
//该数组用于存储组的顺序
int[] groupAns = new int[m];
//哪些组已经排好序了
Set<Integer> usedGroup = new HashSet<>();
int key = 0;
int oldKey = 0;
while (usedGroup.size() < m) {
for (int i = 0; i < m; i++) {
if (usedGroup.contains(i)) {
//这一组已经排序了
continue;
}
//如果我没有提前要完成的组或者提前要完成组都已经完成，我就可以加入排序
if (beforeGroup[i] == null || usedGroup.containsAll(beforeGroup[i])) {
groupAns[key++] = i;
//我组已经被完成，记录一下
usedGroup.add(i);
}
}
if (key == oldKey) {
//一次排序没有新的值，说明出现了循环，直接返回异常数据
return new int[0];
} else {
oldKey = key;
}
}
int[] ans = new int[n];
key = 0;
//清理beforeItems,不是本组的，都移除，后面要用到beforeItems，减少判断数据
for (int i = 0; i < n; i++) {
List<Integer> lis = beforeItems.get(i);
Iterator<Integer> it = lis.iterator();
while (it.hasNext()) {
int v = it.next();
if (group[v] != group[i]) {
it.remove();
}
}
}
for (int i = 0; i < m; i++) {
int gro = groupAns[i];
List<Integer> lis = map.get(gro);
//这个组没有项目
if (lis == null) {
continue;
}
//这个组就一个项目，不需要排序
if (lis.size() == 1) {
ans[key++] = lis.get(0);
continue;
}
//这个组内的项目没有前后顺序要求，直接排序
if (!containsSelf[gro]) {
for (Integer li : lis) {
ans[key++] = li;
}
} else {
//和排组顺序类似
Set<Integer> used = new HashSet<>();
while (used.size() < lis.size()) {
oldKey = key;
for (Integer li : lis) {
//我已经被排过了
if (used.contains(li)) {
continue;
}
List<Integer> before = beforeItems.get(li);
if (before.size() == 0 || used.containsAll(before)) {
ans[key++] = li;
used.add(li);
}
}
if (oldKey == key) {
return new int[0];
}
}
}
}
return ans;
}
