POJ 3026 Brog Maze

解题思路：BFS 找出所有点之间的最短距离，Prim求解最小生成树

  
    

   
     
   
     #include 
   
     <
   
     iostream
   
     >
   
     

   
     using
   
      
   
     namespace
   
      std;


   
     #define
   
      MaxNum 30000
   
     


   
     struct
   
      point
{
 
   
     int
   
      x,y;
};


   
     int
   
      main()
{
 
   
     int
   
      n, row, col, vn, begin, end, x, y, start, tempS, min, t;
 
   
     string
   
      str;
 
   
     char
   
      map[
   
     55
   
     ][
   
     55
   
     ];
 
   
     short
   
      dist[
   
     55
   
     ][
   
     55
   
     ];
 point 
   
     as
   
     [
   
     105
   
     ], queue[
   
     3000
   
     ];
 
   
     const
   
      
   
     int
   
      direc[
   
     4
   
     ][
   
     2
   
     ] 
   
     =
   
      {{
   
     0
   
     , 
   
     1
   
     }, {
   
     0
   
     , 
   
     -
   
     1
   
     }, {
   
     1
   
     , 
   
     0
   
     }, {
   
     -
   
     1
   
     , 
   
     0
   
     }};
 
   
     int
   
      minDist[
   
     105
   
     ][
   
     105
   
     ];

 
   
     int
   
      PrimDist[
   
     105
   
     ];
 
   
     bool
   
      visited[
   
     105
   
     ];

 cin 
   
     >>
   
      n;
 
   
     while
   
      (n
   
     --
   
     )
 {
 vn 
   
     =
   
      
   
     0
   
     ;
 cin 
   
     >>
   
      col 
   
     >>
   
      row;
 
   
     while
   
     (getchar() 
   
     !=
   
      
   
     '
   
     \n
   
     '
   
     );
 
   
     for
   
      (
   
     int
   
      i 
   
     =
   
      
   
     0
   
     ; i 
   
     <
   
      row; i
   
     ++
   
     )
 {
 cin.getline(map[i], 
   
     55
   
     );
 
   
     for
   
      (
   
     int
   
      j 
   
     =
   
      
   
     0
   
     ; j 
   
     <
   
      col; j
   
     ++
   
     )
 {
 
   
     if
   
      (map[i][j] 
   
     ==
   
      
   
     '
   
     A
   
     '
   
      
   
     ||
   
      map[i][j] 
   
     ==
   
      
   
     '
   
     S
   
     '
   
     )
 {
 
   
     as
   
     [vn].x 
   
     =
   
      j;
 
   
     as
   
     [vn].y 
   
     =
   
      i;
 vn
   
     ++
   
     ;
 }
 }
 }
 
   
     for
   
      (
   
     int
   
      i 
   
     =
   
      
   
     0
   
     ; i 
   
     <
   
      vn 
   
     -
   
      
   
     1
   
     ; i
   
     ++
   
     )
 {
 fill(
   
     &
   
     dist[
   
     0
   
     ][
   
     0
   
     ], 
   
     &
   
     dist[
   
     54
   
     ][
   
     55
   
     ], MaxNum);
 dist[
   
     as
   
     [i].y][
   
     as
   
     [i].x] 
   
     =
   
      
   
     0
   
     ;
 queue[
   
     0
   
     ] 
   
     =
   
      
   
     as
   
     [i];
 begin 
   
     =
   
      end 
   
     =
   
      
   
     0
   
     ;
 
   
     while
   
      (begin 
   
     <=
   
      end)
 {
 
   
     for
   
      (
   
     int
   
      j 
   
     =
   
      
   
     0
   
     ; j 
   
     <
   
      
   
     4
   
     ; j
   
     ++
   
     )
 {
 x 
   
     =
   
      queue[begin].x 
   
     +
   
      direc[j][
   
     0
   
     ];
 y 
   
     =
   
      queue[begin].y 
   
     +
   
      direc[j][
   
     1
   
     ];
 
   
     if
   
      (dist[y][x] 
   
     >
   
      (dist[queue[begin].y][queue[begin].x] 
   
     +
   
      
   
     1
   
     ) 
   
     &&
   
      map[y][x] 
   
     !=
   
      
   
     '
   
     #
   
     '
   
     )
 {
 dist[y][x] 
   
     =
   
      dist[queue[begin].y][queue[begin].x] 
   
     +
   
      
   
     1
   
     ;
 end
   
     ++
   
     ;
 queue[end].x 
   
     =
   
      x;
 queue[end].y 
   
     =
   
      y;
 }
 }
 begin
   
     ++
   
     ;
 }
 
   
     for
   
      (
   
     int
   
      j 
   
     =
   
      
   
     0
   
     ; j 
   
     <
   
      vn; j
   
     ++
   
     )
 minDist[i][j] 
   
     =
   
      minDist[j][i] 
   
     =
   
      dist[
   
     as
   
     [j].y][
   
     as
   
     [j].x];
 }
 minDist[vn 
   
     -
   
      
   
     1
   
     ][vn 
   
     -
   
      
   
     1
   
     ] 
   
     =
   
      
   
     0
   
     ;

 fill(
   
     &
   
     PrimDist[
   
     1
   
     ], 
   
     &
   
     PrimDist[vn], MaxNum);
 memset(visited, 
   
     0
   
     , 
   
     sizeof
   
     (
   
     bool
   
     ) 
   
     *
   
      vn);
 PrimDist[
   
     0
   
     ] 
   
     =
   
      
   
     0
   
     ;
 start 
   
     =
   
      
   
     0
   
     ;
 
   
     while
   
      (start 
   
     !=
   
      
   
     -
   
     1
   
     )
 {
 visited[start] 
   
     =
   
      
   
     true
   
     ;
 tempS 
   
     =
   
      
   
     -
   
     1
   
     ;
 min 
   
     =
   
      MaxNum;

 
   
     for
   
      (
   
     int
   
      i 
   
     =
   
      
   
     0
   
     ; i 
   
     <
   
      vn; i
   
     ++
   
     )
 {
 
   
     if
   
      (
   
     !
   
     visited[i])
 {
 
   
     if
   
      (PrimDist[i] 
   
     >
   
      minDist[start][i])
 PrimDist[i] 
   
     =
   
      minDist[start][i];
 
   
     if
   
      (min 
   
     >
   
      PrimDist[i])
 {
 min 
   
     =
   
      PrimDist[i];
 tempS 
   
     =
   
      i;
 }
 }
 }
 start 
   
     =
   
      tempS;
 }
 t 
   
     =
   
      
   
     0
   
     ;
 
   
     for
   
      (
   
     int
   
      i 
   
     =
   
      
   
     0
   
     ; i 
   
     <
   
      vn; i
   
     ++
   
     )
 t 
   
     +=
   
      PrimDist[i];
 printf(
   
     "
   
     %d\n
   
     "
   
     , t);
 }
 
   
     return
   
      
   
     0
   
     ;
}