package Week2;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.StringTokenizer;

//6 5
//1
//2
//2
//3
//3
//4
//1 2
//1 3
 
//2 4
//3 4
//5 6
//題意：   給出一個有向無環圖，每個頂點都有一個權值。 
//求一條從入度為0的頂點到出度為0的頂點的一條路徑， 
//路徑上所有頂點權值和最大。
public class F_Topological {
   static int inDegree[];
   static int outDegree[];
   static int N,M;
   static long maxCost = Integer.MIN_VALUE;
   static int dis[];//每個頂點的權值
   static int dp[];
   static List<NodeF> adjList[] = null
 
;
   public static void main(String[] args) throws Exception{
       System.setIn(new FileInputStream("Solution.txt"));
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        while(br.ready()) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            N 
 
= Integer.parseInt(st.nextToken());
            M = Integer.parseInt(st.nextToken());
            adjList = new ArrayList[N+1];
            inDegree = new int[N+1];
            outDegree = new int[N+1];
            dis = new int[N+1];
            dp = new int[N+1];
            Arrays.fill(dp, Integer.MIN_VALUE);
            Queue<NodeF> pq = new LinkedList<NodeF>();
            maxCost = Integer.MIN_VALUE;
            pq.clear();
            for (int i = 1; i <= N; i++) {
                adjList[i]=new ArrayList<NodeF>();
            }
            for (int i = 1; i <= N; i++) {
                st = new StringTokenizer(br.readLine());
                dis[i]=Integer.parseInt(st.nextToken());
            }
            for (int i = 1; i <= M; i++) {
                st = new StringTokenizer(br.readLine());
                int s = Integer.parseInt(st.nextToken());
                int e = Integer.parseInt(st.nextToken());
                int cost = dis[e];
                adjList[s].add(new NodeF(e,cost));
                outDegree[s]++;
                inDegree[e]++;
            }
            for (int i = 1; i <= N; i++) {
                if(inDegree[i]==0) {
                    pq.add(new NodeF(i,dis[i]));
                    dp[i]=dis[i];
                }
            }
            while(!pq.isEmpty()) {
                NodeF node = pq.poll();
                
                for (int j = 0; j < adjList[node.e].size(); j++) {
                    NodeF next = adjList[node.e].get(j);
                    if(inDegree[next.e] == 0) {
                        continue;
                    }
                    if(dp[node.e] + next.cost > dp[next.e]) {
                        dp[next.e] = dp[node.e]+next.cost;
                    }
                    if(--inDegree[next.e] == 0) {
                        pq.add(next);
                    }
                }
            }
            for (int i = 1; i <= N; i++) {
                if(outDegree[i] == 0) {
                    maxCost = Math.max(maxCost, dp[i]);
                }
            }
            System.out.println(maxCost);
        }
   }
}

class NodeF{
    int e,cost;
    public NodeF(int e,int cost) {
        this.e=e;
        this.cost=cost;
    }
}

package Week2;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.StringTokenizer;

/*火星人的血緣關係體系已經夠混亂的了。事實上，火星人在他們想要的時間和地點發芽。他們以不同的群體聚集在一起，
這樣一個火星人既可以有十個父母，也可以有一個父母。
沒有人會對一百個孩子感到驚訝。火星人已經習慣了這一點，他們的生活方式似乎很自然。
在行星理事會中，混亂的系譜系統導致了一些尷尬。在那裡會遇到最有價值的火星人，因此，為了在所有的討論中不冒犯任何人，
它首先被用來讓老火星人發言，而不是年輕火星人，並且只讓最年輕的無子女評估員發言。然而，維持這一秩序確實不是一項微不足道的任務。
火星人並不總是認識他所有的父母（關於他的祖父母也沒什麼好說的！）。但如果由於一個錯誤第一次說出一個孫子，而只是比他年輕的曾祖父，這是一個真正的醜聞。
你的任務是編寫一個程式，該程式將一勞永逸地定義一個命令，該命令將保證委員會的每一位成員都比其後代更早發言。 
輸入
標準輸入的第一行只包含一個數字N，1<=N<=100——火星行星理事會的一些成員。根據數百年的傳統，理事會成員按從1到N的自然數進行計數。此外，正好有N行，
而且，第I行包含第I個成員的子級的列表。子項列表是子項序列號的序列，按任意順序用空格分隔。子項列表可能為空。列表（即使為空）以0結尾。
輸出
標準輸出應在其唯一一行中包含一系列揚聲器編號，並用空格分隔。如果多個序列滿足問題的條件，則要將其中任何一個序列寫入標準輸出。至少存在一個這樣的序列。*/
public class G_Topological {
    static int N;
    static int degree[];    
    static List<Integer> adjList[];
    public static void main(String[] args) throws Exception{
        System.setIn(new FileInputStream("Solution.txt"));
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        N = Integer.parseInt(br.readLine());
        StringTokenizer st = null;
        adjList = new ArrayList[N+1];
        degree = new int[N+1];
        Queue<Integer> pq = new LinkedList<Integer>();
        for (int i = 1; i <= N; i++) {
            adjList[i]=new ArrayList<Integer>();
        }
        for (int i = 1; i <= N; i++) {
            String str = br.readLine();
            st = new StringTokenizer(str);
            while(st.hasMoreTokens()) {
                int temp = Integer.parseInt(st.nextToken());
                if(temp!= 0) {
                    adjList[i].add(temp);
                    degree[temp]++;
                }
            }
            
        }
        for (int i = 1; i <= N; i++) {
            if(degree[i]==0) {
                pq.add(i);
            }
        }
        StringBuilder ss = new StringBuilder();
        while(!pq.isEmpty()) {
            int n = pq.poll();
            ss.append(n+" ");
            for (int i = 0; i < adjList[n].size(); i++) {
                int next = adjList[n].get(i);
                if(--degree[next] == 0) {
                    pq.add(next);
                }
            }
        }
        System.out.println(ss.toString());
    }

}