Algoritmos Geométricos Marco Teórico

INSTITUTO POLITCNICO NACIONAL Escuela Superior de Ingeniera, Mecnica y Elctrica

Unidad Culhuacn

Ingeniera en Computacin Anlisis de Algoritmos

Nombre del Proyecto Algoritmos Geomtricos

Asignatura Anlisis de Algoritmos

Fecha 16/Diciembre/2015

Nombre de los participantes Iniciales Firma

Zaira Garca Nonoal ZGN

Arturo Rojas Arizmendi ARA

Objetivo General

Aplicar algoritmos geomtricos en la resolucin de un problema que se presenta en la vida cotidiana.

Objetivos Particulares

Aplicar bsqueda geomtrica, inclusin de polgonos y problemas de intersecciones.

Encontrar una solucin sencilla para la aplicacin prctica propuesta.

Descripcin General

El presente trabajo consiste en describir los algoritmos geomtricos enfocndose en la bsqueda geomtrica, inclusin de polgonos y problemas de intersecciones con el fin de definir un problema en el cual se puedan aplicar dichos algoritmos para su resolucin. Para ello se aborda el tema de la Geometra computacional as como algunas de las aplicaciones que encontramos en la vida cotidiana con el fin de ilustrar el campo en el que los algoritmos geomtricos actan. Para la aplicacin prctica del tema se decidi elaborar un algoritmo que buscara el camino en un laberinto lleno de obstculos, el cual se detallara ms adelante.


Unidad Culhuacn



Objetivo Aplicar algoritmos geomtricos en la resolucin de un problema que

se presenta en la vida cotidiana

Marco Terico

GEOMETRA COMPUTACIONAL

Para hablar de algoritmos geomtricos primero se debe comprender el concepto de la Geometra

Computacional (GC). La GC es una rama de las ciencias de la computacin que estudia algoritmos

para resolver problemas geomtricos. Tambin se encarga del estudio sistemtico de algoritmos y

las estructuras de datos necesarios para la solucin eficiente de problemas que implican como

entrada y salida objetos geomtricos.

ALGORITMOS GEOMETRICOS

Los algoritmos geomtricos son importantes en sistemas de diseo y anlisis de modelos de objetos

fsicos, que pueden ser desde edificios y automviles hasta circuitos integrados. Los algoritmos

geomtricos operan sobre los elementos que se muestran a continuacin.

Algoritmos Geomtricos

Puntos

SegmentosPolgonos

Puntos: Objeto fundamental considerado como el par de enteros, es decir, como las

coordenadas en el plano cartesiano.

Lneas: Par de puntos que se suponen unidos por un segmento de lnea recta.

Se representan los objetos geomtricos ms complicados en funcin de estos componentes bsicos.

Los algoritmos geomtricos se basan en clculos simples como son los siguientes:

La Geometra Computacional tiene varias aplicaciones comnmente aplicadas en la robtica, diseo

de circuitos integrados, grficas computacionales, sistemas de informacin geogrfica entre otros.

Para localizar los puntos ms cercanos dado un conjunto de puntos Q se puede utilizar la tcnica e

divide y vencers que tiene una complejidad O(n log n).

PROBLEMA DEL CERCO CONVEXO

Consiste en encontrar el rea ms pequea de un polgono convexo que encierre un conjunto de

puntos en el plano. Algoritmos basados en barrido rotacional, procesan vrtices (puntos) en el

orden de coordenadas polares los ngulos que forman con referencia a un vrtice.

Sumas

Restas

Comparaciones

Multiplicaciones

Como ejemplos tenemos:

Algoritmo Graham O(n log n)

Algoritmo de Jarvis O(n h) donde h nmero de vrtices en el menor polgono

BUSQUEDA GEOMTRICA

Muchos de los algoritmos que se estudian utilizan una bsqueda geomtrica, es decir, se desea

