Universidad Tecnolgica Nacional

Facultad Regional Rosario

Algoritmos Genticos

TRABAJOS PRCTICOS

Comisin: E03
Integrantes:
Legajo
38679
38259
38416

Fecha de entrega: 17/04/2012

Apellido y Nombre
Ferrero Franco
Bertani Ivn
Diez Santiago

Consigna 1
Utilizar un Algoritmo Gentico Cannico para buscar un mximo de la funcin f (x) = x2, definida sobre el
conjunto de enteros entre 0 y 31. El espacio solucin es entonces {x/x pertenece a Z y 0<=x<=31}.
Para re presentar estos elementos como tira, basta considerar a los enteros en su representacin binaria. El
espacio solucin puede verse entonces como {00000, 00001, 00010, 00011,, 11111}. Es decir que el espacio
solucin est formado por cromosomas de longitud 5 y cada gen es un dgito binario 0 o 1.
Tener tambin en cuenta que no habr mutacin en ninguno de los individuos y los padres siempre harn
crossover. La poblacin ser de 4 individuos y se harn 4 ciclos. Se utilizar el mtodo de seleccin de la ruleta.

Resolucin Consigna 1
Poblacin

Poblacin

Poblacin

Poblacin

Individuo

F.Obj

Fitness

01101
11000
01000
10011

13
24
8
19
suma
promedio
mximo
mnimo
x
12
25
27
16
suma
promedio
mximo
mnimo
x
27
17
25
25
suma
promedio
mximo
mnimo
x
27
25
27
25
suma
promedio
mximo
mnimo

169
576
64
361
1170
292,5
576
64
F.Obj
144
625
729
256
1754
438,5
729
144
F.Obj
729
289
625
625
2268
567
729
289
F.Obj
729
625
729
625
2708
677
729
625

0,144444444
0,492307692
0,054700855
0,308547009
1
0,25
0,492307692
0,054700855
Fitness
0,082098062
0,356328392
0,415621437
0,145952109
1
0,25
0,415621437
0,082098062
Fitness
0,321428571
0,127425044
0,275573192
0,275573192
1
0,25
0,321428571
0,127425044
Fitness
0,269202363
0,230797637
0,269202363
0,230797637
1
0,25
0,269202363
0,230797637

Individuo
01100
11001
11000
10011

Individuo
11011
10001
11001
11001

Individuo
11011
11001
11011
11001

Consigna 2

Hacer un programa que utilice un Algoritmo Gentico Cannico para buscar un mximo de la funcin:
2

30

30

f (x) = (x/coef) en el dominio [0 , 2 -1], donde coef = 2 -1 . Teniendo en cuenta los siguientes datos:
Probabilidad de Crossover = 0,75
Probabilidad de Mutacin = 0,05
Poblacin Inicial: 10 individuos
Ciclos del programa: 20
Mtodo de Seleccin: Ruleta
Mtodo de Crossover: 1 Punto
Mtodo de Mutacin: invertida
El programa debe mostrar, finalmente, el Cromosoma correspondiente al valor mximo obtenido, y grficas,
usando EXCEL, de Mximo, Mnimo y Promedio de la funcin objetivo por cada generacin

Resolucin Consigna 2
Tabla de Evolucin de las Poblaciones:
Poblacin

Suma Funcin Objetivo

Promedio Funcin Objetivo

Mximo Funcin Objetivo

Mnimo Funcin Objetivo

Mximo Fitness

Mnimo Fitness

2,42817025360102

0.24281702536010297

0.7687463210465061

0.002740969849395422

0.3165949009985764

0.0011288211134826743

5,19998744421240

0.5199987444212404

0.7687463226796394

0.06161473839522487

0.14783618824604192

0.011849016763262032

6,67569410724385

0.6675694107243852

0.7687463226796394

0.33075685129809396

0.11515601379120506

0.049546436068601

7,11382373443454

0.7113823734434541

0.7687463226796394

0.6253082811916736

0.10806372934973274

0.08790044630496845

7,37047785997941

0.7370477859979419

0.8822502976370384

0.6253082811916736

0.11970055597446731

0.08483958476925942

7,80011108045528

0.7800111080455283

0.8822502958874897

0.7683182645385193

0.11310740152126063

0.09850093884735722

7,48260860250143

0.7482608602501437

0.7687463226796394

0.5651758728084971

0.1027377434151303

0.07553193048471876

7,48303666087538

0.7483036660875387

0.7687463226796394

0.5651758714081944

0.10273186642248913

0.07552760958170669

7,68703684098475

0.7687036840984751

0.7687479950091156

0.7683182645385193

0.10000576436818986

0.09994986110149741

10

7,06025743283406

0.7060257432834062

0.7687479950091156

0.1419652421994742

0.10888384769569685

0.020107658049302583

11

7,68660878121049

0.7686608781210496

0.7687479933759805

0.7683182645385193

0.10001133337957098

0.09995542721214487

12

7,68617905237303

0.7686179052373034

0.7687463226796394

0.7683182645385193

0.1000167075788192

0.09996101564942185

13

7,68617905237212

0.7686179052372124

0.7687463226796394

0.7683182645385193

0.10001670757883104

0.09996101564943367

14

7,68703516865482

0.768703516865482

0.7687463226796394

0.7683182661711979

0.10000556857269653

0.09994988305818413

15

7,80011108710377

0.7800111087103778

0.8822502976370384

0.7683182661711979

0.11310740164915044

0.09850093897271385

16

7,79882691921158

0.7798826919211586

0.8822502976370384

0.7683182661711979

0.11312602610319612

0.09851715830217068

17

7,91230037332544

0.7912300373325445

0.8822502976370384

0.7683182629058407

0.11150364066199363

0.09710428404564293

18

7,94146138102281

0.7941461381022815

0.9113807910224931

0.7683182629058407

0.11476235258164945

0.09674771758530992

19

7,94151488483337

0.7941514884833378

0.9113807910224931

0.7683182629058407

0.11476157940131027

0.09674706577370608

20

8,16975350699456

0.8169753506994561

0.9113807910224931

0.7683182661711979

0.11155548208917336

0.09404424081012966

MINIMO

941175143

MAXIMO

1025061223

Grficos:

Consigna 3
Repetir consigna 2, utilizando elitismo.

Resolucin Consigna 3
Tabla de Evolucin de las Poblaciones:

Poblacin

Suma Funcin Objetivo

Promedio Funcin Objetivo

Mximo Funcin Objetivo

Mnimo Funcin Objetivo

Mximo Fitness

Mnimo Fitness

4,24029446667322

0.42402944666732223

0.8762434706689137

0.01826192979819658

0.20664684435380307

0.0043067598115477616

6,45080400359554

0.6450804003595549

0.8762699227600004

0.17660858139912491

0.13583886942954476

0.02737776272549698

7,45282897058622

0.7452828970586223

0.8762700360945831

0.4918294604352148

0.11757549241407825

0.06599231813534137

6,86967522131064

0.6869675221310648

0.8762700360945831

0.491829485254599

0.12755625380604263

0.07159428494215832

7,99944655436136

0.7999446554361369

0.8762701128133815

0.6320977016866963

0.10954134224893737

0.0790176792095787

7,94091753327028

0.7940917533270289

0.876393681515152

0.6319926947948346

0.11036428445998846

0.07958686035297015

7,90973976068430

0.7909739760684309

0.876393759983095

0.6321133118241198

0.11079931660195026

0.0799158165690944

8,18122396066043

0.8181223960660435

0.875498073343868

0.6321133118241198

0.10701309211845518

0.07726390511537737

8,48260009563532

0.8482600095635322

0.875498073343868

0.6321133118241198

0.10321105126650389

0.07451881553975065

10

8,50768972191165

0.8507689721911657

0.875498073343868

0.6572029381004538

0.10290667642580009

0.07724810842687643

11

8,72598485715507

0.8725984857155071

0.875498073343868

0.846502197060258

0.10033229345177963

0.09700935893398316

12

8,75498074041004

0.8754980740410044

0.8754980803152314

0.875498073343868

0.10000000071664657

0.09999999992037259

13

8,75498074738140

0.8754980747381407

0.8754980803152314

0.875498073343868

0.10000000063701919

0.0999999998407452

14

8,75500928837552

0.8755009288375524

0.8755266282807114

0.875498073343868

0.10000293539873145

0.09999967384458538

15

8,75498073343868

0.875498073343868

0.875498073343868

0.875498073343868

0.09999999999999999

0.09999999999999999

16

8,75503784377802

0.8755037843778029

0.875555183683216

0.875498073343868

0.10000587082618377

0.09999934768597957

17

8,75515184137311

0.8755151841373113

0.875555183683216

0.8754978502602572

0.10000456868671491

0.09999802015117862

18

8,75503762069441

0.8755037620694417

0.875555183683216

0.8754978502602572

0.10000587337439337

0.09999932475342305

19

8,75503739761080

0.8755037397610806

0.875555183683216

0.8754978502602572

0.10000587592260309

0.09999932730146589

20

8,75503735578308

0.8755037355783084

0.8755551976263974

0.8754978502602572

0.1000058779929768

0.09999932777921874

MINIMO

1004679201

MAXIMO

1004712105

Grficos:

Nota: El mximo sufre variaciones, pero son demasiado pequeas para la escala del grfico. Ver tabla de datos.

11

Conclusin consignas 2 y 3
El algoritmo sin elitismo tiene mayor aleatoriedad y esto es observable en las grficas, aunque finalmente
ambas alcanzan un cierto equilibrio cuando las poblaciones tienen menor margen de mejora, siendo el
elitista el primero en hacerlo y por lo tanto el ms eficaz.
Otro punto interesante es el mximo y mnimo fitness, podemos ver que se juntan una vez que la
poblacin es suficientemente fuerte. La diferencia entre el mejor ejemplar y el peor ejemplar de la
poblacin es casi inexistente, significando esto que todos los individuos de la poblacin tienen
prcticamente el mismo peso dentro de la misma. Esto tambin se ve ms pronunciado en el algoritmo
elitista.

12

Consigna 6
A partir del siguiente grfico:
10

55
45

20
40

35

25

30

5
50

