getStaticProps 함수 안에서는 이처럼 context를 사용하여 값을 받아올 수 있다.

getStaticProps 함수는 컴포넌트 함수보다 먼저 실행되기 때문에 데이터의 사전 준비가 필요하거나 하는 상황에서는 getStaticProps의 context를 사용해서 처리하자

v7이 업데이트 된지 얼마 안되서 그런줄알고 자료를 찾아보았으나 해결을 하지 못했는데 천천히 되짚어보니 아주 간단한 부분에서 실수를 한것이었다.

그것은 바로 확장명이 기본적으로 ts로 되어있었는데 이것을 tsx로 바꿔주면 정상적으로 적용이 된다... js라면 jsx로 변경해주면 된다.

그외 redux나 react-router-dom 적용하는것도

이런식으로 index 파일에 적용하는거와 동일하게 해주면 된다.

function solution(str1, str2) {
    var answer = 0;
    str1 = texting(str1);
    str2 = texting(str2);

    let union = unionFn(str1, str2);
    let intersect = intersectFn(str1, str2);

    function unionFn(first, second) {
        let union = { ...first };
        let result = [];
        for (const key in second) {
            if (union[key]) {
                if (union[key] < second[key]) {
                    union[key] = second[key];
                }
            } else {
                union = { ...union, [key]: second[key] };
            }
        }
        for (const key in union) {
            for (let i = 0; i < union[key]; i++) {
                result.push(key);
            }
        }
        return result;
    }

    function intersectFn(first, second) {
        let intersect = {};
        let result = [];
        for (const key in second) {
            if (first[key]) {
                if (first[key] > second[key]) {
                    intersect = { ...intersect, [key]: second[key] };
                } else {
                    intersect = { ...intersect, [key]: first[key] };
                }
            }
        }
        for (const key in intersect) {
            for (let i = 0; i < intersect[key]; i++) {
                result.push(key);
            }
        }
        return result;
    }

    function texting(str) {
        let arr = [...str.toLowerCase()];
        let result = {};
        for (let i = 0; i < arr.length; i++) {
            let left = arr[i];
            let right = arr[i + 1];
            regex = /[a-zA-Z]/;
            if (
                left &&
                right &&
                isNaN(left) &&
                isNaN(right) &&
                regex.test(left) &&
                regex.test(right)
            ) {
                let sum = left + right;
                result[sum]
                    ? result[sum]++
                    : (result = { ...result, [sum]: 1 });
            }
        }
        return result;
    }

    if (!union.length && !intersect.length) {
        return 65536;
    } else {
        answer = Math.floor(Number((intersect.length / union.length) * 65536));
        return Number(answer);
    }
}

function solution(msg) {
    var answer = [];
    msg = msg.split('');
    let dic = {};
    let charCode = [];
    let idxNum = 27;
    for (let i = 65; i <= 90; i++) {
        charCode.push(String.fromCharCode(i));
    }
    for (let i = 0; i < charCode.length; i++) {
        dic[charCode[i]] = i + 1;
    }

    for (let i = 0; i < msg.length; i++) {
        let w = msg[i];
        let wc = msg[i];
        let whileI = i + 1;

        if (msg[whileI]) {
            while (true) {
                wc += msg[whileI];
                whileI++;
                if (dic[wc]) {
                    w = wc;
                } else {
                    answer.push(dic[w]);
                    i += w.length - 1;
                    dic[wc] = idxNum;
                    idxNum += 1;
                    break;
                }
            }
        } else {
            if (dic[w]) {
                answer.push(dic[w]);
            }
        }
    }
    return answer;
}

const fs = require("fs");
const filePath = process.platform === "linux" ? "/dev/stdin" : "./input.txt";
let input = fs.readFileSync(filePath).toString().trim().split("\n");

const N = Number(input[0]);
const towers = input[1].split(" ").map((value) => +value);

let result = [];
let stack = [];
for (let i = 0; i < N; i++) {
    let current = towers[i]; // 현재 타워의 높이
    if (!stack.length) result.push(0); // 현재 타워 왼쪽에 아무것도 없으면 0을 push
    if (stack.length) {
        let nextStack = []; // 현재 타워 왼쪽에서 비교한 것들을 모아두는 스택
        while (stack.length) {
            let [value, idx] = stack.pop();
            if (value >= current) {
                result.push(idx);
                nextStack.push([value, idx]);
                break;
            }
        }
        if (nextStack.length) { // 왼쪽에서 비교한 타워들이 있으면 stack에 다시 push 해주고 없으면 0을 push
            stack.push(...nextStack);
        } else {
            result.push(0);
        }
    }
    stack.push([current, i + 1]); // 반복문이 한번 돌때마다 현재 타워의 값과 인덱스도 push해준다
}