conocer que puntos de un determinado conjunto estn cerca de un punto dado, o que puntos estn

dentro de un rectngulo dado, o cuales son los puntos que estn situados ms cerca entre s.

TIEMPO DE EJECUCIN DE LOS ALGORITMOS GEOMETRICOS

El tiempo de ejecucin de un algoritmo geomtrico puede depender de muchos factores. La

distribucin de los propios puntos, el orden en que se introducen y la utilizacin de funciones

trigonomtricas pueden afectar de forma significativa el tiempo de ejecucin de los algoritmos

geomtricos. Adems muchos de los algoritmos se derivan de estudios complejos y han diseados

para tener buenos rendimientos en el peor caso.

METODO DE LA REJILLA

Es una tcnica eficaz para mantener relaciones de proximidad entre los puntos del plano, se

construye una rejilla imaginaria que divida la zona de bsqueda en pequeas celdas y en mantener

listas de pequeo tamao de los puntos que estn dentro de cada celda. Esta es una tcnica que se

utiliza mucho en la arqueologa.


Unidad Culhuacn





Aplicacin prctica

Laberinto

PROBLEMA:

En el mapa de un edificio se observa una especie de laberinto. Ningn humano puede entrar porque

el edificio tiene el riesgo de ser derribado. Sin embargo, en ese lugar hay an documentos

importantes, por lo que un robot debe ser enviado para extraer dichos documentos.

Encuentra una ruta para el robot para que ste pueda llegar hasta donde debe extraer lo que se le

ha pedido.


Unidad Culhuacn





Metodologa del Diseo y Anlisis de Algoritmos Computacionales

(MDAAC)

Anlisis del algoritmo

Etapa 1. Definicin del problema

Dada una serie de caminos y obstculos, encontrar mediante algoritmos geomtricos una ruta para

que un robot pueda llegar a su destino sin que ste se cruce con algn obstculo.

Precondicin:

Una serie de caminos, rutas, vrtices y obstculos por donde debe pasar el robot. Se deben

representar de manera lgica los espacios libres y los obstculos se utilizaran 1s para definir los

obstculos y 0 para definir los espacios libres.

Postcondicin:

Una meta hacia donde llegar y reconocer la ruta para el regreso. Se indicara la secuencia de pasos

que el robot debe seguir para llegar a la meta deseada.

Etapa 2. Construir el algoritmo e identificar su complejidad temporal.

Cdigo

#include #include #include #include #include #define tam 1000 class laberinto { bool izquierda, derecha, arriba, abajo; int peso, no_casilla, vector_camino[tam], contav, desplazamiento; laberinto *principio, *final, *meta, *casilla, *arcoar, *arcoab, *arcoiz, *arcoder, *final2; laberinto *juntoar, *juntoab, *juntoiz, *juntoder, *iufila, *iucolumna; laberinto *finalc;

int filas, columnas, conta; public: laberinto() { principio=NULL; O(1) final=NULL; O(1) finalc=NULL; O(1) conta=0; O(1) filas=0; O(1) no_casilla=0; O(1) columnas=0; O(1) juntoar=NULL; O(1) juntoab=NULL; O(1) juntoiz=NULL; O(1) juntoder=NULL; O(1) } void menu(); void inicializar_laberinto(void); void crear_laberinto(void); void agregar_fila(void); void agregar_columna(void); void muestra_laberinto(); bool encontrar_ruta(laberinto *auxsig, laberinto *auxant); void encontrar_ruta_aux(); void establecer_meta(); void mostrar_matriz(); void destruir_laberinto(); }; void laberinto::destruir_laberinto() { laberinto *auxdelete, *auxsigf, *auxsigc; auxsigc=principio; O(1) auxsigf=principio->juntoab; O(1) system("cls"); cout

{ auxsigf=auxsigf->juntoab; O(1) } } while(auxsigf!=NULL); O(do) + O(while) = O(1) + O(1) + O(1) + O(1)+ O(1) = O(1) conta=0; O(1) filas=0; O(1) columnas=0; O(1) }

