在BFS超时

Question

这是来自TalentBuddy的问题（​​https://www.talentbuddy.co/challenge/52a9121cc8a6c2dc91481f90525870614af0110af3834439） 卡西安正在渗透外星人基地，以摧毁威胁行星PACO的母舰的控制。基座是尺寸为N×M的矩形，其中每平方米具有相关的光级Li，j。

由于他的能力，外星人不能立即看到他，除非他在光照等级为K的方格中，或者Casian经过的最后X个方格的总和至少是（X * K）/ 2 （整数部分）。

给定N，M，X，K，Casian位置（XCa，YCa）的值，控制器的位置（XCo，YCo）和每平方米基座的亮度水平 您的任务是编写一个函数，打印到标准输出（stdout）Casian可以用于获取控件的最短路径的长度，以及最小风险路径的风险值，路径的风险值是他通过的所有方格的亮度之和

请注意，您的函数将收到以下参数： 数据是一个长度为8的整数数组，包含N，M，X，K，XCa，YCa，XCo，YCo在这个特定顺序基数中的值，它是一个N×M整数数组，表示每平方米的亮度级别基地前N个整数表示矩形基的第一行。下一个N代表第二行，依此类推。

数据限制
0＆lt; N，M < 100个
效率约束
您的函数应该打印请求的结果并在不到2秒的时间内返回

实施例
输入
数据：4 4 3 7 1 1 4 4
基数：1 1 4 4 0 4 4 4 7 3 2 3 14 9 8 3

输出
6 16

这是我的程序，但由于超时问题，它无法通过在线判断。

有人可以帮我吗？谢谢

static int[] dx = {0,0,1,-1};
static int[] dy = {1,-1,0,0};
public static void paco(Integer[] D, Integer[] B) {

    int N = D[0], M = D[1], X = D[2], K = D[3], X0 = D[4], Y0 = D[5], X1 = D[6], Y1 = D[7];
    X0--;   Y0--;   X1--;   Y1--;
    int[][] C = new int[N][M];
    for(int i=0; i<N; i++) {
        for(int j=0; j<M; j++) {
            C[i][j] = B[i*N+j];
        }
    }

    boolean[][] vis = new boolean[N][M];
    int minLen = Integer.MAX_VALUE, minRisk = Integer.MAX_VALUE;
    List<Integer> risks = new LinkedList<>();
    risks.add(C[X0][Y0]);
    vis[X0][Y0] = true;

    Queue<Item> queue = new LinkedList<>();
    queue.add(new Item(X0, Y0, 0, risks, C[X0][Y0], C[X0][Y0]));

    while(!queue.isEmpty()) {
        Item cur = queue.poll();

        vis[cur.x][cur.y] = true;
        if(cur.x == X1 && cur.y == Y1) {
            if(cur.length <= minLen) {
                minLen = cur.length;
                if(cur.sum < minRisk) {
                    minRisk = cur.sum;
                }
            } else break;
        }

        if(cur.x > X1 && cur.y > Y1)    break;

        for(int i=0; i<4; i++) {
            int nx = cur.x+dx[i], ny = cur.y+dy[i];
            if(nx>=0 && nx<N && ny>=0 && ny<M && !vis[nx][ny] && C[nx][ny]<K) {
                int newPartialSum = cur.partialSum;
                List<Integer> newRisks = new LinkedList<>(cur.risks);
                boolean full = false;
                int old = -1;
                if(newRisks.size() < X) {
                    newRisks.add(C[nx][ny]);
                    newPartialSum += C[nx][ny];
                } else {
                    full = true;
                    old = newRisks.get(0);
                    newRisks.remove(0);
                    newRisks.add(C[nx][ny]);
                    newPartialSum -= old;
                    newPartialSum += C[nx][ny];
                }
                if(newPartialSum < X*K/2) {
                    queue.add(new Item(nx, ny, cur.length+1, newRisks, C[nx][ny]+cur.sum, newPartialSum));
                }
            }
        }
    }

    System.out.println(minLen + " " + minRisk);
}

static class Item {
    int length, x, y, sum, partialSum;
    List<Integer> risks;
    public Item(int x, int y, int length, List<Integer> risks, int sum, int partialSum) {
        this.x = x;
        this.y = y;
        this.length = length;
        this.risks = risks;
        this.sum = sum;
        this.partialSum = partialSum;
    }
}