Problem:
最悪の記者
問題
あなたは JOI 新聞社の記者であり，スポーツ記事を担当している．
昨日までに，クロアチアでは，n 個のサッカーチームによる総当りのリーグ戦が行われた．大会実行委員会は，試合結果と規定に基づき各チームに 1 位から n 位までの順位をつけたようである．あなたには，一部の試合の勝敗とともに，次の情報が伝えられた．
情報 1
引き分けの試合はなかった．
情報 2
全てのチームに異なる順位がついた．
情報 3
全ての 1 ≤ a < b ≤ n に対し，a 位のチームと b 位のチームの試合において，必ず a 位のチームが勝利した．
あなたは記事を作成するために，一部の試合の勝敗と，伝えられた情報 1 3 をもとに，順位表を推測することにした．
入力として一部の試合の勝敗が与えられたとき，伝えられた情報に適合する順位表を 1 つ出力するプログラムを作れ．また，出力した順位表以外に，伝えられた情報に適合する順位表が存在するかどうかも判定せよ．
ここで，順位表とは 1 位から n 位の順にチームを並べたもののことをいう．
例
例1 (情報に適合する順位表が 1 つしかない場合)
チーム数が4で，各チームに1から4までの番号が付けられており，勝敗が次の表で与えられていたとする．
i 行 j 列が○のときは，番号 i のチームと番号 j のチームの試合において，番号 i のチームが勝利したことを意味する．また，×のときは，番号 j のチームが勝利したことを意味する．? は勝敗が与えられていないことを意味する．このとき，伝えられた情報に適合する順位表は次の 1 つしかない
1 位 番号 3 のチーム
2 位 番号 4 のチーム
3 位 番号 1 のチーム
4 位 番号 2 のチーム
例2 (情報に適合する順位表が複数存在する場合)
チーム数が3で，各チームに1から3までの番号が付けられており，勝敗が次の表で与えられていたとする．
このとき，伝えられた情報に適合する順位表は，次の 2 つである．
1 位 番号 2 のチーム
2 位 番号 1 のチーム
3 位 番号 3 のチーム
1 位 番号 2 のチーム
2 位 番号 3 のチーム
3 位 番号 1 のチーム
入力
入力は以下の形式で与えられる．
1 行目には，サッカーチームの個数 n が書かれている．各チームには，1 から n までの番号が付けられている．
2 行目には，与えられた試合の勝敗の個数 m が書かれている．
3 行目から m + 2 行目は試合の勝敗を表す．各行は空白で区切られた 2 つの整数 i, j を含み，番号 i のチームが番号 j のチームに勝利したことを表す．
n, m は 1 ≤ n ≤ 5000,  1 ≤  m ≤ 100000 をみたす．
採点の際に用いるテストデータのうち，30% は 1 ≤ n ≤ 7,  1 ≤ m ≤ 15 をみたす．また，60% は 1 ≤ n ≤ 100, 1 ≤ m ≤ 2000 をみたす．
出力
出力
は n + 1 行からなる．
1 行目から n 行目までの n 行には，伝えられた情報に適合する順位表を出力せよ．
i 行目 (1 ≤ i ≤ n) に i 位のチームの番号を出力せよ．
n + 1 行目には，出力した順位表以外に，伝えられた情報に適合する順位表が存在するかどうかを表す整数を出力せよ．もし存在しなければ 0 を，存在する場合は 1 を出力せよ．
入出力例
例 1 に対応する入出力は以下の通りである．
入力例 1
4
5
1 2
3 1
3 2
3 4
4 1
出力例 1
3
4
1
2
0
例 2 に対応する入出力は以下の通りである．
入力例 2
3
2
2 1
2 3
この入力データに対して，次の 2 通りの出力データが考えられる．どちらを出力してもよい．
出力例 2
2
1
3
1
2
3
1
1
上記問題文と自動審判に使われるデータは、
情報オリンピック日本委員会
が作成し公開している問題文と採点用テストデータです。

