JAVA程序设计：项目管理（LeetCode：1203）

公司共有 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]

思路：一道噩梦题，先上图：

简直崩溃啊，现在说思路吧，这题要用到拓扑排序，这也是我一开始就想到的，大致思路是先对群组进行拓扑，之后再对各组分别拓扑，这个思路是没错的，让我怀疑人生的是数据有点刁难人，疯狂卡时间，于是我只好进行反映射，其实就是反过来存储映射信息，这样能够避免我们遍历很多无用的点，采用该方法耗时很低的！我看大多数人是卡时间过的，我只用了82ms。

class Solution {
    public int[] sortItems(int n, int m, int[] group, List<List<Integer>> beforeItems) {
        
    	int len=0;
    	int[] ans=new int[n];
    	int[] nums=new int[n*2];
    	int[] ingree1=new int[n*2];
    	int[] ingree2=new int[n*2];
    	boolean[] flag=new boolean[n*2];
    	boolean[] mark=new boolean[n*2];
    	Queue<Integer> q=new LinkedList<>();
    	List<Integer> list=new ArrayList<>();
    	Map<Integer,List<Integer>> map=new HashMap<>();
    	Map<Integer,List<Integer>> map1=new HashMap<>();
    	Map<Integer,List<Integer>> map2=new HashMap<>();
    	
    	int num=m,sum=0;	
    	for(int i=0;i<n;i++)
    		if(group[i]==-1)
    			group[i]=num++;
    	
    	for(int i=0;i<n;i++) {
			nums[group[i]]++;
			if(!map1.containsKey(group[i])) {
				sum++;
				map1.put(group[i], new ArrayList<>());
			}
			map1.get(group[i]).add(i);
			map2.put(i, new ArrayList<>());
    	}
    	
    	for(int i=0;i<num;i++)
    		map.put(i, new ArrayList<>());
    	
    	for(int i=0;i<beforeItems.size();i++)
    		for(int j=0;j<beforeItems.get(i).size();j++) {
    			int index=beforeItems.get(i).get(j);
    			if(group[i]==group[index]) {
    				ingree2[i]++;
    				map2.get(index).add(i);
    			}
    			else {
    				if(!map.get(group[index]).contains(group[i])) {
    					ingree1[group[i]]++;
    					map.get(group[index]).add(group[i]);
    				}
    			}
    		}
    	
    	for(int i=0;i<num;i++) {
    		if(flag[i] || !map1.containsKey(i)) continue;
    		if(ingree1[i]==0) {
    			q.add(i);
    			flag[i]=true;
    		}
    	}
    	
    	while(!q.isEmpty()) {
    		int now=q.poll();
    		list.add(now);
    		for(int i=0;i<map.get(now).size();i++) {
    			int index=map.get(now).get(i);
    			if(flag[index]) continue;
    			ingree1[index]--;
    			if(ingree1[index]==0) {
    				flag[index]=true;
    				q.add(index);
    			}
    		}
    	}
    	
    	if(list.size()<sum) return new int[0];
    	
    	for(int j=0;j<list.size();j++) {
    		int now=list.get(j);
    		for(int i=0;i<map1.get(now).size();i++) {
    			int index=map1.get(now).get(i);
    			if(ingree2[index]==0) {
    				q.add(index);
    				mark[index]=true;
    				nums[now]--;
    			}
    		}
    		while(!q.isEmpty()) {
    			int top=q.poll();
    			ans[len++]=top;
    			if(len==n) return ans;
    			if(nums[group[top]]==0) continue;
    			if(!map2.containsKey(top)) continue;
    			for(int i=0;i<map2.get(top).size();i++)  {
    				int index=map2.get(top).get(i);
    				if(mark[index]) continue;
					ingree2[index]--;
					if(ingree2[index]==0) {
						q.add(index);
						mark[index]=true;
						nums[group[top]]--;
					}
    			}
    		}
    		if(nums[now]>0) return new int[0];
    	}
    	return new int[0];
    }
}