题目思路

1、第一次bfs,从起点S走到T,用list记录下沿途经过的点，若能到达T，则flag=true
2、如果flag=true,将list中的点都bfs,能达到T的话cnt++;
3、如果flag=false,则表示第一次bfs从S走不到T，输出 I’m stuck!
3、最后输出list.size()-cnt，就是能从S达到的点，但是到达不了T

样例

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Scanner;

public class Main
{

    private static char[][] map;
    private static boolean[][] st;
    private static int n,m;
    private static int sx,sy,ex,ey;
    private static boolean flag=false;//标记第一次是否可以从S走到T
    private static int c=1;//第一次bfs;
    private static int cnt=0;
    private static List<Node> list=new ArrayList<>();


    public static void main(String[] args)
    {
        Scanner scan=new Scanner(System.in);

        n=scan.nextInt();
        m=scan.nextInt();
        scan.nextLine();
        map=new char[n][m];
        st=new boolean[n][m];

        for(int i=0;i<n;i++)
        {
            String str=scan.next();
            map[i]=str.toCharArray();
            for(int j=0;j<str.length();j++)
            {
                if(map[i][j]=='S')
                {
                    sx=i;
                    sy=j;
                }
                if(map[i][j]=='T')
                {
                    ex=i;
                    ey=j;
                }
            }
        }


        //第一次可以从S走到T的话,接着判断途中的点是否也能到达T
        bfs(sx,sy);
        c++;
        if(flag)
        {
            for(int i=0;i<list.size();i++)
            {
                Node node=list.get(i);
                //System.out.print(node.x+"->"+node.y+" ");
                if(map[node.x][node.y]!='S'||map[node.x][node.y]!='T')
                {
                    for(int k1=0;k1<n;k1++)
                        for(int k2=0;k2<m;k2++)
                            st[k1][k2]=false;
                    bfs(node.x,node.y); 
                }
            }
            System.out.println(list.size()-cnt);
        }
        else
        {
            System.out.println("I'm stuck!");
        }



        scan.close();

    }

    private static void bfs(int x,int y)
    {
        Queue<Node> queue=new LinkedList<>();

        queue.offer(new Node(x,y));
        if(c==1)
            list.add(new Node(x,y));
        st[x][y]=true;
        //上 右 下 左
        int[] dx= {-1,0,1,0};
        int[] dy= {0,1,0,-1};

        Node node=null;
        while(!queue.isEmpty())
        {
            node=queue.poll();
            char ch=map[node.x][node.y];
            if(ch=='S')
            {
                if(c>1)
                {
                    cnt++;
                    break;
                }
                //朝着4个方向扩展
                for(int i=0;i<4;i++)
                {
                    int tx=node.x+dx[i];
                    int ty=node.y+dy[i];
                    if(tx>=0&&tx<n&&ty>=0&&ty<m&&st[tx][ty]==false&&map[tx][ty]!='#')
                    {

                        st[tx][ty]=true;
                        queue.offer(new Node(tx,ty));
                        if(c==1)
                            list.add(new Node(tx,ty));
                    }
                }
            }
            else if(ch=='T')
            {
                if(c==1)
                    flag=true;
                else
                {
                    cnt++;
                    break;
                }
                //朝着4个方向扩展
                for(int i=0;i<4;i++)
                {
                    int tx=node.x+dx[i];
                    int ty=node.y+dy[i];
                    if(tx>=0&&tx<n&&ty>=0&&ty<m&&st[tx][ty]==false&&map[tx][ty]!='#')
                    {
                        st[tx][ty]=true;
                        queue.offer(new Node(tx,ty));
                        if(c==1)
                            list.add(new Node(tx,ty));
                    }
                }
            }
            else if(ch=='+')
            {
                //朝着4个方向扩展
                for(int i=0;i<4;i++)
                {
                    int tx=node.x+dx[i];
                    int ty=node.y+dy[i];
                    if(tx>=0&&tx<n&&ty>=0&&ty<m&&st[tx][ty]==false&&map[tx][ty]!='#')
                    {
                        st[tx][ty]=true;
                        queue.offer(new Node(tx,ty));
                        if(c==1)
                            list.add(new Node(tx,ty));
                    }
                }
            }
            else if(ch=='-')
            {
                //朝着左右走
                for(int i=1;i<4;i+=2)
                {
                    int tx=node.x+dx[i];
                    int ty=node.y+dy[i];
                    if(tx>=0&&tx<n&&ty>=0&&ty<m&&st[tx][ty]==false&&map[tx][ty]!='#')
                    {

                        st[tx][ty]=true;
                        queue.offer(new Node(tx,ty));
                        if(c==1)
                            list.add(new Node(tx,ty));
                    }
                }

            }
            else if(ch=='|')
            {
                //朝着上下走
                for(int i=0;i<4;i+=2)
                {
                    int tx=node.x+dx[i];
                    int ty=node.y+dy[i];
                    if(tx>=0&&tx<n&&ty>=0&&ty<m&&st[tx][ty]==false&&map[tx][ty]!='#')
                    {
                        st[tx][ty]=true;
                        queue.offer(new Node(tx,ty));
                        if(c==1)
                            list.add(new Node(tx,ty));
                    }
                }
            }
            else if(ch=='.')
            {
                //只能超下走
                int tx=node.x+dx[2];
                int ty=node.y+dy[2];
                if(tx>=0&&tx<n&&ty>=0&&ty<m&&st[tx][ty]==false&&map[tx][ty]!='#')
                {

                    st[tx][ty]=true;
                    queue.offer(new Node(tx,ty));
                    if(c==1)
                        list.add(new Node(tx,ty));
                }
            }
        }


    }


    private static class Node
    {
        private int x;
        private int y;
        public Node(int x,int y)
        {
            this.x=x;
            this.y=y;
        }
    }

}