静态邻接表

　　上次比赛的时候有一道题目要用到最小生成树，用动态邻接表存储边的结构，结果MLE。实际上很多次了，没有学会用静态邻接表，吃亏不小。

       今天趁着Lost大牛来这请客并教育我一番的劲头下，到它（哦，不，是他）的blog上偷盗了他的邻接表代码，花了一个晚上的时间，自己加上了自己的注释，并且加上了权的情况，终于把它搞懂了！

 

代码

   
     

    
      
    
      #include 
    
      <
    
      iostream
    
      >
    
      
#include 
    
      <
    
      queue
    
      >
    
      

    
      using
    
       
    
      namespace
    
       std;

    
      const
    
       
    
      long
    
       edge_maxn 
    
      =
    
       
    
      1005
    
      ; 
    
      //
    
      边的最大上限
    
      

    
      const
    
       
    
      long
    
       point_maxn 
    
      =
    
       
    
      105
    
      ; 
    
      //
    
      点的最大上限
    
      

    
      struct
    
       node
{
    
      /*
    
      node存储边，一个edge代表一条边
    
      */
    
      
 
    
      int
    
       v; 
    
      //
    
      终点位置
    
      

    
       
    
      int
    
       w; 
    
      //
    
      权值
    
      

    
       
    
      int
    
       next; 
    
      //
    
      同一起点的下一条边存储在edge数组中的位置（理解了这个静态邻接表就可以了）
    
      

    
      }edge[edge_maxn];

    
      int
    
       pre[point_maxn]; 
    
      //
    
      以该点为起点的第一条边存储在edge数组中的位置
    
      

    
      int
    
       n; 
    
      //
    
      点的数量
    
      

    
      int
    
       m; 
    
      //
    
      边的数量
    
      

    
      void
    
       Init()
{
 memset(pre,
    
      -
    
      1
    
      ,
    
      sizeof
    
      (pre));
 
    
      int
    
       Index 
    
      =
    
       
    
      1
    
      ;
 
    
      int
    
       i,x,y,w;
 
    
      for
    
      (i
    
      =
    
      0
    
      ;i
    
      <
    
      m;i
    
      ++
    
      )
 {
 scanf(
    
      "
    
      %d%d%d
    
      "
    
      ,
    
      &
    
      x,
    
      &
    
      y,
    
      &
    
      w);
 
 edge[Index].v 
    
      =
    
       y;
 edge[Index].w 
    
      =
    
       w;
 edge[Index].next 
    
      =
    
       pre[x]; 
    
      //
    
      保存x起点的上一条边在edge数组中的位置
    
      

    
       pre[x] 
    
      =
    
       Index
    
      ++
    
      ; 
    
      //
    
      位置更新
    
      

    
       }
}

    
      void
    
       print()
{
 
    
      for
    
      (
    
      int
    
       i
    
      =
    
      1
    
      ;i
    
      <=
    
      n;i
    
      ++
    
      )
 {
 printf(
    
      "
    
      %d\n
    
      "
    
      ,i);
 
    
      for
    
      (
    
      int
    
       j
    
      =
    
      pre[i];j
    
      !=-
    
      1
    
      ;j
    
      =
    
      edge[j].next)
 {
 printf(
    
      "
    
       -> %d value is %d\n
    
      "
    
      ,edge[j].v,edge[j].w);
 }
 
    
      //
    
      printf("\n");
    
      

    
       }
}

    
      int
    
       main()
{
 
    
      while
    
      (scanf(
    
      "
    
      %d%d
    
      "
    
      ,
    
      &
    
      n,
    
      &
    
      m)
    
      !=
    
      EOF 
    
      &&
    
       (n
    
      !=
    
      0
    
       
    
      ||
    
       m
    
      !=
    
      0
    
      ))
 {
 Init();
 print();
 }
 
    
      return
    
       
    
      0
    
      ;
}