INSTITUTO POLITÉCNICO

NACIONAL
“ESIME CULHUACÁN”
INGENIERÍA EN COMPUTACIÓN

ANÁLISIS DE ALGORITMOS

Aplicación de Intersección de
Polígonos e intersección de rectas
PROFESORA: GUARDIÁN SOTO BEATRIZ
DOLORES
ALUMNA:
BENITEZ CONTRERAS JESSICA YARELY

GRUPO:5CM13
Teoría
DESARROLLO

a) Definición y análisis del problema.

Una intersección de una línea recta, que es común a dos o más elementos, dada una
colección de n segmentos de línea en el plano, computar todos los puntos de
intersección.

Para realizar el algoritmo de intersección de segmentos, se realiza una consulta de

intersección por todos los pares de segmentos, es decir utilizaremos el algoritmo de
Fuerza Bruta, por tanto, un algoritmo de esta índole seria de cierta forma óptimo ya que
el máximo de intersecciones es n², se espera pocas intersecciones.

b) Construcción del algoritmo.

1. Dados dos conjuntos de segmentos de rectas, calcular las intersecciones entre un
segmento de un conjunto A y un segmento del otro conjunto B.
2. Consideraremos un segmento de A cuyo punto extremo esté sobre un segmento en
3. B como segmentos que intersectan (los segmentos son cerrados).
4. Para encontrar todas las intersecciones creamos un conjunto S = A ∪ B.
5. La especificación del problema es la siguiente:
6. Dado un conjunto S de n segmentos cerrados en el plano, reportar todos los puntos
de instersección entre los segmentos en S.
7. Tomar cada par de segmentos,
8. Calcular si intersectan o no,
9. Reportar la intersección

c) Pseudocódigo

DIRECTION(pi, pj, pk)

{return (pk - pi) × (pj - pi);}

ON-SEGMENT(pi, pj, pk)

{if min(xi, xj) ≤ xk ≤ max(xi, xj) and

min(yi, yj) ≤ yk ≤ max(yi, yj)

return TRUE;

else return FALSE ;

}
 a) Complejidad temporal.
Este algoritmo requiere un tiempo de ejecución de O(n²). Cuando cada par de segmentos
está intersectando, cualquier algoritmo toma Ω(n²) porque tiene que reportar todas las
intersecciones.

En el caso general el número total de puntos de intersección es mucho menor que una cota
cuadrática.

T(f(n))=O(n²)
d) Código e implementación.

#include <iostream>

using namespace std;

int main() {

int a1, b1, a2, b2;

cin >> a1 >> b1 >> a2 >> b2;

int a = max(a1, a2), b = min(b1, b2);

if (a <= b) cout << a << " " << b << endl;

else cout << "Interseccion vacia" << endl;

}
Teoría
DESARROLLO

c) Definición y análisis del problema.

Se desea encontrar un algoritmo que encuentre el menor polígono convexo que contenga a
los puntos de un conjunto Q. Cada punto es interior al polígono o pertenece a uno de sus
lados. Un polígono es convexo si todos segmento cuyos extremos son puntos interiores del
polígono no corta a un segmento de borde.

Algunos algoritmos para resolver están basados en barrido rotacional, procesan vértices en
el orden de sus coordenadas polares los ángulos que forman con referencia a un vértice son
dos Graham y Jarvis,

El casco convexo es el área cerrada mínima que puede cubrir todos los puntos de datos
dados.

El algoritmo de escaneo de Graham encontrará los puntos de esquina del casco convexo. En
este algoritmo, al principio se elige el punto más bajo. Ese punto es el punto de partida del
casco convexo. Los vértices restantes n-1 se ordenan según la dirección antihoraria desde el
punto de inicio. Si dos o más puntos están formando el mismo ángulo, elimine todos los
puntos del mismo ángulo, excepto el punto más alejado desde el principio.

Desde los puntos restantes, empújalos hacia la pila. Y retire los elementos de la pila uno por
uno, cuando la orientación no sea en sentido antihorario para el punto superior de la pila, el
segundo punto superior y los puntos de punto recientemente seleccionados [i], después de
verificar, inserte los puntos [i] en la pila.

d) Construcción del algoritmo.

1. Dado el polígono A como la región de recorte y el polígono B como el polígono
sujeto a recortar.
2. Liste los vértices del polígono A de la región de recorte y los del polígono B.
3. Etiquete los vértices enumerados del polígono B sujeto como dentro o fuera de la
región de recorte A.
4. Encuentre todas las intersecciones de polígonos e insértelas en ambas listas,
vinculando las listas en las intersecciones.
5. Genere una lista de intersecciones "entrantes": las intersecciones donde el vector
desde la intersección hasta el vértice posterior del polígono B sujeto comienza
dentro de la región de recorte.
6. Siga cada intersección en sentido horario alrededor de las listas vinculadas hasta que
se encuentre la posición de inicio.
7. Si no hay intersecciones, una de las tres condiciones debe ser verdadera:
8. A está dentro de B: devuelve A para recortar, B para fusionar.
9. B está dentro de A - devuelve B para recortar, A para fusionar.
10. A y B no se superponen: devuelva Ninguno para recortar o A y B para fusionar.
c) Pseudocódigo

