Java 嗯，你好，我'；我是个初学者，don'；我不知道如何加速我的代码。我的家庭作业是为CCC&x27；20 S2-逃生室速度超过两秒

嗯，嗨，我是一个初学者，不知道如何加速我的代码。我的作业是为CCC'20 S2-逃生室编写一个程序，速度超过两秒。 目的是确定是否有可能逃离房间。房间是一个M×N的网格，每个位置（单元）包含一个正整数。行编号为1,2，…，M，列编号为1,2，…，N。我们使用（r，c）表示行r和列c中的单元格

从左上角（1,1）开始，从右下角（M，N）退出。如果您位于包含值x的单元格中，则可以跳转到满足a×b=x的任何单元格（a，b）。例如，如果您位于包含6的单元格中，则可以跳转到单元格（2,3）

请注意，从包含6的单元格中，最多可以跳到四个单元格：（2,3）、（3,2）、（1,6）或（6,1）。如果房间是5乘6的网格，则没有第6行，因此只有前三次跳跃是可能的。 这是我的密码：

package programs;

import java.util.ArrayList;
import java.util.Scanner;

public class Escape_Room {

    static boolean method(int[][] array, int m, int n, int x, int y, boolean check, ArrayList<String> list) {
        boolean flag=false;
        for(int i=0; i<m; i++){
            for(int j=0; j<n; j++){
                if(array[i][j]==(x*y) && !list.contains(i+", "+j)) {
                    list.add(i+", "+j);
                    flag=true;
                    if (i==0 && j==0) {
                        check=true;
                        return check;
                    }
                    boolean o=method(array, m, n, i+1, j+1, check, list);
                    if (o==true) {
                        return o;
                    }
                }
            }
        }
        if (flag==false) {
            return flag;
        }
        return check;
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner input=new Scanner(System.in);
        int m=Integer.parseInt(input.nextLine());
        int n=Integer.parseInt(input.nextLine());
        int[][] array=new int[m][n];
        String[] strarray=new String[m];
        for (int i=0; i<m; i++) {
            strarray=input.nextLine().split(" ");
            for (int j=0; j<n; j++) {
                array[i][j]=Integer.parseInt(strarray[j]);
            }
        }
        ArrayList<String> list=new ArrayList<String>();
        boolean o=method(array, m, n, m, n, false, list);
        if (o==true) {
            System.out.println("yes");
        }
        else if (o==false) {
            System.out.println("no");
        }
    }

}

