Java - me ayudan

me ayudarian a comentar lineas de un codigo


#include <windows.h>
// 02-Algoritmo del GRASP.cpp: define el punto de entrada de la
//aplicación de consola. //
// 01-INICIO DE LIBRERIAS //
//#include "stdafx.h"//
#include <malloc.h>
#include <stdio.h>
#include <tchar.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>
# define getrandom(min,max)((rand()%(int)(((max)+1)-(min)))+(min))
// 01-FIN DE LIBRERIAS //
// 02-INICIO DE CABECERAS DE FUNCIONES //
void ProblemaMemoria(char * texto);
void LiberaMatriz(int** matriz, int dim);
int* ReservaVector(int dim);
void EscribeMatriz(FILE* pescribir, int dim1, int dim2, int** matriz);
int* fun_reserva_vector(int dim);
void fun_escribe_matriz_dis(FILE* ps, int dim1, int dim2, int** matriz);
int fun_numero_aleatorio(int m, int n);
int fun_esta_en_tour(int size, int verso, int* vs);
void fun_ver_candidatos(FILE* ps, int ciu, int verso, int* vc);
int fun_verdime(FILE* ps, int ciu, int verso, int** matriz, int I,
int* vs);
int fun_nuevo_ver_so(FILE* ps, int ciu, int verso, int** matriz,
int I, int* vs, int* vcr, int dime);
void fun_escribe_solucion(FILE* ps, int ciu, int* vs, int** matriz);
int fun_distancia(FILE* ps, int ciu, int* vs, int** matriz);
void funcion_copia_vector(FILE* ps, int ciu, int* vs, int* vss);
void funcion_intercambio(FILE* ps, int inicio, int fin, int* vs);
void funcion_reorden(FILE* ps, int inicio, int fin, int* vs);
void escribe_vector(FILE* ps, int ciu, int* vs);
// 02-FIN DE CABECERAS DE FUNCIONES //
// 03-INICIO DE MAIN //
void main(int argc, char** argv)
{
// 03.1-DECLARACIÓN DE VARIABLES //
int ciudades,**matriz, ver_az, ver_so, *vso, *vca, *vcar, i, di_me;
int coste, costea, a, b, c, d, j, antiguo, nuevo,*vsoa,*vsoaa;
int k, solucion_grasp,*vsgrasp;
FILE* ps;
FILE* pleer;
time_t tstart1, cstart1, tend1, cend1;
// 03.2-ABRIR ARCHIVO DE ESCRITURA //
ps = fopen("02-GRASP.txt", "w");
if (ps == NULL)
ProblemaMemoria("PROBLEMAS AL RESERVAR MEMORIA");
// 03.3-ABRIR ARCHIVO DE LECTURA //
pleer = fopen("gr17.txt", "r");
if (ps == NULL)
ProblemaMemoria("PROBLEMAS AL RESERVAR MEMORIA");
fscanf(pleer, "%d", &ciudades);
fprintf(ps, "LA DIMENSIÓN ES %d\n\n", ciudades);
// 03.4-RESERVA MATRIZ DINÁMICA //
matriz = (int**)calloc(ciudades, sizeof(int*));
if (matriz == NULL)
printf("\n NO HAY ESPACIO PARA RESERVAR MATRIZ");
// 03.5-LEE MATRIZ //
for (i = 0; i < ciudades; i++)
matriz[i] = ReservaVector(ciudades);
for (i = 0; i < ciudades; i++)
{
fscanf(pleer, "\n\n");
for (j = 0; j < ciudades; j++)
fscanf(pleer, "%d", &matriz[i][j]);
}
fclose(pleer);
EscribeMatriz(ps, ciudades, ciudades, matriz);
fprintf(ps, "\n\n");
// 03.6-LEE MATRIZ //
vso = fun_reserva_vector(ciudades);
vca = fun_reserva_vector(ciudades - 1);
vcar = fun_reserva_vector(ciudades);
vsoa = fun_reserva_vector(ciudades);
vsoaa = fun_reserva_vector(ciudades);
vsgrasp = fun_reserva_vector(ciudades);
// 03.7-ITERACIONES DEL GRASP //
time(&tstart1);
cstart1 = clock();
solucion_grasp = 1000000;
for (k = 1; k < 1000; k++)
{
// FASE CONSTRUCTIVA DEL GRASP //
ver_az = fun_numero_aleatorio(1, ciudades);
ver_so = ver_az;
fun_ver_candidatos(ps, ciudades, ver_so, vca);
for (i = 0; i < ciudades - 1; i++)
{
vso[i] = ver_so;
di_me = fun_verdime(ps, ciudades, ver_so, matriz, i, vso);
ver_so = fun_nuevo_ver_so(ps, ciudades, ver_so, matriz, i,
vso, vcar, di_me);
vso[i + 1] = ver_so;
}
fprintf(ps, "\n\n*** Fase Constructiva %d ***", k);
fun_escribe_solucion(ps, ciudades, vso, matriz);
// FASE DE MEJORA DEL GRASP //
costea = 1000000;
for (i = 0; i < ciudades - 2; i++)
{
a = vso[i];
b = vso[i + 1];
for (j = i + 2; j < ciudades; j++)
{
c = vso[j];
if (j + 1 < ciudades) d = vso[j + 1];
else d = vso[0];
antiguo = matriz[a - 1][b - 1] + matriz[c - 1][d - 1];
nuevo = matriz[a - 1][c - 1] + matriz[b - 1][d - 1];
if (nuevo < antiguo)
{
coste = fun_distancia(ps, ciudades, vso, matriz)
- antiguo + nuevo;
if (coste < costea)
{
costea = coste;
funcion_copia_vector(ps, ciudades, vso, vsoa);
funcion_intercambio(ps, i + 1, j, vsoa);
if (j - (i + 1) <= 2)
funcion_copia_vector(ps, ciudades, vsoa, vsoaa);
else
{
funcion_reorden(ps, i + 2, j, vsoa);
funcion_copia_vector(ps, ciudades, vsoa, vsoaa);
}
}
}
}
}
fprintf(ps, "\n*** Fase de Mejora %d ***", k);
fun_escribe_solucion(ps, ciudades, vsoaa, matriz);
if (fun_distancia(ps, ciudades, vsoaa, matriz) < solucion_grasp)
{
solucion_grasp = fun_distancia(ps, ciudades, vsoaa, matriz);
funcion_copia_vector(ps, ciudades, vsoaa, vsgrasp);
}
}
fprintf(ps, "\n\n\n*** Después de %d Iteraciones GRASP ***", k);
fun_escribe_solucion(ps, ciudades, vsgrasp, matriz);
time(&tend1);
cend1 = clock();
fprintf(ps, "\ntiempo = %4.2fseg/", ((float)cend1 - cstart1) / CLK_TCK);
// 03.8-LIBERA MEMORIA //
LiberaMatriz(matriz, ciudades);
// 03.9-CIERRA LOS ARCHIVOS DE SALIDA DE ESCRITURA//
fclose(ps);
}
// 03-FIN DE MAIN //
// 04-INICIO DE LAS FUNCIONES AUXILIARES //
// 04.1-PROBLEMAS AL RESERVAR MEMORIA //
void ProblemaMemoria(char* texto)
{
printf("\n%s", texto);
exit(0);
}
// 04.2-LIBERA MATRIZ //
void LiberaMatriz(int** matriz, int dim)
{
int i;
for (i = 0; i < dim; i++)
{
free(matriz[i]);
}
free(matriz);
}
// 04.3-RESERVA MEMORIA PARA EL VECTOR //
int* ReservaVector(int dim)
{
int* v;
v = (int*)calloc(dim, sizeof(int));
if (v == NULL)
printf("Problemas en Lectura");
return (v);
}
// 04.4-ESCRIBE MATRIZ //
void EscribeMatriz(FILE* ps, int dim1, int dim2, int** matriz)
{
int i, j;
fprintf(ps, "MATRIZ DE %d FILAS Y %d COLUMNAS: \n\n", dim1, dim2);
for (i = 0; i < dim1; i++)
{
for (j = 0; j < dim2; j++)
{
fprintf(ps, "%6d", matriz[i][j]);
}
fprintf(ps, "\n\n");
}
}
// 04.5-FUNCIÓN RESERVA VECTOR //
int* fun_reserva_vector(int dimension)
{
int* reserva_vector;
reserva_vector = (int*)calloc(dimension, sizeof(int));
if (reserva_vector == NULL)
printf("Problemas en Lectura");
return (reserva_vector);
}
// 04.6-FUNCIÓN ESCRIBE MATRIZ DE DISTANCIAS //
void fun_escribe_matriz_dis(FILE* ps, int dim1, int dim2, int** matriz)
{
int i, j;
fprintf(ps, "Matriz de Distancias Entre %d Ciudades\n\n", dim1);
for (i = 0; i < dim1; i++)
{
for (j = 0; j < dim2; j++)
{
fprintf(ps, "%3d", matriz[i][j]);
}
fprintf(ps, "\n");
}
}
// 04.7-FUNCIONES DE LA FASE CONSTRUCTIVA DEL GRASP //
int fun_numero_aleatorio(int m, int n)
{
int numero_aleatorio;
numero_aleatorio = getrandom(m, n);
return (numero_aleatorio);
}
void fun_ver_candidatos(FILE* ps, int ciu, int verso, int* vc)
{
int i, j;
j = 0;
for (i = 0; i < ciu; i++)
{
vc[i] = i + 1;
if (vc[i] != verso)
{
vc[j] = i + 1;
j++;
}
}
}
int fun_verdime(FILE* ps, int ciu, int verso, int** matriz, int I, int* vs)
{
int a, j, verme, d = 1000000;
for (j = 0; j < ciu; j++)
{
a = fun_esta_en_tour(I + 1, j + 1, vs);
if (a == 0 && matriz[verso - 1][j] < d)
{
d = matriz[verso - 1][j];
verme = j + 1;
}
}
return (d);
}
int fun_nuevo_ver_so(FILE* ps, int ciu, int verso, int** matriz,
int I, int* vs, int* vcr, int dime)
{
int a, j, veres, dimej, con, b;
for (j = 0; j < ciu; j++)
{
vcr[j] = 0;
}
con = 0;
for (j = 0; j < ciu; j++)
{
a = fun_esta_en_tour(I + 1, j + 1, vs);
if (a == 0 && matriz[verso - 1][j] <= dime + dime)
{
vcr[con] = j + 1;
veres = vcr[con];
dimej = matriz[verso - 1][j];
con++;
}
}
b = fun_numero_aleatorio(0, con - 1);
return (vcr[b]);
}
int fun_esta_en_tour(int size, int verso, int* vs)
{
int i;
for (i = 0; i < size; i++)
{
if (vs[i] == verso)
return (1);
}
return (0);
}
void fun_escribe_solucion(FILE* ps, int ciu, int* vs, int** matriz)
{
int i, suma;
fprintf(ps, "\nSolución = ");
for (i = 0; i < ciu; i++)
{
fprintf(ps, "%d ", vs[i]);
}
suma = matriz[vs[ciu - 1] - 1][vs[0] - 1];
for (i = 0; i < ciu - 1; i++)
{
suma = suma + matriz[vs[i] - 1][vs[i + 1] - 1];
}
fprintf(ps, " Distancia = %d ", suma);
}
// 04.8-FUNCIONES DE LA FASE DE MEJORA DEL GRASP //
int fun_distancia(FILE* ps, int ciu, int* vs, int** matriz)
{
int i, suma;
suma = matriz[vs[ciu - 1] - 1][vs[0] - 1];
for (i = 0; i < ciu - 1; i++)
{
suma = suma + matriz[vs[i] - 1][vs[i + 1] - 1];
}
return (suma);
}
void funcion_copia_vector(FILE* ps, int ciu, int* vs, int* vss)
{
int r;
for (r = 0; r < ciu; r++)
{
vss[r] = vs[r];
}
}
void funcion_intercambio(FILE* ps, int inicio, int fin, int* vs)
{
int aux;
aux = vs[inicio];
vs[inicio] = vs[fin];
vs[fin] = aux;
}
void funcion_reorden(FILE* ps, int inicio, int fin, int* vs)
{
int cota, aux, k;
cota = (fin - inicio) / 2;
for (k = 1; k <= cota; k++)
{
aux = vs[inicio - 1 + k];
vs[inicio - 1 + k] = vs[fin - k];
vs[fin - k] = aux;
}
}
void escribe_vector(FILE* ps, int ciu, int* vs)
{
int i;
fprintf(ps, "\n\n");
for (i = 0; i < ciu; i++)
{
fprintf(ps, "%3d", vs[i]);
}
}