T(f(n))= Omax(1,1,1,1,1,1,1) = O(1) void laberinto::mostrar_matriz() { system("cls"); laberinto *auxsigf, *auxsigc; auxsigf=principio; O(1) auxsigc=principio; O(1) cout

do { if(auxsigc->no_casilla==auxmeta) O(if) + O(then) = O(1) + O(1) = O(1) { meta=auxsigc; O(1) band=true; O(1) break; } auxsigc=auxsigc->juntoder; O(1) } while(auxsigc != NULL); O(do) + O(while) = O(1) + O(1) + O(1) = O(1) auxsigf=auxsigf->juntoab; O(1) auxsigc=auxsigf; O(1) if(band!=false) O(if) + O(then) = O(1) + O(1) = O(1) { auxsigf=NULL; O(1) break; } } while(auxsigf!=NULL); O(do) + O(while) = O(1)+ O(1)+ O(1)+ O(1)+ O(1)+ O(1) = O(1) } T(f(n))= Omax(1,1,1,1,1)= O(1) void laberinto::encontrar_ruta_aux(void) { bool bandera=false; O(1) contav=0; O(1) desplazamiento=0; O(1) int i; laberinto *auxiliar1, *auxiliar2; auxiliar1 = principio; O(1) if(auxiliar1->abajo == 0 && auxiliar1->arcoab != NULL) O(if) + O(then)= O(1) + O(1) = O(1) { auxiliar2=auxiliar1->arcoab; O(1) bandera=encontrar_ruta(auxiliar2, auxiliar1); O(1) } if(bandera==false) O(if) + O(then)= O(1) + O(1) = O(1) { if(auxiliar1->derecha == 0 && auxiliar1->arcoder != NULL) O(if) + O(then)= O(2) + O(1) = O(1) { auxiliar2=auxiliar1->arcoder; O(1) bandera=encontrar_ruta(auxiliar2,auxiliar1); O(1) } } if(bandera==true) O(if) + O(then) + O(else) = O(1)+O(n)+O(1) = O(n) { mostrar_matriz(); vector_camino[contav]=auxiliar1->no_casilla; O(1)

contav++; O(1) desplazamiento+=auxiliar1->peso; O(1) cout

if(camencontrado==false) O(if) + O(then) + O(else)= O(1) + O(1) + O(1) = O(1) { if(auxsig->derecha == 0 && auxsig->arcoder != auxant && auxsig->arcoder!=NULL) O(if) + O(then) = O(3) + O(1) = O(1) { auxant=auxsig; O(1) auxsig=auxsig->arcoder; O(1) camencontrado=encontrar_ruta(auxsig, auxant); O(1) } if(camencontrado==true) O(if) + O(then) = O(1) + O(1)= O(1) { vector_camino[contav]=auxant->no_casilla; O(1) contav++; O(1) desplazamiento+=auxant->peso; O(1) return true; O(1) } } else { vector_camino[contav]=auxant->no_casilla; O(1) contav++; O(1) desplazamiento+=auxant->peso; O(1) return true; O(1) } } else { vector_camino[contav]=auxant->no_casilla; O(1) contav++; O(1) desplazamiento+=auxant->peso; O(1) return true; O(1) } } else { vector_camino[contav]=auxant->no_casilla; O(1) contav++; O(1) desplazamiento+=auxant->peso; O(1) return true; O(1) } } else { vector_camino[contav]=auxant->no_casilla; O(1) contav++; O(1) desplazamiento+=auxant->peso; O(1) return true; O(1)

} } else { camencontrado=true; O(1) vector_camino[contav]=auxsig->no_casilla; O(1) contav++; O(1) desplazamiento+=auxsig->peso; O(1) return camencontrado; O(1) } if(camencontrado==false) { return camencontrado; O(1) } } T(f(n)) = Omax(1,1,1,1) = O(1) void laberinto::muestra_laberinto(void) { system("cls"); laberinto *auxsigf, *auxsigc; auxsigf=principio; O(1) auxsigc=principio; O(1) cout

principio -> arriba= NULL; O(1) principio -> arriba= NULL; O(1) coutprincipio->arriba; cout>principio->abajo; cout>principio->izquierda; cout>principio->derecha; cout>principio->peso; coutarcoab=NULL; O(1) principio->arcoiz=NULL; O(1) principio->arcoder=NULL; O(1) principio->juntoar=NULL; O(1) principio->juntoab=NULL; O(1) principio->juntoiz=NULL; O(1) principio->juntoder=NULL; O(1) iufila=principio; O(1) iucolumna=principio; O(1) final=principio; O(1) finalc=principio; O(1) final2=principio; O(1) filas++; O(1) columnas++; O(1) conta++; O(1) principio->no_casilla=conta; O(1) } T(f(n)) = O(1) void laberinto::agregar_fila(void) { int i, j=0; O(1) laberinto *auxsig, *aux, *aux2; auxsig=iufila; O(1) filas++; O(1)

for(i=0; iarriba; cout>casilla->abajo; cout>casilla->izquierda; cout>casilla->derecha; cout>casilla->peso; //Seccin para conectar las casillas casilla->juntoar=auxsig; O(1) auxsig->juntoab=casilla; O(1) casilla->juntoab=NULL; O(1) casilla->juntoder=NULL; O(1) if(auxsig==iufila) O(if)+O(then)+O(else)=O(1)+O(1)+O(1)=O(1) { casilla->juntoiz=NULL; O(1) } else { casilla->juntoiz=final; O(1) final->juntoder=casilla; //nueva modificacin realizada al cdigo para conectar las casillas O(1) } //cuando estas sean diferentes del inicio de la ltima fila agregada //Asignar arcos o pasos por casillas if(casilla->arriba == 0) O(if)+O(then)+O(else)=O(1)+O(1) { casilla->arcoar=auxsig; O(1) auxsig->arcoab=casilla; O(1) if(jjuntoder; //juntoder O(1) auxsig=aux2; O(1) } } else

{ casilla->arcoar=NULL; O(1) if(jjuntoder; O(1) auxsig=aux2; O(1) } } if(casilla!=aux) O(if)+O(then)+O(else)= O(1)+ O(1)+ O(1)= O(1) { if(casilla->izquierda == 0) O(if)+O(then)+O(else)=O(1)+ O(1)+ O(1)= O(1) { casilla->arcoiz=final; O(1) final->arcoder=casilla; O(1) } else { casilla->arcoiz=NULL; //arcoar O(1) } } else { casilla->arcoiz=NULL; O(1) } casilla->no_casilla=conta; O(1) final=casilla; O(1) j++; O(1) } final2=casilla; O(1) cout

casilla = new(laberinto); //contruye nueva casilla O(1) coutcasilla->arriba; cout>casilla->abajo; cout>casilla->izquierda; cout>casilla->derecha; cout>casilla->peso; //Seccin para conectar las casillas casilla->juntoiz=auxsig; // auxsig->juntoder=casilla; O(1) casilla->juntoab=NULL; O(1) casilla->juntoder=NULL; O(1) if(auxsig==iucolumna) O(if)+O(then)+O(else)=O(1)+O(1) { casilla->juntoar=NULL; O(1) } else { casilla->juntoar=finalc; O(1) finalc->juntoab=casilla; O(1) } //Asignar arcos o pasos por casillas //Seccin para modificar maana if(casilla!=aux) //iucolumna O(if)+O(then)+O(else)=O(1)+ O(1)+ O(1)= O(1) { if(casilla->arriba == 0) O(if)+O(then)+O(else)= O(1)+ O(1)+ O(1) { casilla->arcoar=finalc; O(1) finalc->arcoab=casilla; //Seccin de cdigo modificada para la conexin de casillas O(1) } //Cuando stas sean diferentes del inicio de la ltima columna agregada else { casilla->arcoar=NULL; O(1) } } else {

casilla->arcoar=NULL; O(1) } //Seccin para modificar if(casilla->izquierda == 0) O(if)+O(then)+O(else)= O(1)+ O(1)+ O(1)= O(1) { casilla->arcoiz=auxsig; O(1) auxsig->arcoder=casilla; O(1) if(jjuntoab; O(1) auxsig=aux3; O(1) } } else { casilla->arcoiz=NULL; O(1) if(jjuntoab; O(1) auxsig=aux3; O(1) } } casilla->no_casilla=conta; O(1) finalc=casilla; O(1) j++; O(1) } final2=casilla; O(1) cout

while(opc23); switch(opc2) { case 1: agregar_fila(); mostrar_matriz(); break; case 2: agregar_columna(); mostrar_matriz(); break; case 3: break; default: cout


Unidad Culhuacn





Laberinto muestra

Laberinto muestra

Inicio

Meta

Las celdas marcadas de color verde indican el camino a seguir para encontrar la meta, cabe destacar

que lgicamente las paredes sern representadas por 1s y los espacios libres por 0s


Unidad Culhuacn





Actividad propuesta para la presentacin

Cuestionario base con respuestas

Responde brevemente las siguientes preguntas de acuerdo a lo que se mencion en la presentacin.

1. Da una de las definiciones que se mencionaron de qu es la Geometra Computacional.

a. Rama de las ciencias de la computacin que estudia algoritmos para resolver

problemas geomtricos.

b. Estudio sistemtico de algoritmos y las estructuras de datos necesarios para la

solucin eficiente de problemas que implican como entrada y salida objetos

geomtricos.

2. Los algoritmos geomtricos operan sobre cuerpos geomtricos como:

a. Puntos

b. Segmentos

c. Polgonos

3. Menciona la complejidad de los siguientes algoritmos:

a. Graham: O(n log n)

b. Jarvis: O(n h)

4. La siguiente afirmacin pertenece a una de las condiciones de:

El extremo de un segmento cae sobre el otro segmento

-Interseccin de segmentos

5. Mencione tres aplicaciones de los algoritmos geomtricos.

a) Robtica

b) Diseo de circuitos integrados

c) Grficas computacionales

d) Sistemas de informacin geogrficos