console.log(result.join(" "));

const fs = require("fs");
const filePath = process.platform === "linux" ? "/dev/stdin" : "./input.txt";
let input = fs.readFileSync(filePath).toString().trim().split("\n");

const N = Number(input.shift());
const line = input
    .map((item) => item.split(" ").map((value) => +value))
    .sort((a, b) => a[0] - b[0]); // x좌표를 기준으로 오름차순 정렬

let result = [line[0]]; // 제일 처음값을 기준으로 시작
let count = 0;
for (let i = 1; i < N; i++) {
    let [x, y] = line[i];
    if (x <= result[0][1] && y > result[0][1]) { // x보다 기준이 되는 좌표의 y가 크거나 같고 y가 기준이 되는 좌표의 y보다 크면 선이 이어지는 부분이다
        result[0][1] = y; // 기준좌표 y값을 갱신해준다.
    }
    if (x > result[0][1]) { // x가 기준좌표 y보다 크면 새로운 선이 생긴다
        count += result[0][1] - result[0][0]; // count에 기준좌표 y - x의 값을 더해주고
        result[0] = [x, y]; // 기준좌표를 새로 갱신해준다
    }
}
count += result[0][1] - result[0][0]; // 반복문이 종료된 후 기준좌표의 값을 count에 더해준다

console.log(count);

const fs = require("fs");
const filePath = process.platform === "linux" ? "/dev/stdin" : "./input.txt";
let input = fs
    .readFileSync(filePath)
    .toString()
    .trim()
    .split("\n")
    .map((item) => item.split(" ").map((value) => +value));

const [n, m] = input.shift();
const visited = Array.from({ length: n }, () =>
    Array.from({ length: m }, () => false)
);
let direction = [
    [1, 0],
    [-1, 0],
    [0, 1],
    [0, -1],
];
let answer = 0; // 그림의 갯수
let result = [];
const BFS = (start) => {
    let queue = [start];
    let total = 0; // 그림의 넓이 카운트
    while (queue.length) {
        let [y, x] = queue.shift();
        if (visited[y][x]) continue;
        visited[y][x] = true;
        total++;
        for (let i = 0; i < direction.length; i++) {
            let [dy, dx] = [y + direction[i][0], x + direction[i][1]];
            if (dy < 0 || dx < 0 || dy >= n || dx >= m) continue;
            if (visited[dy][dx]) continue;
            if (input[dy][dx] === 1) { // 상하좌우 인접한곳에 그림이 연결되있으면
                queue.push([dy, dx]);
            }
        }
    }
    if (total) { // 그림의 넓이가 계산되어 있다면
        answer++; // 그림의 갯수 +1
        result.push(total); // result에 그림의 넓이 push
    }
};

for (let i = 0; i < n; i++) {
    for (let j = 0; j < m; j++) {
        if (input[i][j] === 1 && !visited[i][j]) { // 그림이 있는곳이고 방문한적이 없다면 BFS 실행
            BFS([i, j]);
        }
    }
}
if (!answer) return console.log(0 + "\n" + 0); // 그림의 갯수가 없으면 0 출력
console.log(answer + "\n" + Math.max(...result)); // 그림의 갯수와 넓이가 담긴 배열에서 제일 큰 값을 출력한다

const fs = require("fs");
const filePath = process.platform === "linux" ? "/dev/stdin" : "./input.txt";
let input = fs
    .readFileSync(filePath)
    .toString()
    .trim()
    .split("\n")
    .map((item) => item.split(" ").map((value) => +value));

const [N, M] = input[0];
const graph = Array.from({ length: N + 1 }, () => []);
let answer = [];

// 인접리스트 
for (let i = 1; i <= M; i++) {
    let [a, b] = input[i];
    graph[b].push(a);
}

