Java - Ayuda resultado funcion recursiva

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

public class RedSocial {

	static int MAX = 5;

	static ArrayList<Integer>[] amistades = new ArrayList[MAX];

	static List<Integer> solucion = new ArrayList<>();

	static List<List<Integer>> soluciones = new ArrayList<>();

	public RedSocial(ArrayList<Integer>[] amistades) {

		// Se construye una nueva instancia para buscar cadenas de amigos en una

		// población con las características especificadas por amistades.

		// Los individuos de la población se consideran numerados

		// consecutivamente 0,

		// 1, 2,...n-1, siendo n la longitud del array amistades.

		// Precondiciones: Para todos los valores amistades[i] (0 <= i < n) se

		// cumple

		// • amistades[i] es distinto de null y no tiene valores repetidos

		// • los elementos de amistades[i] son los índices de los amigos del

		// individuo i.

		// Por tanto, si la lista amistades[i] contiene un valor x,entonces 0 <=

		// x

		// < n

		// • Si a es amigo de b, entonces b es amigo de a. Por tanto, si la

		// lista

		// amistades[i] contiene un valor x, la lista amistades[x] contiene el

		// valor

		// i.

		ArrayList<Integer> amigos = new ArrayList<>(Arrays.asList(1, 2, 3, 4));

		amistades[0] = amigos;

		amigos = new ArrayList<>(Arrays.asList(0, 3, 4));

		amistades[1] = amigos;

		amigos = new ArrayList<>(Arrays.asList(1));

		amistades[2] = amigos;

		amigos = new ArrayList<>(Arrays.asList(0, 2));

		amistades[3] = amigos;

		amigos = new ArrayList<>(Arrays.asList(0));

		amistades[4] = amigos;

		solucion = search(2, 4);

		System.out.println(soluciones.toString());

	}

	public List<Integer> search(int a, int b) {

		// Devuelve la cadena de amigos más larga que puede formarse entre los

		// individuos A y B, con las características indicadas arriba; null, si

		// no puede

		// formarse una cadena así.

		// Observaciones:

		// • si el resultado no es null, la lista resultante no contiene

		// elementos repetidos.

		// Es decir, una persona solo puede aparecer en la cadena una vez como

		// mucho.

		// • Si pueden formarse varias cadenas de amistades, cumpliendo los

		// requisitos

		// indicados, y con la misma longitud, devuelve una cualquiera de ellas.

		ArrayList<Integer> lista = new ArrayList<>(Arrays.asList(a));

		List<Integer> indices = new ArrayList<>(Arrays.asList(-1, -1));

		DevuelveLista(lista, b, indices);

		return null;

	}

	public static void main(String[] args) {

		RedSocial red = new RedSocial(amistades);

	}

	public static void DevuelveLista(List<Integer> solu, int b, List<Integer> indices) {

		List<Integer> lista = new ArrayList<>();

		lista = amistades[solu.get(solu.size() - 1)];

		if (indices.size() > 1) {

			indices.set(indices.size() - 1, indices.get(indices.size() - 1) + 1); // aumento

																					// en

																					// uno

																					// el

																					// último

																					// indice

			int hijo = indices.get(indices.size() - 1);

			if (amistades[solu.get(solu.size() - 1)].size() == indices.get(indices.size() - 1)) {

				// si el padre no tiene más hijos

				solu.remove(solu.size() - 1); // eliminamos hijo

				indices.remove(indices.size() - 1); // eliminamos hijo

				if (solu.size() > 0) {

					DevuelveLista(solu, b, indices);

				}

			} else {

				if (lista.get(hijo) == b && !solu.contains(lista.get(hijo))) {

					solu.add(lista.get(hijo));

					indices.add(-1);

					System.out.println("es respuesta!" + solu.toString());

                                        soluciones.add(solu); //Guarda List<Integer> vacío!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

					DevuelveLista(solu, b, indices);

				}

				if (lista.get(hijo) != b && !solu.contains(lista.get(hijo))) {

					solu.add(lista.get(hijo));

					indices.add(-1);

					DevuelveLista(solu, b, indices);

				}

				if (lista.get(hijo) != b && solu.contains(lista.get(hijo))) {

					DevuelveLista(solu, b, indices);

				}

			}

		}

	}

}