1. 


/**
* Angewandte Mathematik, SS09, IFB 2C
* ACM Problem #10305 Ordering Tasks
* Link: http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&category=15&problem=1246&mosmsg=Submission+received+with+ID+7208958
*
* @author Andre Wolfram
* @author Christoph Miesel
* @author Robert Seilbeck
* @version 1.0, 06/24/2009
*
* Status : Accepted
* Runtime 0.116
*/

import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;

public class Main {

public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {

ArrayList<Task> allTasks = new ArrayList<Task>();
int tasks = sc.nextInt();
//Tasks anlegen
for (int i = 1; i <= tasks; i++) {
allTasks.add(new Task(i));
}
int tasksCounter = sc.nextInt();
//Input einlesen. Beziehungen anlegen
for (int i = 0; i < tasksCounter; i++) {
int nachfolgerNr = sc.nextInt();
Task nachfolger = allTasks.get(allTasks.indexOf(new Task(sc
.nextInt())));
nachfolger.addOneToVorgaenger();
allTasks.get(allTasks.indexOf(new Task(nachfolgerNr)))
.addNachfolger(nachfolger);
}

String result = "";
ArrayList<Task> modification = new ArrayList<Task>();
//Beziehungen auflösen
while (allTasks.size() > 1) {
for (int i = 0; i < allTasks.size(); i++) {
Task task = allTasks.get(i);
if (task.getAnzahlVorgaenger() == 0) {
for (Task nachfolgerTasks : task.getNachfolger()) {
modification.add(nachfolgerTasks);
}
result += task.toString() + " ";
allTasks.remove(task);
i--;
}
}
for (Task task : modification) {
task.subtractOneVorganeger();
}
modification.clear();

}
if (allTasks.size() > 0)
result += allTasks.get(0);

System.out.println(result);

}

}

/**
* Task object welches alle wichtigen Beziehungen speichert
*
*/
private static class Task {
private ArrayList<Task> nachfolger;
private int anzahlVorgaenger;
private int taskNr;

public Task(int taskNr) {
this.taskNr = taskNr;
nachfolger = new ArrayList<Task>();
}

public int getAnzahlVorgaenger() {
return anzahlVorgaenger;
}

public ArrayList<Task> getNachfolger() {
return nachfolger;
}

public void addOneToVorgaenger() {
anzahlVorgaenger++;
}

public void addNachfolger(Task task) {
nachfolger.add(task);
}

public void subtractOneVorganeger() {
anzahlVorgaenger--;
}

@Override
public boolean equals(Object obj) {
if (obj instanceof Task) {
if (((Task) obj).taskNr == taskNr) {
return true;
}
return false;
}
return super.equals(obj);
}

@Override
public int hashCode() {
return taskNr;
}

@Override
public String toString() {
return String.valueOf(taskNr);
}
}

}


2.

/* @Problem 10305 - Ordering Tasks
* @Autor Markus Stadler
* @Autor Johannes Müller
* @Version 22.06.2009
* bemerkung: viel kürzer als die c++ lösungen die ich gefunden hatte :p
*/

import java.io.BufferedWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Scanner;

class OrderingTasks {
public static void main (String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
Writer out = new BufferedWriter(new PrintWriter(System.out));
while(true){
int n = sc.nextInt(); //anzahl der zahlen
int m = sc.nextInt(); //anzahl der regeln
if(n == 0 && m == 0)
break;
int[][] calc = new int[m][2];
for(int i = 0; i < m; i++){ //regeln einlesen
calc[i][0] = sc.nextInt();
calc[i][1] = sc.nextInt();
sc.nextLine();
}
ArrayList<Integer> result = new ArrayList<Integer>();
for(int i = 1; i <= n; i++) //arraylist auffüllen
result.add(i);
for(int i = 0; i < m; i++){
if(result.indexOf(calc[i][0]) >= result.indexOf(calc[i][1])){ //regeln überprüfen und reihenfolge ändern
int first = result.indexOf(calc[i][0]);
int second = result.indexOf(calc[i][1]);
int tmp = result.set(first, result.get(second));
result.set(second, tmp);
i = 0; //nochmal von vorne
}
}
for(int i = 0; i < n; i++)
out.write(result.get(i)+" ");
out.write("\n");
}
out.close();
}
}
/*
12 10
1 3
3 8
3 4
8 12
4 7
7 11
7 10
3 2
4 5
12 9
output:
1 6 3 2 4 5 7 10 11 8 12 9 (oder anders^^)
*/