zoj1119 SPF

#include <cstdlib>

#include <iostream>

#include <queue>

#include <stack>



using namespace std;



struct Edge{

       int to;

       Edge*next;

       void insert(Edge* e)

       {

            e->next = next;

            next = e;

       }

};



class Graph{

  private:

        Edge** adj;

        int n;

  public:

       Graph(int s);

       ~Graph();

       void Insert(int i, int j);

       void Bfs(int v, int*id, int cid);

       void Dfs(int v);

       Edge* Remove(int v);

       void Insert(Edge* list, int v);

       int Components();

       bool HasEdge(int v);

};



Graph::Graph(int s)

{

    n = s;

    adj = (Edge**) malloc(sizeof(Edge*)*n);

    for (int i = 0; i < n; i++)

    {

       adj[i] = (Edge*) malloc(sizeof(Edge));

       adj[i]->next = NULL;

    }

}



Graph::~Graph()

{

    for (int v = 0; v<n; v++)

    {

        Edge* e = adj[v]->next;

        while (e)

        {

              adj[v]->next = e->next;

              free(e);

              e = adj[v]->next;

        }

    }

    free(adj);

}



void Graph::Insert(int i, int j)

{

    Edge* ei = (Edge*) malloc(sizeof(Edge));

    Edge* ej = (Edge*) malloc(sizeof(Edge));

    ei->to = i; ej->to = j;

    adj[i]->insert(ej);

    adj[j]->insert(ei);

}



//Remove all edges attaches to v

Edge* Graph::Remove(int v)

{

     for (Edge* e = adj[v]->next; e; e=e->next)

     {

         int w = e->to;

         for(Edge*p = adj[w], *eg=p->next; eg; )

         {

               if (eg->to == v)

               {

                   p->next = eg->next;

                   free(eg);

                   eg = p->next;

                   break;

               }

               else

               {

                   p = eg; eg = eg->next;

               }

         }

     }

     Edge *list = adj[v]->next;

     adj[v]->next = NULL;

     return list;

}



void Graph::Insert(Edge* list, int v)

{

     adj[v]->next = list;

     for (Edge* e = list; e; e = e->next)

     {

         int w = e->to;

         Edge* ee = (Edge*) malloc(sizeof(Edge));

         ee->to = v;

         adj[w]->insert(ee);

     }

}



bool Graph::HasEdge(int v)

{

     return adj[v]->next && adj[v]->next->next;

}



void Graph::Bfs(int v, int*id, int cid)

{

     queue<int> Q;

     Q.push(v);

     id[v]  = cid;

     while (!Q.empty())

     {

       v = Q.front();Q.pop();

       Edge* e = adj[v]->next;

       while (e)

       {

           int w =  e->to;

           if (!id[w]){

               Q.push(w);

               id[w] = cid;

           }

           e = e->next;

       }

     }

}



void Graph::Dfs(int v)

{

     int cnt = 2;

     int* id = (int*)malloc(sizeof(int)*n);

     memset(id, 0, sizeof(int)*n);

     id[v] = 1;

     stack<Edge*> S;

     S.push(adj[v]->next);

     while(!S.empty())

     {

        Edge* e = S.top(); S.pop();

        int w = e->to;

        if (e->next) S.push(e->next);

        if (id[w] == 0){

              id[w] = cnt++;

              if (adj[w]->next) S.push(adj[w]->next);

        }

     }      

}



int Graph::Components()

{

    int* id = (int*) malloc(sizeof(int)*n);

    memset(id, 0, sizeof(int)*n);

    int cid = 1;

    for (int v = 0; v < n; v++)

    {

        if (id[v]==0){ Bfs(v, id, cid); cid++; }

    }

    free(id);

    return cid-1;

}





int main(int argc, char *argv[])

{

    int t=1;

    while(1)

    {

            Graph g(1001);

            int v, w;

            int a = 0;

            while(scanf("%d", &v), v)

            {

                  scanf("%d", &w);

                  a++;

                  g.Insert(v, w);

            }

            if (a==0) break;

            if (t > 1) printf("/n");

            printf("Network #%d/n", t++);

            int cmp = g.Components(), com;

            int cnt = 0;

            

            for (int i = 1; i < 1001; i++)

            {

                if (!g.HasEdge(i)) continue;

                Edge* list = g.Remove(i);

                com = g.Components();

                if (com > cmp+1)

                {

                        cnt++;

                        printf("  SPF node %d leaves %d subnets/n", i, com-cmp);

                }

                g.Insert(list, i);

            }

            if (cnt == 0) printf("  No SPF nodes/n");

    }

        

}