图的操作，没做出来，WA呀，遗憾～～

1157.寻找一星龙珠

Time Limit : 1000 MS         Memory Limit : 65536 K
Total Submissions : 192 (65 users)         Accepted : 46 (45 users)

 

Description

　 　上次神龙实现愿望后，七龙珠散落各处。如今一年过去了，悟空又开始了新的寻找征途。小悟空在寻找的途中遇到了红缎带军团，该军团虽然个人能力远不及悟 空，但是他们却研究出了一个新的阵法。该阵法由N个阵眼组成，每个阵眼可以与旁边若干阵眼相互配合，从而形成一个连通的整体，威力无穷。悟空与之大战三百 回合，依然无法占到上方，但却发现了破阵之法。该阵法讲究整体，若其中某个阵眼被摧毁，使得余下的阵眼不能再形成一个协作的整体，那么阵法的威力将减。现 在悟空准备集中全力摧毁其中一个阵眼 ，但又只想花费最小的攻击代价。假设攻击某个阵眼需要的代价为C，C = 与该点协作的所有阵眼个数+1。现在的小悟空思考能力还比较差，所以请你帮帮他吧。

 

Input

　　第一行输入N，M。 N(1<N<100)表示阵点数,N个阵眼的编号分别为1,2,...,N。M表示协作关系。
　　接下来M行，每行输入两个数字v1 v2，表示这两个阵眼之间可以互相协作，输入保证不会重复。

 

Output

　　如果剑阵本身就不是一个整体，请输出"0"，不包含引号；
　　如果不存在满足条件的攻击阵眼，请输出"No"，不包含引号；
　　如果存在满足条件的攻击阵眼，分两行输出，第一行输出最小攻击代价；第二行输出攻击代价最小的所有可攻击阵眼的编号。若存在多个，请按编号从小到大的顺序依次输出，中间用空格隔开。

 

Sample Input

5 6
1 2
2 3
3 1
3 4
3 5
4 5

 

Sample Output

5
3

 

Source

zzz

#include<iostream>
#include<malloc.h>
#include<fstream>
#define Vnum 100
using namespace std;

typedef struct arcnode
{
  int adjvex;
   struct  arcnode *nextarc;
}arcnode;
typedef struct vexnode
{
  int vervex;
  arcnode *firstarc;
}adjlist[Vnum];
typedef struct graph
{
  adjlist a_list;
  int vexnum,arcnum;
}graph;

void create(graph *g)
{
  //    ifstream cin("a.in");
  int n,e,i,j,k;
  arcnode *p;
  cin>>n;
  cin>>e;
  g->vexnum=n;
  g->arcnum=e;
  for(i=1;i<=g->vexnum;i++)
    {
      g->a_list[i].vervex=i;
      g->a_list[i].firstarc=NULL;
    }
  for(k=0;k<e;k++)
    {
      cin>>i>>j;

      p=(arcnode *)malloc(sizeof(arcnode));
      p->adjvex=j;
      p->nextarc=g->a_list[i].firstarc;
      g->a_list[i].firstarc=p;

      p=(arcnode *)malloc(sizeof(arcnode));
      p->adjvex=i;
      p->nextarc=g->a_list[j].firstarc;
      g->a_list[j].firstarc=p;

    }
  g->arcnum*=2;
}
/*
void dis(graph *g)
{
  int i,have;
  arcnode *p;
  for(int i=1;i<=g->vexnum;i++)
    {
      p=g->a_list[i].firstarc;
      have=0;
      while(p!=NULL)
    {
      cout<<"("<<i<<","<<p->adjvex<<")";
      p=p->nextarc;
      have=1;
    }
      if(have) cout<<endl;
    }
}
*/
void dfs(graph g,int v,int visited[])
{
  arcnode *p;
  //  cout<<v<<" ";
  visited[v]=1;
  p=g.a_list[v].firstarc;
  while(p!=NULL)
    {
      if(!visited[p->adjvex])
    {
      dfs(g,p->adjvex,visited);
    }
      p=p->nextarc;
    }
}
int outdegree(graph g,int v)
{
  arcnode *p;
  int n=0;
  p=g.a_list[v].firstarc;
  while(p!=NULL)
    {
      n++;
      p=p->nextarc;
    }
  return n;
}
int connect(graph g)
{
  int i,flag=1;
  int visited[Vnum];
  for(int i=0;i<=g.vexnum;i++)
    {
      visited[i]=0;
    }
  dfs(g,1,visited);
  for(i=1;i<g.vexnum;i++)
    {
      if(visited[i]==0)
    {
      flag=0;
      break;
    }
    }
  return flag;
}
int maxa(int a[],int n)
{
  int max=0;
  if(n==0)
    {
      return a[0];
    }
  else
    {
  for(int i=0;i<n;i++)
    {
      if(a[i]>max) max=a[i];
    }
  return max;
    }
}
void maxoutds(graph g)
{
  int maxv=0,maxds=0,i,x;
  for(i=0;i<g.vexnum;i++)
    {
      x=outdegree(g,i+1);
      if(x>maxds)
    {
      maxds=x;
      maxv=i;
    }
    }
  cout<<maxv+1<<endl;
}
int main()
{
  graph g;
  int a[100],b[100],c[100];
  create(&g);
  int visit[Vnum];
  for(int i=1;i<Vnum;i++)
    {
      visit[0]=0;
    }
    dfs(g,1,visit);
  int flag=1;
  int j=0;

  for(int i=0;i<g.vexnum;i++)
    {
      a[i]=outdegree(g,i+1);
      //            cout<<a[i]<<" ";
      if(a[i]>2)
    {
        flag=1;
               b[j]=a[i];
    c[j]=i;
    //    cout<<c[j]<<"#";
        j++;

    }
    }
  if(!connect(g)) printf("0");

  if(!flag)
    {
      //     printf("%d/n",maxa(b,j-1)+1);
      printf("N0/n");

    }
  if(j==1)
    {
      printf("%d/n%d/n",b[0]+1,c[0]+1);
    }
  else
    {
      for(int i=0;i<j;i++)
    {
      printf("%d %d ",b[i]+1,c[i]+1);
    }
    }
  //  maxoutds(g);
  //  dis(&g);

  return 0;
}