1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
#include <cstdio>
#include <vector>
#include <utility>
#include <stack>

using namespace std;

const int r = 500005;
vector < int > g[r];
bool odw[r];
int ile_razy_w_cyklu[r], po_kolei[r], ile_w_1_cyklu[r];
int ilosc_cykli = 0;
stack<int> s;

void dfs(int w){
    
    
        
        for(int i = 0; i < g[w].size(); i++){
            
            if(odw[g[w][i]] == 1 ){
                
                if(ilosc_cykli == 0){
                    
                    int poczatek = g[w][i];
                    po_kolei[g[w][i]] = w;
                    ile_w_1_cyklu[poczatek] = po_kolei[poczatek];
                    ile_razy_w_cyklu[poczatek] ++;
                    
                    while(po_kolei[poczatek] != g[w][i]){
                        int xx = po_kolei[poczatek];
                        poczatek = xx;
                        ile_w_1_cyklu[poczatek] = po_kolei[poczatek];
                        if(ile_razy_w_cyklu[poczatek] == 0) ile_razy_w_cyklu[poczatek]++;
                    } // koniec while'a
                    
                    ilosc_cykli++;

                }
                else{
                    
                    po_kolei[g[w][i]] = w;
                    
                    int iteratorek = g[w][i];
                    
                    if(ile_razy_w_cyklu[g[w][i]] == ilosc_cykli) ile_razy_w_cyklu[g[w][i]]++;
                    s.push(g[w][i]);
                    
                   // printf("A %d %d\n", w, g[w][i]);
                    int xx = 0;
                    bool petla_jest_gupia = 0;
                    
                    // for(int k = 0; k <= 10; k++) printf("%d %d\n", k, po_kolei[k]);
                    
                    while(g[w][i] != po_kolei[iteratorek] ){
                       // printf("xx %d %d\n", iteratorek, po_kolei[iteratorek]);
                        
                        if(po_kolei[iteratorek] == ile_w_1_cyklu[iteratorek]){
                            
                            int pocz = po_kolei[iteratorek];
                            
                            while(po_kolei[iteratorek] != po_kolei[pocz]){
                               // printf("AA %d %d %d\n", pocz, po_kolei[pocz], ile_w_1_cyklu[pocz]);
                                if(ilosc_cykli == ile_razy_w_cyklu[po_kolei[pocz]]) ile_razy_w_cyklu[po_kolei[pocz]]++;
                                xx = po_kolei[pocz];
                                pocz = xx;
                                s.push(po_kolei[pocz]);
                                if(pocz == g[w][i]) break;
                            }
                            
                            if(g[w][i] != pocz) petla_jest_gupia = 1;
                            while(!s.empty()){
                                if(petla_jest_gupia == 1) ile_razy_w_cyklu[s.top()]--;
                                s.pop();
                            }
                            
                            
                            break;
                            
                        }
                        else{
                            if(ilosc_cykli == ile_razy_w_cyklu[po_kolei[iteratorek]]) ile_razy_w_cyklu[po_kolei[iteratorek]]++;
                            xx = po_kolei[iteratorek];
                            iteratorek = xx;
                            
                            s.push(po_kolei[iteratorek]);
                        }
                        
                        
                      //  printf("xx %d %d %d\n", iteratorek, po_kolei[iteratorek], ile_w_1_cyklu[iteratorek]);
                        
                        
                    }
                    if(petla_jest_gupia == 0) ilosc_cykli++;

                }
                
            } // koniec if'a z odw
            
             odw[w] = 1;
            
            
            // jesli nie wlezlismy w jakas sciezke to w nia wlazimy
            if(odw[g[w][i]] == 0){
                po_kolei[g[w][i]] = w;
                dfs(g[w][i]);
            }
            
            
            
        } // koniec for'a
        
    
} // koniec funkcji





int main() {
    
    int n, m;
    scanf("%d%d", &n, &m);
    
    for(int i = 0; i < m; i++){
        int a, b;
        scanf("%d%d", &a, &b);
        g[a].push_back(b);
    }
    
    for(int i = 1; i <= n; i++) if(odw[i] == 0) dfs(i);
       
    
    if(ilosc_cykli == 0){
        printf("NIE\n");
        return 0;
    }
    
  //  for(int i = 1; i <= n; i++) printf("%d %d %d\n", i, ile_razy_w_cyklu[i], ilosc_cykli);
    
    vector<int> wynik;
    
    for(int i = 1; i <= n; i++) if(ile_razy_w_cyklu[i] == ilosc_cykli) wynik.push_back(i);
    
    printf("%lu\n", wynik.size());
    
    for(int i = 0; i < wynik.size(); i++) printf("%d ", wynik[i]);
    
    return 0;
}