#include <bits/stdc++.h>
using namespace std;
#define directed true
#define undirected false
#define weighted true
#define unweighted false
const int nmax = 105;
/*class Edge{
int i, j, cost;
Edge(int _i, int _j, int _cost) : i(_i), j(_j), cost(_cost){}
friend bool operator<(const Edge& e1, const Edge& e2) {
return e1.cost < e2.cost;
}
// util in ordonarea dupa cost
};
// o structura de tip muchie, utila in problema APM cand, aplicand algoritmul lui Kruskall
// avem nevoie sa sortam muchiile crescator dupa cost
*/
// in principiu util doar pt HavelHakimi
void countSort(vector<int> &input)
{
map<int, int> freq;
for (int x: input) {
freq[x]++;
}
int i = 0;
for (auto p: freq)
{
while (p.second--) {
input[i++] = p.first;
}
}
}
bool HavelHakimi(vector<int> d){
int n = d.size();
int sum = 0;
for(auto degree: d) {
if(degree > n - 1)
return false;
sum += degree;
}
while(d.size()){
countSort(d);
int biggest = d[0];
d.erase(d.begin());
for(int i = 0; i < biggest; ++i)
{
--d[i];
if(d[i] < 0){
return false;
}
}
}
return true;
}
class Graph {
public:
int V;
int E;
bool dir;
bool wgt;
Graph(bool, bool);
// constructorul care contine doar informatii de tipul
// 'graful este orientat/neorientat si are/n-are costuri pe muchii'
void build(int, int, vector<vector<pair<int, int>>>);
vector<vector<pair<int, int>>> adj;
// lista de adiacenta a nodului 'n' e formata din perechi de tipul
// {vecin, cost}, unde cost = costul muchiei {n, vecin}.
// daca graful n-are costuri pe muchii cost = 0;
void DFSUtil(int, vector<bool>&, vector<int>&);
vector<int> DFS(int, vector<bool>&);
int cc(int);
pair<vector<int>, vector<int>> bfs(int src);
// returnez ordinea parcurgerii bfs, dar si
// un vector de distante minime. Amandoua sunt relevante
// si specifice parcurgerii in latime
vector<int> topoSort();
void dfForTopoSort(int, vector<bool>&, stack<int>&);
void DFtranspose(vector<vector<pair<int, int>>>, vector<vector<int>>&, int, vector<bool>&);
vector<vector<int>> Kosaraju();
};
Graph::Graph(bool _directed, bool _weighted) : dir(_directed), wgt(_weighted) {
}
void Graph::build(int _V, int _E, vector<vector<pair<int, int>>> _adj) {
V = _V;
E = _E;
adj = _adj;
}
void Graph::DFSUtil(int v, vector<bool>& vis, vector<int>& island){
for(auto i : adj[v]){
int ngb = i.first;
if(!(vis[ngb])) {
island.push_back(ngb);
vis[ngb] = true;
DFSUtil(ngb, vis, island);
}
}
}
vector<int> Graph::DFS(int src, vector<bool>& vis) {
vector<int> island;
DFSUtil(src, vis, island);
return island;
}
int Graph::cc(int src) {
int nrIslands = 0;
vector<bool> vis;
vis.resize(V + 1, false);
for(int i = 1; i <= V; ++i) {
if(!vis[i]){
++nrIslands;
DFS(i, vis);
}
}
return nrIslands;
}
// returnez un vector al distantelor minime
// dar si un vector ce contine ordinea parcurgerii bfs
pair<vector<int>, vector<int>> Graph::bfs(int src) {
pair<vector<int>, vector<int>> toReturn;
queue<int> q;
q.push(src);
vector<int> bfsOrder;
vector<int> dist;
dist.resize(V + 1, -1);
q.push(src);
dist[src] = 0;
while(!(q.empty())){
int dad = q.front();
bfsOrder.push_back(dad);
q.pop();
for(auto i : adj[dad]) {
int ngb = i.first;
if(dist[ngb] == - 1){
dist[ngb] = dist[dad] + 1;
q.push(ngb);
}
}
}
toReturn.first = dist;
toReturn.second = bfsOrder;
return toReturn;
}
void Graph::dfForTopoSort(int src, vector<bool>& vis, stack<int>& st) {
for(auto i: adj[src]) {
int ngb = i.first;
if(vis[ngb] == false) {
vis[ngb] = true;
dfForTopoSort(ngb, vis, st);
}
}
st.push(src);
}
vector<int> Graph::topoSort(){
vector<bool> vis;
stack<int> st;
vis.resize(V + 1, false);
for(int i = 1; i <= V; ++i)
if(!vis[i]) {
vis[i] = true;
dfForTopoSort(i, vis, st);
}
vector<int> topoSorted;
while(st.size()) {
topoSorted.push_back(st.top());
st.pop();
}
return topoSorted;
}
void Graph::DFtranspose(vector<vector<pair<int, int>>> adjT, vector<vector<int>>& sol, int node, vector<bool>& visT){
//cout << "totomeda\n";
sol[sol.size() - 1].push_back(node);
visT[node] = true;
for(auto i: adjT[node]) {
int ngb = i.first;
if(visT[ngb] == false)
{
DFtranspose(adjT, sol, ngb, visT);
}
}
}
vector<vector<int>> Graph::Kosaraju() {
vector<vector<pair<int, int>>> adjT;
adjT.resize(V + 1);
for(int i = 1; i <= V; ++i)
for(auto ngb : adj[i])
adjT[ngb.first].push_back(make_pair(i, 0));
vector<bool> visT;
vector<bool> vis;
visT.resize(V + 1, false);
vis.resize(V + 1, false);
stack<int> st;
vector<vector<int>> stronglyCC;
for(int i = 1; i <= V; ++i)
if(!vis[i])
{
vis[i] = true;
dfForTopoSort(i, vis, st);
// construim stiva specifica sortarii topologice
}
stronglyCC.push_back(vector<int>());
while(st.size())
{
int k = 0;
while(st.size() && visT[st.top()] == true)
st.pop();
if(st.size())
k = 1;
if(st.size())
{
int crt = st.top();
DFtranspose(adjT, stronglyCC, crt, visT);
}
if(k == 1)
stronglyCC.push_back(vector<int>());
if(st.size())
st.pop();
}
return stronglyCC;
}
int main()
{
/*
// problema dfs pe pe infoarena
// https://www.infoarena.ro/problema/dfs
ifstream fin("dfs.in");
ofstream fout("dfs.out");
int v, e;
fin >> v >> e;
vector<vector<pair<int, int>>> adj;
adj.resize(v + 1);
Graph g(undirected, unweighted);
for(int i = 1; i <= e; ++i) {
int src, dst;
fin >> src >> dst;
adj[src].push_back(make_pair(dst, 0));
adj[dst].push_back(make_pair(src, 0));
}
g.build(v, e, adj);
fout << g.cc(1);
*/
// problema bfs de pe infoarena
// https://www.infoarena.ro/problema/bfs
/*
// problema Sortare topologica de pe infoarena
// https://www.infoarena.ro/problema/sortaret
ifstream fin("sortaret.in");
ofstream fout("sortaret.out");
int v, e, start;
Graph g(directed, unweighted);
vector<vector<pair<int, int>>> adj;
fin >> v >> e;
adj.resize(v + 1);
for(int i = 1; i <= e; ++i) {
int src, dst;
fin >> src >> dst;
adj[src].push_back(make_pair(dst, 0));
}
g.build(v, e, adj);
vector<int> topoOrder = g.topoSort();
for(auto v: topoOrder)
fout << v << ' ';
fout << '\n';
*/
/* pentru HavelHakimi, in vectorul 'forHavelHakimi'
punem secventa de numere despre care vrem sa vedem
daca poate reprezenta secventa gradelor unui graf
vector<int> forHavelHakimi = {1, 2, 1};
cout << HavelHakimi(forHavelHakimi);
*/
/*
*/
Graph g(true, true);
ifstream fin("ctc.in");
ofstream fout("ctc.out");
int v, e;
vector<vector<pair<int, int>>> adj;
fin >> v >> e;
adj.resize(v + 1);
for(int i = 1; i <= e; ++i) {
int src, dst;
fin >> src >> dst;
adj[src].push_back(make_pair(dst, 0));
}
g.build(v, e, adj);
vector<vector<int>> SOL = g.Kosaraju();
fout << SOL.size() << '\n';
for(int i = 0; i < SOL.size(); ++i)
{
for(int j = 0; j < SOL[i].size(); ++j)
fout << SOL[i][j] << ' ';
fout << '\n';
}
return 0;
}