迷宫的最短路径（局限版）

 
 

  
  //书上的例题，算法竞赛入门经典！！敲了一晚上终于AC了！！！还是水题。。
 
 
 
 

  
  #include<cstdio>
 
 
 
 

  
  #include<iostream>
 
 
 
 

  
  #include<algorithm>
 
 
 
 

  
  #include<cmath>
 
 
 
 

  
  #include<map>
 
 
 
 

  
  #include<queue>
 
 
 
 

  
  #include<stdlib.h>
 
 
 
 

  
  #include<string>
 
 
 
 

  
  #include<cstring>
 
 
 
 

  
  

 
 
 
 

  
  using 
  
  namespace 
  
  std
  
  ;
 
 
 
 

  
  const 
  
  int 
  
  MAX_N
  
  =
  
  10
  
  ;
 
 
 
 

  
  const 
  
  int 
  
  MAX_M
  
  =
  
  10
  
  ;
 
 
 
 

  
  

 
 
 
 

  
  const 
  
  int 
  
  INF 
  
  = 
  
  100000000
  
  ;
 
 
 
 

  
  

 
 
 
 

  
  typedef 
  
  pair
  
  <
  
  int 
  
  ,
  
  int
  
  > 
  
  P
  
  ;
 
 
 
 

  
  

 
 
 
 

  
  char 
  
  maze
  
  [
  
  MAX_N
  
  ][
  
  MAX_M
  
  +
  
  1
  
  ] 
  
  =
 
 
 
 

  
  {
 
 
 
 
    
  
  { 
  
  '#'
  
  , 
  
  'S'
  
  , 
  
  '#' 
  
  , 
  
  '#'
  
  ,
  
  '#'
  
  , 
  
  '#'
  
  , 
  
  '#'
  
  , 
  
  '#'
  
  , 
  
  '.'
  
  , 
  
  '#'
  
  },
 
 
 
 
    
  
  { 
  
  '.'
  
  , 
  
  '.'
  
  , 
  
  '.' 
  
  , 
  
  '.'
  
  ,
  
  '.'
  
  , 
  
  '.'
  
  , 
  
  '#'
  
  , 
  
  '.'
  
  , 
  
  '.'
  
  , 
  
  '#'
  
  },
 
 
 
 
    
  
  { 
  
  '.'
  
  , 
  
  '#'
  
  , 
  
  '.' 
  
  , 
  
  '#'
  
  ,
  
  '#'
  
  , 
  
  '.'
  
  , 
  
  '#'
  
  , 
  
  '#'
  
  , 
  
  '.'
  
  , 
  
  '#'
  
  },
 
 
 
 
    
  
  { 
  
  '.'
  
  , 
  
  '#'
  
  , 
  
  '.' 
  
  , 
  
  '.'
  
  ,
  
  '.'
  
  , 
  
  '.'
  
  , 
  
  '.'
  
  , 
  
  '.'
  
  , 
  
  '.'
  
  , 
  
  '.'
  
  },
 
 
 
 
    
  
  { 
  
  '#'
  
  , 
  
  '#'
  
  , 
  
  '.' 
  
  , 
  
  '#'
  
  ,
  
  '#'
  
  , 
  
  '.'
  
  , 
  
  '#'
  
  , 
  
  '#'
  
  , 
  
  '#'
  
  , 
  
  '#'
  
  },
 
 
 
 
    
  
  { 
  
  '.'
  
  , 
  
  '.'
  
  , 
  
  '.' 
  
  , 
  
  '.'
  
  ,
  
  '#'
  
  , 
  
  '.'
  
  , 
  
  '.'
  
  , 
  
  '.'
  
  , 
  
  '.'
  
  , 
  
  '#'
  
  },
 
 
 
 
    
  
  { 
  
  '.'
  
  , 
  
  '#'
  
  , 
  
  '#' 
  
  , 
  
  '#'
  
  ,
  
  '#'
  
  , 
  
  '#'
  
  , 
  
  '#'
  
  , 
  
  '#'
  
  , 
  
  '.'
  
  , 
  
  '#'
  
  },
 
 
 
 
    
  
  { 
  
  '.'
  
  , 
  
  '.'
  
  , 
  
  '.' 
  
  , 
  
  '.'
  
  ,
  
  '#'
  
  , 
  
  '.'
  
  , 
  
  '.'
  
  , 
  
  '.'
  
  , 
  
  '.'
  
  , 
  
  '.'
  
  },
 
 
 
 
    
  
  { 
  
  '.'
  
  , 
  
  '#'
  
  , 
  
  '#' 
  
  , 
  
  '#'
  
  ,
  
  '#'
  
  , 
  
  '.'
  
  , 
  
  '#'
  
  , 
  
  '#'
  
  , 
  
  '#'
  
  , 
  
  '.'
  
  },
 
 
 
 
    
  
  { 
  
  '.'
  
  , 
  
  '.'
  
  , 
  
  '.' 
  
  , 
  
  '.'
  
  ,
  
  '#'
  
  , 
  
  '.'
  
  , 
  
  '.'
  
  , 
  
  '.'
  
  , 
  
  'G'
  
  , 
  
  '#'
  
  },
 
 
 
 

  
  };
 
 
 
 

  
  

 
 
 
 

  
  int 
  
  N 
  
  = 
  
  10
  
  , 
  
  M 
  
  = 
  
  10
  
  ;
 
 
 
 

  
  int 
  
  sx 
  
  = 
  
  0
  
  ;
 
 
 
 

  
  int 
  
  sy 
  
  = 
  
  1
  
  ;
 
 
 
 

  
  int 
  
  gx 
  
  = 
  
  9
  
  ;
 
 
 
 

  
  int 
  
  gy 
  
  = 
  
  8
  
  ;
 
 
 
 

  
  int 
  
  d
  
  [
  
  MAX_N
  
  ][
  
  MAX_M
  
  ];
 
 
 
 

  
  int 
  
  dx
  
  [
  
  4
  
  ] 
  
  = 
  
  {
  
  1
  
  , 
  
  0
  
  , 
  
  -
  
  1
  
  , 
  
  0
  
  }, 
  
  dy
  
  [] 
  
  = 
  
  { 
  
  0
  
  , 
  
  1
  
  , 
  
  0
  
  , 
  
  -
  
  1
  
  };
 
 
 
 

  
  

 
 
 
 

  
  int 
  
  bfs
  
  ()
 
 
 
 

  
  {
 
 
 
 
    
  
  queue
  
  <
  
  P
  
  > 
  
  que
  
  ;
 
 
 
 
    
  
  // 初始化所有距离为INF
 
 
 
 
    
  
  for
  
  ( 
  
  int 
  
  i 
  
  = 
  
  0
  
  ; 
  
  i 
  
  < 
  
  N
  
  ;
  
  i
  
  ++
  
  )
 
 
 
 
    
  
  {
 
 
 
 
        
  
  for
  
  ( 
  
  int 
  
  j 
  
  = 
  
  0
  
  ; 
  
  j 
  
  <
  
  M
  
  ; 
  
  j
  
  ++
  
  )
 
 
 
 
        
  
  {
 
 
 
 
            
  
  d
  
  [
  
  i
  
  ][
  
  j
  
  ] 
  
  = 
  
  INF
  
  ;
 
 
 
 
        
  
  }
 
 
 
 
    
  
  }
 
 
 
 

  
  

 
 
 
 
    
  
  // 将起点加入队列，并将这一点的距离设置为0
 
 
 
 
    
  
  que
  
  .
  
  push
  
  (
  
  P
  
  (
  
  sx
  
  , 
  
  sy
  
  ));
 
 
 
 
    
  
  d
  
  [
  
  sx
  
  ][
  
  sy
  
  ] 
  
  = 
  
  0
  
  ;
 
 
 
 
    
  
  while
  
  ( 
  
  que
  
  .
  
  size
  
  ())
 
 
 
 
    
  
  {
 
 
 
 
        
  
  P 
  
  p 
  
  = 
  
  que
  
  .
  
  front
  
  ();
  
  que
  
  .
  
  pop
  
  ();
 
 
 
 
        
  
  if
  
  (
  
  p
  
  .
  
  first 
  
  == 
  
  gx
  
  && 
  
  p
  
  .
  
  second 
  
  == 
  
  gy
  
  )
 
 
 
 
            
  
  break
  
  ;
 
 
 
 

  
  

 
 
 
 
        
  
  // 向四个方向循环
 
 
 
 
        
  
  for
  
  ( 
  
  int 
  
  i 
  
  = 
  
  0
  
  ; 
  
  i 
  
  <
  
  4
  
  ; 
  
  i
  
  ++ 
  
  )
 
 
 
 
        
  
  {
 
 
 
 
            
  
  // 移动之后的坐标
 
 
 
 
            
  
  int 
  
  nx 
  
  = 
  
  p
  
  .
  
  first 
  
  +
  
  dx
  
  [
  
  i
  
  ];
 
 
 
 
            
  
  int 
  
  ny 
  
  = 
  
  p
  
  .
  
  second
  
  + 
  
  dy
  
  [
  
  i
  
  ];
 
 
 
 

  
  

 
 
 
 
            
  
  // 判断是否可以移动以及是否已经访问过(d[nx][ny] != INF即已经访问过)
 
 
 
 
            
  
  if
  
  (
  
  0
  
  <= 
  
  nx
  
  && 
  
  nx 
  
  < 
  
  N 
  
  && 
  
  0 
  
  <= 
  
  ny 
  
  && 
  
  ny 
  
  < 
  
  M 
  
  &&
  
  maze
  
  [
  
  nx
  
  ][
  
  ny
  
  ] 
  
  != 
  
  '#' 
  
  && 
  
  d
  
  [
  
  nx
  
  ][
  
  ny
  
  ] 
  
  == 
  
  INF
  
  )
 
 
 
 
            
  
  {
 
 
 
 
                
  
  // 可以移动的话，将它加入队列，并且到达该位置的距离确定为到p的距离+1
 
 
 
 
                
  
  que
  
  .
  
  push
  
  (
  
  P
  
  (
  
  nx
  
  ,
  
  ny
  
  ));
 
 
 
 
                
  
  d
  
  [
  
  nx
  
  ][
  
  ny
  
  ] 
  
  = 
  
  d
  
  [
  
  p
  
  .
  
  first
  
  ][
  
  p
  
  .
  
  second
  
  ]
  
  + 
  
  1
  
  ;
 
 
 
 
            
  
  }
 
 
 
 
        
  
  }
 
 
 
 
    
  
  }
 
 
 
 

  
  

 
 
 
 
    
  
  return 
  
  d
  
  [
  
  gx
  
  ][
  
  gy
  
  ];
 
 
 
 

  
  }
 
 
 
 

  
  

 
 
 
 

  
  int 
  
  main
  
  ()
 
 
 
 

  
  {
 
 
 
 

  
  

 
 
 
 
    
  
  int 
  
  res 
  
  = 
  
  bfs
  
  ();
 
 
 
 

  
  

 
 
 
 
    
  
  printf
  
  (
  
  "%d/n"
  
  ,
  
  res
  
  );
 
 
 
 
    
  
  return 
  
  0
  
  ;
 
 
 
 

  
  }