Begin

minY := points[0].y

min := 0

for i := 1 to n-1 do

y := points[i].y

if y < minY or minY = y and points[i].x < points[min].x, then

minY := points[i].y

min := i

done

swap points[0] and points[min]

p0 := points[0]

sort points from points[1] to end

arrSize := 1

for i := 1 to n, do

when i < n-1 and (p0, points[i], points[i+1]) are collinear, do

i := i + 1

done

points[arrSize] := points[i]

arrSize := arrSize + 1

done

if arrSize < 3, then

return cHullPoints

push points[0] into stack

push points[1] into stack

 push points[2] into stack

for i := 3 to arrSize, do

while top of stack, item below the top and points[i] is not in

anticlockwise rotation, do

delete top element from stack

done

push points[i] into stack

done

while stack is not empty, do

item stack top element into cHullPoints

pop from stack

done

End

b) Complejidad temporal.
Dado un conjunto de puntos Q, encontrar los puntos más cercanos. Un algoritmo de “fuerza
bruta” requiere analizar O(n²) pares de puntos.

T(f(n))=O(n²)

d) Código e implementación.

#include<iostream>
#include<stack>

#include<algorithm>

#include<vector>

using namespace std;

struct point { //define points for 2d plane

int x, y;

};

point p0; //used to another two points

point secondTop(stack<point> &stk) {

point tempPoint = stk.top();

stk.pop();

point res = stk.top(); //get the second top element

stk.push(tempPoint); //push previous top again

return res;

int squaredDist(point p1, point p2) {

return ((p1.x-p2.x)*(p1.x-p2.x) + (p1.y-p2.y)*(p1.y-p2.y));

int direction(point a, point b, point c) {

int val = (b.y-a.y)*(c.x-b.x)-(b.x-a.x)*(c.y-b.y);

if (val == 0)

return 0; //colinear

else if(val < 0)

return 2; //anti-clockwise direction

return 1; //clockwise direction

}

int comp(const void *point1, const void*point2) {

point *p1 = (point*)point1;

point *p2 = (point*)point2;

int dir = direction(p0, *p1, *p2);

if(dir == 0)

return (squaredDist(p0, *p2) >= squaredDist(p0, *p1))?-1 : 1;

return (dir==2)? -1 : 1;

vector<point> findConvexHull(point points[], int n) {

vector<point> convexHullPoints;

int minY = points[0].y, min = 0;

for(int i = 1; i<n; i++) {

int y = points[i].y;

//find bottom most or left most point

if((y < minY) || (minY == y) && points[i].x < points[min].x) {

minY = points[i].y;

min = i;

swap(points[0], points[min]); //swap min point to 0th location

p0 = points[0];

qsort(&points[1], n-1, sizeof(point), comp); //sort points from 1 place to end

int arrSize = 1; //used to locate items in modified array

for(int i = 1; i<n; i++) {

 //when the angle of ith and (i+1)th elements are same, remove points

while(i < n-1 && direction(p0, points[i], points[i+1]) == 0)

i++;

points[arrSize] = points[i];

arrSize++;

if(arrSize < 3)

return convexHullPoints; //there must be at least 3 points, return empty list.

//create a stack and add first three points in the stack

stack<point> stk;

stk.push(points[0]); stk.push(points[1]); stk.push(points[2]);

for(int i = 3; i<arrSize; i++) { //for remaining vertices

while(direction(secondTop(stk), stk.top(), points[i]) != 2)

stk.pop(); //when top, second top and ith point are not making left turn, remove
point

stk.push(points[i]);

while(!stk.empty()) {

convexHullPoints.push_back(stk.top()); //add points from stack

stk.pop();

int main() {

point points[] = {{-7,8},{-4,6},{2,6},{6,4},{8,6},{7,-2},{4,-6},{8,-7},{0,0},

{3,-2},{6,-10},{0,-6},{-9,-5},{-8,-2},{-8,0},{-10,3},{-2,2},{-10,4}};

int n = 18;
 vector<point> result;

result = findConvexHull(points, n);

cout << "Los puntos límite del poligono convexo son: "<<endl;

vector<point>::iterator it;

for(it = result.begin(); it!=result.end(); it++)

cout << "(" << it->x << ", " <<it->y <<") ";