Нужно понять, на что тратиться больше все времени при выполнении

import java.io.PrintWriter;
import java.util.Scanner;
 
public class Main {
 
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        PrintWriter writer = new PrintWriter(System.out);
        int h, n, m;
        int si = 0;
        int sj = 0;
        int sz = 0;
        h = scanner.nextInt();
        n = scanner.nextInt();
        m = scanner.nextInt();
 
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < h * n; i++) {
            builder.append(scanner.next());
        }
        char[] c = builder.toString().toCharArray();
        int countChar = 0;
        int[][][] a = new int[h][n][m];
        Cell[] wave = new Cell[4 * n * m];
        Cell[] dwave = new Cell[4 * n * m];
 
        for (int r = 0; r < h; ++r) {
            for (int i = 0; i < n; ++i) {
                for (int j = 0; j < m; ++j) {
                    if (c[countChar] == ('.')) {
                        a[r][i][j] = 0;
                    } else if (c[countChar] == ('1')) {
                        a[r][i][j] = -1;
                        si = i;
                        sj = j;
                        sz = r;
                    } else if (c[countChar] == ('2')) {
                        a[r][i][j] = -2;
                    } else {
                        a[r][i][j] = -3;
                    }
                    countChar++;
                }
            }
        }
        int p = 0, count = 0, dcount = 0, i, j, k;
        int tmp;
        Cell cu;
        boolean trigger = false;
        dwave[dcount++] = new Cell(si, sj, sz);
        while (true) {
            count = 0;
            tmp = dcount;
            for (int u = 0; u < tmp; ++u) {
                cu = dwave[--dcount];
                i = cu.i;
                j = cu.j;
                k = cu.z;
                if (a[k][i][j] == -3) continue;
                if (a[k][i][j] == -2) trigger = true;
                if (i > 0 && a[k][i - 1][j] != -3) {
                    wave[count++] = new Cell(i - 1, j, k);
                }
                if (i < n - 1 && a[k][i + 1][j] != -3) {
                    wave[count++] = new Cell(i + 1, j, k);
                }
                if (j > 0 && a[k][i][j - 1] != -3) {
                    wave[count++] = new Cell(i, j - 1, k);
                }
                if (j < m - 1 && a[k][i][j + 1] != -3) {
                    wave[count++] = new Cell(i, j + 1, k);
                }
                if (k < h - 1 && a[k + 1][i][j] != -3) {
                    wave[count++] = new Cell(i, j, k + 1);
                }
                a[k][i][j] = -3;
            }
            if (trigger) {
                break;
            }
 
            Cell[] copy1 = copy(wave);
            Cell[] copy2 = copy(dwave);
//            swap(wave, dwave);
            wave = copy2;
            dwave = copy1;
 
            int temp = count;
            count = dcount;
            dcount = temp;
//            swap(count, dcount);
            p++;
        }
        writer.print(p * 5);
        writer.flush();
    }
 
    private static Cell[] copy(Cell[] c) {
        Cell[] res = new Cell[c.length];
        for (int i = 0; i < c.length; i++) {
            if (c[i] == null) {
                break;
            }
            Cell cell = new Cell(c[i]);
            res[i] = cell;
        }
        return res;
    }
 
    static class Cell {
        int i, j, z;
 
        Cell(int _i, int _j, int _z) {
            this.i = _i;
            this.j = _j;
            this.z = _z;
        }
 
        Cell(Cell cell) {
            this(cell.getI(), cell.getJ(), cell.getZ());
        }
 
        public int getI() {return i;}
 
        public void setI(int i) {this.i = i;}
 
        public int getJ() {return j;}
 
        public void setJ(int j) {this.j = j;}
 
        public int getZ() {return z;}
 
        public void setZ(int z) {this.z = z;}
    }
}

Cell[] wave = new Cell[4 * n * m];
Cell[] dwave = new Cell[4 * n * m];

Cell[] wave = new Cell[2 * n * m];
Cell[] dwave = new Cell[2 * n * m];