let max = 0; // 해킹할수 있는 컴퓨터의 최대 수
const DFS = (start) => {
    const stack = [start];
    const visited = Array.from({ length: N + 1 }, () => false);
    let count = 0; // 해킹 가능한 컴퓨터의 수 카운트
    let result = 0; // 해당 컴퓨터의 해킹 가능한 최대 수
    while (stack.length) {
        let cur = stack.pop();
        if (result < count) result = count;
        visited[cur] = true;
        for (let i = 0; i < graph[cur].length; i++) {
            let value = graph[cur][i];
            if (visited[value]) continue;
            visited[value] = true;
            count += 1;
            stack.push(value);
        }
    }
    if (max < result) { // 현재 해킹할수 있는 컴퓨터의 최대 수보다 이번 컴퓨터의 해킹 가능한 최대 수가 크다면
        max = result;
        answer = []; // 초기화
        answer.push(start);
    } else if (max === result) {
        answer.push(start);
    }
};

for (let i = 1; i <= N; i++) {
    DFS(i);
}

console.log(answer.join(" "));

시간초과와 메모리초과가 번갈아가면서 나와서 멘붕이 왔던 문제였다.. 우선 N과 M을 헷갈려서 헤멘것도 있고 while문 안에서 stack에 start를 [start] 이렇게 넣어서 구조분해 할당 하는식으로 했었는데 코드를 천천히 살펴보니 불필요한 부분이라서 배열을 제거했더니 시간초과였던 코드가 통과됬다.. 이유는 찾아보고 추가해야겠다

const fs = require("fs");
const filePath = process.platform === "linux" ? "/dev/stdin" : "./input.txt";
let input = fs
    .readFileSync(filePath)
    .toString()
    .trim()
    .split("\n")
    .map((item) => item.split(" ").map((value) => +value));

const [N, M] = input.shift();
const graph = Array.from({ length: N + 1 }, () => []);
const result = [];

// 친구 관계를 그래프로 정리
for (let i = 0; i < M; i++) {
    const [A, B] = input[i];
    graph[A].push(B);
    graph[B].push(A);
}

const BFS = (start, target) => {
    const queue = [[start, 0]];
    const visited = Array.from({ length: N + 1 }, () => false);
    while (queue.length) {
        let [cur, count] = queue.shift();
        let friend = graph[cur];
        if (visited[cur]) continue;
        visited[cur] = true;
        if (cur === target) return count;

      // 그래프에서 가져온 친구관계를 순회하며 queue에 추가
        for (let i = 0; i < friend.length; i++) {
            let value = friend[i];
            if (visited[value]) continue;
            queue.push([value, count + 1]);
        }
    }
};

// 1번부터 순차적으로 친구관계를 확인해야하기에 반복문을 통해 BFS 실행
for (let i = 0; i < N; i++) {
    let count = 0;
    for (let j = 1; j <= N; j++) {
        count += BFS(i + 1, j); // 리턴된 값들을 count에 더해준다
    }
    result.push(count); 
}

let min = Math.min(...result); // 케빈 베이컨의 수가 가장 작은것을 찾는다
console.log(result.indexOf(min) + 1); // 배열에서 가장 작은 수의 맨앞 인덱스를 출력한다

const fs = require("fs");
const filePath = process.platform === "linux" ? "/dev/stdin" : "./input.txt";
let input = fs.readFileSync(filePath).toString().trim().split("\n");

const n = Number(input.shift());
const [x, y] = input
    .shift()
    .split(" ")
    .map((value) => +value);
const m = Number(input.shift());

const data = input.map((item) => item.split(" ").map((v) => +v));
const graph = Array.from({ length: n + 1 }).map(() => []);
const visited = Array.from({ length: n + 1 }).map(() => false);

// 1촌 관계를 그래프로 정리
for (let i = 0; i < data.length; i++) {
    const [x, y] = data[i];
    graph[x].push(y);
    graph[y].push(x);
}

// 사람수가 1이면 촌수 계산이 불가능하기에 -1 출력
if (n === 1) return console.log(-1);

const BFS = (start) => {
    const queue = [[start, 0]];

    while (queue.length) {
        let [qx, count] = queue.shift();
        let nearQx = graph[qx]; // 1촌 관계 그래프 가져오기
        if (visited[qx]) continue; // 방문체크
        if (qx === y) return count;
        visited[qx] = true;

       // 1촌 관계 반복문으로 순회
        for (let i = 0; i < nearQx.length; i++) {
            let value = nearQx[i];
            if (visited[value]) continue; // 방문체크
            if (value === y) return count + 1; // y값과 일치하면 +1 해서 출력
            queue.push([value, count + 1]);
        }
    }
    return -1;
};