Hacer un anlisis exhaustivo para encontrar el camino ms corto entre

los 5 puntos, siendo las cifras sobre las aristas, las unidades de tiempo
correspondiente a recorrer ese camino (en cualquiera de sus
direcciones).
3

15

13

Resolucin Consigna 6
Todas las combinaciones posibles son:
123451
123541
124351
124531
125341
125431
132451
132541
134251
134521
135241
135421
142351
142531
143251
143521
145231
145321
152341
152431
153241
153421
154231
154321

213452
213542
214352
214532
215342
215432
231452
231542
234152
234512
235142
235412
241352
241532
243152
243512
245132
245312
251342
251432
253142
253412
254132
254312

312453
312543
314253
314523
315243
315423
321453
321543
324153
324513
325143
325413
341253
341523
342153
342513
345123
345213
351243
351423
352143
352413
354123
354213

412354
412534
413254
413524
415234
415324
421254
421524
423154
423514
425134
425314
431254
431524
432154
432514
435124
435214
451234
451324
452134
452314
453124
453214

512345
512435
513245
513425
514235
514325
521345
521435
523145
523415
524135
524315
531245
531425
532145
532415
534125
534215
541235
541325
542135
542315
543125
543215

412354
412534
413254
413524
415234
415324
421254
421524
423154
425134
431254
432154

512345
512435
513245
513425
514235
514325
521345
521435
523145
524135
531245
532145

Eliminando los caminos de retorno del mismo circuito, quedan:

123451
123541
124351
124531
125341
125431
132451
132541
134251
135241
142351
143251

213452
213542
214352
214532
215342
215432
231452
231542
234152
235142
241352
243152

312453
312543
314253
314523
315243
315423
321453
321543
324153
325143
341253
342153

14

Por ltimo, tomando en consideracin las combinaciones que indican el mismo camino pero de diferente punto de
partida llegamos a:
123451
123541

140
145

124351

125

124531
125341
125431
132451
132541
134251
135241
142351
143251

170
130
170
195
200
180
185
155
155

Siendo la combinacin 1-2-4-3-5-1 la ms corta, tomando slo 125 unidades de tiempo.

15

Consigna 7
Hallar la ruta de distancia mnima que logre unir todas las capitales de Provincias de la Repblica Argentina,
utilizando la siguiente heurstica:
Desde cada ciudad ir a la ciudad ms cercana no visitada.
La ruta de distancia mnima en lnea recta, utilizando la heurstica propuesta, es:
Comenzar la ruta en Crdoba, siguiendo por San Luis, Mendoza, San Juan, La Rioja, San Fernando del Valle de
Catamarca, Santiago del Estero, San Miguel de Tucumn, Salta, San Salvador de Jujuy, Resistencia, Corrientes,
Formosa, Posadas, Paran, Santa Fe, La Plata, Santa Rosa, Neuqun, Viedma, Rawson, Rio Gallegos, Ushuaia y
finalmente volviendo al punto de partida(Crdoba).
La distancia total es de 9779 kilmetros.

Los datos de la tabla presentada a continuacin

muestran los otros caminos posibles de acuerdo a
la heurstica propuesta.

1
2
3
4
5
6
7
8
9
10
11
12

Crdoba
Corrientes
Formosa
La Plata
La Rioja
Mendoza
Neuqun
Paran
Posadas
Rawson
Resistencia
Rio Gallegos

13
14
15
16
17
18
19
20
21
22
23

San Fernando del Valle de Catamarca

San Miguel de Tucumn
San Salvador de Jujuy
Salta
San Juan
San Luis
Santa Fe
Santa Rosa
Santiago del Estero
Ushuaia
Viedma

16

Resolucin Consigna 7
Secuencia
2-11-3-9-8-19-1-18-6-17-5-13-21-14-16-15-20-7-23-10-12-22-4-2
3-2-11-9-8-19-1-18-6-17-5-13-21-14-16-15-20-7-23-10-12-22-4-3
4-8-19-1-18-6-17-5-13-21-14-16-15-11-2-3-9-20-7-23-10-12-22-4
5-13-21-14-16-15-11-2-3-9-8-19-1-18-6-17-20-7-23-10-12-22-4-5
6-17-5-13-21-14-16-15-11-2-1-18-20-7-23-10-12-22-4-8-19-3-9-6
7-20-18-6-17-5-13-21-14-16-15-11-2-1-19-8-4-9-3-23-10-12-22-7
8-19-1-18-6-17-5-13-21-14-16-15-11-2-3-9-4-20-7-23-10-12-22-8
9-3-2-11-19-8-1-18-6-17-5-13-21-14-16-15-20-7-23-10-12-22-4-9
10-23-20-18-6-17-5-13-21-14-16-15-11-2-1-19-8-4-9-3-7-12-22-10
11-2-3-9-8-19-1-18-6-17-5-13-21-14-16-15-20-7-23-10-12-22-4-11
12-22-10-23-20-18-6-17-5-13-21-14-16-15-11-2-1-19-8-4-9-3-7-12
13-5-17-6-18-1-19-8-4-20-7-23-10-12-22-21-14-16-15-11-2-3-9-13
14-21-13-5-17-6-18-1-19-8-4-20-7-23-10-12-22-11-2-3-9-16-15-14
15-16-14-21-13-5-17-6-18-1-19-8-4-20-7-23-10-12-22-11-2-3-9-15
16-15-14-21-13-5-17-6-18-1-19-8-4-20-7-23-10-12-22-11-2-3-9-16
17-6-18-1-19-8-4-20-7-23-10-12-22-5-13-21-14-16-15-11-2-3-9-17
18-6-17-5-13-21-14-16-15-11-2-1-19-8-4-20-7-23-10-12-22-9-3-18
19-8-1-18-6-17-5-13-21-14-16-15-11-2-3-9-4-20-7-23-10-12-22-19
20-18-6-17-5-13-21-14-16-15-11-2-1-19-8-4-23-10-7-12-22-9-3-20
21-14-13-5-17-6-18-1-19-8-4-20-7-23-10-12-22-11-2-3-9-16-15-21
22-12-10-23-20-18-6-17-5-13-21-14-16-15-11-2-1-19-8-4-9-3-7-22
23-10-7-20-18-6-17-5-13-21-14-16-15-11-2-1-19-8-4-9-3-12-22-23

Distancia total (Km)

10282
10572
9857
10350
10969
10674
9881
10160
10621
10281
10621
10646
10274
10224
10274
10660
11367
9905
12219
10418
10648
11378

17

18

Conclusin consigna 7
Al enfrentar problemticas de este tipo es necesario evaluar la situacin desde el principio para saber
que metodologa tomar para su resolucin. Cuando la cantidad de elementos es pequea (de tal forma
que su resolucin tome solo unos das), es preferible resolver de manera exhaustiva, buscando la mejor
opcin posible.
Sin embargo, cuando solo unos pocos elementos se agregan a la situacin, puede que el tiempo
requerido para encontrar la opcin posible pase de unos das a aos (y hasta incluso siglos). En estos
debera solicitarse la ayuda de mtodos heursticos para alcanzar un resultado en menor tiempo. No
encontraramos el mejor, pero, por lo menos, un resultado en s.

19

Consigna 8
Repetir consigna 7, utilizando un algoritmo gentico.

20

Conclusin consigna 8
Si bien aunque la cantidad de poblaciones con las que se trabaja puede ser bastante grande, y se
obtienen resultados en poco tiempo, el mtodo es demasiado aleatorio como para presentar una
respuesta satisfactoria.
Debido a esto, al igual que en la conclusin de la consigna 7, creemos preferible utilizar heurstica para
este tipo de problemas cuando la cantidad de elementos comienza a presentar problemas al modo
exhaustivo.

21

Anexo 1 (Cdigo consigna 2)