Submitted solutions:

code_snippet: #include <bits/stdc++.h>
using namespace std;

void visit(vector<vector<int>> const& g, int v, vector<bool>& used, vector<int>& res) {
    if(!used[v]) {
        used[v] = true;
        for(auto& to : g[v]) {
            visit(g, to, used, res);
        }
        res.push_back(v);
    }
}

vector<int> tsort(vector<vector<int>> const& g) {
    vector<bool> used(g.size());
    vector<int> res;
    for(int i=0; i<g.size(); ++i) {
        visit(g, i, used, res);
    }
    reverse(res.begin(), res.end());
    return res;
}

int main() {
    int n, m;
    cin >> n >> m;
    vector<vector<int>> g(n);
    for(int i=0; i<m; ++i) {
        int a, b;
        cin >> a >> b;
        a--; b--;
        g[a].push_back(b);
    }
    auto res = tsort(g);
    bool f = true;
    for(int i=0; i<n-1; ++i) {
        bool f2 = false;
        for(int j=0; j<g[res[i]].size(); ++j) {
            f2 |= g[res[i]][j] == res[i+1];
        }
        f &= f2;
    }

    for(auto x : res) {
        cout << x+1 << endl;
    }
    cout << !f << endl;
}
accuracy: 1
time_ms: 30
memory_kb: 4240
final_rank: 14

code_snippet: #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define all(a) a.begin(),a.end()
#define reps(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) reps(i, 0, n)
#define rreps(i, a, n) for (int i = (a); i > (int)(n); i--)
const long long mod = 1000000007;
const long long INF = 1e18;
ll myceil(ll a, ll b) {return (a+b-1)/b;}


template <typename T>
struct edge {
  int src, to;
  T cost;

  edge(int _to, T _cost) : src(-1), to(_to), cost(_cost) {}
  edge(int _src, int _to, T _cost) : src(_src), to(_to), cost(_cost) {}

  edge &operator=(const int &x) {
    to = x;
    return *this;
  }

  operator int() const { return to; }
};
template <typename T>
using Edges = vector<edge<T>>;
template <typename T>
using WeightedGraph = vector<Edges<T>>;
using UnweightedGraph = vector<vector<int>>;

// Input of (Unweighted) Graph
UnweightedGraph graph(int N, int M = -1, bool is_directed = false,
                      bool is_1origin = true) {
  UnweightedGraph g(N);
  if (M == -1) M = N - 1;
  for (int _ = 0; _ < M; _++) {
    int x, y;
    cin >> x >> y;
    if (is_1origin) x--, y--;
    g[x].push_back(y);
    if (!is_directed) g[y].push_back(x);
  }
  return g;
}

// Input of Weighted Graph
template <typename T>
WeightedGraph<T> wgraph(int N, int M = -1, bool is_directed = false,
                        bool is_1origin = true) {
  WeightedGraph<T> g(N);
  if (M == -1) M = N - 1;
  for (int _ = 0; _ < M; _++) {
    int x, y;
    cin >> x >> y;
    T c;
    cin >> c;
    if (is_1origin) x--, y--;
    g[x].emplace_back(x, y, c);
    if (!is_directed) g[y].emplace_back(y, x, c);
  }
  return g;
}

// Input of Edges
template <typename T>
Edges<T> esgraph([[maybe_unused]] int N, int M, int is_weighted = true,
                 bool is_1origin = true) {
  Edges<T> es;
  for (int _ = 0; _ < M; _++) {
    int x, y;
    cin >> x >> y;
    T c;
    if (is_weighted)
      cin >> c;
    else
      c = 1;
    if (is_1origin) x--, y--;
    es.emplace_back(x, y, c);
  }
  return es;
}

