UBB/points
1
0
Fork 0
Code Issues Pull Requests Releases 1 Wiki Activity

Merge branch 'informe' of https://git.cromer.cl/UBB/points into informe

Browse Source
This commit is contained in:
Rodolfo Cuevas 2018-12-14 20:45:30 -03:00
commit 5e4b08193a
3 changed files with 86 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
doc/Informe.tex
View File

@ -82,32 +82,23 @@ Xavier Canales
\subsection{Análisis temporal} \subsection{Análisis temporal}
\subsubsection{Brute Force} \subsubsection{Brute Force}
\underline{Caso Promedio:} $ \Theta(n log n)) $ \\ \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. 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
\bigskip
\underline{Peor Caso:} $ O(n log n) $ \\ \underline{Peor Caso:} $ O(n log n) $ \\
el peor caso es similar al caso promedio El peor caso es similar al caso promedio.\bigskip
\bigskip
\underline{Mejor Caso:} $ \Omega(n log n)$ \\ \underline{Mejor Caso:} $ \Omega(n log n)$ \\
el mejor caso es similar al caso promedio El mejor caso es similar al caso promedio.\bigskip
\bigskip
\subsubsection{Divide and Conquer} \subsubsection{Divide and Conquer}
\underline{Caso Promedio:} $ \Theta(n log n)) $ \\ \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. 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
\bigskip
\underline{Peor Caso:} $ O(n log n) $ \\ \underline{Peor Caso:} $ O(n log n) $ \\
el peor caso es similar al caso promedio El peor caso es similar al caso promedio.\bigskip
\bigskip
\underline{Mejor Caso:} $ \Omega(n log n)$ \\ \underline{Mejor Caso:} $ \Omega(n log n)$ \\
el mejor caso es similar al caso promedio El mejor caso es similar al caso promedio.\bigskip
\bigskip
\newpage \newpage
\subsection{Datos} \subsection{Datos}
@ -121,7 +112,7 @@ La siguiente tabla contiene los resultados de las pruebas de los 2 algoritmos me
\hline \hline
\rule[-1ex]{0pt}{3.5ex} 1.000.000 & 15403.951[s] & 3[s] \\ \rule[-1ex]{0pt}{3.5ex} 1.000.000 & 15403.951[s] & 3[s] \\
\hline \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 \hline
\end{tabular} \end{tabular}
\end{center} \end{center}

22
doc/pseudo/brute_force.txt
View File

@ -1,15 +1,15 @@
entrada: array: arreglo de n puntos; n: tamaño del arreglo entrada: array: arreglo de n puntos; n: tamaño del arreglo
salida: los dos puntos mas cercanos con su distancia salida: los dos puntos mas cercanos con su distancia
funcion brute_force(points, n) { funcion brute_force(points, n)
para i = 0 mientras que i < n - 1 hacer para i = 0 mientras que i < n - 1 hacer
para j = i + 1 mientras que j < n hacer para j = i + 1 mientras que j < n hacer
si distance(points[i], points[j]) < distancia_minimo entonces si distance(points[i], points[j]) < distancia_minimo entonces
distancia_minimo = distancia distancia_minimo = distancia
closest_pair[0] = points[i] closest_pair[0] = points[i]
closest_pair[1] = points[j] closest_pair[1] = points[j]
} fin si
} fin para
} fin para
return par_mas_cerca y distancia_minimo return par_mas_cerca y distancia_minimo
fin funcion fin funcion

136
doc/pseudo/divide_and_conquer.txt
View File

