Problema al añadir List<Integer> vacío en Consulta Java

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());
					DevuelveLista(solu, b, indices);
                                        soluciones.add(solu); //NO GUARDA LOS VALORES!!!
				}
				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);
				}
			}
		}
		
	}

}