Lenguaje: Java
import java.util.Random;
import java.util.Scanner;
class Manhattan {
//con metodo de la ruleta
//Declaracion de variables
private final int PROB_CROSS= 75;
private final int PROB_MUT= 5;
private int[] valores; //arreglo potencias de 2
private int[][][] poblaciones; // contiene los individuos de las 20 poblaciones
private double[][] tabla;
private int[] pares;
private int[][] hijos; // los 2 hijos producidos por cada par de padres
private double[][][] sumPromMaxMin;
private boolean cross;
public Manhattan(int pob){
//inicializacion variables
valores= new int[30];
poblaciones= new int[pob][10][30];
tabla= new double[10][pob*4];
pares= new int[10];
hijos= new int[2][30];
sumPromMaxMin= new double[pob][4][2];
}
//Carga las potencias de 2 en un arreglo, de mayor(2^29) a menor (2^0)
public void cargarValores(){
for(int i=0; i<30; i++){
valores[i]=((int) Math.pow(2, (29-i)));
};
}
//Genera la primer poblacin aleatoriamente
public void generarTablaInicial(){
int x;
Random generator= new Random();
for(int i=0; i<10; i++){
x= generator.nextInt(1073741823); //
poblaciones[0][i]=escribir(x);
tabla[i][0]=x; //PASAR A BINARIO
tabla[i][1]=x;
}
}
//Calcula los valores necesarios (x/coef) y dems
public void calcularTabla(int pob){
double cont=0;
double max=0;
double min=Math.pow(2, 30);
for(int i=0; i<10;i++){
tabla[i][(pob*4)+2]=Math.pow(((tabla[i][(pob*4)+1])/(Math.pow(2, 30)
-1)), 2);
}
for(int i=0; i<10; i++){
cont+=tabla[i][(pob*4)+2];
if(max<tabla[i][(pob*4)+2]){
max= tabla[i][(pob*4)+2];
}
};

22

for(int i=0; i<10; i++){

if(min > tabla[i][(pob*4)+2]){
min = tabla[i][(pob*4)+2];
}
};
sumPromMaxMin[pob][0][0]=cont;
sumPromMaxMin[pob][1][0]=(cont/10);
sumPromMaxMin[pob][2][0]=max;
sumPromMaxMin[pob][3][0]=min;
for(int i=0; i<10; i++){
tabla[i][(pob*4)+3]=((tabla[i][(pob*4)+2])/(sumPromMaxMin[pob][0][0]));
};
cont=0;
max=0;
min = Math.pow(2, 30);
for(int i=0; i<10; i++){
cont+=tabla[i][(pob*4)+3];
if(max<tabla[i][(pob*4)+3]){
max= tabla[i][(pob*4)+3];
}
};
for(int i=0; i<10; i++){
if(min > tabla[i][(pob*4)+3]){
min = tabla[i][(pob*4)+3];
}
};
sumPromMaxMin[pob][0][1]=cont;
sumPromMaxMin[pob][1][1]=(cont/10);
sumPromMaxMin[pob][2][1]=max;
sumPromMaxMin[pob][3][1]=min;
}
/*Crea un arreglo de 100 espacios que representa la ruleta. Cada espacio es 1% de
probabilidad
* de que ese numero sea seleccionado como padre, la cantidad de casillas que le
pertenece
* a cada numero esta dado por el fitness.Ej. si el nro N tiene fitness .2,
* y el numero W tiene fitness .8, la ruleta estaria compuesta de la sig. manera:
* N.N.W.W.W.W.W.W.W.W */
public int[] girarRuleta(int columna){
Random generator= new Random();
int[] ruleta;
int x=0;
ruleta= new int[100];
int max= ((int)((tabla[0][columna+2])*100));
int min=0;
for(int i=0; i<10; i++){
for(int j=min;j<max;j++){
ruleta[j]=((int)(tabla[i][columna]));
}
min=max;
if(i!=9){
if(i==8){
max=100;
} else{
max += ((int) ((tabla[i+1][columna+2])*100));
}
} else{};
}
for(int i=0; i<10; i++){
x= generator.nextInt(100);
pares[i]=ruleta[x];
}

23

return pares; //retorna el par de pardes seleccionado

}
/* Genera un nmero aleatoriamente entre 1 y 100,si el nro. esta entre el 1 y la
prob de crossover
* entonces retorna positivo */
public boolean consultarProbabilidad(){
Random generator= new Random();
int x;
x= generator.nextInt(100);
if(PROB_CROSS>=x){
return true;
} else{
return false;
}
}
/* Hace la cruza de padres para obtener los hijos.
* el corte de genes se hace aleatoriamente */
public int[][] cruzar(int mother, int father){
Random generator= new Random();
int[] madre;
int[] padre;
int x,m;
int[] hijo;
int[] hija;
int[][]retorno;
madre= new int[30];
padre= new int[30];
hijo= new int[30];
hija= new int[30];
retorno= new int[2][30];
padre= escribir(father);
madre= escribir(mother);
x= generator.nextInt(30);
for(int i=0; i<=x; i++){
hijo[i]=padre[i];
hija[i]=madre[i];
};
for(int i=(x+1); i<30; i++){
hijo[i]=madre[i];
hija[i]=padre[i];
};
if (consultarMutacion()){
m= generator.nextInt(30);
if(hijo[m]==1){
hijo[m]=0;
} else{
hijo[m]=1;
}
}
retorno[0]=hijo;
if (consultarMutacion()){
m= generator.nextInt(30);
if(hija[m]==1){
hija[m]=0;
} else{
hija[m]=1;
}
}
retorno[1]=hija;
return retorno;
}

24

//Pasa un numero (ej 14) a binario (1110)

public int[] escribir(int aEscribir){
int[] enBinario;
int x=aEscribir;
enBinario= new int[30]; //en este arreglo se guardan los 1 y 0 en casillas
separadas
for( int i=0; i<30; i++){
if(x>=valores[i]){
enBinario[i]=1;
x-=valores[i];
} else{
enBinario[i]=0;
};
};
return enBinario;
}
// Lee el numero en binario en un arreglo de 0s y 1s y lo transforma a decimal
public int leer(int[] aLeer){
int contador=0;
for(int i=0; i<30; i++){
if(aLeer[i]==1){
contador+=valores[i];
};
};
return contador;
}
/* Si el numero generado aleatoriamente se encuentra entre 0 y la probabilidad de
mutacion,
* entonces retorna positivo para que esta suceda */
public boolean consultarMutacion(){
Random generator= new Random();
int x= generator.nextInt(100);
if(PROB_MUT>=x){
return true;
} else {
return false;
}
}
public void imprimirDatos(int pob){
int max=0;
double min=Math.pow(2,30);
for(int i=0; i<pob; i++){
System.out.println();
System.out.println("Poblacion :" + (i+1));
System.out.println("Suma Fcion :" + sumPromMaxMin[i][0][0] +
"\t\tSuma Fitness: " + sumPromMaxMin[i][0][1]);
System.out.println("Promedio Fcion :" + sumPromMaxMin[i][1][0] +
"\tPromedio Fitness: " + sumPromMaxMin[i][1][1]);
System.out.println("Maximo Fcion :" + sumPromMaxMin[i][2][0] +
"\tMaximo Fitness: " + sumPromMaxMin[i][2][1]);
System.out.println("Minimo Fcion :" + sumPromMaxMin[i][3][0] +
"\tMinimo Fitness: " + sumPromMaxMin[i][3][1]);
};
for(int i=0; i<10; i++){
if(max<(int)tabla[i][77]){
max= (int)tabla[i][77];
}
};
for(int i=0; i<10; i++){
if(min >tabla[i][(pob*4)-3]){
min= tabla[i][(pob*4)-3];

25

}
};
System.out.println();
System.out.println("(Ultima Poblacin)");
System.out.println("Maximo :"+ max);
System.out.println("Minimo :"+ (int)min);
}
//Crea la nueva poblacin a partir de la anterior
public void popularManhattan(int i){
pares= girarRuleta(((i-1)*4)+1);
for(int k=0; k<10; k+=2){
cross= consultarProbabilidad();
if(cross){
hijos= cruzar(pares[k], pares[k+1]);
} else {
hijos[0]= escribir(pares[k]);
hijos[1]= escribir(pares[k+1]);
}
poblaciones[i][k]=hijos[0];
poblaciones[i][k+1]= hijos[1];
tabla[k][(i*4)+1] = leer(hijos[0]);
tabla[k+1][(i*4)+1] =leer(hijos[1]);
tabla[k][(i*4)]= tabla[k][(i*4)+1];
tabla[k+1][(i*4)]= tabla[k+1][(i*4)+1];
}
calcularTabla(i);
}
}
class manhattanDemo {
public static void main(String[] args) {
int poblaciones;
Scanner input = new Scanner( System.in );
System.out.print("Numero de poblaciones: ");
poblaciones = input.nextInt();
Manhattan projManhattan= new Manhattan(poblaciones);
projManhattan.cargarValores();
projManhattan.generarTablaInicial();
projManhattan.calcularTabla(0);
for(int i=1; i< poblaciones; i++){
projManhattan.popularManhattan(i);
}
projManhattan.imprimirDatos(poblaciones);
}
}

26

Anexo 2 (Cdigo consigna 3)

