图-拓扑排序

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());
    }

}