Problem:
Score : 500 points

Problem Statement

There is a rooted tree (see Notes) with N vertices numbered 1 to N.
Each of the vertices, except the root, has a directed edge coming from its parent.
Note that the root may not be Vertex 1.

Takahashi has added M new directed edges to this graph.
Each of these M edges, u \rightarrow v, extends from some vertex u to its descendant v.

You are given the directed graph with N vertices and N-1+M edges after Takahashi added edges.
More specifically, you are given N-1+M pairs of integers, (A_1, B_1), ..., (A_{N-1+M}, B_{N-1+M}), which represent that the i-th edge extends from Vertex A_i to Vertex B_i.

Restore the original rooted tree.

Notes

For "tree" and other related terms in graph theory, see the article in Wikipedia, for example.

Constraints

3 \leq N

1 \leq M

N + M \leq 10^5

1 \leq A_i, B_i \leq N

A_i \neq B_i

If i \neq j, (A_i, B_i) \neq (A_j, B_j).

The graph in input can be obtained by adding M edges satisfying the condition in the problem statement to a rooted tree with N vertices.

Input

Input is given from Standard Input in the following format:

N M
A_1 B_1
:
A_{N-1+M} B_{N-1+M}

Output

Print N lines.
In the i-th line, print 0 if Vertex i is the root of the original tree, and otherwise print the integer representing the parent of Vertex i in the original tree.

Note that it can be shown that the original tree is uniquely determined.

Sample Input 1

3 1
1 2
1 3
2 3

Sample Output 1

0
1
2

The graph in this input is shown below:

It can be seen that this graph is obtained by adding the edge 1 \rightarrow 3 to the rooted tree 1 \rightarrow 2 \rightarrow 3.

Sample Input 2

6 3
2 1
2 3
4 1
4 2
6 1
2 6
4 6
6 5

Sample Output 2

6
4
2
0
6
2

Solution in C# (Mono 4.6.2.0) (judge verdict: Time Limit Exceeded)

using System;
using System.Collections.Generic;
class Program
{
	static void Main(string[] args)
	{
		// 入力フェーズ
		string[] input = Console.ReadLine().Split(' ');
        int N = int.Parse(input[0]);
        int M = int.Parse(input[1]);

        // 辺の情報を取得して配列にする
        List<List<int> > saveGraph = new List<List<int> >();
				List<List<int> > parentGraph = new List<List<int> >();
				createGraph(N, M, ref saveGraph, ref parentGraph);// 保存用 最後に見る
				List<Tree> graph = copyGraph(saveGraph);

				// 各ノードを並び替えて順番をつける(葉ノードから番号を振る)
				int[] sortedNode = new int[N+1]; // [0]は使わない
				sortLeafToRoot(ref sortedNode, graph);

        // graphから出力用の表記を生成する
        int[] ret = output(sortedNode, parentGraph);
        
        //出力
        for (int i = 1; i <= N; i++)
        {
            Console.WriteLine(ret[i]);
        }
    }

		class Tree
		{
				public int nodeNo{set; get;}
				public List<int> children{set; get;}
		}

		static private List<Tree> copyGraph(List<List<int> > graph)
		{
			List<Tree> ret = new List<Tree>();
			for(int i=1; i<graph.Count; i++) // graph.Count = N+1
			{
				Tree t = new Tree();
				t.nodeNo = i;
				List<int> tt = new List<int>(graph[i]);
				t.children = tt;
				ret.Add(t);
			}

			return ret;
		}
		static private void sortLeafToRoot(ref int[] sortedNode, List<Tree> graph)
		{
			int cnt = 1;
			while(graph.Count > 0)
			{
					for(int i=0; i<graph.Count; i++)
					{
						//葉ノードだったらsotedNode[a(ノード番号)]に１から順番を振って番号を入れる
						if(graph[i].children.Count == 0)
						{
							int node = graph[i].nodeNo;
							sortedNode[node] = cnt++;
							graph.RemoveAt(i);

							// nodeを別の枝から削除する
							for(int j=0 ;j<graph.Count; j++)
							{
								if(graph[j].children.Contains(node))
								{
									graph[j].children.Remove(node);
								}
							}
						}
					}
			}
		}

    ///Ai→Biの表記から、各頂点と子供を管理するタイプの表記にする
    /// return List<int[]> ret
    /// ret[i] は i+1のノードから伸びている子供の番号を配列にして格納する
    static private void createGraph(int N, int M, ref List<List<int> > graph, ref List<List<int> > Pgraph)
    {
        // graphをN+1行にする
        for (int i = 0; i <= N; i++)
        {
            List<int> arr = new List<int>();
						List<int> arr2 = new List<int>();
            graph.Add(arr);
						Pgraph.Add(arr2);
        }

        for (int i = 0; i < N-1+M; i++)
        {
            string[] ab = Console.ReadLine().Split(' ');
            int a = int.Parse(ab[0]); // 親 1→1番目に格納する
            int b = int.Parse(ab[1]); // 子
            //Console.WriteLine(a + " " + b + " " + bars.GetLength(1));
            graph[a].Add(b);
						Pgraph[b].Add(a);
        }
    }

    /// graph表記から、出力できる形に変形する
    static private int[] output(int[] sortedNode, List<List<int>> graph)
    {
			// graph[i]にはiの親ノード番号が格納されている
        int N = graph.Count;
        int[] ret = new int[N];

        //Console.WriteLine(N);
        for (int i = 1; i <= N-1; i++)
        {
            //Console.WriteLine(i + " i" );
            List<int> parent = graph[i];
						// 親ノードのうち、sortedNodeを参照して一番小さい数字が格納されているものを親とする
						int[] minP = new int[]{0, sortedNode.Length};
            for (int j = 0; j < parent.Count; j++)
            {
                int parentNode = parent[j];
								int parentRank = sortedNode[parentNode];
                //Console.WriteLine(node + " node");
                if(minP[1] > parentRank)
								{
									minP[0] = parentNode;
									minP[1] = parentRank;
								}
            }
						ret[i] = minP[0];
        }
        return ret;
    }
}