console.log(BFS(x));

문제풀이 queue에 배열로 [값, 촌수] 를 넣어주는게 핵심이었다.

const fs = require("fs");
const filePath = process.platform === "linux" ? "/dev/stdin" : "./input.txt";
let input = fs.readFileSync(filePath).toString().trim().split("\n");

const [N, M] = input
    .shift()
    .split(" ")
    .map((value) => +value);

const map = input.map((item) => item.split("").map((value) => +value));

// 방문체크 배열 3차원 배열로 (벽을 부수지 않은 경우, 벽을 부순 경우) 2개로 나눈다.
const visited = Array.from({ length: 2 }, () =>
    Array.from({ length: N }, () => Array.from({ length: M }).fill(false))
);

const direction = [
    [1, 0],
    [-1, 0],
    [0, 1],
    [0, -1],
];

if (N === 1 && M === 1) return console.log(1);

const BFS = (start) => {
    let queue = [[...start, false, 1, 0]]; // 순서대로(시작지점, 벽을 부쉈는지 여부, 이동횟수, 방문체크 배열 z축 위치)
    let i = 0;
    while (queue.length > i) {
        let [y, x, destroy, count, z] = queue[i];
        i++;
        visited[z][y][x] = true;
        if (y === N - 1 && x === M - 1) return count;
        for (let i = 0; i < direction.length; i++) {
            const [dy, dx] = [y + direction[i][0], x + direction[i][1]];
            if (dy < 0 || dx < 0 || dy >= N || dx >= M || visited[z][dy][dx])
                continue;
            if (dy === N - 1 && dx === M - 1) return count + 1;
            if (destroy) { // 벽을 부순 경우에는
                if (map[dy][dx] === 1) continue;
              // 방문체크 z축을 이동하여 탐색한다
                queue.push([dy, dx, true, count + 1, 1]);
            } else {
                if (map[dy][dx] === 0)
                    queue.push([dy, dx, false, count + 1, 0]);
              // 다음에 벽을 부수게 된다면
                if (map[dy][dx] === 1) queue.push([dy, dx, true, count + 1, 1]);  // 방문체크 z축을 이동하여 탐색한다
            }
            visited[z][dy][dx] = true;
        }
    }
  // queue를 다 탐색했는데 목적지에 도달하지 못한다면 -1 출력
    return -1;
};

console.log(BFS([0, 0]));

풀이 이미 벽을 부순적이 있는 경우가 방문처리를 해버리는 바람에 부순적이 없는 경우가 접근해야 하는곳도 방문처리가 되어 결과를 제대로 도출할수가 없었다. 해결방법은 벽을 부순적이 있는지, 없는지에대해 방문여부를 3차원 배열로 만들어서 벽을 부수게 된다면 이후에는 z축으로 이동해서 진행하고 벽은 부순적이 없다면 계속 진행하면된다

queue 자료구조에 shift()를 사용하면 최대 100만개 크기인 이번 문제에서는 시간초과가 발생하기 떄문에 i라는 인덱스를 부여해서 while문이 1회 반복될때마다 i에 1을 더해주는 방식으로 queue를 순서대로 탐색하였다.

const fs = require("fs");
const filePath = process.platform === "linux" ? "/dev/stdin" : "./input.txt";
let input = fs
    .readFileSync(filePath)
    .toString()
    .trim()
    .split("\n")
    .map((item) => item.split(" ").map((value) => +value));

let [M, N, H] = input.shift();
let direction = [
    [-1, 0, 0],
    [1, 0, 0],
    [0, -1, 0],
    [0, 1, 0],
    [0, 0, 1],
    [0, 0, -1],
];

let box = [];

// 토마토 상자를 3차원 배열로 변환
for (let i = 0; i < input.length; i++) {
    box.push(input.slice(i, N + i));
    i += N - 1;
}

// 방문여부 3차원 배열
let visited = Array.from({ length: H }, () =>
    Array.from({ length: N }, () => Array.from({ length: M }).fill(false))
);

let tomato = []; // 익은 토마토의 위치
let unripe = 0; // 안익은 토마토의 갯수