Lenguaje: Java
import java.util.Random;
import java.util.Scanner;
class ManhattanElite {
//Declaracion de variables
private final int PROB_CROSS= 75;
private final int PROB_MUT= 5;
private int[] valores; //arreglo potencias de 2
private int[][][] poblaciones; // contiene los individuos de las 20 poblaciones
private double[][] tabla;
private int[] pares;
private int[][] hijos; // los 2 hijos producidos por cada par de padres
private double[][][] sumPromMaxMin;
private boolean cross;
public ManhattanElite(int pob){
//inicializacion variables
valores= new int[30];
poblaciones= new int[pob][10][30];
tabla= new double[10][pob*4];
pares= new int[10];
hijos= new int[2][30];
sumPromMaxMin= new double[pob][4][2];
}
//Carga las potencias de 2 en un arreglo, de mayor(2^29) a menor (2^0)
public void cargarValores(){
for(int i=0; i<30; i++){
valores[i]=((int) Math.pow(2, (29-i)));
};
}
//Genera la primer poblacin aleatoriamente
public void generarTablaInicial(){
int x;
Random generator= new Random();
for(int i=0; i<10; i++){
x= generator.nextInt(1073741823); //
poblaciones[0][i]=escribir(x);
tabla[i][0]=x; //PASAR A BINARIO
tabla[i][1]=x;
}
}
//Calcula los valores necesarios (x/coef) y dems
public void calcularTabla(int pob){
double cont=0;
double max=0;
double min=Math.pow(2, 30);
for(int i=0; i<10;i++){
tabla[i][(pob*4)+2]=Math.pow(((tabla[i][(pob*4)+1])/(Math.pow(2, 30)
-1)), 2);
}
for(int i=0; i<10; i++){
cont+=tabla[i][(pob*4)+2];
if(max<tabla[i][(pob*4)+2]){
max= tabla[i][(pob*4)+2];
}
};
for(int i=0; i<10; i++){

27

if(min > tabla[i][(pob*4)+2]){

min = tabla[i][(pob*4)+2];
}
};
sumPromMaxMin[pob][0][0]=cont;
sumPromMaxMin[pob][1][0]=(cont/10);
sumPromMaxMin[pob][2][0]=max;
sumPromMaxMin[pob][3][0]=min;
for(int i=0; i<10; i++){
tabla[i][(pob*4)+3]=((tabla[i][(pob*4)+2])/(sumPromMaxMin[pob][0][0]));
};
cont=0;
max=0;
min = Math.pow(2, 30);
for(int i=0; i<10; i++){
cont+=tabla[i][(pob*4)+3];
if(max<tabla[i][(pob*4)+3]){
max= tabla[i][(pob*4)+3];
}
};
for(int i=0; i<10; i++){
if(min > tabla[i][(pob*4)+3]){
min = tabla[i][(pob*4)+3];
}
};
sumPromMaxMin[pob][0][1]=cont;
sumPromMaxMin[pob][1][1]=(cont/10);
sumPromMaxMin[pob][2][1]=max;
sumPromMaxMin[pob][3][1]=min;
}
/*Crea un arreglo de 100 espacios que representa la ruleta. Cada espacio es 1% de
probabilidad
* de que ese numero sea seleccionado como padre, la cantidad de casillas que le
pertenece
* a cada numero esta dado por el fitness.Ej. si el nro N tiene fitness .2,
* y el numero W tiene fitness .8, la ruleta estaria compuesta de la sig. manera:
* N.N.W.W.W.W.W.W.W.W */
public int[] girarRuleta(int columna){
Random generator= new Random();
int[] ruleta;
int x=0;
ruleta= new int[100];
int max= ((int)((tabla[0][columna+2])*100));
int min=0;
for(int i=0; i<10; i++){
for(int j=min;j<max;j++){
ruleta[j]=((int)(tabla[i][columna]));
}
min=max;
if(i!=9){
if(i==8){
max=100;
} else{
max += ((int) ((tabla[i+1][columna+2])*100));
}
} else{};
}
for(int i=1; i<10; i++){
x= generator.nextInt(100);
pares[i]=ruleta[x];
}
return pares; //retorna el par de pardes seleccionado

28

}
/* Genera un nmero aleatoriamente entre 1 y 100,si el nro. esta entre el 1 y la
prob de crossover
* entonces retorna positivo */
public boolean consultarProbabilidad(){
Random generator= new Random();
int x;
x= generator.nextInt(100);
if(PROB_CROSS>=x){
return true;
} else{
return false;
}
}
/* Hace la cruza de padres para obtener los hijos.
* el corte de genes se hace aleatoriamente */
public int[][] cruzar(int mother, int father){
Random generator= new Random();
int[] madre;
int[] padre;
int x,m;
int[] hijo;
int[] hija;
int[][]retorno;
madre= new int[30];
padre= new int[30];
hijo= new int[30];
hija= new int[30];
retorno= new int[2][30];
padre= escribir(father);
madre= escribir(mother);
x= generator.nextInt(30);
for(int i=0; i<=x; i++){
hijo[i]=padre[i];
hija[i]=madre[i];
};
for(int i=(x+1); i<30; i++){
hijo[i]=madre[i];
hija[i]=padre[i];
};
if (consultarMutacion()){
m= generator.nextInt(30);
if(hijo[m]==1){
hijo[m]=0;
} else{
hijo[m]=1;
}
}
retorno[0]=hijo;
if (consultarMutacion()){
m= generator.nextInt(30);
if(hija[m]==1){
hija[m]=0;
} else{
hija[m]=1;
}
}
retorno[1]=hija;
return retorno;
}
//Pasa un numero (ej 14) a binario (1110)

29

public int[] escribir(int aEscribir){

int[] enBinario;
int x=aEscribir;
enBinario= new int[30]; //en este arreglo se guardan los 1 y 0 en casillas
separadas
for( int i=0; i<30; i++){
if(x>=valores[i]){
enBinario[i]=1;
x-=valores[i];
} else{
enBinario[i]=0;
};
};
return enBinario;
}
// Lee el numero en binario en un arreglo de 0s y 1s y lo transforma a decimal
public int leer(int[] aLeer){
int contador=0;
for(int i=0; i<30; i++){
if(aLeer[i]==1){
contador+=valores[i];
};
};
return contador;
}
/* Si el numero generado aleatoriamente se encuentra entre 0 y la probabilidad de
mutacion,
* entonces retorna positivo para que esta suceda */
public boolean consultarMutacion(){
Random generator= new Random();
int x= generator.nextInt(100);
if(PROB_MUT>=x){
return true;
} else {
return false;
}
}
public void imprimirDatos(int pob){
int max=0;
double min=Math.pow(2,30);
for(int i=0; i<pob; i++){
System.out.println();
System.out.println("Poblacion :" + (i+1));
System.out.println("Suma Fcion :" + sumPromMaxMin[i][0][0] +
"\t\tSuma Fitness: " + sumPromMaxMin[i][0][1]);
System.out.println("Promedio Fcion :" + sumPromMaxMin[i][1][0] +
"\tPromedio Fitness: " + sumPromMaxMin[i][1][1]);
System.out.println("Maximo Fcion :" + sumPromMaxMin[i][2][0] +
"\tMaximo Fitness: " + sumPromMaxMin[i][2][1]);
System.out.println("Minimo Fcion :" + sumPromMaxMin[i][3][0] +
"\tMinimo Fitness: " + sumPromMaxMin[i][3][1]);
};
for(int i=0; i<10; i++){
if(max<(int)tabla[i][77]){
max= (int)tabla[i][77];
}
};
for(int i=0; i<10; i++){
if(min >tabla[i][(pob*4)-3]){
min= tabla[i][(pob*4)-3];
}

30

};
System.out.println();
System.out.println("(Ultima Poblacin)");
System.out.println("Maximo :"+ max);
System.out.println("Minimo :"+ (int)min);
}
//Crea la nueva poblacin a partir de la anterior
public void popularManhattan(int i){
pares= girarRuleta(((i-1)*4)+1);
cross= consultarProbabilidad();
if(cross){
hijos= cruzar(pares[0], pares[1]);
if (leer(hijos[0]) < leer(hijos[1])){
hijos[0]= escribir((int)sumPromMaxMin[i-1][2][0]);
} else{
hijos[1]= escribir((int)sumPromMaxMin[i-1][2][0]);
}
} else {
hijos[0]= escribir((int)sumPromMaxMin[i-1][2][0]);
if (pares[0]< pares[1]){
hijos[1]= escribir(pares[1]);
} else{
hijos[1]= escribir(pares[0]);
}
}
poblaciones[i][0]=hijos[0];
poblaciones[i][1]= hijos[1];
tabla[0][(i*4)+1] = leer(hijos[0]);
tabla[1][(i*4)+1] =leer(hijos[1]);
tabla[0][(i*4)]= tabla[0][(i*4)+1];
tabla[1][(i*4)]= tabla[1][(i*4)+1];
for(int k=2; k<10; k+=2){
cross= consultarProbabilidad();
if(cross){
hijos= cruzar(pares[k], pares[k+1]);
} else {
hijos[0]= escribir(pares[k]);
hijos[1]= escribir(pares[k+1]);
}
poblaciones[i][k]=hijos[0];
poblaciones[i][k+1]= hijos[1];
tabla[k][(i*4)+1] = leer(hijos[0]);
tabla[k+1][(i*4)+1] =leer(hijos[1]);
tabla[k][(i*4)]= tabla[k][(i*4)+1];
tabla[k+1][(i*4)]= tabla[k+1][(i*4)+1];
}
calcularTabla(i);
}
}
class manhattanEliteDemo {
public static void main(String[] args) {
int poblaciones;
Scanner input = new Scanner( System.in );
System.out.print("Numero de poblaciones: ");
poblaciones = input.nextInt();
ManhattanElite projManhattanElite= new ManhattanElite(poblaciones);
projManhattanElite.cargarValores();
projManhattanElite.generarTablaInicial();
projManhattanElite.calcularTabla(0);
for(int i=1; i< poblaciones; i++){
projManhattanElite.popularManhattan(i);

31

}
projManhattanElite.imprimirDatos(poblaciones);
}
}

Anexo 2 (Cdigo consigna 7)

Lenguaje: C#
using System;
using System.Collections.Generic;
using System.Text;
namespace Viajante
{
class Program
{
static void Main(string[] args)
{
Eurstico a = new Eurstico();
Console.WriteLine();
a.inicializarDistancias();
a.calcularDistancias();
Console.WriteLine();
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("--------------------------------------------------------------------------------");
Console.WriteLine();
Console.WriteLine();
Exhaustivo exh = new Exhaustivo(); ;
exh.something();
}
}
}