// Input of Adjacency Matrix
template <typename T>
vector<vector<T>> adjgraph(int N, int M, T INF, int is_weighted = true,
                           bool is_directed = false, bool is_1origin = true) {
  vector<vector<T>> d(N, vector<T>(N, INF));
  for (int _ = 0; _ < M; _++) {
    int x, y;
    cin >> x >> y;
    T c;
    if (is_weighted)
      cin >> c;
    else
      c = 1;
    if (is_1origin) x--, y--;
    d[x][y] = c;
    if (!is_directed) d[y][x] = c;
  }
  return d;
}

/**
 * @brief グラフテンプレート
 * @docs docs/graph/graph-template.md
 */



// if the graph is not DAG, return empty vector
template <typename T>
vector<int> TopologicalSort(T &g) {
  int N = g.size();
  vector<int> marked(N, 0), temp(N, 0), v;
  auto visit = [&](auto f, int i) -> bool {
    if (temp[i] == 1) return false;
    if (marked[i] == 0) {
      temp[i] = 1;
      for (auto &e : g[i]) {
        if (f(f, e) == false) return false;
      }
      marked[i] = 1;
      v.push_back(i);
      temp[i] = 0;
    }
    return true;
  };

  for (int i = 0; i < N; i++) {
    if (marked[i] == 0) {
      if (visit(visit, i) == false) return vector<int>();
    }
  }
  reverse(v.begin(), v.end());
  return v;
}


void solve() {
    int n,m;
    cin >> n >> m;
    auto g = graph(n,m,true,true);
    auto tg = TopologicalSort(g);



    for (auto x : tg) {
        cout << x+1 << endl;
    }
    rep(i,tg.size()-1) {
        rep(j,g[tg[i]].size()) {
            if (g[tg[i]][j] == tg[i+1]) {
                break;
            }
            if (j == g[tg[i]].size()-1) {
                // cout << i << ' ' << j << endl;
                cout << 1 << endl;
                return;
            }
        }
    }
    cout << 0 << endl;
    return;
}