for (let i = 0; i < H; i++) {
    for (let j = 0; j < N; j++) {
        for (let k = 0; k < M; k++) {
            if (box[i][j][k] === 1) {
                tomato.push([k, j, i]);
            }
            if (box[i][j][k] === 0) {
                unripe++;
            }
        }
    }
}

// 안익은 토마토가 없으면 0을 반환
if (!unripe) return console.log(0);

const BFS = (tomato) => {
    let queue = [...tomato];
    let next = []; // 안익은 토마토의 위치
    let days = 0; // 날짜
    let i = 0;
    while (queue.length > i) {
        let [x, y, h] = queue[i];
        i++;
        if (visited[h][y][x]) continue;
        visited[h][y][x] = true;
        box[h][y][x] = 1;
        for (let i = 0; i < direction.length; i++) {
            let [dx, dy, dh] = [
                x + direction[i][0],
                y + direction[i][1],
                h + direction[i][2],
            ];
            if (
                dx < 0 ||
                dy < 0 ||
                dh < 0 ||
                dx >= M ||
                dy >= N ||
                dh >= H ||
                visited[dh][dy][dx] ||
                box[dh][dy][dx] === -1 ||
                box[dh][dy][dx] === 1
            ) {
                continue;
            }
            next.push([dx, dy, dh]);
            box[dh][dy][dx] = 1;
        }
        if (queue.length <= i && next.length) { // 현재 익은 토마토의 위치를 모두 확인했고 다음 안익은 토마토의 위치가 있으면
            days++;
            i = 0;
            queue = [];
            queue.push(...next);
            unripe -= next.length;
            next = [];
        }
    }
    if (unripe) return -1;

    return days;
};
console.log(BFS(tomato));

BFS로 풀이했다 처음에는 2차원 배열로도 충분히 푸는게 가능할것 같았으나 계속 시간초과 이슈가 생겨서 해결하지 못하고 3차원 배열로 풀이를 진행했다. shift()를 이용하니까 시간초과가 발생해서 인덱스를 0부터 확인하는 방법으로 구현했더니 통과가 됬다.

const fs = require("fs");
const filePath = process.platform === "linux" ? "/dev/stdin" : "./input.txt";
let input = fs.readFileSync(filePath).toString().trim().split("\n");

const N = Number(input.shift());
const map = input.map((item) => item.split(""));
const direction = [
    [-1, 0],
    [1, 0],
    [0, -1],
    [0, 1],
];
const BFS = (start, map, N, weakness, visited, color) => { // 각 시작좌표, 맵, N, 색약여부, 방문여부, 시작좌표의 색
    let queue = [start];
    let count = 0;
    while (queue.length) {
        let [x, y] = queue.shift();
        if (visited[x][y]) continue;
        visited[x][y] = true;
        count++;
        for (let i = 0; i < direction.length; i++) {
            let [dx, dy] = [x + direction[i][0], y + direction[i][1]];
            if (dx < 0 || dy < 0 || dx >= N || dy >= N) continue;
            if (visited[dx][dy]) continue;
            if (weakness) { // 색약일 경우
                if ( // R, G는 같은색으로 취급한다.
                    (color === "R" || color === "G") &&
                    (map[dx][dy] === "R" || map[dx][dy] === "G")
                ) {
                    queue.push([dx, dy]);
                }
                if (color === "B" && map[dx][dy] === "B") {
                    queue.push([dx, dy]);
                }
            } else { // 색약이 아니면 3개의 색을 구분한다
                if (color === "R" && map[dx][dy] === "R") {
                    queue.push([dx, dy]);
                }
                if (color === "G" && map[dx][dy] === "G") {
                    queue.push([dx, dy]);
                }
                if (color === "B" && map[dx][dy] === "B") {
                    queue.push([dx, dy]);
                }
            }
        }
    }
    return count;
};

let result = [0, 0];
for (let total = 0; total < 2; total++) {
    let mode = [false, true]; // 색약여부 
    let count = 0;
    let visited = Array.from({ length: N }, () => Array(N).fill(false));
    for (let i = 0; i < N; i++) {
        for (let j = 0; j < N; j++) {
            if (visited[i][j]) continue;
            count = BFS([i, j], map, N, mode[total], visited, map[i][j]);
            if (count > 0) result[total] += 1; // BFS에서 반환된 값이 0보다 크면 값을 1 올려준다
        }
    }
}

console.log(result.join(" "));

