5 5
**..T
**.*.
..|..
.*.*.
S....

 1 　　if   |  　　//遇到的楼梯初始是‘|’
 2 　　　　if  step是奇数，变化
 3 　　　　　　if  i 是奇数
 4 　　　　　　　　不能通过
 5 　　　　　　else
 6 　　　　　　　　能通过
 7 　　　　else　　//不变
 8 　　　　　　if  i 是奇数
 9 　　　　　　　　能通过
10 　　　　　　else
11 　　　　　　　　不能通过
12 　　if   -  　　//遇到的楼梯初始是‘-’
13 　　　　if  step是奇数，变化
14 　　　　　　if  i 是奇数
15 　　　　　　　　能通过
16 　　　　　　else
17 　　　　　　　　不能通过
18 　　　　else　　//不变
19 　　　　　　if  i 是奇数
20 　　　　　　　　不能通过
21 　　　　　　else
22 　　　　　　　　能通过

  1 #include <iostream>
  2 #include <queue>
  3 #include <string.h>
  4 using namespace std;
  5 char a[21][21];
  6 bool isw[21][21];
  7 int dx[4] = {0,1,0,-1};
  8 int dy[4] = {1,0,-1,0};
  9 int M,N;
 10 int startx,starty;
 11 bool pass;    //能否通过梯子 
 12 struct NODE{
 13     int x;
 14     int y;
 15     int step;
 16 };
 17 int abs(int n)
 18 {
 19     return n>0?n:-n;
 20 }
 21 bool judge(int x,int y,int i,int step)
 22 {
 23     if( x<1 || y<1 || x>M ||y>N )    //越界 
 24         return 1;
 25     if( isw[x][y] )        //走过了 
 26         return 1;
 27     if( a[x][y]==‘*‘ )    //遇到墙
 28         return 1;
 29     if( a[x][y]==‘|‘ ){
 30         if( isw[x+dx[i]][y+dy[i]] )
 31             return 1;
 32         if( step%2 ){    //奇，变 
 33             if( i%2 )    //奇数 
 34                 pass = false;    //不可以通过
 35             else 
 36                 pass = true;    //可以通过
 37         }
 38         else {    //不变 
 39             if( i%2 )    //奇数 
 40                 pass = true;    //可以通过
 41             else 
 42                 pass = false;    //不可以通过
 43         }
 44     }
 45     else if( a[x][y]==‘-‘ ){
 46         if( isw[x+dx[i]][y+dy[i]] )
 47             return 1;
 48         if( step%2 ){    //奇，变 
 49             if( i%2 )    //奇数 
 50                 pass = true;    //可以通过
 51             else 
 52                 pass = false;    //不可以通过
 53         }
 54         else{    //不变 
 55             if( i%2 )    //奇数 
 56                 pass = false;    //不可以通过
 57             else 
 58                 pass = true;    //可以通过
 59         }
 60     }
 61     return 0;
 62 }
 63 int bfs(int x,int y)
 64 {
 65     queue <NODE> q;
 66     NODE cur,next;
 67     cur.x = x;
 68     cur.y = y;
 69     cur.step = 0;
 70     q.push(cur);    //第一个节点入队 
 71     while(!q.empty()){
 72         //队首出队
 73         cur = q.front();
 74         q.pop(); 
 75         if(a[cur.x][cur.y]==‘T‘)    //如果这一步已经走到了终点，则输出走到这一步的步数 
 76             return cur.step;
 77         for(int i=0;i<4;i++){    //下一层节点入队 
 78             int nx = cur.x + dx[i];
 79             int ny = cur.y + dy[i];
 80             if( judge(nx,ny,i,cur.step) )    //判定这一步可走否 
 81                 continue;
 82             if(a[nx][ny]==‘|‘ || a[nx][ny]==‘-‘){    //如果这一步是碰到梯子的 
 83                 if(pass){    //可以通过梯子 
 84                     nx += dx[i];
 85                     ny += dy[i];
 86                 }
 87                 else{    //不可以通过梯子 
 88                     nx -= dx[i];
 89                     ny -= dy[i];
 90                 }
 91             }
 92             next.x = nx;    //可走，记录下一步的位置 
 93             next.y = ny;
 94             next.step = cur.step + 1;    //可走，步数累加 
 95             isw[next.x][next.y] = true;    //可走，标记走过
 96             q.push(next); 
 97         } 
 98     }
 99 }
100 int main()
101 {
102     while(cin>>M>>N){
103         for(int i=1;i<=M;i++)
104             for(int j=1;j<=N;j++){
105                 cin>>a[i][j];
106                     if(a[i][j]==‘S‘){
107                     startx = i;
108                     starty = j;
109                 }
110             }
111         memset(isw,0,sizeof(isw));
112         isw[startx][starty] = true;
113         cout<<bfs(startx,starty)<<endl;
114     }
115     return 0;
116 }