using System;
using System.Collections.Generic;
using System.Text;
namespace Viajante
{
class Exhaustivo
{
/* Parmetros de clase
* @contador se utilizar para contar la cantidad de permutaciones hechas

32

* @menorRecorrido toma el total del menor recorrido

* @recorridoMasCorto contendr la secuencia de ciudades a recorrer para
* el @menorRecorrido
*/
int contador;
int menorRecorrido = 0;
int[] recorridoMasCorto = new int[10];
public void GenerarPermutaciones(int[] cadenaOriginal, int posFijas, int[,] distancia)
{
// @aux variable auxiliar que uso para el intercambio
int aux;
int totalCiudades = cadenaOriginal.Length - 1;
// Como se usa recursivamente este for con el valor max totalCiudades-posFijas simula el "sin repeticion"
// Ya que al usar un elemento tengo n-1 elementos para las proximas posiciones
for (int i = 0; i < totalCiudades - posFijas; i++)
{
if (totalCiudades - posFijas > 2)
GenerarPermutaciones(cadenaOriginal, posFijas + 1, distancia);
else
{
contador = contador + 1;
int totalRecorrido = 0;
for (int num = 0; num < totalCiudades; num++)
{
totalRecorrido = totalRecorrido + distancia[cadenaOriginal[num], cadenaOriginal[num + 1]];
}
totalRecorrido = totalRecorrido + distancia[cadenaOriginal[totalCiudades], cadenaOriginal[0]];
if (totalRecorrido < menorRecorrido || menorRecorrido == 0)
{
menorRecorrido = totalRecorrido;
for (int num = 0; num < totalCiudades; num++)
{
recorridoMasCorto[num] = cadenaOriginal[num];
}
}
}
// Aca es donde intercambio las posiciones, del ultimo elemento fijado, con sus siguientes
aux = cadenaOriginal[posFijas];
cadenaOriginal[posFijas] = cadenaOriginal[posFijas + i + 1];
cadenaOriginal[posFijas + i + 1] = aux;
if (posFijas + i == totalCiudades - 1)
{
// Corro todos los elementos desde la posFija hasta el final, un indice menos y en el ultimo vuelvo a dejar el hueco
for (int j = posFijas; j < totalCiudades; j++)
cadenaOriginal[j] = cadenaOriginal[j + 1];
}
}
}

33

public void something()

{
contador = 0;
byte cantCiudades = 10;
int[,] distancia = new int[cantCiudades, cantCiudades];
// Declaro un vector de una posicion mas que la pedida(para dejar un hueco al final)
int[] ciudades = new int[cantCiudades + 1];
// Determinamos el tiempo inicial de la ejecucion
DateTime tiempo1 = DateTime.Now;
Random a = new Random();
//Damos valores aleatorios para las distancias de supuestas ciudades
for (int i = 0; i < cantCiudades; i++)
{
for (int j = i + 1; j < cantCiudades; j++)
{
distancia[i, j] = a.Next(500000);
distancia[j, i] = distancia[i, j];
}
ciudades[i] = i;
}
// Llamo a la funcion que generara las permutaciones de ese vector sin repeticion(diciendole 0 elementos fijados)
GenerarPermutaciones(ciudades, 0, distancia);
/* Determinamos el tiempo final de la ejecucin
* Calculamos la diferencia en Ticks(1 segundo = 10 000 000 ticks)
* pasamos esa diferencia a das
*/
DateTime tiempo2 = DateTime.Now;
TimeSpan total = new TimeSpan(tiempo2.Ticks - tiempo1.Ticks);
double cantDias = total.TotalDays;
//Calculamos cuanto tardara la ejecucion para 23 ciudades
for (int i = cantCiudades + 1; i < 23; i++)
{
cantDias = cantDias * i;
}
this.tiempo(cantDias);
#region Mostrar valores de la prueba
/* Esta regin muestra los datos obtenidos para las 10 ciudades de prueba
*
Console.WriteLine(total.ToString());
Console.WriteLine("La menor distancia posible por recorrer es: {0}", menorRecorrido);
Console.WriteLine("Recorrido:");
for (int i = 0; i < cantCiudades; i++)
{
Console.Write(recorridoMasCorto[i]);
}
Console.WriteLine();
Console.WriteLine(contador);

34

*
*/
#endregion
Console.Read();
}
/* Se encarga de descomponer los das de ejecucin
* en aos, meses, das, horas, minutos y segundos
*/
public void tiempo(double totalEjecucionEnDias)
{
double aux;
double aos;
double meses;
double dias;
double horas;
double minutos;
double segundos;
// Toma los decimales restantes y los convierte en una unidad inferior
aux = totalEjecucionEnDias / 365;
aos = Math.Truncate(aux);
aux = (aux - aos) * 12;
meses = Math.Truncate(aux);
aux = (aux - meses) * 30.4;
dias = Math.Truncate(aux);
aux = (aux - dias) * 24;
horas = Math.Truncate(aux);
aux = (aux - horas) * 60;
minutos = Math.Truncate(aux);
aux = (aux - minutos) * 60;
segundos = Math.Truncate(aux);
Console.WriteLine("La ejecucion de este algoritmo para 23 ciudades en la presente maquina tomara:");
Console.WriteLine();
Console.WriteLine("{0} aos, {1} mes(es), {2} da(s), {3} hora(s), {4} minuto(s) y {5} segundo(s).", aos, meses, dias, horas,
minutos, segundos);
Console.WriteLine();
Console.WriteLine();
}
}
}

using System;
using System.Collections.Generic;
using System.Text;
namespace Viajante
{

35

class Eurstico
{
int[,] distancia = new int[24, 24];

//esta vacia desde [0,0..23] y [x,0] x=1..23. MY BAD

public void inicializarDistancias()

{
/* Inicializamos el arreglo que tendra las distancias entre las 23 ciudades.
*
* Siendo la lista de ciudades:
* 1-Crdoba, 2-Corrientes, 3-Formosa, 4-La Plata, 5-La Rioja,
* 6-Mendoza, 7-Neuqun, 8-Paran, 9-Posadas, 10-Rawson,
* 11-Resistencia, 12-Ro Gallegos, 13-S.F.d.V.d. Catamarca,
* 14-S.M. de Tucumn, 15-S.S. de Jujuy, 16-Salta, 17-San Juan,
* 18-San Luis, 19-Santa Fe, 20-Santa Rosa, 21-Sgo. Del Estero,
* 22-Ushuaia, 23-Viedma.
*
* Ejemplo: distancia[1,2]=667 (Distancia que hay entre Crdoba y Corrientes es de 667 kilmetros)
*/
#region cargar arreglo de distancias
distancia[1, 2] = 667;
distancia[1, 3] = 824;
distancia[1, 4] = 968;
distancia[1, 5] = 340;
distancia[1, 6] = 466;
distancia[1, 7] = 907;
distancia[1, 8] = 348;
distancia[1, 9] = 919;
distancia[1, 10] = 1321;
distancia[1, 11] = 669;
distancia[1, 12] = 2281;
distancia[1, 13] = 362;
distancia[1, 14] = 517;
distancia[1, 15] = 809;
distancia[1, 16] = 745;
distancia[1, 17] = 412;
distancia[1, 18] = 293;
distancia[1, 19] = 330;
distancia[1, 20] = 577;
distancia[1, 21] = 401;
distancia[1, 22] = 2618;
distancia[1, 23] = 1047;
distancia[2, 3] = 157;
distancia[2, 4] = 830;
distancia[2, 5] = 814;
distancia[2, 6] = 1131;
distancia[2, 7] = 1534;
distancia[2, 8] = 500;
distancia[2, 9] = 291;
distancia[2, 10] = 1845;
distancia[2, 11] = 13;

36

distancia[2, 12] = 2819;

distancia[2, 13] = 691;
distancia[2, 14] = 633;
distancia[2, 15] = 742;
distancia[2, 16] = 719;
distancia[2, 17] = 1039;
distancia[2, 18] = 969;
distancia[2, 19] = 498;
distancia[2, 20] = 1136;
distancia[2, 21] = 535;
distancia[2, 22] = 3131;
distancia[2, 23] = 1527;
distancia[3, 4] = 968;
distancia[3, 5] = 927;
distancia[3, 6] = 1269;
distancia[3, 7] = 1690;
distancia[3, 8] = 656;
distancia[3, 9] = 263;
distancia[3, 10] = 1999;
distancia[3, 11] = 161;
distancia[3, 12] = 2974;
distancia[3, 13] = 793;
distancia[3, 14] = 703;
distancia[3, 15] = 750;
distancia[3, 16] = 741;
distancia[3, 17] = 1169;
distancia[3, 18] = 1117;
distancia[3, 19] = 654;
distancia[3, 20] = 1293;
distancia[3, 21] = 629;
distancia[3, 22] = 3284;
distancia[3, 23] = 1681;
distancia[4, 5] = 1038;
distancia[4, 6] = 1029;
distancia[4, 7] = 1005;
distancia[4, 8] = 427;
distancia[4, 9] = 857;
distancia[4, 10] = 1116;
distancia[4, 11] = 833;
distancia[4, 12] = 2064;
distancia[4, 13] = 1030;
distancia[4, 14] = 1132;
distancia[4, 15] = 1385;
distancia[4, 16] = 1333;
distancia[4, 17] = 1053;
distancia[4, 18] = 795;
distancia[4, 19] = 444;
distancia[4, 20] = 602;
distancia[4, 21] = 991;
distancia[4, 22] = 2350;

37

distancia[4, 23] = 789;

distancia[5, 6] = 427;
distancia[5, 7] = 1063;
distancia[5, 8] = 659;
distancia[5, 9] = 1098;
distancia[5, 10] = 1548;
distancia[5, 11] = 802;
distancia[5, 12] = 2473;
distancia[5, 13] = 149;
distancia[5, 14] = 330;
distancia[5, 15] = 600;
distancia[5, 16] = 533;
distancia[5, 17] = 283;
distancia[5, 18] = 435;
distancia[5, 19] = 640;
distancia[5, 20] = 834;
distancia[5, 21] = 311;
distancia[5, 22] = 2821;
distancia[5, 23] = 1311;
distancia[6, 7] = 676;
distancia[6, 8] = 790;
distancia[6, 9] = 1384;
distancia[6, 10] = 1201;
distancia[6, 11] = 1121;
distancia[6, 12] = 2081;
distancia[6, 13] = 569;
distancia[6, 14] = 756;
distancia[6, 15] = 1023;
distancia[6, 16] = 957;
distancia[6, 17] = 152;
distancia[6, 18] = 235;
distancia[6, 19] = 775;
distancia[6, 20] = 586;
distancia[6, 21] = 713;
distancia[6, 22] = 2435;
distancia[6, 23] = 1019;
distancia[7, 8] = 1053;
distancia[7, 9] = 1709;
distancia[7, 10] = 543;
distancia[7, 11] = 1529;
distancia[7, 12] = 1410;
distancia[7, 13] = 1182;
distancia[7, 14] = 1370;
distancia[7, 15] = 1658;
distancia[7, 16] = 1591;
distancia[7, 17] = 824;
distancia[7, 18] = 643;
distancia[7, 19] = 1049;
distancia[7, 20] = 422;

38

distancia[7, 21] = 1286;

distancia[7, 22] = 1762;
distancia[7, 23] = 479;
distancia[8, 9] = 658;
distancia[8, 10] = 1345;
distancia[8, 11] = 498;
distancia[8, 12] = 2320;
distancia[8, 13] = 622;
distancia[8, 14] = 707;
distancia[8, 15] = 959;
distancia[8, 16] = 906;
distancia[8, 17] = 757;
distancia[8, 18] = 574;
distancia[8, 19] = 19;
distancia[8, 20] = 642;
distancia[8, 21] = 566;
distancia[8, 22] = 2635;
distancia[8, 23] = 1030;
distancia[9, 10] = 1951;
distancia[9, 11] = 305;
distancia[9, 12] = 2914;
distancia[9, 13] = 980;
distancia[9, 14] = 924;
distancia[9, 15] = 1007;
distancia[9, 16] = 992;
distancia[9, 17] = 1306;
distancia[9, 18] = 1200;
distancia[9, 19] = 664;
distancia[9, 20] = 1293;
distancia[9, 21] = 827;
distancia[9, 22] = 3207;
distancia[9, 23] = 1624;
distancia[10, 11] = 1843;
distancia[10, 12] = 975;
distancia[10, 13] = 1647;
distancia[10, 14] = 1827;
distancia[10, 15] = 2120;
distancia[10, 16] = 2054;
distancia[10, 17] = 1340;
distancia[10, 18] = 1113;
distancia[10, 19] = 1349;
distancia[10, 20] = 745;
distancia[10, 21] = 1721;
distancia[10, 22] = 1300;
distancia[10, 23] = 327;
distancia[11, 12] = 2818;
distancia[11, 13] = 678;
distancia[11, 14] = 620;

39

distancia[11, 15] = 729;

distancia[11, 16] = 706;
distancia[11, 17] = 1029;
distancia[11, 18] = 961;
distancia[11, 19] = 495;
distancia[11, 20] = 1132;
distancia[11, 21] = 523;
distancia[11, 22] = 3130;
distancia[11, 23] = 1526;
distancia[12, 13] = 2587;
distancia[12, 14] = 2773;
distancia[12, 15] = 3063;
distancia[12, 16] = 2997;
distancia[12, 17] = 2231;
distancia[12, 18] = 2046;
distancia[12, 19] = 2325;
distancia[12, 20] = 1712;
distancia[12, 21] = 2677;
distancia[12, 22] = 359;
distancia[12, 23] = 1294;
distancia[13, 14] = 189;
distancia[13, 15] = 477;
distancia[13, 16] = 410;
distancia[13, 17] = 430;
distancia[13, 18] = 540;
distancia[13, 19] = 602;
distancia[13, 20] = 915;
distancia[13, 21] = 166;
distancia[13, 22] = 2931;
distancia[13, 23] = 1391;
distancia[14, 15] = 293;
distancia[14, 16] = 228;
distancia[14, 17] = 612;
distancia[14, 18] = 727;
distancia[14, 19] = 689;
distancia[14, 20] = 1088;
distancia[14, 21] = 141;
distancia[14, 22] = 3116;
distancia[14, 23] = 1562;
distancia[15, 16] = 67;
distancia[15, 17] = 874;
distancia[15, 18] = 1017;
distancia[15, 19] = 942;
distancia[15, 20] = 1382;
distancia[15, 21] = 414;
distancia[15, 22] = 3408;
distancia[15, 23] = 1855;

40

distancia[16, 17] = 808;

distancia[16, 18] = 950;
distancia[16, 19] = 889;
distancia[16, 20] = 1316;
distancia[16, 21] = 353;
distancia[16, 22] = 3341;
distancia[16, 23] = 1790;
distancia[17, 18] = 284;
distancia[17, 19] = 740;
distancia[17, 20] = 686;
distancia[17, 21] = 583;
distancia[17, 22] = 2585;
distancia[17, 23] = 1141;
distancia[18, 19] = 560;
distancia[18, 20] = 412;
distancia[18, 21] = 643;
distancia[18, 22] = 2392;
distancia[18, 23] = 882;
distancia[19, 20] = 641;
distancia[19, 21] = 547;
distancia[19, 22] = 2641;
distancia[19, 23] = 1035;
distancia[20, 21] = 977;
distancia[20, 22] = 2044;
distancia[20, 23] = 477;
distancia[21, 22] = 3016;
distancia[21, 23] = 1446;
distancia[22, 23] = 1605;
#endregion
for (int i = 1; i <= 22; i++)
{
for (int j = i + 1; j <= 23; j++)
{
distancia[j, i] = distancia[i, j];
}
};
}
public struct retorno
{
public int[] secuencia;
public int total;
public retorno(int[] a, int b)
{

41

total = b;
secuencia = new int[24];
for (int i = 0; i <= 23; i++)
{
secuencia[i] = a[i];
}
}
};
public retorno hacerRecorrido(int numCiudad)
{
/*
* masCorto[0] contrendr la secuencia de ciudades a recorrer
* masCorto[1] contrendr la cadena que indica el total del recorrido
*/
int[] masCorto = new int[24];
masCorto[0] = numCiudad;
int total = 0;
int ultima;
ultima = numCiudad;
for (int b = 1; b < 23; b++)
{
int menor = 20000;
int aux = 0;
for (int i = 1; i <= 23; i++)
{
bool continuar = true;
foreach (int ciudad in masCorto)
{
if (ciudad == i)
{
continuar = false;
}
}
if (continuar)
{
if (distancia[ultima, i] < menor)
{
menor = distancia[ultima, i];
aux = i;
}
}
}
ultima = aux;
total += menor;
masCorto[b] = ultima;
}
masCorto[23] = numCiudad;
retorno camino = new retorno(masCorto, total);
return camino;
}

42

public void calcularDistancias()

{
retorno recorridoMasCorto = hacerRecorrido(1);
retorno aux;
for (int i = 2; i <= 23; i++)
{
aux = hacerRecorrido(i);
if (aux.total < recorridoMasCorto.total)
{
recorridoMasCorto = aux;
}
}
Console.WriteLine("El recorrido mas corto es de: {0} kilmetros.", recorridoMasCorto.total);
Console.WriteLine("Pasando por las siguientes ciudades, en el orden especificado:");
foreach (int i in recorridoMasCorto.secuencia)
{
Console.Write("{0} ", i);
}
}
}
}

