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
Asignatura
Fecha
Algoritmos Geomtricos
16/Diciembre/2015
Nombre de los participantes

Zaira Garca Nonoal
Arturo Rojas Arizmendi
Iniciales
ZGN
ARA
Firma
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
Nombre del Proyecto

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.
Puntos
Algoritmos
Geomtricos
Polgonos
Segmentos
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:
Sumas
Multiplicaciones
Restas
Comparaciones
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.
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
Nombre del Proyecto
Objetivo
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
Nombre del Proyecto
Objetivo
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 <stdio.h>
#include <iostream.h>
#include <stdlib.h>
#include <conio.h>
#include <dos.h>
#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;
final=NULL;
finalc=NULL;
conta=0;
filas=0;
no_casilla=0;
columnas=0;
juntoar=NULL;
juntoab=NULL;
juntoiz=NULL;
juntoder=NULL;
}
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();
O(1)
O(1)
O(1)
O(1)
O(1)
O(1)
O(1)
O(1)
O(1)
O(1)
O(1)
};
void laberinto::destruir_laberinto()
{
laberinto *auxdelete, *auxsigf, *auxsigc;
auxsigc=principio;
O(1)
auxsigf=principio->juntoab;
O(1)
system("cls");
cout<<"\n\n\t\tDestruyendo el laberinto...";
O(1)
do
{
do
{
auxdelete=auxsigc;
O(1)
auxsigc=auxsigc->juntoder;
O(1)
delete auxdelete;
O(1)
}
while(auxsigc != NULL);
O(do)+O(while) = O(1) + O(1) = O(1)
cout<<"\n";
O(1)
auxsigc=auxsigf;
O(1)
if(auxsigf!=NULL)
O(if)+O(then) = O(1) + O(1) = O(1)
{
auxsigf=auxsigf->juntoab;
}
}
while(auxsigf!=NULL);
conta=0;
filas=0;
columnas=0;
O(1)
O(do) + O(while) = O(1) + O(1) + O(1) + O(1)+ O(1) = O(1)

O(1)
O(1)
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<<"\n\n\n\t\t\t\t\t\tMostrando Matriz de casillas:\n\n\n";
O(1)
do
{
do
{
cout<<auxsigc->no_casilla<<"["<<auxsigc->peso<<"]\t"; O(1)
O(1)
}
O(do) + O(while) = O(1) + O(1) = O(1)
cout<<"\n";
O(1)
O(1)
auxsigc=auxsigf;
O(1)
}
O(do) + O(while) = O(1) + O(1) = O(1)
cout<<"\n\n";
O(1)
}
T(f(n))= Omax(1,1,1,1,1) = O(1)
void laberinto::establecer_meta(void)
{
int auxmeta;
bool band=false;
O(1)
auxsigf=principio;
O(1)
auxsigc=principio;
O(1)
cout<<"\n\nFavor de ingresar el numero de casilla donde va a establecer la meta:\n\n>> ";
cin>>auxmeta;
do
{
O(1)
do
{
if(auxsigc->no_casilla==auxmeta)
{
meta=auxsigc;
band=true;
break;
}
}
auxsigc=auxsigf;
if(band!=false)
{
auxsigf=NULL;
break;
}
}
O(if) + O(then) = O(1) + O(1) = O(1)

O(1)
O(1)
O(1)
O(do) + O(while) = O(1) + O(1) + O(1) = O(1)
O(1)
O(1)
O(if) + O(then) = O(1) + O(1) = O(1)
O(1)
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<<"\n\nCamino encontrado!\n\n\t\t\tCamino (paso por casillas):\n\n\n";
O(1)
for(i=(contav-1); i>=0; i--)
O(contav+2) = O(contav) = O(n)
{
cout<<vector_camino[i]<<" ";
O(1)
}
cout<<"\n\nDesplazamiento total:\n"<<desplazamiento<<"\n\n\n";
O(1)
}
else
{
cout<<"\n\nCamino no encontrado\n\n";
O(1)
}
}
T(f(n))=Omax(1,1,1,1,1,1,n) = O(n)
bool laberinto::encontrar_ruta(laberinto *auxsig, laberinto *auxant)
{
bool camencontrado=false;
O(1)
if(auxsig != meta)
O(if) + O(then)+ O(else) = O(1) + O(1) + O(1)= O(1)
{
if(camencontrado==false)
O(if) + O(then)+ O(else) = O(1) + O(1)+ O(1)= O(1)
{
if(auxsig->arriba == 0 && auxsig->arcoar != auxant && auxsig->arcoar!=NULL)
O(if)+O(then) = O(3) + O(1) = O(1)
{
auxant=auxsig;
O(1)
auxsig=auxsig->arcoar;
O(1)
camencontrado=encontrar_ruta(auxsig, auxant); O(1)
}
O(if) + O(then) = O(1)
{
if(auxsig->abajo == 0 && auxsig->arcoab != auxant && auxsig->arcoab!=NULL)
O(if) + O(then) = O(3) + O(1) = O(1)
{
auxant=auxsig;
O(1)
auxsig=auxsig->arcoab;
O(1)
camencontrado=encontrar_ruta(auxsig, auxant); //Pendiente 2 O(1)
}
O(if) + O(then) + O(else)= O(1) + O(1) + O(1)= O(1)
{
if(auxsig->izquierda == 0 && auxsig->arcoiz != auxant && auxsig->arcoiz!=NULL)
O(if) + O(then) = O(3) + O(1) = O(1)
{
auxant=auxsig;
O(1)
auxsig=auxsig->arcoiz;
O(1)
camencontrado=encontrar_ruta(auxsig, auxant); //Pendiente 3 O(1)
}
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
{
O(1)
contav++;
O(1)
O(1)
return true;
O(1)
}
}
else
{
O(1)
contav++;
O(1)
O(1)
return true;
O(1)
}
}
else
{
contav++;
return true;
}
}
else
{
contav++;
return true;
O(1)
O(1)
O(1)
O(1)
O(1)
O(1)
O(1)
O(1)
}
}
else
{
camencontrado=true;
vector_camino[contav]=auxsig->no_casilla;
contav++;
desplazamiento+=auxsig->peso;
return camencontrado;
}
{
return camencontrado;
}
O(1)
O(1)
O(1)
O(1)
O(1)
O(1)
}
T(f(n)) = Omax(1,1,1,1) = O(1)
void laberinto::muestra_laberinto(void)
{
system("cls");
auxsigf=principio;
O(1)
auxsigc=principio;
O(1)
cout<<"\n\n\n\t\t\t\t\t\tMostrando laberinto:\n\n\n";
O(1)
do
{
do
{
//modificar
O(1)
}
O(do) + O(while) = O(1) +O(1)=O(1)
cout<<"\n";
O(1)
auxsigc=auxsigf;
O(1)
}
O(do) + O(while)= O(1)+ O(1)+ O(1)= O(1)
cout<<"\n\n";
}
T(f(n))=Omax(1,1,1,1)=O(1)
void laberinto::inicializar_laberinto(void)
{
principio= new (laberinto);
principio -> arriba= NULL;
O(1)
O(1)
O(1)

O(1)
O(1)
cout<<"\n\nAgregando primer casilla, ingresa los datos que se piden:\n\n\n";

cout<<"Hay paso por arriba?\n0 Si\n1 NO\n>> ";
cin>>principio->arriba;
cout<<"Hay paso por abajo?\n0 Si\n1 NO\n>> ";
cin>>principio->abajo;
cout<<"Hay paso por la izquierda?\n0 Si\n1 NO\n>> ";
cin>>principio->izquierda;
cout<<"Hay paso por la derecha?\n0 Si\n1 NO\n>> ";
cin>>principio->derecha;
cout<<"\nIngresa el peso (longitud) de la primer casilla (pasillo)\n>> ";
cin>>principio->peso;
cout<<"\nEl laberinto se ha inicializado correctamente.\n\n";

principio->arcoar=NULL;
principio->arcoab=NULL;
principio->arcoiz=NULL;
principio->arcoder=NULL;
O(1)
O(1)
O(1)
O(1)
principio->juntoar=NULL;
principio->juntoab=NULL;
principio->juntoiz=NULL;
principio->juntoder=NULL;
O(1)
O(1)
O(1)
O(1)
iufila=principio;
iucolumna=principio;
final=principio;
finalc=principio;
final2=principio;
O(1)
O(1)
O(1)
O(1)
O(1)
filas++;
columnas++;
conta++;
principio->no_casilla=conta;
O(1)
O(1)
O(1)
O(1)
}
T(f(n)) = O(1)
void laberinto::agregar_fila(void)
{
int i, j=0;
laberinto *auxsig, *aux, *aux2;
auxsig=iufila;
filas++;
O(1)
O(1)
O(1)
for(i=0; i<columnas; i++)

O(columnas+2)+ O(1)=O(columnas) = O(n)
{
cout<<"\nAgregando nueva casilla. Ingresa los datos:\n\n";
O(1)
casilla = new(laberinto);
O(1)
conta++;
O(1)
if(i==0) //Para marcar el inicio de la ltima fila agregada
O(if) + O(then) = O(1)+O(1)= O(1)
{
aux=casilla;
O(1)
}
cin>>casilla->arriba;
cin>>casilla->abajo;
cin>>casilla->izquierda;
cin>>casilla->derecha;
cout<<"\nIngresa el peso (longitud) de la casilla (pasillo)\n>> ";
cin>>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(j<(columnas-1))
O(if)+O(then)=O(1)+O(1)
{
aux2=auxsig->juntoder;
//juntoder
O(1)
auxsig=aux2;
O(1)
}
}
else
{
casilla->arcoar=NULL;
if(j<(columnas-1))
{
aux2=auxsig->juntoder;
auxsig=aux2;
}
O(1)
O(if)+O(then)=O(1)+O(1)=O(1)
O(1)
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;
final=casilla;
j++;
O(1)
O(1)
O(1)
}
final2=casilla;
cout<<"\nEl laberinto se ha modificado correctamente.\n\n";
iufila=aux;
O(1)
O(1)
O(1)
}
T(f(n))=Omax(1,1,1n,1,1,1)=O(n)
//Seccin de cdigo para agregar una nueva columna al laberinto
void laberinto::agregar_columna(void)
{
int i, j=0;
laberinto *auxsig, *aux, *aux3;
auxsig=iucolumna;
columnas++;
for(i=0; i<filas; i++)
{
conta++;
O(1)
O(1)
O(1)
O(filas+2)+ O(1)=O(filas)=O(n)
O(1)
casilla = new(laberinto);
//contruye nueva casilla
O(1)
cout<<"\nAgregando nueva casilla. Ingresa los datos:\n\n";
O(1)
if(i==0) //Para marcar el inicio de la ltima columna agregada O(if)+O(then)=O(1)+O(1)=O(1)
{
aux=casilla;
O(1)
}
cin>>casilla->arriba;
cin>>casilla->abajo;
cin>>casilla->izquierda;
cin>>casilla->derecha;
cout<<"\nIngresa el peso (longitud) de la casilla (pasillo)\n>> ";
cin>>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
{
O(1)
}
}
else
{
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(j<(filas-1))
O(if)+O(then)= O(1)+ O(1)= O(1)
{
aux3=auxsig->juntoab;
O(1)
auxsig=aux3;
O(1)
}
}
else
{
casilla->arcoiz=NULL;
O(1)
if(j<(filas-1))
O(if)+O(then)= O(1)+ O(1)= O(1)
{
aux3=auxsig->juntoab;
O(1)
auxsig=aux3;
O(1)
}
}
casilla->no_casilla=conta;
O(1)
finalc=casilla;
O(1)
j++;
O(1)
}
final2=casilla;
O(1)
cout<<"\nEl laberinto se ha modificado correctamente.\n\n";
O(1)
iucolumna=aux;
O(1)
}
T(f(n))=Omax(1,1,1n,1,1,1)=O(n)
void laberinto::crear_laberinto(void)
{
int opc2, opc3;
do
{
do
{
system("cls");
cout<<"\n\nMenu\n\nElije un opcion\n\n";
cout<<"1 Agregar nueva fila\n"
<<"2 Agregar nueva columna\n"
<<">> ";
cin>>opc2;
}
while(opc2<1 && opc2>3);

switch(opc2)
{
case 1:
agregar_fila();
mostrar_matriz();
break;
case 2:
agregar_columna();
mostrar_matriz();
break;
case 3:
break;
default:
cout<<"\n\nLo sentimos, Pero tiene que elejir una de las opciones correctas.\n\n";
}
do
{
system("pause");
system("cls");
cout<<"\n\nSeguir agregando?"
<<"\n1 SI"
<<"\n2 NO"
<<"\n>> ";
cin>>opc3;
}
while(opc3<1 && opc3>2);
}
while(opc3==1);
}
void laberinto::menu(void)
{
int opc;
system("color b5");
system("mode 180, 500");
do
{
cout<<"\n\n\n\t\tMENU\n\n";
cout<<"|---|______________________________________________________________________\n"
<<"| 4
|_______________________________________________________________\n"
<<"|____|
______________________________________________________________________\n";
cout<<"\n\nElija una de las siguientes opciones\n\n\n";

cout<<"1 Inicializar laberinto\n"
<<"2 Modificar laberinto\n"
<<"3 Mostrar matriz\n"
<<"4 Establecer Meta/Llegada\n"
<<"5 Encontrar ruta\n"
<<"6 Destruir laberinto\n"
<<"7 Salir del programa\n";
cout<<">> ";
cin>>opc;
switch(opc)
{
case 1:
inicializar_laberinto();
break;
case 2:
crear_laberinto();
break;
case 3:
mostrar_matriz();
break;
case 4:
establecer_meta();
break;
case 5:
encontrar_ruta_aux();
break;
case 6:
destruir_laberinto();
break;
case 7:
cout<<"\n\n\nUsted esta saliendo del programa...\n\n\n";
break;
default:
cout<<"\n\n\nLo sentimos, pero la opcion que ha elegido es incorrecta\n"
<<"Favor de elegir una de las opciones que aparcen en el menu.\n\n";
}
system("pause");
system("cls");
}
while(opc!=7);
}
void main()
{
laberinto robot;
robot.menu();
}
La complejidad temporal algortmica del cdigo realizado es: T(f(n))=Omax(n,n,1,1,1,n,1,1,1)=O(n)