Cuestionario para aplicar

Responde brevemente las siguientes preguntas de acuerdo a lo que se mencion en la presentacin.

1. Da una de las definiciones que se mencionaron de qu es la Geometra Computacional.

__________________________________________________________________________

__________________________________________________________________________

__________________________________________________________________________

__________________________________________________________________________

2. Los algoritmos geomtricos operan sobre cuerpos geomtricos como:

a. ________________________________

b. ________________________________

c. ________________________________

3. Menciona la complejidad de los siguientes algoritmos:

a. Graham: _________________________

b. Jarvis: ___________________________

4. La siguiente afirmacin pertenece a una de las condiciones de:

El extremo de un segmento cae sobre el otro segmento

__________________________________________________________________________

5. Mencione tres aplicaciones de los algoritmos geomtricos.

a. _______________________________

b. _______________________________

c. _______________________________


Unidad Culhuacn





Bibliografa

Bibliografa

Algoritmos en C++ Sedgewick, Robert 1995 Addison-Wesley Iberoamericana

http://www.tamps.cinvestav.mx/~ertello/gc/sesion01.pdf

http://www.exa.unicen.edu.ar/catedras/aydalgo2/docs/Teorica-5.pdf

http://www.cimat.mx/~alram/analisis_algo/01_AplicacionesGeometria.pdf

Documents

Algoritmos Geométricos Marco Teórico