题目思路

1、直接从起点1,1 bfs 拓展可以到达的位置
2、如果此位置不是危险位置，则可以直接拓展。若是，则再判断是否在危险期
3、需要注意的是每一个位置可能会走多次，所以每次出队，都需要标记为false

import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
import java.util.Scanner;

public class Main
{
    private static int N=110;
    private static int n,m,t;
    private static int[][] g=new int[N][N];
    private static boolean[][] st=new boolean[N][N];
    private static Map<String,String> map=new HashMap<>();

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

        n=scan.nextInt();
        m=scan.nextInt();
        t=scan.nextInt();
        for(int i=0;i<t;i++)
        {
            int x=scan.nextInt();
            int y=scan.nextInt();
            int a=scan.nextInt();
            int b=scan.nextInt();
            g[x][y]=1;//标记此处为陷阱
            String s1=x+"-"+y;
            String s2=a+"-"+b;
            map.put(s1, s2);
        }

        System.out.println(bfs());


        scan.close();
    }

    private static int bfs()
    {
        Queue<Node> queue=new LinkedList<>();
        queue.offer(new Node(1,1,0));
        st[1][1]=true;

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

        Node t=null;
        while(!queue.isEmpty())
        {
            t=queue.poll();
            st[t.x][t.y]=false;
            if(t.x==n&&t.y==m)
            {
                return t.step;
            }

            for(int i=0;i<4;i++)
            {
                int tx=t.x+dx[i];
                int ty=t.y+dy[i];
                if(tx>=1&&tx<=n&&ty>=1&&ty<=m&&st[tx][ty]==false)
                {
                    if(g[tx][ty]==0)
                    {
                        st[tx][ty]=true;
                        queue.offer(new Node(tx,ty,t.step+1));
                    }
                    else
                    {
                        int temStep=t.step+1;
                        String s1=tx+"-"+ty;
                        String value = map.get(s1);
                        String[] split = value.split("-");
                        int t1=Integer.valueOf(split[0]);
                        int t2=Integer.valueOf(split[1]);
                        //System.out.println(t1+" "+t2);
                        if(temStep>=t1&&temStep<=t2) continue;
                        st[tx][ty]=true;
                        queue.offer(new Node(tx,ty,t.step+1));
                    }
                }
            }



        }



        return 0;
    }

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

}