PageRenderTime 693ms CodeModel.GetById 462ms app.highlight 106ms RepoModel.GetById 85ms app.codeStats 0ms

/src/main/Main.java

https://bitbucket.org/JanGames/algo1tp1
Java | 260 lines | 186 code | 40 blank | 34 comment | 27 complexity | f63662257c7a661481fefbaedd80269d MD5 | raw file
  1package main;
  2
  3import java.util.Arrays;
  4import java.util.ArrayList;
  5import java.util.List;
  6
  7public class Main {
  8
  9	public static int[][] matriz0 = {
 10	                                 { 0,  7, -1,  5, -1, -1, -1},
 11	                                 { 7,  0,  2,  9,  1, -1, -1},
 12	                                 {-1,  2,  0, -1,  5, -1, -1},
 13	                                 { 5,  9, -1,  0, 15,  6, -1},
 14	                                 {-1,  1,  5, 15,  0,  1, 14},
 15	                                 {-1, -1, -1,  6,  1,  0, 11},
 16	                                 {-1, -1, -1, -1, 14, 11,  0}
 17									};
 18	//public static int[][] matriz;
 19	
 20	/*VALORES GENERALES
 21	public static int N = 5;
 22	public static int a = 1;
 23	public static int b = 2;
 24	public static int c = 3;
 25	public static int M = 70;
 26	public static int k = 40;
 27	public static int origen = 0;
 28	public static int destino = 1;*/
 29	
 30	public static void main(String[] args) {		
 31		//Genera la matriz de NxN
 32		//matriz = generar_matriz(N, a, b, c, M, k);
 33		
 34		int[][] cb = {
 35				{5, 1, 2, 3, 70, 40, 0, 1},
 36				{5, 1, 2, 3, 70, 40, 2, 4},
 37				{9, 3, 5, 7, 3739, 2468, 0, 4},
 38				{9, 3, 5, 7, 3739, 2468, 8, 5},
 39				{10, 3, 5, 7, 1037, 120, 6, 8},
 40				{10, 3, 5, 7, 1037, 120, 0, 2},
 41				{10, 3, 5, 7, 1037, 120, 6, 1},
 42		};
 43		
 44		//Creo camino de todos los casos base y printeo camino y costo
 45		int i = 0;
 46		while(i < cb.length) {
 47			int[][] matriz = generar_matriz(cb[i][0], cb[i][1], cb[i][2], cb[i][3], cb[i][4], cb[i][5]);
 48			List<Integer> camino = camino_minimo(matriz, cb[i][6], cb[i][7]);
 49			int costo = calcular_costo(matriz, lista_array(camino));
 50			System.out.println("Camino: " + camino + ", Costo: " + costo);
 51			i++;
 52		}
 53		
 54		/*
 55		System.out.println(camino_minimo(generar_matriz(5, 1, 2, 3, 70, 40), 0, 1));
 56		System.out.println(camino_minimo(generar_matriz(5, 1, 2, 3, 70, 40), 2, 4));
 57		System.out.println(camino_minimo(generar_matriz(9, 3, 5, 7, 3739, 2468), 0, 4));
 58		System.out.println(camino_minimo(generar_matriz(9, 3, 5, 7, 3739, 2468), 8, 5));
 59		System.out.println(camino_minimo(generar_matriz(10, 3, 5, 7, 1037, 120), 6, 8));
 60		System.out.println(camino_minimo(generar_matriz(10, 3, 5, 7, 1037, 120), 0, 2));
 61		System.out.println(camino_minimo(generar_matriz(10, 3, 5, 7, 1037, 120), 6, 0));
 62		*/
 63	}
 64	
 65	public static int[][] generar_matriz(int N, int a, int b, int c, int M, int k)
 66	{
 67		int i = 0, j = 0;
 68		int[][] nMatriz = new int[N][N];
 69		
 70		while(i < nMatriz.length) {
 71			while(j < nMatriz[i].length) {
 72				int valor = (int) ((Math.pow((i - j), 2) * (a * Math.pow(2, i+j) + b * i * j + c)) % M);
 73				//Modulo de java va entre -resto y resto, como no quiero costos negativos le sumo M en caso de que sea negativo
 74				if(valor < 0) { valor += M; }
 75				
 76				if(valor <= k) { nMatriz[i][j] = valor; }
 77				else { nMatriz[i][j] = -1; }
 78				j++;
 79			}
 80			
 81			i++;
 82			j = 0;
 83		}
 84		
 85		return nMatriz;
 86	}
 87	
 88	public static void actualizar_vecinos (int[][] matriz, int vertice, int[] padre, int[] costo)
 89	{
 90		int i = 0;
 91		int nCosto = 0;
 92		
 93		while(i < padre.length) {
 94			if(matriz[vertice][i] != -1) {
 95				nCosto = costo[vertice] + matriz[vertice][i];
 96				
 97				if(costo[i] == -1 || nCosto < costo[i]) {
 98					padre[i] = vertice;
 99					costo[i] = nCosto;
100				}
101			}
102			
103			i++;
104		}
105	}
106	
107	public static boolean existe_alcanzable(int[] padre, int[] uso)
108	{
109		int i = 0;
110		boolean exists = false;
111		
112		while(i < padre.length) {
113			if(padre[i] != -1 && uso[i] == 0) { exists = true; }
114		
115			i++;
116		}
117		
118		return exists;
119		
120	}
121	
122	public static int buscar_minimo(int[] costo, int[] uso, int[] padre)
123	{
124		int i = 0;
125		int minimo = -1;
126		
127		while(i < uso.length) {
128			if(uso[i] == 0 && padre[i] != -1 && (minimo == -1 || costo[i] < costo[minimo])) { minimo = i; }
129			
130			i++;
131		}
132		
133		return minimo;
134	}
135	
136	public static List<Integer> generar_camino (int[] padre, int origen, int destino)
137	{
138		List<Integer> camino = new ArrayList<Integer>();
139
140		int i = destino;
141		while(i != -1 && i != origen) {
142			camino.add(0, i);
143			i = padre[i];
144		}
145		if(i != -1) { camino.add(0, i);	}
146		else { camino.clear(); }
147		
148		return camino;
149	}
150	
151	public static List<Integer> camino_minimo (int[][] adj , int origen, int destino)
152	{
153		int[] uso = new int[adj.length];
154		int[] padre = new int[adj.length];
155		int[] costo = new int[adj.length];
156		Arrays.fill(uso, 0);
157		Arrays.fill(padre, -1);
158		Arrays.fill(costo, -1);
159		
160		int i = origen;
161		indicar_origen(uso, padre, costo, i);
162		while(existe_alcanzable(padre, uso) && i != destino) {
163			uso[i] = 1;
164			actualizar_vecinos(adj, i, padre, costo);
165			i = buscar_minimo(costo, uso, padre);
166		}
167		
168		return generar_camino(padre, origen, destino);
169	}
170	
171	public static int calcular_costo(int[][] matriz, int[] camino) {
172		int i = 0;
173		int costo = 0;
174		
175		while(i < camino.length - 1) {
176			costo += matriz[camino[i]][camino[i + 1]];
177			i++;
178		}
179		
180		return costo;
181	}
182
183	public static void indicar_origen(int[] uso, int[] padre, int[] costo, int vertice)
184	{
185		uso[vertice] = 0;
186		padre[vertice] = vertice;
187		costo[vertice] = 0;
188	}
189	
190	public static int[] lista_array(List<Integer> lista) {
191		int[] array = new int[lista.size()];
192		int i = 0;
193		while(i < array.length) {
194			array[i] = lista.get(i);
195			i++;
196		}
197		return array;
198	}
199	
200	/*
201	 * -----------------------------------------------------------------------
202	 * A PARTIR DE ACA SON TODAS FUNCIONES AUXILIARES NO NECESARIAS PARA EL TP
203	 * -----------------------------------------------------------------------
204	 */
205	public static void print_matriz(int[][] matriz)
206	{
207		//Crea indices i y j, crea string
208		int i = 0, j = 0;
209		String mRow = "";
210		//Crea primera fila de vx para referencia
211		mRow = "\t";
212		while(i < matriz.length) {
213			mRow += "v" + i + "\t";
214			i++;
215		}
216		System.out.println(mRow);
217		mRow = "";
218		i = 0;
219		//Recorre matriz por i vertical y j horizontal y crea filas de ints, agrega vx al principio
220		while(i < matriz.length) {
221			while(j < matriz[i].length) {
222				mRow += matriz[i][j] + ",\t";
223				j++;
224			}
225			//Printea linea en consola
226			System.out.println("v" + i + "\t" + mRow);
227			//Reinicia loop en j
228			mRow = "";
229			i++;
230			j = 0;
231		}
232	}
233	
234	public static void print_lista(int[] uso, int[] padre, int[] costo)
235	{
236		//Imprimo los valores de las listas
237		int i = 0;
238		String lRow = "Uso\t";
239		while(i < uso.length) {
240			lRow += uso[i] + "\t";
241			i++;
242		}
243		System.out.println(lRow);
244		lRow = "Padre\t";
245		i = 0;
246		while(i < padre.length) {
247			lRow += padre[i] + "\t";			
248			i++;
249		}
250		System.out.println(lRow);
251		lRow = "Costo\t";
252		i = 0;
253		while(i < costo.length) {
254			lRow += costo[i] + "\t";			
255			i++;
256		}
257		System.out.println(lRow);
258	}
259
260}