@ -2,83 +2,83 @@ entrada: array: arreglo de n puntos; n: tamaño del arreglo
salida: los dos puntos mas cercanos con su distancia salida: los dos puntos mas cercanos con su distancia
funcion divide_and_conquer_run(puntos_x, nx, puntos_y, ny) funcion divide_and_conquer_run(puntos_x, nx, puntos_y, ny)
si nx <= 4 then si nx <= 4 then
par_mas_cerca2 = brute_force(puntos_x, nx, d) par_mas_cerca2 = brute_force(puntos_x, nx, d)
par_mas_cerca[0] = par_mas_cerca2[0] par_mas_cerca[0] = par_mas_cerca2[0]
par_mas_cerca[1] = par_mas_cerca2[1] par_mas_cerca[1] = par_mas_cerca2[1]
return d return d
fin si fin si
medio = puntos_x[nx / 2].x; medio = puntos_x[nx / 2].x;
izquerda = -1 izquerda = -1
derecha = ny derecha = ny
para i = 0 mientras que i < ny hacer para i = 0 mientras que i < ny hacer
si puntos_y[i].x < medio entonces si puntos_y[i].x < medio entonces
puntos_y2[++izquerda] = puntos_y[i] puntos_y2[++izquerda] = puntos_y[i]
sino sino
puntos_y2[--derecha] = puntos_y[i] puntos_y2[--derecha] = puntos_y[i]
fin si fin si
fin para fin para
para i = ny - 1 mientras que derecha < i hacer para i = ny - 1 mientras que derecha < i hacer
par_mas_cerca2[0] = puntos_y2[derecha] par_mas_cerca2[0] = puntos_y2[derecha]
puntos_y2[derecha] = puntos_y2[i] puntos_y2[derecha] = puntos_y2[i]
puntos_y2[i] = par_mas_cerca2[0] puntos_y2[i] = par_mas_cerca2[0]
fin para fin para
min_d = divide_and_conquer_run(puntos_x, nx / 2, puntos_y2, 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) d = divide_and_conquer_run(puntos_x + nx / 2, nx - nx / 2, puntos_y2 + izquerda + 1, ny - izquerda - 1)
si d < min_d entonces si d < min_d entonces
min_d = d min_d = d
par_mas_cerca[0] = par_mas_cerca2[0] par_mas_cerca[0] = par_mas_cerca2[0]
par_mas_cerca[1] = par_mas_cerca2[1] par_mas_cerca[1] = par_mas_cerca2[1]
fin si fin si
d = sqrt(min_d) d = sqrt(min_d)
izquerda = -1 izquerda = -1
derecha = ny derecha = ny
para i = 0 mientras que i < ny hacer para i = 0 mientras que i < ny hacer
x = puntos_y[i].x - medio x = puntos_y[i].x - medio
si x <= -d o x >= d entonces si x <= -d o x >= d entonces
continuar continuar
fin si fin si
si x < 0 entonces si x < 0 entonces
puntos_y2[++izquerda] = puntos_y[i] puntos_y2[++izquerda] = puntos_y[i]
sino sino
puntos_y2[--derecha] = puntos_y[i] puntos_y2[--derecha] = puntos_y[i]
fin si fin si
fin para fin para
mientras que izquerda >= 0 hacer mientras que izquerda >= 0 hacer
x0 = puntos_y2[izquerda].y + d x0 = puntos_y2[izquerda].y + d
mientras que derecha < ny y puntos_y2[derecha].y > x0 hacer mientras que derecha < ny y puntos_y2[derecha].y > x0 hacer
derecha = dercha + 1 derecha = dercha + 1
fin mientras fin mientras
si derecha >= ny entonces si derecha >= ny entonces
romper romper
fin si fin si
x1 = puntos_y2[izquerda].y - d x1 = puntos_y2[izquerda].y - d
para i = derecha mientras que i < ny y puntos_y2[i].y > x1 hacer 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 si distance(puntos_y2[izquerda], puntos_y2[i])) < min_d entonces
min_d = x min_d = x
par_mas_cerca[0] = puntos_y2[izquerda] par_mas_cerca[0] = puntos_y2[izquerda]
par_mas_cerca[1] = puntos_y2[i] par_mas_cerca[1] = puntos_y2[i]
fin si fin si
fin para fin para
izquerda = izquerda - 1 izquerda = izquerda - 1
fin mientras fin mientras
return min_d return min_d
fin funcion fin funcion
funcion divide_and_conquer(puntos, n) { funcion divide_and_conquer(puntos, n)
puntos_x = puntos puntos_x = puntos
puntos_y = puntos puntos_y = puntos
sort(puntos_x, n) sort(puntos_x, n)
sort(puntos_y, n) sort(puntos_y, n)
distancia_minimo y par_mas_cerca = divide_and_conquer_run(puntos_x, n, 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 return par_mas_cerca y distancia_minimo
fin funcion fin funcion