Java - Ayuda resultado funcion recursiva

   
Vista:

Ayuda resultado funcion recursiva

Publicado por Shefinald (1 intervención) el 07/06/2016 11:47:31
Buenos días gente!
Tengo un problemilla con la siguiente función:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
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);
				}
			}
		}
 
	}
 
}

El problema es que cuando intento imprimir "soluciones" veo que el List<Integer> está vacío... ¿Qué hago mal?

Gracias de antemano!
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
información
Otras secciones de LWP con contenido de Java
- Código fuente de Java
- Cursos de Java
- Temas de Java
- Chat de Java
información
Códigos de Java
- Album de fotos
- Sueldos
- ArbolesBinarios