Найдите лучший способ создания путей в JavaScript для максимального захвата

Question

Я работал над алгоритмом, наконец, неделю. Я успешно создал алгоритм для создания путей, которые собирают фигуры противника, а затем нахожу Максимальный путь захвата на доске 8x8.

Я создал массивследующего хода захватывает.

var moves = [[37 , 69] , [69 , 101] , [ 101 , 99] , [69 ,71], [ 69 , 67] , [67 , 99] , [99 , 101] ,  [71 ,103] ]

Примечание: Невозможно захватить вниз относительно черного.

Здесь я не знаю конечной точкивот почему я могу использовать алгоритмы поиска, такие как BFS, DFS и т. д.

Поэтому я решил сначала найти все возможные захваты, которые на данный момент добавлены в массив ходов.

Затем созданалгоритм, который создает пути, но сложность алгоритма намного выше, но мне нужна та же работа с лучшим алгоритмом.

Вот мой алгоритм

var getPaths = GetPaths(moves);
function GetPaths(moves) {
    var paths = [];
    for (var x = 0 ; x < moves.length ; x++) {
        var path = [];
        for (var y = x + 1 ; y < moves.length ; y++) {
            if (moves[x][1] == moves[y][0]) {
                if (!(path.includes(moves[x]))) {
                    path.push(moves[x]);
                }
                var data = [moves[y][0], moves[y][1]];
                path.push(data);
            }
        }
        if (path.length > 0) paths.push(path);



    }

    var newpaths = [];

    var nextRow = paths[0];
    var len = paths.length;


    for (var h = 1 ; h < nextRow.length; h++) {

        for (var j = 1 ; j < len ; j++) {
            var newpath = [];
            if (isInArray(nextRow[h], paths[j][0])) {

                newpath.push(nextRow[0]);
                var nextfound = false;
                for (var k = j + 1 ; k < paths.length ; k++) {
                    if (isInArray(paths[j][paths[j].length - 1], paths[k][0])) {
                        newpath.push(paths[j][0]);
                        if (paths[k][0][0] - paths[k][0][1] != -(paths[k][1][0] - paths[k][1][1])) {
                            newpath.push(paths[k]);
                        } else {
                            newpath.push(paths[k][0]);
                        }

                        nextfound = true;
                    }

                }
                if (!nextfound) {
                    newpath.push(paths[j]);
                }

            }
            if (newpath.length > 0) {
                newpaths.push(newpath);
            }
        }

    }

    return newpaths;
}

var maxPath = FindMaximumCapture(getPaths);
function FindMaximumCapture(totalPaths) {
    var max = totalPaths[0].toString().length;

    var index = 0;
    for (var count = 1 ; count < totalPaths.length ; count++) {
        if (max < totalPaths[count].toString().length) {
            max = totalPaths[count].toString().length;
            index = count;
        }
    }
    return totalPaths[index];
}
function isInArray(value, array) {
    return array.indexOf(value[0]) > -1 && array.indexOf(value[1]) > -1;
}

Вотссылка кода в JSFiddle