Anexo 3 (Consigna 6)
Lenguaje: C#

using System;
using System.Collections.Generic;
using System.Text;
namespace Mochila
{
class Program
{
static void Main(string[] args)
{
Program prog = new Program();
Console.WriteLine("EXHAUSTIVO.");
prog.realizarExhaustivo();
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("---------------------------------------------------------");
Console.WriteLine();

43

Console.WriteLine("GREEDY.");
prog.realizarGreedy();
Console.Read();
}
public void realizarGreedy()
{
Greedy grd = new Greedy();
Console.WriteLine("1.Utilizar elementos existentes.");
Console.WriteLine("2.Ingresar elementos por teclado.");
Console.Write("Opcin elejida: ");
int op;
op = int.Parse(Console.ReadLine());
int cant = 10;
if (op == 1)
{
grd.cargarElementosConocidos();
}
else
{
cant = grd.cargarDatos();
grd.cargarElementos(cant);
}
grd.cargarElementosConocidos();
grd.hacer();
grd.mostrar();
}
public void realizarExhaustivo()
{
Exhaustivo comb = new Exhaustivo();
Console.WriteLine("1.Utilizar elementos existentes.");
Console.WriteLine("2.Ingresar elementos por teclado.");
Console.Write("Opcin elejida: ");
int op;
op = int.Parse(Console.ReadLine());
int cant=10;
if (op == 1)
{
comb.cargarElementosConocidos();
}
else
{
cant = comb.cargarDatos();
comb.cargarElementos(cant);
}
for (int i = 0; i < cant; i++)
{
comb.inicializar(0, i, 0);
comb.combinar(i, cant, i);
}

44

comb.mostrar();
}
}
}
using System;
using System.Collections.Generic;
using System.Text;
namespace Mochila
{
class Mochila
{
public int[] C;
public double[] Precio;
public double[] Kilaje;
public double PrecioMaximo=0;
public double PesoMaximo;
public int[] ElementosOptimos;
public int[] E;
public int cant;
public int cargarDatos()
{
Console.Write("Ingrese cantidad de elementos: ");
cant = int.Parse(Console.ReadLine());
Precio = new double[cant];
Kilaje = new double[cant];
C = new int[cant];
E = new int[cant];
Console.Write("Ingrese peso maximo de mochila: ");
PesoMaximo = double.Parse(Console.ReadLine());
return cant;
}
public void cargarElementos(int cant) //precios y pesos de elementos por teclado. Param @cant cantidad de elementos a
ingresar
{
for (int i = 0; i < cant; i++)
{
Console.Write("Ingrese precio de elemento {0}: ",i+1);
Precio[i] = double.Parse(Console.ReadLine());
Console.Write("Ingrese peso de elemento {0}: ", i+1);
Kilaje[i] = double.Parse(Console.ReadLine());
E[i] = i;
}
}
/*
* Inicializa Precio y Kilaje con los elementos que se encuentran

45

* en la tabla del ejercicio.

* No usar cargarDatos(), ni cargarElementos(int cant) en caso de usar este
* metodo
*/
public void cargarElementosConocidos()
{
PesoMaximo = 4200;
cant = 10;
C = new int[cant];
E = new int[cant];
for (int i = 0; i < cant; i++)
{
E[i] = i;
}
Precio = new double[cant];
Kilaje = new double[cant];
Precio[0]=20;
Kilaje[0]=150;
Precio[1]=40;
Kilaje[1]=325;
Precio[2]=50;
Kilaje[2]=600;
Precio[3]=36;
Kilaje[3]=805;
Precio[4]=25;
Kilaje[4]=430;
Precio[5]=64;
Kilaje[5]=1200;
Precio[6]=54;
Kilaje[6]=770;
Precio[7]=18;
Kilaje[7]=60;
Precio[8]=46;
Kilaje[8]=930;
Precio[9]=28;
Kilaje[9]=353;
}
//public void inicializar(int pos) //inicializa arreglo C (Combinaciones) en una secuencia numerica ascendente
//{
// for (int i = 0; i <= pos; i++)
// {
//
C[i] = i;
// }
//}
public void mostrar()
{
Console.WriteLine();
Console.WriteLine("El precio maximo que se puede obtener es: {0}",PrecioMaximo);

46

Console.Write("Los elementos son: {0}", ElementosOptimos[0]+1);

for (int i = 1; i < cant && ElementosOptimos[i]!=0; i++ )
{
Console.Write(", {0}",ElementosOptimos[i]+1);
}
}

}
}
using System;
using System.Collections.Generic;
using System.Text;
namespace Mochila
{
class Exhaustivo : Mochila
{
public void combinar(int pos, int cantEl, int posFija)
{
evaluar(posFija);
if (C[pos] == E[cantEl - 1])
{
if (pos != 0)
{
combinar(pos - 1, cantEl - 1, posFija);
}
}
else
{
C[pos] = C[pos] + 1;
if (pos == posFija)
{
combinar(pos, cantEl, posFija);
}
else
{
inicializar(pos + 1, posFija, C[pos] + 1);
combinar(posFija, E.Length, posFija);
}
}
}
/*
* Inicializa el arreglo @C desde el ndice @ini hasta el ndice @pos,
* en una secuencia numerica ascendente desde el numero @algo hasta @algo + (@pos - @ini)
*/
public void inicializar(int ini, int pos, int algo)
{
int a = algo;

47

for (int i = ini; i <= pos; i++)

{
C[i] = a;
a = a + 1;
}
}
/*
* Evalua la combinacin generada para encontrar la combinacin ptima.
* Param @set indica el indice mximo que tiene el array de la combinacin.
*/
public void evaluar(int set)
{
double peso = 0;
double precio = 0;
int[] aux = new int[cant];
aux = C;
for (int i = 0; i <= set; i++)
{
peso = peso + Kilaje[C[i]];
precio = precio + Precio[C[i]];
}
if (peso <= PesoMaximo)
{
if (precio > PrecioMaximo)
{
PrecioMaximo = precio;
ElementosOptimos = new int[cant];
for (int j = 0; j < cant; j++)
{
ElementosOptimos[j] = aux[j];
}
}
}
//MOSTRAR LA COMBINACIN EVALUADA:
//for (int i = 0; i < cant; i++)
//{
// Console.Write(C[i]);
//}
//Console.WriteLine();
}
}
}
using System;
using System.Collections.Generic;
using System.Text;
namespace Mochila
{
class Greedy : Mochila
{
double[] densidad;

48

int[] elementos;
public void densi()
{
densidad = new double[cant];
elementos = new int[cant];
for (int i = 0; i < cant;i++ )
{
densidad[i] = Precio[i] / Kilaje[i];
}
double aux;
int aux1;
for (int i = 0; i < cant; i++)
{
for (int j = i + 1; j < cant; j++)
{
if(densidad[i]>densidad[j])
{
aux = densidad[i];
densidad[i] = densidad[j];
densidad[j] = aux;
aux1 = elementos[i];
elementos[i] = elementos[j];
elementos[j] = aux1;
}
}
}
}
public void inicializarElementos()
{
elementos = new int[cant];
for (int i = 0; i < cant; i++)
{
elementos[i]=i;
}
}
public void agregarElementos()
{
double pesoMochila=0;
double pesoActual;
ElementosOptimos = new int[cant];
int a=0;
for (int i = 0; i < cant;i++ )
{
pesoActual=pesoMochila+Kilaje[elementos[i]];
if (pesoActual <= PesoMaximo)
{
pesoMochila = pesoActual;
PrecioMaximo = Precio[elementos[i]] + PrecioMaximo;

49

ElementosOptimos[a] = elementos[i];
a = a + 1;
}
}
}
public void hacer()
{
this.densi();
this.inicializarElementos();
this.agregarElementos();
}

}
}

