Рекурсивная функция для создания пирамидального слайда в Java

Question

У меня проблемы с поиском решения проблемы с рекурсивной функцией, которую я выполняю, и я хотел бы получить представление о том, как ее решить.

Это функция Я делал для CodeWars упражнения по кодированию. Задача упражнения - создать код, который может динамически анализировать «пирамиду» (в данном случае это двумерный массив) и выбрать путь с наибольшей суммой путем скольжения этих чисел в массиве пирамид. Вот мой метод:

    public static String[] analyzeSlidePath(int[][] pyramid, int drop, int height, int depth, int index,
                                                ArrayList<String[]> possibilities, String[] input, int sum){
            // index gives the current index the slide is at in the pyramid
            // drop gives the height of the pyramid we want the slide to fall
            // height gives the current height the slide is at in the pyramid
            // depth is used to recur this method a certain amount of times
            // possibilities is used to store the potential combinations to use when sliding down
            // sum gives the total amount added during the fall
            if(depth == drop){
                input[drop] = "" + sum; // input has a size of (drop + 1)
                possibilities.add(input);
                System.out.println(Arrays.toString(input));
            } else { input[depth] = "left";
                analyzeSlidePath(pyramid, drop, height, depth + 1, index, possibilities, input, sum + pyramid[height + depth + 1][index]);
                input[depth] = "right";
                analyzeSlidePath(pyramid, drop, height, depth + 1, index + 1, possibilities, input, sum + pyramid[height + depth + 1][index + 1]);
            } int lastMaxValue = Integer.MIN_VALUE;
            int lastMaxIndex = 0;
            for(int i = 0 ; i < possibilities.size() ; i++){
                if(Integer.parseInt(possibilities.get(i)[drop]) > lastMaxValue){
                    lastMaxValue = Integer.parseInt(possibilities.get(i)[drop]);
                    lastMaxIndex = i;
                }
            } return possibilities.get(lastMaxIndex);
        }

The problem is that, when I call the function, I see that the "input" is correctly adding the right instructions (String array with any permutation of "left" and "right" plus the sum of the drop), but when the method gets to the return, all of the String arrays in "possibilities" are only going "right" and all have the same sum. My best guess is that this is because when the function gets to the **right** version of **analyzeSlidePath**, setting the String to overwrite "left" to "right" is losing all the instruction data.

Пример ввода:

public static void main(String[] args) {
        ArrayList<String[]> possibilities = new ArrayList<>();
        String[] strings = new String[4];
        int[][] test = new int[][]{
                {75},
                {95, 64},
                {17, 47, 82},
                {18, 35, 87, 10}};
        String[] myPossibilities = analyzeSlidePath(test, 3, 0, 0, 0, 
        possibilities, strings, 0);
        for(String instruction : myPossibilities){
            System.out.println(instruction);
        }
    }

Вывод:

[left, left, left, 130]
[left, left, right, 147]
[left, right, left, 177]
[left, right, right, 229]
[right, left, left, 146]
[right, left, right, 198]
[right, right, left, 233]
[right, right, right, 156]
right
right
right
156

Ожидаемый вывод:

right
right
left
233