From aeb59bcd0aeae5c24958982855b25e7625ebd7a4 Mon Sep 17 00:00:00 2001 From: Chris Cromer Date: Fri, 14 Dec 2018 20:28:04 -0300 Subject: [PATCH 1/3] fix typos --- doc/Informe.tex | 23 +++++++---------------- 1 file changed, 7 insertions(+), 16 deletions(-) diff --git a/doc/Informe.tex b/doc/Informe.tex index 5d3124a..00946f3 100644 --- a/doc/Informe.tex +++ b/doc/Informe.tex @@ -82,32 +82,23 @@ Xavier Canales \subsection{Análisis temporal} \subsubsection{Brute Force} \underline{Caso Promedio:} $ \Theta(n log n)) $ \\ - Para el algoritmo de fuerza bruta el tiempo de respuesta es igual en todos los casos de n log n, esto se debe a que este donde este los puntos mas cercanos este recorrerá todo de igual forma. Esto es netamente debido a el cómo se programó las funciones con ciclos for anidados que son altamente costosos en tiempo. - \bigskip - +Para el algoritmo de fuerza bruta el tiempo de respuesta es igual en todos los casos de $ n^2 $ , esto se debe a que este donde este los puntos mas cercanos este recorrerá todo de igual forma. Esto es netamente debido a el cómo se programó las funciones con ciclos for anidados que son altamente costosos en tiempo.\bigskip \underline{Peor Caso:} $ O(n log n) $ \\ - el peor caso es similar al caso promedio - \bigskip - +El peor caso es similar al caso promedio.\bigskip \underline{Mejor Caso:} $ \Omega(n log n)$ \\ - el mejor caso es similar al caso promedio - \bigskip - +El mejor caso es similar al caso promedio.\bigskip \subsubsection{Divide and Conquer} \underline{Caso Promedio:} $ \Theta(n log n)) $ \\ -Para el algoritmo de dividir y conquistar se repite lo del analisis anterior que es la misma complejidad en todos los casos, de nuevo producto de que tiene que recorrer todo el mapa de puntos para llegar a saber cuales son los mas cercanos. Aquí es n log n, ya que este algoritmo divide el mapa para y compara las mitades separadamente lo cual es mucho mas eficiente que el caso anterior. -\bigskip +Para el algoritmo de dividir y conquistar se repite lo del análisis anterior que es la misma complejidad en todos los casos, de nuevo producto de que tiene que recorrer todo el mapa de puntos para llegar a saber cuales son los mas cercanos. Aquí es $ n log(n) $, ya que este algoritmo divide el mapa para y compara las mitades separadamente lo cual es mucho mas eficiente que el caso anterior.\bigskip \underline{Peor Caso:} $ O(n log n) $ \\ -el peor caso es similar al caso promedio -\bigskip +El peor caso es similar al caso promedio.\bigskip \underline{Mejor Caso:} $ \Omega(n log n)$ \\ -el mejor caso es similar al caso promedio -\bigskip +El mejor caso es similar al caso promedio.\bigskip \newpage \subsection{Datos} @@ -121,7 +112,7 @@ La siguiente tabla contiene los resultados de las pruebas de los 2 algoritmos me \hline \rule[-1ex]{0pt}{3.5ex} 1.000.000 & 15403.951[s] & 3[s] \\ \hline - \rule[-1ex]{0pt}{3.5ex} 5.000.000 & 372984[s] & 11.210[s] \\ + \rule[-1ex]{0pt}{3.5ex} 5.000.000 & 372984[s] & 11.210[s] \\ \hline \end{tabular} \end{center} From 079d431905f4776c9c522f4765fa2e63c79735a7 Mon Sep 17 00:00:00 2001 From: Chris Cromer Date: Fri, 14 Dec 2018 20:29:29 -0300 Subject: [PATCH 2/3] remove space --- doc/Informe.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/Informe.tex b/doc/Informe.tex index 00946f3..a3c0c67 100644 --- a/doc/Informe.tex +++ b/doc/Informe.tex @@ -82,7 +82,7 @@ Xavier Canales \subsection{Análisis temporal} \subsubsection{Brute Force} \underline{Caso Promedio:} $ \Theta(n log n)) $ \\ -Para el algoritmo de fuerza bruta el tiempo de respuesta es igual en todos los casos de $ n^2 $ , esto se debe a que este donde este los puntos mas cercanos este recorrerá todo de igual forma. Esto es netamente debido a el cómo se programó las funciones con ciclos for anidados que son altamente costosos en tiempo.\bigskip +Para el algoritmo de fuerza bruta el tiempo de respuesta es igual en todos los casos de $ n^2 $, esto se debe a que este donde este los puntos mas cercanos este recorrerá todo de igual forma. Esto es netamente debido a el cómo se programó las funciones con ciclos for anidados que son altamente costosos en tiempo.\bigskip \underline{Peor Caso:} $ O(n log n) $ \\ El peor caso es similar al caso promedio.\bigskip From e114151b8730328f406aa1f28d4acbd23ca53a68 Mon Sep 17 00:00:00 2001 From: Chris Cromer Date: Fri, 14 Dec 2018 20:32:04 -0300 Subject: [PATCH 3/3] fix minor details in psuedo code --- doc/pseudo/brute_force.txt | 22 ++--- doc/pseudo/divide_and_conquer.txt | 136 +++++++++++++++--------------- 2 files changed, 79 insertions(+), 79 deletions(-) diff --git a/doc/pseudo/brute_force.txt b/doc/pseudo/brute_force.txt index e03f6e8..4bd6281 100644 --- a/doc/pseudo/brute_force.txt +++ b/doc/pseudo/brute_force.txt @@ -1,15 +1,15 @@ entrada: array: arreglo de n puntos; n: tamaño del arreglo salida: los dos puntos mas cercanos con su distancia -funcion brute_force(points, n) { - para i = 0 mientras que i < n - 1 hacer - para j = i + 1 mientras que j < n hacer - si distance(points[i], points[j]) < distancia_minimo entonces - distancia_minimo = distancia - closest_pair[0] = points[i] - closest_pair[1] = points[j] - } - } - } - return par_mas_cerca y distancia_minimo +funcion brute_force(points, n) + para i = 0 mientras que i < n - 1 hacer + para j = i + 1 mientras que j < n hacer + si distance(points[i], points[j]) < distancia_minimo entonces + distancia_minimo = distancia + closest_pair[0] = points[i] + closest_pair[1] = points[j] + fin si + fin para + fin para + return par_mas_cerca y distancia_minimo fin funcion diff --git a/doc/pseudo/divide_and_conquer.txt b/doc/pseudo/divide_and_conquer.txt index 39f8a4d..a3faf76 100644 --- a/doc/pseudo/divide_and_conquer.txt +++ b/doc/pseudo/divide_and_conquer.txt @@ -2,83 +2,83 @@ entrada: array: arreglo de n puntos; n: tamaño del arreglo salida: los dos puntos mas cercanos con su distancia funcion divide_and_conquer_run(puntos_x, nx, puntos_y, ny) - si nx <= 4 then - par_mas_cerca2 = brute_force(puntos_x, nx, d) - par_mas_cerca[0] = par_mas_cerca2[0] - par_mas_cerca[1] = par_mas_cerca2[1] - return d - fin si + si nx <= 4 then + par_mas_cerca2 = brute_force(puntos_x, nx, d) + par_mas_cerca[0] = par_mas_cerca2[0] + par_mas_cerca[1] = par_mas_cerca2[1] + return d + fin si - medio = puntos_x[nx / 2].x; + medio = puntos_x[nx / 2].x; - izquerda = -1 - derecha = ny - para i = 0 mientras que i < ny hacer - si puntos_y[i].x < medio entonces - puntos_y2[++izquerda] = puntos_y[i] - sino - puntos_y2[--derecha] = puntos_y[i] - fin si - fin para + izquerda = -1 + derecha = ny + para i = 0 mientras que i < ny hacer + si puntos_y[i].x < medio entonces + puntos_y2[++izquerda] = puntos_y[i] + sino + puntos_y2[--derecha] = puntos_y[i] + fin si + fin para - para i = ny - 1 mientras que derecha < i hacer - par_mas_cerca2[0] = puntos_y2[derecha] - puntos_y2[derecha] = puntos_y2[i] - puntos_y2[i] = par_mas_cerca2[0] - fin para + para i = ny - 1 mientras que derecha < i hacer + par_mas_cerca2[0] = puntos_y2[derecha] + puntos_y2[derecha] = puntos_y2[i] + puntos_y2[i] = par_mas_cerca2[0] + fin para - min_d = divide_and_conquer_run(puntos_x, nx / 2, puntos_y2, izquerda + 1) - d = divide_and_conquer_run(puntos_x + nx / 2, nx - nx / 2, puntos_y2 + izquerda + 1, ny - izquerda - 1) + min_d = divide_and_conquer_run(puntos_x, nx / 2, puntos_y2, izquerda + 1) + d = divide_and_conquer_run(puntos_x + nx / 2, nx - nx / 2, puntos_y2 + izquerda + 1, ny - izquerda - 1) - si d < min_d entonces - min_d = d - par_mas_cerca[0] = par_mas_cerca2[0] - par_mas_cerca[1] = par_mas_cerca2[1] - fin si - d = sqrt(min_d) + si d < min_d entonces + min_d = d + par_mas_cerca[0] = par_mas_cerca2[0] + par_mas_cerca[1] = par_mas_cerca2[1] + fin si + d = sqrt(min_d) - izquerda = -1 - derecha = ny - para i = 0 mientras que i < ny hacer - x = puntos_y[i].x - medio - si x <= -d o x >= d entonces - continuar - fin si - si x < 0 entonces - puntos_y2[++izquerda] = puntos_y[i] - sino - puntos_y2[--derecha] = puntos_y[i] - fin si - fin para + izquerda = -1 + derecha = ny + para i = 0 mientras que i < ny hacer + x = puntos_y[i].x - medio + si x <= -d o x >= d entonces + continuar + fin si + si x < 0 entonces + puntos_y2[++izquerda] = puntos_y[i] + sino + puntos_y2[--derecha] = puntos_y[i] + fin si + fin para - mientras que izquerda >= 0 hacer - x0 = puntos_y2[izquerda].y + d + mientras que izquerda >= 0 hacer + x0 = puntos_y2[izquerda].y + d - mientras que derecha < ny y puntos_y2[derecha].y > x0 hacer - derecha = dercha + 1 - fin mientras - si derecha >= ny entonces - romper - fin si + mientras que derecha < ny y puntos_y2[derecha].y > x0 hacer + derecha = dercha + 1 + fin mientras + si derecha >= ny entonces + romper + fin si - x1 = puntos_y2[izquerda].y - d - para i = derecha mientras que i < ny y puntos_y2[i].y > x1 hacer - si distance(puntos_y2[izquerda], puntos_y2[i])) < min_d entonces - min_d = x - par_mas_cerca[0] = puntos_y2[izquerda] - par_mas_cerca[1] = puntos_y2[i] - fin si - fin para - izquerda = izquerda - 1 - fin mientras - return min_d + x1 = puntos_y2[izquerda].y - d + para i = derecha mientras que i < ny y puntos_y2[i].y > x1 hacer + si distance(puntos_y2[izquerda], puntos_y2[i])) < min_d entonces + min_d = x + par_mas_cerca[0] = puntos_y2[izquerda] + par_mas_cerca[1] = puntos_y2[i] + fin si + fin para + izquerda = izquerda - 1 + fin mientras + return min_d fin funcion -funcion divide_and_conquer(puntos, n) { - puntos_x = puntos - puntos_y = puntos - sort(puntos_x, n) - sort(puntos_y, n) - distancia_minimo y par_mas_cerca = divide_and_conquer_run(puntos_x, n, puntos_y, n) - return par_mas_cerca y distancia_minimo +funcion divide_and_conquer(puntos, n) + puntos_x = puntos + puntos_y = puntos + sort(puntos_x, n) + sort(puntos_y, n) + distancia_minimo y par_mas_cerca = divide_and_conquer_run(puntos_x, n, puntos_y, n) + return par_mas_cerca y distancia_minimo fin funcion