algoritmos geométricos marco teórico
DESCRIPTION
Algoritmo y marco teórico para la creación de un Laberinto mediante la aplicación de algoritmos Geométricos.TRANSCRIPT
-
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.
-
INSTITUTO POLITCNICO NACIONAL Escuela Superior de Ingeniera, Mecnica y Elctrica
Unidad Culhuacn
Ingeniera en Computacin Anlisis de Algoritmos
Nombre del Proyecto Algoritmos Geomtricos
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.
-
INSTITUTO POLITCNICO NACIONAL Escuela Superior de Ingeniera, Mecnica y Elctrica
Unidad Culhuacn
Ingeniera en Computacin Anlisis de Algoritmos
Nombre del Proyecto Algoritmos Geomtricos
Objetivo Aplicar algoritmos geomtricos en la resolucin de un problema que
se presenta en la vida cotidiana
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.
-
INSTITUTO POLITCNICO NACIONAL Escuela Superior de Ingeniera, Mecnica y Elctrica
Unidad Culhuacn
Ingeniera en Computacin Anlisis de Algoritmos
Nombre del Proyecto Algoritmos Geomtricos
Objetivo Aplicar algoritmos geomtricos en la resolucin de un problema que
se presenta en la vida cotidiana
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
- cout
-
INSTITUTO POLITCNICO NACIONAL Escuela Superior de Ingeniera, Mecnica y Elctrica
Unidad Culhuacn
Ingeniera en Computacin Anlisis de Algoritmos
Nombre del Proyecto Algoritmos Geomtricos
Objetivo Aplicar algoritmos geomtricos en la resolucin de un problema que
se presenta en la vida cotidiana
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
-
INSTITUTO POLITCNICO NACIONAL Escuela Superior de Ingeniera, Mecnica y Elctrica
Unidad Culhuacn
Ingeniera en Computacin Anlisis de Algoritmos
Nombre del Proyecto Algoritmos Geomtricos
Objetivo Aplicar algoritmos geomtricos en la resolucin de un problema que
se presenta en la vida cotidiana
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. _______________________________
-
INSTITUTO POLITCNICO NACIONAL Escuela Superior de Ingeniera, Mecnica y Elctrica
Unidad Culhuacn
Ingeniera en Computacin Anlisis de Algoritmos
Nombre del Proyecto Algoritmos Geomtricos
Objetivo Aplicar algoritmos geomtricos en la resolucin de un problema que
se presenta en la vida cotidiana
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