uva 280 - Vertex

 #include <iostream>
 #include <cstdio>
 using namespace std;

 #include <vector>
 #define loop(i, n) for (int i = 0; i < n; i++)
 #define loopfrom1(i, n) for (int i =1; i < n; i++)
 #define pb(a) push_back(a)
 #define SZ size()
 #define getint(n) scanf("%d", &n)

 #define MAXX 105
 #define looptill(i, n) for (int i = 0; i <= n; i++)

 vector<int> Graph[MAXX];
 bool visited[MAXX];
 int inaccessible;

 void dfs(int u)
 {
     int len = Graph[u].SZ;
     int v;
     loop(i, len)
     {
         v = Graph[u][i];
         if( ! visited[v] )
         {
             visited[v] = true;
             inaccessible --;
             dfs(v);
         }
     }
 }

 int main()
 {
     int number_of_nodes, total_nodes;
     int node1, node2;
     while(true)
     {
         getint(total_nodes);
         if(total_nodes == ) break;
         looptill(i, total_nodes)
         {
             Graph[i].clear();
         }

         while(true)
         {
             getint(node1);
             if(node1 == ) break;
             while(true)
             {
                 getint (node2);
                 if(node2 == ) break;
                 Graph[node1].pb(node2);
             }
         }

         getint(number_of_nodes);
         loop(t, number_of_nodes)
         {
             looptill(i, total_nodes)
             {
                 visited[i] = false;
             }

             getint(node1);
             inaccessible = total_nodes;
             dfs(node1);

             cout << inaccessible;

             for (int j = ; j <= total_nodes; j++)
             {
                 if( ! visited[j] )
                 {
                     cout <<" "<<j;
                 }
             }
             cout << endl;
         }
     }
     return ;
 }

 // @BEGIN_OF_SOURCE_CODE

 #include <iostream>
 #include <algorithm>
 #include <cstring>
 #include <string>
 #include <cctype>
 #include <vector>
 #include <map>
 #include <set>
 #include <math.h>
 #define For(a) for ( i = 0; i < a; i++ )
 #define Rep(a, b) for ( i = a; i <= b; i++ )
 #define N 1000000
 using namespace std;

 enum related_color {gray, white, black};

 bool matrix [ + ] [ + ];
 bool related_vertics [ + ];
 related_color color [ + ];
 int number_of_vertics_n;

 void reset_all (int n)
 {
     for ( int i = ; i < n; i++ ) {
         for ( int j = ; j < n; j++ )
             matrix [i] [j] = false;
     }
 }

 void dfs (int u)
 {
     color [u] = gray;

     for ( int i = ; i < number_of_vertics_n; i++ ) {
         if ( matrix [u] [i] ) {
             related_vertics [i] = true;
             if ( color [i] == white ) {
                 related_vertics [i] = true;
                 dfs (i);
             }
         }
     }

     color [u] = black;
 }

 int main ()
 {
     while ( scanf ("%d", &number_of_vertics_n) && number_of_vertics_n ) {
         reset_all (number_of_vertics_n);

         int starting_vertex;

         while ( scanf ("%d", &starting_vertex) && starting_vertex ) {
             int series_of_edges;
             while ( scanf ("%d", &series_of_edges) && series_of_edges ) {
                 matrix [starting_vertex - ] [series_of_edges - ] = true;
             }
         }

         int testCase;
         scanf ("%d", &testCase);

         while ( testCase-- ) {
             int query;
             scanf ("%d", &query);

             for ( int i = ; i < number_of_vertics_n; i++ ) {
                 related_vertics [i] = false;
                 color [i] = white;
             }

             dfs (query - );

             vector <int> v;

             for ( int i = ; i < number_of_vertics_n; i++ ) {
                 if ( !related_vertics [i] )
                     v.push_back (i + );
             }

             printf ("%d", v.size ());

             for ( unsigned int i = ; i < v.size (); i++ )
                 printf (" %d", v [i]);

             printf ("\n");
         }

         /*
         for ( int i = 0; i < number_of_vertics_n; i++ ) {
             for ( int j = 0; j < number_of_vertics_n; j++ )
                 related_vertics [j] = false;

             dfs (i);

             for ( int j = 0; j < number_of_vertics_n; j++ ) {
                 if ( related_vertics [j] )
                     matrix [i] [j] = true;
             }
         }
         */
     }

     return ;
 }

 // @END_OF_SOURCE_CODE