Unidad Culhuacn
Nombre del Proyecto
Objetivo
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
Nombre del Proyecto
Objetivo
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
Nombre del Proyecto
Objetivo
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

Algoritmos Geométricos Marco Teórico

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Algoritmos Geométricos Marco Teórico

Încărcat de

Drepturi de autor:

Formate disponibile

INSTITUTO POLITCNICO NACIONAL

Escuela Superior de Ingeniera, Mecnica y Elctrica

Nombre de los participantes

INSTITUTO POLITCNICO NACIONAL

Nombre del Proyecto

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

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

Como ejemplos tenemos:

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

TIEMPO DE EJECUCIN DE LOS ALGORITMOS GEOMETRICOS

INSTITUTO POLITCNICO NACIONAL

INSTITUTO POLITCNICO NACIONAL

Anlisis del algoritmo

Etapa 1. Definicin del problema

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

int filas, columnas, conta;

O(do) + O(while) = O(1) + O(1) + O(1) + O(1)+ O(1) = O(1)

O(if) + O(then) = O(1) + O(1) = O(1)

O(do) + O(while) = O(1)+ O(1)+ O(1)+ O(1)+ O(1)+ O(1) = O(1)

principio -> arriba= NULL;

cout<<"\n\nAgregando primer casilla, ingresa los datos que se piden:\n\n\n";

cout<<"\nEl laberinto se ha inicializado correctamente.\n\n";

for(i=0; i<columnas; i++)

while(opc2<1 && opc2>3);

cout<<"\n\nElija una de las siguientes opciones\n\n\n";

INSTITUTO POLITCNICO NACIONAL

INSTITUTO POLITCNICO NACIONAL

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

Cuestionario para aplicar

INSTITUTO POLITCNICO NACIONAL

S-ar putea să vă placă și