const fs = require("fs");
const filePath = process.platform === "linux" ? "/dev/stdin" : "./input.txt";
let input = fs
    .readFileSync(filePath)
    .toString()
    .trim()
    .split("\n")
    .map((item) => item.split(" ").map((value) => +value));

const N = input.shift()[0];
const map = input.slice();
const visited = Array.from(Array(N + 1), () => Array(N).fill(false));
let direction = [
    [-1, 0],
    [0, 1],
    [1, 0],
    [0, -1],
];
let result = [];
let max = 0;

for (let i = 0; i < N; i++) {
    for (let j = 0; j < N; j++) {
        let info = map[i][j];
        if (max < info) {
            max = info;
        }
    }
}

const DFS = (map, visited, safeList) => {
    let stack = [safeList];
    let count = 0;
    while (stack.length) {
        let [x, y] = stack.pop();
        if (!visited[x][y]) {
            visited[x][y] = true;
            count++;
        }
        for (let i = 0; i < direction.length; i++) {
            let [dx, dy] = [x + direction[i][0], y + direction[i][1]];
            if (dx < 0 || dy < 0 || dx >= N || dy >= N) continue;
            if (!visited[dx][dy] && map[dx][dy] > 0) {
                count++;
                visited[dx][dy] = true;
                stack.push([dx, dy]);
            }
        }
    }

    return [count, map, visited];
};

//강수량이 0부터 최대높이까지 반복
for (let water = 0; water <= max; water++) {
    // map과 visited를 복사한다
    let copyMap = map.map((item) => item.slice());
    let copyVisited = visited.map((item) => item.slice());
    let safeList = [];
    //강수량 이하인 지형들을 물에 잠기게한다
    for (let i = 0; i < N; i++) {
        for (let j = 0; j < N; j++) {
            if (copyMap[i][j] <= water) {
                copyMap[i][j] = 0;
                copyVisited[i][j] = true;
            } else {
                safeList.push([i, j]);
            }
        }
    }
    let count = 0;
    for (let i = 0; i < safeList.length; i++) {
        let [value, newMap, newVisited] = DFS(
            copyMap,
            copyVisited,
            safeList[i]
        );
        // 값이 있으면 증가
        if (value) {
            count++;
        }
        // 지도와 방문여부를 최신화해준다.
        copyMap = newMap;
        copyVisited = newVisited;
    }
    result.push(count);
    //DFS 실행해서 [0,0]부터 시작해서 잠기지않은 영역의 갯수를 카운트해서 결과에 넣는다
}

//결과중에서 제일 높은값을 출력한다.
console.log(Math.max(...result));

const fs = require("fs");
const filePath = process.platform === "linux" ? "/dev/stdin" : "./input.txt";
let input = fs
    .readFileSync(filePath)
    .toString()
    .trim()
    .split("\n")
    .map((item) => item.split(" ").map((value) => +value));

let map;
let direction = [
    [-1, 2],
    [-2, 1],
    [-2, -1],
    [-1, -2],
    [1, -2],
    [2, -1],
    [2, 1],
    [1, 2],
];

let num = input.shift()[0];
let result = [];

const BFS = (start, goal, L) => {
    let queue = [start];
    let [goalX, goalY] = goal;
    while (queue.length) {
        let [x, y] = queue.shift();
        if (map[y][x][1]) {
            continue;
        } else {
            map[y][x][1] = true;
        }
        for (let i = 0; i < direction.length; i++) {
            let [dx, dy] = direction[i];
            if (x + dx < 0 || y + dy < 0 || x + dx >= L || y + dy >= L)
                continue;
            if (!map[y + dy][x + dx][1]) {
                map[y + dy][x + dx][0] = map[y][x][0] + 1;
                queue.push([x + dx, y + dy]);
                if (x + dx === goalX && y + dy === goalY) {
                    return map[y + dy][x + dx][0];
                }
            }
        }
    }
};

for (let i = 0; i < input.length; i++) {
    let testCase = input.slice(i, i + 3);
    i = i + 2;
    let L = testCase[0][0];
    let [startX, startY] = testCase[1];
    let [goalX, goalY] = testCase[2];
    map = [...Array(L)].map(() => [...Array(L)].map(() => [0, false]));

    if (startX === goalX && startY === goalY) {
        result.push(0);
    } else {
        result.push(BFS([startX, startY], [goalX, goalY], L));
    }
}

console.log(result.join("\n"));