int main() {
    cin.tie(nullptr);
    ios_base::sync_with_stdio(false);

    solve();
    

	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 4372
final_rank: 13

code_snippet: #include <iostream>
#include <vector>
#include <set>


using namespace std;

typedef long long int ll;
typedef vector<ll> vll;
typedef set<ll> sll;

int main() {
  ll n, m;
  cin >> n >> m;

  bool is_team_mentioned[n+1];
  sll wins[n+1];
  sll loses[n+1];
  sll nodes;
  for (ll i = 1; i <= n; i++) {
    is_team_mentioned[n] = false;
    wins[i] = sll();
    loses[i] = sll();
    nodes.insert(i);
  }

  for (ll i = 0; i < m; i++) {
    ll win, lose;
    cin >> win >> lose;
    is_team_mentioned[win] = true;
    is_team_mentioned[lose] = true;
    wins[win].insert(lose);
    loses[lose].insert(win);
  }

  bool cant_determine = false;
  vll res;
  for (ll t = 1; t <= n; t++) {
    if (is_team_mentioned[t] == false) {
      cant_determine = true;
      res.push_back(t);
      nodes.erase(t);
    }
  }

  while (!nodes.empty()) {
    // 勝利の情報だけあるチームを列挙
    vll current_best;
    for (ll t = 1; t <= n; t++) {
      if (nodes.count(t) == 0) {
        continue;
      }
      if (loses[t].size() == 0) {
        current_best.push_back(t);
      }
    }

    // 複数チームあったなら一意にソート不可
    if (current_best.size() > 1) {
      cant_determine = true;
    }

    // 列挙したチームを出力し、グラフから削除
    for (ll t : current_best) {
      res.push_back(t);
      for (auto lose_team : wins[t]) {
        loses[lose_team].erase(t);
      }
      nodes.erase(t);
    }
  }

  for (ll t : res) {
    cout << t << endl;
  }
  cout << ((cant_determine == true) ? 1 : 0) << endl;
}
accuracy: 1
time_ms: 770
memory_kb: 13560
final_rank: 20

code_snippet: #include <bits/stdc++.h>
using namespace std;

int main() {
    int N, M; cin >> N >> M;
    vector<vector<int>> g(N), rg(N);
    vector<int> in(N, 0), out(N, 0);
    for (int i = 0; i < M; i++) {
        int a, b; cin >> a >> b;
        a--, b--;
        g[a].push_back(b);
        rg[b].push_back(a);
        in[b]++;
        out[a]++;
    }
    queue<int> que;
    for (int i = 0; i < N; i++) {
        if (out[i] == 0) que.push(i);
    }
    int ok = 1;
    vector<int> usd(N, 0), ans;
    while (!que.empty()) {
        ok &= que.size() == 1;
        int u = que.front(); que.pop();
        ans.push_back(u+1);
        usd[u] = 1;
        for (auto v : rg[u]) {
            if (usd[v]) continue;
            out[v]--;
            if (out[v] == 0) que.push(v);
        }
    }
    reverse(ans.begin(), ans.end());
    for (auto x : ans) {
        cout << x << '\n';
    }
    cout << !ok << endl;
}
accuracy: 1
time_ms: 30
memory_kb: 4968
final_rank: 16

code_snippet: #include <bits/stdc++.h>
using namespace std;

int main() {
    int N, M; cin >> N >> M;
    vector<vector<int>> g(N), rg(N);
    vector<int> in(N, 0), out(N, 0);
    for (int i = 0; i < M; i++) {
        int a, b; cin >> a >> b;
        a--, b--;
        g[a].push_back(b);
        rg[b].push_back(a);
        in[b]++;
        out[a]++;
    }
    queue<int> que;
    for (int i = 0; i < N; i++) {
        if (out[i] == 0) que.push(i);
    }
    int ok = 1;
    vector<int> usd(N, 0), ans;
    while (!que.empty()) {
        ok &= que.size() == 1;
        int u = que.front(); que.pop();
        ans.push_back(u+1);
        usd[u] = 0;
        for (auto v : rg[u]) {
            out[v]--;
            if (out[v] == 0) que.push(v);
        }
    }
    reverse(ans.begin(), ans.end());
    for (auto x : ans) {
        cout << x << '\n';
    }
    cout << !ok << endl;
}
accuracy: 1
time_ms: 30
memory_kb: 5052
final_rank: 17

code_snippet: #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
#include <stack>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
typedef pair<int, int> pii;
int n, m;
vector<int> edge[5000];
int cnt[5000];
int main() {
  cin >> n >> m;
  REP(i, m) {
    int a, b;
    scanf("%d %d", &a, &b);
    a--;
    b--;
    edge[a].push_back(b);
    cnt[b]++;
  }
  vector<int> ans;
  bool flag = false;
  stack<int> next;  // Change next to stack
  REP(i, n) if (cnt[i] == 0) next.push(i);
  REP(i, n) {
    int tar = next.top();  // use top() instead of next[next.size() - 1]
    ans.push_back(tar + 1);
    next.pop();  // use pop() instead of next.erase(next.end() - 1)
    if (!next.empty())  // use empty() instead of next.size() > 0
      flag = true;  // move flag update inside if condition
    REP(j, edge[tar].size()) {
      int to = edge[tar][j];
      if (--cnt[to] == 0)
        next.push(to);
    }
  }
  REP(i, ans.size()) printf("%d\n", ans[i]);
  if (flag)
    puts("1");
  else
    puts("0");
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3892
final_rank: 7

code_snippet: #include <algorithm>
#include <cstdio>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
typedef pair<int, int> pii;
int n, m;
vector<int> edge[5000];
int cnt[5000];
int main() {
  scanf("%d %d", &n, &m);
  REP(i, m) {
    int a, b;
    scanf("%d %d", &a, &b);
    a--;
    b--;
    edge[a].push_back(b);
    cnt[b]++;
  }
  vector<int> ans(n); // preallocate size
  bool flag = false;
  vector<int> next;
  REP(i, n) if (cnt[i] == 0) next.push_back(i);
  int index = 0; // keep track of next node to be processed
  REP(i, n) {
    int tar = next[index++]; // use index to get next node
    ans[i] = tar + 1;
    if (index < next.size())
      flag = true;
    REP(j, edge[tar].size()) {
      int to = edge[tar][j];
      if (--cnt[to] == 0)
        next.push_back(to);
    }
  }
  REP(i, ans.size()) printf("%d\n", ans[i]);
  if (flag)
    puts("1");
  else
    puts("0");
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3432
final_rank: 2

code_snippet: #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
typedef pair<int, int> pii;
int n, m;
vector<int> edge[5000];
int cnt[5000];

int main() {
  cin >> n >> m;
  REP(i, m) {
    int a, b;
    scanf("%d %d", &a, &b);
    a--;
    b--;
    edge[a].push_back(b);
    cnt[b]++;
  }

  bool flag = false;
  queue<int> next;
  REP(i, n) if (cnt[i] == 0) next.push(i);
  REP(i, n) {
    int tar = next.front();
    next.pop();
    printf("%d\n", tar + 1);
    if (!next.empty())
      flag = true;
    REP(j, edge[tar].size()) {
      int to = edge[tar][j];
      if (--cnt[to] == 0)
        next.push(to);
    }
  }
  
  if (flag)
    puts("1");
  else
    puts("0");
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3780
final_rank: 4

code_snippet: #include <cstdio>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)

const int MAX_N = 5000;

int n, m;
vector<int> edge[MAX_N];
int cnt[MAX_N];

int main() {
  scanf("%d %d", &n, &m);
  REP(i, m) {
    int a, b;
    scanf("%d %d", &a, &b);
    a--;
    b--;
    edge[a].push_back(b);
    cnt[b]++;
  }

  vector<int> ans;
  bool flag = false;
  vector<int> next;
  REP(i, n) if (cnt[i] == 0) next.push_back(i);

  REP(i, n) {
    int tar = next.back();
    next.pop_back();
    ans.push_back(tar + 1);
    if (!next.empty())
      flag = true;

    REP(j, edge[tar].size()) {
      int to = edge[tar][j];
      if (--cnt[to] == 0)
        next.push_back(to);
    }
  }

  REP(i, ans.size()) printf("%d\n", ans[i]);
  if (flag)
    puts("1");
  else
    puts("0");
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3364
final_rank: 1

code_snippet: #include <cstdio>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)

int n, m;
vector<int> edge[5000];
int cnt[5000];

int main() {
  scanf("%d%d", &n, &m);
  REP(i, m) {
    int a, b;
    scanf("%d%d", &a, &b);
    --a;
    --b;
    edge[a].push_back(b);
    ++cnt[b];
  }
  vector<int> ans;
  bool flag = false;
  vector<int> next;
  REP(i, n) if (cnt[i] == 0) next.push_back(i);
  REP(i, n) {
    int tar = next.back();
    ans.push_back(tar + 1);
    next.pop_back();
    if (!next.empty())
      flag = true;
    for (int j = 0; j < edge[tar].size(); ++j) {
      int to = edge[tar][j];
      if (--cnt[to] == 0)
        next.push_back(to);
    }
  }
  REP(i, ans.size()) printf("%d\n", ans[i]);
  if (flag)
    puts("1");
  else
    puts("0");
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3440
final_rank: 3

code_snippet: #include <algorithm>
#include <cstdio>
#include <iostream>
#include <stack>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
typedef pair<int, int> pii;
int n, m;
vector<int> edge[5000];
int cnt[5000];
int main() {
  cin >> n >> m;
  REP(i, m) {
    int a, b;
    scanf("%d %d", &a, &b);
    a--;
    b--;
    edge[a].push_back(b);
    cnt[b]++;
  }
  vector<int> ans;
  bool flag = false;
  stack<int> next;
  REP(i, n) if (cnt[i] == 0) next.push(i);
  REP(i, n) {
    int tar = next.top();
    next.pop();
    ans.push_back(tar + 1);
    if (!next.empty())
      flag = true;
    REP(j, edge[tar].size()) {
      int to = edge[tar][j];
      if (--cnt[to] == 0)
        next.push(to);
    }
  }
  REP(i, ans.size()) printf("%d\n", ans[i]);
  if (flag)
    puts("1");
  else
    puts("0");
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3936
final_rank: 11

code_snippet: #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vvvb = vector<vvb>;
#define all(A) A.begin(),A.end()
#define rep(i, n) for (ll i = 0; i < (ll) (n); i++)
template<class T>
bool chmax(T& p, T q, bool C = 1) {
    if (C == 0 && p == q) {
        return 1;
    }
    if (p < q) {
        p = q;
        return 1;
    }
    else {
        return 0;
    }
}
template<class T>
bool chmin(T& p, T q, bool C = 1) {
    if (C == 0 && p == q) {
        return 1;
    }
    if (p > q) {
        p = q;
        return 1;
    }
    else {
        return 0;
    }
}

int main() {

    cin.tie(nullptr);
    ios::sync_with_stdio(false);

    ll N,M;
    cin>>N>>M;
    vvll G(N);
    vll E(N,0);
    rep(i,M){
        ll U,V;
        cin>>U>>V;
        U--;V--;
        G[U].push_back(V);
        E[V]++;
    }
    queue<ll> Q;
    vll AN;
    vb seen(N,false);
    rep(i,N)if(E[i]==0)Q.push(i);
    while(!Q.empty()){
        ll p=Q.front();
        Q.pop();
        if(seen[p])continue;
        seen[p]=1;
        AN.push_back(p);
        for(auto v:G[p]){
            E[v]--;
            if(E[v]==0&&!seen[v])Q.push(v);
        }
    }
    bool OK=0;
    rep(i,N-1){
        bool EG=0;
        for(auto v:G[AN[i]])if(v==AN[i+1])EG=1;
        if(!EG)OK=1;
    }
    rep(i,N)cout<<AN[i]+1<<endl;
    cout<<OK<<endl;
}
accuracy: 1
time_ms: 10
memory_kb: 4808
final_rank: 15

code_snippet: #include <bits/stdc++.h>
using namespace std;
#define int long long
#define repi(i, m, n) for (int i = m; i < n; i++)
#define rep(i, n) repi(i, 0, n)
typedef pair<int, int> P;
typedef vector<int> vi;
const int inf = 1e9 + 7;
const int INF = 1e18 + 7;
class t_sort {
public:
  int n;
  vi ans, deg;
  vector<vi> G;
  void init(int N) {
    n = N;
    deg.resize(n);
    G.resize(n);
  }
  void add_edge(int from, int to) {
    G[from].push_back(to);
    deg[to]++;
  }
  void tsort() {
    stack<int> st;
    rep(i, n) if (deg[i] == 0) st.push(i);
    while (!st.empty()) {
      int v = st.top();
      st.pop();
      ans.push_back(v);
      rep(i, G[v].size()) if (--deg[G[v][i]] == 0) st.push(G[v][i]);
    }
  }
};
map<P, int> mp;
signed main() {
  int n, m;
  scanf("%lld%lld", &n, &m);
  t_sort t;
  t.init(n);
  rep(i, m) {
    int x, y;
    scanf("%lld%lld", &x, &y);
    x--;
    y--;
    t.add_edge(x, y);
    mp[P(x, y)] = 1;
  }
  t.tsort();
  vi ans = t.ans;
  rep(i, n) printf("%lld\n", ans[i] + 1);
  int res = 1;
  rep(i, n - 1) {
    if (mp[P(ans[i], ans[i + 1])] == 0)
      res = 0;
  }
  printf("%lld\n", res == 1 ? 0 : 1);
  return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 11028
final_rank: 18

code_snippet: #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
int n, m;
vector<int> edge[5000];
int cnt[5000];
int main() {
  cin >> n >> m;
  REP(i, m) {
    int a, b;
    scanf("%d %d", &a, &b);
    a--;
    b--;
    edge[a].push_back(b);
    cnt[b]++;
  }
  vector<int> ans;
  bool flag = false;
  vector<int> next;
  REP(i, n) if (cnt[i] == 0) next.push_back(i);
  REP(i, n) {
    int tar = next[next.size() - 1];
    ans.push_back(tar + 1);
    next.erase(next.end() - 1);
    if (next.size() > 0)
      flag = true;
    REP(j, edge[tar].size()) {
      int to = edge[tar][j];
      if (--cnt[to] == 0)
        next.push_back(to);
    }
  }
  REP(i, ans.size()) printf("%d\n", ans[i]);
  if (flag)
    puts("1");
  else
    puts("0");
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3944
final_rank: 12

code_snippet: #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
typedef pair<int, int> pii;
int n, m;
vector<int> edge[5000];
int cnt[5000];
int main() {
  cin >> n >> m;
  REP(i, m) {
    int a, b;
    scanf("%d %d", &a, &b);
    a--;
    b--;
    edge[a].push_back(b);
    cnt[b]++;
  }
  vector<int> ans;
  bool flag = false;
  vector<int> next;
  REP(i, n) if (cnt[i] == 0) next.push_back(i);
  REP(i, n) {
    int tar = next[next.size() - 1];
    ans.push_back(tar + 1);
    next.erase(next.end() - 1);
    if (next.size() > 0)
      flag = true;
    REP(j, edge[tar].size()) {
      int to = edge[tar][j];
      if (--cnt[to] == 0)
        next.push_back(to);
    }
  }
  REP(i, ans.size()) printf("%d\n", ans[i]);
  if (flag)
    puts("1");
  else
    puts("0");
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3860
final_rank: 5

code_snippet: #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
typedef pair<int, int> pii;
int n, m;
vector<int> edge[5000];
int cnt[5000];
int main() {
  cin >> n >> m;
  REP(i, m) {
    int a, b;
    scanf("%d %d", &a, &b);
    a--;
    b--;
    edge[a].push_back(b);
    cnt[b]++;
  }
  vector<int> ans;
  bool flag = false;
  vector<int> next;
  REP(i, n) if (cnt[i] == 0) next.push_back(i);
  REP(i, n) {
    int tar = next[next.size() - 1];
    ans.push_back(tar + 1);
    next.pop_back();
    if (next.size() > 0)
      flag = true;
    REP(j, edge[tar].size()) {
      int to = edge[tar][j];
      if (--cnt[to] == 0)
        next.push_back(to);
    }
  }
  REP(i, ans.size()) printf("%d\n", ans[i]);
  if (flag)
    puts("1");
  else
    puts("0");
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3932
final_rank: 10

code_snippet: #include <bits/stdc++.h>
using namespace std;
#define int long long
#define UNIQUE(v) v.erase(unique(all(v)), v.end());
#define ZIP(v) sort(all(v)), UNIQUE(v)
#define ADD(a, b) a = (a + b) % mod
#define SUB(a, b) a = (a + mod - b) % mod
#define MUL(a, b) a = (a * b) % mod
#define repi(i, m, n) for (int i = m; i < n; i++)
#define drep(i, n, m) for (int i = n; i >= m; i--)
#define rep(i, n) repi(i, 0, n)
#define rrep(i, n) repi(i, 1, n + 1)
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define dmp(x, y) make_pair(x, y)
#define pb(x) push_back(x)
#define fi first
#define se second
typedef pair<int, int> P;
typedef pair<int, P> PP;
typedef vector<int> vi;
typedef deque<int> dq;
const int inf = 1e9 + 7;
const int INF = 1e18 + 7;

const int MAX_N = 2e5 + 5;
int n, m, res;
vector<int> ans, deg, G[MAX_N], top_sort;
map<P, int> mp;

void init() {
  rep(i, n) deg.pb(0);
}

void add_edge(int from, int to) {
  G[from].pb(to);
  deg[to]++;
}

void tsort() {
  stack<int> st;
  rep(i, n) if (deg[i] == 0) st.push(i);
  while (!st.empty()) {
    int v = st.top();
    st.pop();
    top_sort.pb(v);
    rep(i, G[v].size()) if (--deg[G[v][i]] == 0) st.push(G[v][i]);
  }
}

signed main() {
  scanf("%lld%lld", &n, &m);
  init();
  rep(i, m) {
    int x, y;
    scanf("%lld%lld", &x, &y);
    x--;
    y--;
    add_edge(x, y);
    mp[P(x, y)] = 1;
  }
  tsort();
  ans = top_sort;
  rep(i, n) printf("%lld\n", ans[i] + 1);
  rep(i, n - 1) {
    if (mp[P(ans[i], ans[i + 1])] == 0) res = 1;
  }
  printf("%lld\n", res);
  return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 15428
final_rank: 19

code_snippet: #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
typedef pair<int, int> pii;
int n, m;
vector<int> edge[5000];
int cnt[5000];
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  scanf("%d %d", &n, &m);
  REP(i, m) {
    int a, b;
    scanf("%d %d", &a, &b);
    a--;
    b--;
    edge[a].push_back(b);
    cnt[b]++;
  }
  vector<int> ans;
  bool flag = false;
  vector<int> next;
  REP(i, n) if (cnt[i] == 0) next.push_back(i);
  REP(i, n) {
    int tar = next.back();
    next.pop_back();
    ans.push_back(tar + 1);
    if (!next.empty())
      flag = true;
    REP(j, edge[tar].size()) {
      int to = edge[tar][j];
      if (--cnt[to] == 0)
        next.push_back(to);
    }
  }
  REP(i, ans.size()) printf("%d\n", ans[i]);
  if (flag)
    puts("1");
  else
    puts("0");
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3896
final_rank: 8

code_snippet: #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
typedef pair<int, int> pii;
int n, m;
vector<int> edge[5000];
int cnt[5000];
int main() {
  cin >> n >> m;
  REP(i, m) {
    int a, b;
    scanf("%d %d", &a, &b);
    a--;
    b--;
    edge[a].push_back(b);
    cnt[b]++;
  }
  vector<int> ans;
  bool flag = false;
  vector<int> next;
  REP(i, n) if (cnt[i] == 0) next.push_back(i);
  REP(i, n) {
    int tar = next[next.size() - 1];
    ans.push_back(tar + 1);
    next.erase(next.end() - 1);
    if (next.size() > 0)
      flag = true;
    REP(i, edge[tar].size()) {
      int to = edge[tar][i];
      if (--cnt[to] == 0)
        next.push_back(to);
    }
  }
  REP(i, ans.size()) printf("%d\n", ans[i]);
  if (flag)
    puts("1");
  else
    puts("0");
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3880
final_rank: 6

code_snippet: #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
typedef pair<int, int> pii;
int n, m;
vector<int> edge[5000];
int cnt[5000];
int main() {
  cin >> n >> m;
  REP(i, m) {
    int a, b;
    scanf("%d %d", &a, &b);
    a--;
    b--;
    edge[a].push_back(b);
    cnt[b]++;
  }
  vector<int> ans;
  bool flag = false;
  vector<int> next;
  REP(i, n) if (cnt[i] == 0) next.push_back(i);
  REP(i, n) {
    int tar = next[next.size() - 1];
    ans.push_back(tar + 1);
    next.erase(next.end() - 1);
    if (next.size() > 0)
      flag = true;
    REP(j, edge[tar].size())
    if (--cnt[edge[tar][j]] == 0)
      next.push_back(edge[tar][j]);
  }
  REP(i, ans.size()) printf("%d\n", ans[i]);
  if (flag)
    puts("1");
  else
    puts("0");
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3920
final_rank: 9