打包程序；
导入java.util.ArrayList；
导入java.util.Scanner；
公共逃生室{
静态布尔方法（int[][]数组、int m、int n、int x、int y、布尔检查、数组列表）{
布尔标志=假；
对于（int i=0；i请看这一点。我已经尝试了网格10x10-在cca3-4ms（包括输入）中求解，它远低于2s

class Escape_Room {

    static boolean method(Map<Integer, Set<Integer>> transitionMap, int size, int start) {
        Set<Integer> closed = new HashSet<Integer>(size);
        Queue<Integer> q = new LinkedList<>();
        q.add(start);
        int key;
        while(!q.isEmpty()) {
            key = q.poll();
            if(closed.contains(key)) {
                continue;
            }
            if(key == size) {
                return true;
            }
            closed.add(key);
            if(transitionMap.containsKey(key)) {
                for (int i : transitionMap.get(key)) {
                    if(i == size) {
                        return true;
                    }
                    if (!closed.contains(i)) {
                        q.add(i);
                    }
                }
            }
        }
        return false;
    }

}

public class Solution {
    static StringBuilder str;
    static InputStreamReader in;
    static int buf;

    private static int readInt() throws IOException {
        buf = 0;
        int c;
        do {
            c = in.read(); 
        } while (c < '0' || c > '9' );
        do {
            buf = 10*buf + c - 48;
            c = in.read();
        } while (!(c < '0' || c > '9' ));
        return buf;
    }

    public static void main(String[] args) throws IOException {
        long t1 = System.currentTimeMillis();
        Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
        in = new InputStreamReader(new BufferedInputStream(System.in));
        int m=readInt();
        int n=readInt();
        int size = m*n;
        Map<Integer, Set<Integer>> transitionMap = new HashMap<>(size);
        Set<Integer> temp;
        int start = 0, key = 0;

        for (int i = 0, j, value; i < m; i++) {
            for(j = 0; j < n; ++j) {
                key = (i+1)*(j+1);
                value = readInt();
                if(i == 0 && j == 0) {
                    start = key;
                }
                if (transitionMap.containsKey(key)) {
                    transitionMap.get(key).add(value);
                } else {
                    temp = new HashSet<>(size);
                    temp.add(value);
                    transitionMap.put(key, temp);
                }
            }
        }
        long t2 = System.currentTimeMillis();       
        boolean o = Escape_Room.method(transitionMap, size, start);
        long t3 = System.currentTimeMillis();
        System.out.println(o?"yes":"no");
        System.out.println("Finished in: " + (t3 - t1) + "ms. Input: " + (t2 - t1)  + "ms. Solving: " + (t3 - t2) + " ms.");
    }
}

class逃生室{
静态布尔方法（Map transitionMap、int size、int start）{
Set closed=新哈希集（大小）；
队列q=新的LinkedList（）；
q、 添加（开始）；
int键；
而（！q.isEmpty（））{
key=q.poll（）；
如果（关闭。包含（键））{
继续；
}
如果（键==大小）{
返回true；
}
关闭。添加（键）；
if（transitionMap.containsKey（键））{
for（inti:transitionMap.get（key））{
如果（i==大小）{
返回true；
}
如果（！closed.contains（i））{
q、 加（i）；
}
}
}
}
返回false；
}
}
公共类解决方案{
静态StringBuilder str；
静态输入流读取器；
静态int-buf；
私有静态int readInt（）引发IOException{
buf=0；
INTC；
做{
c=in.read（）；
}而（c<'0'| c>'9'）；
做{
buf=10*buf+c-48；
c=in.read（）；
}而（！（c<'0'| c>'9'）；
返回buf；
}
公共静态void main（字符串[]args）引发IOException{
long t1=System.currentTimeMillis（）；
Thread.currentThread（）.setPriority（Thread.MAX_PRIORITY）；
in=新的InputStreamReader（新的BufferedInputStream（System.in））；
int m=readInt（）；
int n=readInt（）；
int size=m*n；
Map transitionMap=新的HashMap（大小）；
设定温度；
int start=0，key=0；
对于（int i=0，j，value；i 道歉，我对java不太熟悉，但这是我C++编写的解决方案，经过一些思考。
#include <bits/stdc++.h>
using namespace std;
typedef vector<int> vint;
typedef pair<int,int> pii;
vector<pii> vpairs[1000001];
vector<vector<bool>> vis;
int main(void){
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    int A,B;
    cin>>A>>B;
    for(int i=0;i<A;i++)
    {
        vector<bool> newvecbool;
        for(int j=0;j<B;j++)
        {
            newvecbool.push_back(false);
            int k;
            cin>>k;
            vpairs[k].push_back(pii(i,j));
        }
        vis.push_back(newvecbool);
    }
    queue<pii> queue;
    queue.push(pii(A,B));
    while(!queue.empty())
    {
        pii curpair = queue.front();
        queue.pop();
        if(curpair.first==1 && curpair.second==1){
            cout<<"yes";
            return 0;
        }
        int value = curpair.first*curpair.second;
       // cout<<curpair.first<<' '<<curpair.second<<endl;
        for(int i=0; i<vpairs[value].size();i++)
        {
            pii pair = vpairs[value][i];
            if(!vis[pair.first][pair.second]){
                //int fuck=pair.first-1,me=pair.second-1;
                vis[pair.first][pair.second] = true;
                queue.push(pii(pair.first+1,pair.second+1));
            }
        }
    }
    cout<<"no";
}

#包括
使用名称空间std；
typedef向量vint；
typedef对pii；
向量vpairs[1000001]；
矢量视觉；
内部主（空）{
ios：：与标准同步（0）；cin.tie（0）；cout.tie（0）；
INTA，B；
cin>>A>>B；
对于（int i=0；ik；
vpairs[k].推回（pii（i，j））；
}
视觉推回（newvecbool）；
}
排队；
push（pii（A，B））；
而（！queue.empty（））
{
pii curpair=queue.front（）；
queue.pop（）；
if（curpair.first==1&&curpair.second==1）{
coutIt通常无法预先确定程序的运行时间。您是否给出了任何复杂度、可变约束或最坏的测试用例？^@exto说了什么，而且，您的代码似乎不完整。如果您可以发布一个工作示例，我们将为您提供如何优化它的提示，这将有所帮助。目前，您的程序需要∞ 运行时间为秒，因为它没有编译。所以将
方法（
更改为
计算（
（严重的是，我们不能测试没有编译的代码。）的两个实例都更改为
数组列表
将大大提高速度。大约10乘10格