50

Anexo 4(Consigna 8)
class Program
{
static void Main(string[] args)
{
Genetico vg = new Genetico();
vg.pobInicial();
for (int i = 0; i < 200; i++)
{
vg.calcularRecorridos();
vg.calcularFitness();
vg.ordenarFitness();
vg.cargarRuleta();
vg.girarRuleta();
vg.nuevaPoblacion();
}
vg.calcularRecorridos();
vg.buscarMejorRecorrido();
}
}
class Genetico
{
private const int PROB_CROSS = 75;
private const int PROB_MUT = 5;
private int[,] distancia = new int[24,24];
private int[,] hijos, poblacion;
private int[] recorrido;
private int[,] padres;
private double[] fitness;
private Random genRand;
int[] ruleta;
List<int> listaCiudades = new List<int>();
/* Inicializamos el arreglo que tendra las distancia entre las 23 ciudades,
* y tambin las dems variables de instancia.
*
* Siendo la lista de ciudades:
* 1-Crdoba, 2-Corrientes, 3-Formosa, 4-La Plata, 5-La Rioja,
* 6-Mendoza, 7-Neuqun, 8-Paran, 9-Posadas, 10-Rawson,
* 11-Resistencia, 12-Ro Gallegos, 13-S.F.d.V.d. Catamarca,
* 14-S.M. de Tucumn, 15-S.S. de Jujuy, 16-Salta, 17-San Juan,
* 18-San Luis, 19-Santa Fe, 20-Santa Rosa, 21-Sgo. Del Estero,
* 22-Ushuaia, 23-Viedma.
*
* Ejemplo: distancia[1,2]=667 (Distancia que hay entre Crdoba y Corrientes es
de 667 kilmetros)
*/
public Genetico()
{
poblacion = new int[50,23];
hijos = new int[50, 23];
genRand = new Random();
recorrido = new int[50];
fitness = new double[50];
padres = new int[25, 2];
ruleta = new int[100];
#region cargar arreglo de distancias
distancia[1, 2] = 667;
distancia[1, 3] = 824;
distancia[1, 4] = 968;

51

distancia[1,
distancia[1,
distancia[1,
distancia[1,
distancia[1,
distancia[1,
distancia[1,
distancia[1,
distancia[1,
distancia[1,
distancia[1,
distancia[1,
distancia[1,
distancia[1,
distancia[1,
distancia[1,
distancia[1,
distancia[1,
distancia[1,

5] = 340;
6] = 466;
7] = 907;
8] = 348;
9] = 919;
10] = 1321;
11] = 669;
12] = 2281;
13] = 362;
14] = 517;
15] = 809;
16] = 745;
17] = 412;
18] = 293;
19] = 330;
20] = 577;
21] = 401;
22] = 2618;
23] = 1047;

distancia[2,
distancia[2,
distancia[2,
distancia[2,
distancia[2,
distancia[2,
distancia[2,
distancia[2,
distancia[2,
distancia[2,
distancia[2,
distancia[2,
distancia[2,
distancia[2,
distancia[2,
distancia[2,
distancia[2,
distancia[2,
distancia[2,
distancia[2,
distancia[2,

3] = 157;
4] = 830;
5] = 814;
6] = 1131;
7] = 1534;
8] = 500;
9] = 291;
10] = 1845;
11] = 13;
12] = 2819;
13] = 691;
14] = 633;
15] = 742;
16] = 719;
17] = 1039;
18] = 969;
19] = 498;
20] = 1136;
21] = 535;
22] = 3131;
23] = 1527;

distancia[3,
distancia[3,
distancia[3,
distancia[3,
distancia[3,
distancia[3,
distancia[3,
distancia[3,
distancia[3,
distancia[3,
distancia[3,
distancia[3,
distancia[3,
distancia[3,
distancia[3,
distancia[3,
distancia[3,
distancia[3,
distancia[3,
distancia[3,

4] = 968;
5] = 927;
6] = 1269;
7] = 1690;
8] = 656;
9] = 263;
10] = 1999;
11] = 161;
12] = 2974;
13] = 793;
14] = 703;
15] = 750;
16] = 741;
17] = 1169;
18] = 1117;
19] = 654;
20] = 1293;
21] = 629;
22] = 3284;
23] = 1681;

distancia[4, 5] = 1038;

52

distancia[4,
distancia[4,
distancia[4,
distancia[4,
distancia[4,
distancia[4,
distancia[4,
distancia[4,
distancia[4,
distancia[4,
distancia[4,
distancia[4,
distancia[4,
distancia[4,
distancia[4,
distancia[4,
distancia[4,
distancia[4,

6] = 1029;
7] = 1005;
8] = 427;
9] = 857;
10] = 1116;
11] = 833;
12] = 2064;
13] = 1030;
14] = 1132;
15] = 1385;
16] = 1333;
17] = 1053;
18] = 795;
19] = 444;
20] = 602;
21] = 991;
22] = 2350;
23] = 789;

distancia[5,
distancia[5,
distancia[5,
distancia[5,
distancia[5,
distancia[5,
distancia[5,
distancia[5,
distancia[5,
distancia[5,
distancia[5,
distancia[5,
distancia[5,
distancia[5,
distancia[5,
distancia[5,
distancia[5,
distancia[5,

6] = 427;
7] = 1063;
8] = 659;
9] = 1098;
10] = 1548;
11] = 802;
12] = 2473;
13] = 149;
14] = 330;
15] = 600;
16] = 533;
17] = 283;
18] = 435;
19] = 640;
20] = 834;
21] = 311;
22] = 2821;
23] = 1311;

distancia[6,
distancia[6,
distancia[6,
distancia[6,
distancia[6,
distancia[6,
distancia[6,
distancia[6,
distancia[6,
distancia[6,
distancia[6,
distancia[6,
distancia[6,
distancia[6,
distancia[6,
distancia[6,
distancia[6,

7] = 676;
8] = 790;
9] = 1384;
10] = 1201;
11] = 1121;
12] = 2081;
13] = 569;
14] = 756;
15] = 1023;
16] = 957;
17] = 152;
18] = 235;
19] = 775;
20] = 586;
21] = 713;
22] = 2435;
23] = 1019;

distancia[7,
distancia[7,
distancia[7,
distancia[7,
distancia[7,
distancia[7,
distancia[7,
distancia[7,

8] = 1053;
9] = 1709;
10] = 543;
11] = 1529;
12] = 1410;
13] = 1182;
14] = 1370;
15] = 1658;

53

distancia[7,
distancia[7,
distancia[7,
distancia[7,
distancia[7,
distancia[7,
distancia[7,
distancia[7,

16]
17]
18]
19]
20]
21]
22]
23]

=
=
=
=
=
=
=
=

1591;
824;
643;
1049;
422;
1286;
1762;
479;

distancia[8,
distancia[8,
distancia[8,
distancia[8,
distancia[8,
distancia[8,
distancia[8,
distancia[8,
distancia[8,
distancia[8,
distancia[8,
distancia[8,
distancia[8,
distancia[8,
distancia[8,

9] = 658;
10] = 1345;
11] = 498;
12] = 2320;
13] = 622;
14] = 707;
15] = 959;
16] = 906;
17] = 757;
18] = 574;
19] = 19;
20] = 642;
21] = 566;
22] = 2635;
23] = 1030;

distancia[9,
distancia[9,
distancia[9,
distancia[9,
distancia[9,
distancia[9,
distancia[9,
distancia[9,
distancia[9,
distancia[9,
distancia[9,
distancia[9,
distancia[9,
distancia[9,

10]
11]
12]
13]
14]
15]
16]
17]
18]
19]
20]
21]
22]
23]

=
=
=
=
=
=
=
=
=
=
=
=
=
=

1951;
305;
2914;
980;
924;
1007;
992;
1306;
1200;
664;
1293;
827;
3207;
1624;

distancia[10,
distancia[10,
distancia[10,
distancia[10,
distancia[10,
distancia[10,
distancia[10,
distancia[10,
distancia[10,
distancia[10,
distancia[10,
distancia[10,
distancia[10,

11]
12]
13]
14]
15]
16]
17]
18]
19]
20]
21]
22]
23]

=
=
=
=
=
=
=
=
=
=
=
=
=

1843;
975;
1647;
1827;
2120;
2054;
1340;
1113;
1349;
745;
1721;
1300;
327;

distancia[11,
distancia[11,
distancia[11,
distancia[11,
distancia[11,
distancia[11,
distancia[11,
distancia[11,
distancia[11,
distancia[11,

12]
13]
14]
15]
16]
17]
18]
19]
20]
21]

=
=
=
=
=
=
=
=
=
=

2818;
678;
620;
729;
706;
1029;
961;
495;
1132;
523;

54

distancia[11, 22] = 3130;

distancia[11, 23] = 1526;
distancia[12,
distancia[12,
distancia[12,
distancia[12,
distancia[12,
distancia[12,
distancia[12,
distancia[12,
distancia[12,
distancia[12,
distancia[12,

13]
14]
15]
16]
17]
18]
19]
20]
21]
22]
23]

=
=
=
=
=
=
=
=
=
=
=

2587;
2773;
3063;
2997;
2231;
2046;
2325;
1712;
2677;
359;
1294;

distancia[13,
distancia[13,
distancia[13,
distancia[13,
distancia[13,
distancia[13,
distancia[13,
distancia[13,
distancia[13,
distancia[13,

14]
15]
16]
17]
18]
19]
20]
21]
22]
23]

=
=
=
=
=
=
=
=
=
=

189;
477;
410;
430;
540;
602;
915;
166;
2931;
1391;

distancia[14,
distancia[14,
distancia[14,
distancia[14,
distancia[14,
distancia[14,
distancia[14,
distancia[14,
distancia[14,

15]
16]
17]
18]
19]
20]
21]
22]
23]

=
=
=
=
=
=
=
=
=

293;
228;
612;
727;
689;
1088;
141;
3116;
1562;

distancia[15,
distancia[15,
distancia[15,
distancia[15,
distancia[15,
distancia[15,
distancia[15,
distancia[15,

16]
17]
18]
19]
20]
21]
22]
23]

=
=
=
=
=
=
=
=

67;
874;
1017;
942;
1382;
414;
3408;
1855;

distancia[16,
distancia[16,
distancia[16,
distancia[16,
distancia[16,
distancia[16,
distancia[16,

17]
18]
19]
20]
21]
22]
23]

=
=
=
=
=
=
=

808;
950;
889;
1316;
353;
3341;
1790;

distancia[17,
distancia[17,
distancia[17,
distancia[17,
distancia[17,
distancia[17,

18]
19]
20]
21]
22]
23]

=
=
=
=
=
=

284;
740;
686;
583;
2585;
1141;

distancia[18,
distancia[18,
distancia[18,
distancia[18,

19]
20]
21]
22]

=
=
=
=

560;
412;
643;
2392;

55

distancia[18, 23] = 882;

distancia[19,
distancia[19,
distancia[19,
distancia[19,

20]
21]
22]
23]

=
=
=
=

641;
547;
2641;
1035;

distancia[20, 21] = 977;

distancia[20, 22] = 2044;
distancia[20, 23] = 477;
distancia[21, 22] = 3016;
distancia[21, 23] = 1446;
distancia[22, 23] = 1605;
#endregion
for (int i = 1; i <= 22; i++)
{
for (int j = i + 1; j <= 23; j++)
{
distancia[j, i] = distancia[i, j];
}
};
}
/*Creamos la poblacin inicial y calculamos el recorrido de cada uno
*de los individuos*/
public void pobInicial()
{
for (int i = 0; i < 50; i++)
{
for (int u = 1; u < 24; u++)
{
listaCiudades.Add(u);
}
int[] listTemp = ShuffleList<int>(listaCiudades).ToArray();
for (int q = 0; q < 23; q++)
{
poblacion[i, q] = listTemp[q];
}
}
calcularRecorridos();
}
public void calcularRecorridos()
{
int contador;
for (int i = 0; i < 50; i++)
{
contador = 0;
for (int j = 0; j < 22; j++)
{
contador += distancia[poblacion[i, j], poblacion[i, j + 1]];
}
contador += distancia[poblacion[i, 22], poblacion[i, 0]];
recorrido[i] = contador;
}
}
/*Cargamos la ruleta con los indices que apuntan a los individuos segun su
fitness*/

56

public void cargarRuleta()

{
int max = Convert.ToInt32(fitness[0] * 100);
int min = 0;
for (int i = 0; i < 50; i++)
{
for (int j = min; j < max; j++)
{
ruleta[j] = i;
}
min = max;
if (i != 49)
{
if (i == 48)
{
max = 100;
}
else
{
max += Convert.ToInt32(fitness[i + 1]) * 100;
}
}
}
}
public void calcularFitness()
{
int total = 0;
for (int i = 0; i < 50; i++)
{
total += recorrido[i];
}
for (int i = 0; i < 50; i++)
{
fitness[i] = recorrido[i] / total;
}
}
/*Giramos la ruleta y obtenemos los indices a los 25 pares de padres*/
public void girarRuleta()
{
for (int i = 0; i < 25; i++)
{
padres[i, 0] = ruleta[genRand.Next(100)];
padres[i, 1] = ruleta[genRand.Next(100)];
}
}
/*Obtenemos la nueva poblacin*/
public void nuevaPoblacion()
{
for (int i = 0; i < 25; i++)
{
if (genRand.Next(100) <= PROB_CROSS)
{
bool iguales=true;
for (int m = 0; m < 23 & iguales; m++)
{
if (poblacion[padres[i, 0], m] != poblacion[padres[i, 1], m])
iguales = false;
}
if (iguales)
{
for (int w = 0; w < 23; w++)

57

{
hijos[i * 2 , w] = poblacion[padres[i, 0], w];
hijos[(i * 2) +1, w] = poblacion[padres[i, 1], w];
}

}
else
{
bool[] usados1 = new bool[23];
bool[] usados2 = new bool[23];
for (int k = 0; k < 23; k++)
{
usados1[k] = false;
usados2[k] = false;
}
usados1[0] = true;
usados2[0] = true;
int aBuscar1, aBuscar2;
hijos[i * 2, 0] = poblacion[padres[i, 0], 0];
hijos[(i * 2) +1, 0] = poblacion[padres[i, 1], 0];
aBuscar1 = poblacion[padres[i, 1], 0];
aBuscar2 = poblacion[padres[i, 0], 0];
int b1, b2;
bool continuar = true;
do
{
b1 = 1;
bool encontrado = false;
do
{
if (aBuscar1 == poblacion[padres[i, 0], b1])
{
encontrado = true;
}
b1++;
} while (!encontrado);
if (!usados1[b1])
{
hijos[i * 2, b1] = aBuscar1;
usados1[b1] = true;
aBuscar1 = poblacion[padres[i, 1], b1];
}
else continuar = false;
} while (continuar);
continuar = true;
do
{
b2 = 1;
bool encontrado = false;
do
{
if (aBuscar2 == poblacion[padres[i, 1], b2])
{
encontrado = true;
}
b2++;
} while (!encontrado);
if (!usados2[b2])
{
hijos[(i * 2) +1, b2] = aBuscar2;
usados2[b2] = true;
aBuscar2 = poblacion[padres[i, 0], b2];
}
else continuar = false;
} while (continuar);

58

for (int y = 0; y < 23; y++)

{
if (!usados1[y])
{
hijos[i * 2, y] = poblacion[padres[i, 1], y];
}
if (!usados2[y])
{
hijos[(i * 2) +1, y] = poblacion[padres[i, 0], y];
}
}
}
}
}
poblacion = (int[,])hijos.Clone();
}
/*Obtenemos un recorrido aleatorio*/
private List<E> ShuffleList<E>(List<E> inputList)
{
List<E> randomList = new List<E>();
int randomIndex = 0;
while (inputList.Count > 0)
{
randomIndex = genRand.Next(0, inputList.Count); //Choose a random
object in the list
randomList.Add(inputList[randomIndex]); //add it to the new, random
list
inputList.RemoveAt(randomIndex); //remove to avoid duplicates
}
return randomList; //return the new random list
}
public void ordenarFitness()
{
double[] fitnessAux = new double[50];
fitnessAux = (double[])fitness.Clone();
double aux;
for (int i = 0; i < 50; i++)
{
for (int j = i + 1; j < i; j++)
{
if (fitnessAux[i] < fitnessAux[j])
{
aux = fitnessAux[i];
fitnessAux[i] = fitnessAux[j];
fitnessAux[j] = aux;
}
}
}

//ordena de mayor a menor

int[] marcadoFitness = new int[50];

for (int a = 0; a < 50; a++)
marcadoFitness[a] = 0;
for (int i = 0; i < 50; i++)
{
int b = 0;
int cortar = 0;
do
{
if (fitness[i] == fitnessAux[b] && marcadoFitness[b] == 0)
{

59

fitness[i] = fitnessAux[49 - b];

marcadoFitness[b] = 1;
cortar = 1;
}
b = b + 1;
} while (cortar == 0);
}
}
public void buscarMejorRecorrido()
{
int mejorRecorrido=recorrido[0];
int indiceMejorRecorrido = 0;
for (int i = 1; i < 50; i++)
{
if (recorrido[i] < mejorRecorrido)
{
mejorRecorrido = recorrido[i];
indiceMejorRecorrido = i;
}
}
System.Console.WriteLine("El mejor recorrido encontrado es:");
System.Console.Write(poblacion[indiceMejorRecorrido, 0]);
for (int i=1; i<23; i++)
{
System.Console.Write("-{0}",poblacion[indiceMejorRecorrido,i]);
}
System.Console.WriteLine("-{0}",poblacion[indiceMejorRecorrido,0]);
System.Console.Write("Con un recorrido de: {0}", mejorRecorrido);
System.Console.ReadKey();
}
}

60