hihocoder 1175 : 拓撲排序·二

時間限制:10000ms

單點時限:1000ms

內存限制:256MB

描述

小Hi和小Ho所在學校的校園網被黑客入侵併投放了病毒。這事在校內BBS上立刻引起了大家的討論，當然小Hi和小Ho也參與到了其中。從大家各自了解的情況中，小Hi和小Ho整理得到了以下的信息：

• 校園網主幹是由N個節點(編號1..N)組成，這些節點之間有一些單向的網路連接。若存在一條網路連接(u,v)鏈接了節點u和節點v，則節點u可以向節點v發送信息，但是節點v不能通過該鏈接向節點u發送信息。
• 在剛感染病毒時，校園網立刻切斷了一些網絡鏈接，恰好使得剩下網絡連接不存在環，避免了節點被反覆感染。也就是說從節點i擴散出的病毒，一定不會再回到節點i。
• 當1個病毒感染了節點後，它並不會檢查這個節點是否被感染，而是直接將自身的拷貝向所有鄰居節點發送，它自身則會留在當前節點。所以一個節點有可能存在多個病毒。
• 現在已經知道黑客在一開始在K個節點上分別投放了一個病毒。

舉個例子，假設切斷部分網絡連接後學校網絡如下圖所示，由4個節點和4條鏈接構成。最開始只有節點1上有病毒。

最開始節點1向節點2和節點3傳送了病毒，自身留有1個病毒：

其中一個病毒到達節點2後，向節點3傳送了一個病毒。另一個到達節點3的病毒向節點4發送自己的拷貝：

當從節點2傳送到節點3的病毒到達之後，該病毒又發送了一份自己的拷貝向節點4。此時節點3上留有2個病毒：

最後每個節點上的病毒爲：

小Hi和小Ho根據目前的情況發現一段時間之後，所有的節點病毒數量一定不會再發生變化。那麼對於整個網絡來說，最後會有多少個病毒呢？

提示：拓撲排序的應用

輸入

第1行：3個整數N,M,K，1≤K≤N≤100,000，1≤M≤500,000

第2行：K個整數A[i]，A[i]表示黑客在節點A[i]上放了1個病毒。1≤A[i]≤N

第3..M+2行：每行2個整數 u,v，表示存在一條從節點u到節點v的網絡鏈接。數據保證爲無環圖。1≤u,v≤N

輸出

第1行：1個整數，表示最後整個網絡的病毒數量 MOD 142857

樣例輸入

4 4 1
1
1 2
1 3
2 3
3 4

超時代碼：

import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Main2 {
	//超時代碼
	public static final int MOD=142857;
	public static void main(String[] args) {
		Scanner scan=new Scanner(System.in);
		int verNum=scan.nextInt();
		int[] nodes=new int[verNum+1];
		for(int i=1;i<=verNum;i++) nodes[i]=0;
		int count=scan.nextInt();
		HashMap<Integer,HashSet<Integer>> from=new HashMap<Integer,HashSet<Integer>>();
		HashMap<Integer,HashSet<Integer>> to=new HashMap<Integer,HashSet<Integer>>();
		for(int i=1;i<=verNum;i++){
			from.put(i,new HashSet<Integer>());
			to.put(i,new HashSet<Integer>());
		}
		int virNum=scan.nextInt();
		for(int i=0;i<virNum;i++) nodes[scan.nextInt()]++;
		for(int i=1;i<=count;i++){
			int x=scan.nextInt();
			int y=scan.nextInt();
			from.get(y).add(x);
			to.get(x).add(y);
		}
		solve(from,to,nodes);
		int re=0;
		for(int i=1;i<=verNum;i++){
			re+=nodes[i];
			re%=MOD;
		} 
//		for(int i=1;i<nodes.length;i++) System.out.println(nodes[i]);
		System.out.println(re);
	}
	private static void solve(HashMap<Integer, HashSet<Integer>> from,HashMap<Integer, HashSet<Integer>> to,int[] nodes) {
		int[] queue=new int[100000+100];
		int tail=0,head=0;
		for(Integer node:from.keySet()){
			if(from.get(node).isEmpty()) queue[tail++]=node;
		}
		while(tail!=head){
			Integer node=queue[head++];
			for(Integer n:to.get(node)){
				nodes[n]=(nodes[n]+nodes[node])%MOD;
				from.get(n).remove(node);
				if(from.get(n).isEmpty()) queue[tail++]=n;
			}
		}
	}
}

超時分析：運用大量java自帶容器，因爲數據量非常大，儘量不要用HashMap，Queue等java自帶容器。

AC代碼：

import java.util.HashSet;
import java.util.Scanner;


public class Main {
	public static final int MOD=142857;
	public static int topSort(HashSet<Integer>[] map,int[] indegree,int[] val){
		int[] queue=new int[100000+100];
		int head=0,tail=0;
		for(int i=1;i<indegree.length;i++){
			if(indegree[i]==0) queue[tail++]=i;
 		}
		while(head!=tail){
			Integer a=queue[head++];
			if(val[a]!=0){
				for(Integer key:map[a]) val[key]=(val[key]+val[a])%MOD;
			}
			for(Integer key:map[a]){
				indegree[key]--;
				if(indegree[key]==0) queue[tail++]=key;
			}
		}
		int re=0;
		for(int i=1;i<val.length;i++){
			re+=val[i];re%=MOD;
		}
		return re;
	}
	
	public static void main(String[] args) {
		Scanner scan=new Scanner(System.in);
		int verNum=scan.nextInt();
		int[] indegree=new int[verNum+1];
		HashSet<Integer>[] map=new HashSet[verNum+1];
		for(int i=0;i<map.length;i++) map[i]=new HashSet<Integer>();
		int[] val=new int[verNum+1];
		int num=scan.nextInt();
		int virNum=scan.nextInt();
		for(int i=0;i<virNum;i++){
			val[scan.nextInt()]++;
		}
		for(int i=0;i<num;i++){
			int x=scan.nextInt();
			int y=scan.nextInt();
			map[x].add(y);
			indegree[y]++;
		}
		System.out.println(topSort(map, indegree, val));
	}
}