POJ 1125 单源最短路 dijkstra的算法初步探索

 
 

  
  //好久没有写对题了，心里有点慌，这题遇到了很大的障碍，
 
 
 
 

  
  //debug了好久 还是太不熟悉了 
 
 
 
 

  
  //最短路
 
 
 
 

  
  //边权为正，有向边
 
 
 
 

  
  //可能会有不连通的点哦
 
 
 
 

  
  //用dijkstra算法应该可行
 
 
 
 

  
  //现在自己试试
 
 
 
 

  
  //忘记返回函数的值了，还有把源点去掉
 
 
 
 

  
  //这个复杂度是n三方的
 
 
 
 

  
  #include<cstdio>
 
 
 
 

  
  #include<cstring>
 
 
 
 

  
  #include<algorithm>
 
 
 
 

  
  #define INF 1000+100
 
 
 
 

  
  using 
  
  namespace 
  
  std
  
  ;
 
 
 
 

  
  

 
 
 
 

  
  const 
  
  int 
  
  maxn
  
  =
  
  100
  
  +
  
  10
  
  ;
 
 
 
 

  
  int 
  
  w
  
  [
  
  maxn
  
  ][
  
  maxn
  
  ];
  
  //边的权值
 
 
 
 

  
  int 
  
  d
  
  [
  
  maxn
  
  ];
 
 
 
 

  
  bool 
  
  vis
  
  [
  
  maxn
  
  ];
 
 
 
 

  
  int 
  
  fa
  
  [
  
  maxn
  
  ];
 
 
 
 

  
  int 
  
  n
  
  ;
 
 
 
 

  
  void 
  
  read_graph
  
  (
  
  void
  
  )
 
 
 
 

  
  {
 
 
 
 
        
  
  for
  
  (
  
  int 
  
  i
  
  =
  
  1
  
  ;
  
  i
  
  <=
  
  n
  
  ;
  
  i
  
  ++
  
  )
 
 
 
 
            
  
  for
  
  (
  
  int 
  
  j
  
  =
  
  1
  
  ;
  
  j
  
  <=
  
  n
  
  ;
  
  j
  
  ++
  
  )
 
 
 
 
                
  
  w
  
  [
  
  i
  
  ][
  
  j
  
  ]
  
  =
  
  INF
  
  ;
 
 
 
 
        
  
  memset
  
  (
  
  fa
  
  ,
  
  0
  
  ,
  
  sizeof
  
  (
  
  fa
  
  ));
 
 
 
 
        
  
  for
  
  (
  
  int 
  
  i
  
  =
  
  1
  
  ;
  
  i
  
  <=
  
  n
  
  ;
  
  i
  
  ++
  
  )
  
  //读入图
 
 
 
 
        
  
  {
 
 
 
 
            
  
  int 
  
  m
  
  ;
  
  //边的个数
 
 
 
 
            
  
  int 
  
  v
  
  ,
  
  t
  
  ;
  
  //边的一个端点和所耗费的时间
 
 
 
 
            
  
  scanf
  
  (
  
  "%d"
  
  ,
  
  &
  
  m
  
  );
 
 
 
 
            
  
  for
  
  (
  
  int 
  
  j
  
  =
  
  1
  
  ;
  
  j
  
  <=
  
  m
  
  ;
  
  j
  
  ++
  
  )
 
 
 
 
            
  
  {
 
 
 
 
                
  
  scanf
  
  (
  
  "%d %d"
  
  ,
  
  &
  
  v
  
  ,
  
  &
  
  t
  
  );
 
 
 
 
                
  
  w
  
  [
  
  i
  
  ][
  
  v
  
  ]
  
  =
  
  t
  
  ;
 
 
 
 
            
  
  }
 
 
 
 
        
  
  }
 
 
 
 
 
  
  /*       for(int i=1;i<=n;i++)
 
 
 
 

  
   //           for(int j=1;j<=n;j++)
 
 
 
 

  
   //           printf("%d%c",w[i][j],j==n?'\n':' ');
 
 
 
 

  
  */
 
 
 
 

  
  }
 
 
 
 

  
  int 
  
  dijkstra
  
  (
  
  int 
  
  s
  
  )
 
 
 
 

  
  {
 
 
 
 
    
  
  //dijkstra
 
 
 
 
        
  
  memset
  
  (
  
  vis
  
  ,
  
  false
  
  ,
  
  sizeof
  
  (
  
  vis
  
  ));
  
  //初始化所有点都没有访问过
 
 
 
 

  
  

 
 
 
 
        
  
  for
  
  (
  
  int 
  
  i
  
  =
  
  1
  
  ;
  
  i
  
  <=
  
  n
  
  ;
  
  i
  
  ++
  
  ) 
  
  d
  
  [
  
  i
  
  ]
  
  =
  
  INF
  
  ;
  
  //初始化距离
 
 
 
 
        
  
  d
  
  [
  
  s
  
  ]
  
  =
  
  0
  
  ;
 
 
 
 

  
  

 
 
 
 
        
  
  int 
  
  ans
  
  =
  
  0
  
  ;
 
 
 
 
        
  
  for
  
  (
  
  int 
  
  i
  
  =
  
  1
  
  ;
  
  i
  
  <=
  
  n
  
  ;
  
  i
  
  ++
  
  )
 
 
 
 
        
  
  {
 
 
 
 
            
  
  int 
  
  x
  
  ,
  
  m
  
  =
  
  INF
  
  ;
 
 
 
 
            
  
  for
  
  (
  
  int 
  
  j
  
  =
  
  1
  
  ;
  
  j
  
  <=
  
  n
  
  ;
  
  j
  
  ++
  
  )
 
 
 
 
            
  
  {
 
 
 
 
                
  
  if
  
  (
  
  !
  
  vis
  
  [
  
  j
  
  ]
  
  &&
  
  m
  
  >=
  
  d
  
  [
  
  j
  
  ]){
  
  m
  
  =
  
  d
  
  [
  
  j
  
  ]; 
  
  x
  
  =
  
  j
  
  ; 
  
  }
 
 
 
 

  
  

 
 
 
 
            
  
  }
 
 
 
 
            
  
  vis
  
  [
  
  x
  
  ]
  
  =
  
  1
  
  ;
 
 
 
 
            
  
  for
  
  (
  
  int 
  
  y
  
  =
  
  1
  
  ;
  
  y
  
  <=
  
  n
  
  ;
  
  y
  
  ++
  
  )
 
 
 
 
            
  
  {
 
 
 
 
                
  
  if
  
  (
  
  d
  
  [
  
  y
  
  ]
  
  >
  
  d
  
  [
  
  x
  
  ]
  
  +
  
  w
  
  [
  
  x
  
  ][
  
  y
  
  ]) 
  
  {
  
  d
  
  [
  
  y
  
  ]
  
  =
  
  d
  
  [
  
  x
  
  ]
  
  +
  
  w
  
  [
  
  x
  
  ][
  
  y
  
  ];
  
  fa
  
  [
  
  y
  
  ]
  
  =
  
  x
  
  ; 
  
  }
 
 
 
 
            
  
  }
 
 
 
 

  
  

 
 
 
 
        
  
  }
 
 
 
 
        
  
  for
  
  (
  
  int 
  
  i
  
  =
  
  1
  
  ;
  
  i
  
  <=
  
  n
  
  ;
  
  i
  
  ++
  
  )   
  
  {
  
  if
  
  (
  
  i
  
  !=
  
  s
  
  ) 
  
  ans
  
  =
  
  max
  
  (
  
  ans
  
  ,
  
  d
  
  [
  
  i
  
  ]);}
 
 
 
 
        
  
  return 
  
  ans
  
  ;
 
 
 
 

  
  }
 
 
 
 

  
  int 
  
  main
  
  ()
 
 
 
 

  
  {
 
 
 
 

  
  

 
 
 
 
    
  
  while
  
  (
  
  scanf
  
  (
  
  "%d"
  
  ,
  
  &
  
  n
  
  )
  
  &&
  
  n
  
  !=
  
  0 
  
  )
 
 
 
 
    
  
  {
 
 
 
 
        
  
  int 
  
  anss
  
  =
  
  0
  
  ;
 
 
 
 
        
  
  int 
  
  ans
  
  =
  
  INF
  
  ;
 
 
 
 
        
  
  read_graph
  
  ();
 
 
 
 
        
  
  for
  
  (
  
  int 
  
  i
  
  =
  
  1
  
  ;
  
  i
  
  <=
  
  n
  
  ;
  
  i
  
  ++
  
  )
 
 
 
 
        
  
  {
 
 
 
 
            
  
  int 
  
  temp
  
  =
  
  dijkstra
  
  (
  
  i
  
  );
 
 
 
 
            
  
  if
  
  (
  
  temp
  
  <
  
  ans
  
  ) 
  
  { 
  
  ans
  
  =
  
  temp
  
  ;
  
  anss
  
  =
  
  i
  
  ; 
  
  }
 
 
 
 
        
  
  }
 
 
 
 
        
  
  if
  
  (
  
  ans
  
  ==
  
  INF
  
  ) 
  
  printf
  
  (
  
  "disjoint
  
  \n
  
  "
  
  );
 
 
 
 
        
  
  else    
  
  printf
  
  (
  
  "%d %d
  
  \n
  
  "
  
  ,
  
  anss
  
  ,
  
  ans
  
  );
 
 
 
 

  
  

 
 
 
 
    
  
  }
 
 
 
 
    
  
  return 
  
  0
  
  ;
 
 
 
 

  
  }