ESCUELA POLITCNICA NACIONAL

FACULTAD DE INGENIERA DE SISTEMAS

INGENIERA DE SISTEMAS INFORMTICOS Y DE COMPUTACIN

Laboratorio de: Algoritmos.

Prctica No.: 7 - Segundo Bimestre
Tema: Problemas P y NP
Nombres: Juan Pablo Mendieta, Juan Erazo, Bryan Jarrin
OBJETIVOS:

Conocer las diferencias y semejanzas existentes entre ambas clases para su discusin y
anlisis

Analizar el comportamiento de los algoritmos pertenecientes a las clases P y NP

Fomentar el conocimiento de las tcnicas de algoritmos para ser implementadas en

problemas de la vida real.

Marco terico:
Problemas P y NP
Existen diferentes modelos que suponen que una computadora es determinista (dado el estado
actual de la computadora y las variables de entrada, existe una nica accin posible que la
computadora puede tomar) y secuencial (realiza las acciones una despus de la otra).

En estos modelos encontramos 2 clases definidas:

La clase P: son aquellos problemas de decisin que pueden ser resueltos en un tiempo
polinmico en una mquina determinista secuencial tomando en cuenta todos sus
datos.
La clase NP: consiste de todos aquellos problemas de decisin que pueden ser
verificadas en tiempo polinmico a partir de ser alimentadas con la informacin
apropiada, o en forma equivalente, cuya solucin puede ser hallada en tiempo
polinmico en una mquina no determinista.

Para la resolucin de este tipo de problemas hacemos uso de la teora de la complejidad cuya
finalidad es la creacin de mecanismos y herramientas capaces de describir y analizar la
complejidad de un algoritmo y la de un problema en general.
A esto se suma la complejidad computacional donde se toman en cuenta 2 rasgos importantes:

Tiempo: Numero de pasos base de ejecucin de un algoritmo para resolver un problema

Espacio: Cantidad de memoria utilizada para resolver un problema

Desarrollo de la prctica:
Los problemas aqu presentados forman parte del anlisis de otros problemas previamente
resueltos en el anlisis del curso, as:

ESCUELA POLITCNICA NACIONAL

FACULTAD DE INGENIERA DE SISTEMAS
INGENIERA DE SISTEMAS INFORMTICOS Y DE COMPUTACIN

Algoritmo sobre NP
public class Hannoi {
public static void main(String[] args) {
int num=0;
Scanner discos= new Scanner(System.in);
System.out.println("Ingrese el numero de discos: ");
num = discos.nextInt();
Hannoi(num,1,2,3);
}

public static void Hannoi(int n, int origen, int auxiliar, int destino){
if(n==1)
System.out.println("Moviendo el disco de: " + origen + " a " + destino);
else{
Hannoi(n-1, origen, destino, auxiliar);
System.out.println("Moviendo el disco de: "+ origen + " a " + destino);
Hannoi(n-1, auxiliar, origen, destino);
}
}
}

Algoritmo sobre P
Bsqueda Secuencial
public static boolean secuencial(int[] array, int dato){ //busca el element comparando uno por
uno en un bucle
for(int i = 0; i < array.length; i++){
if(array[i]==dato) {
System.out.println("El elemento " + dato + " esta en la posicin
" + (i+1) + ".");
return true; /
}
}
System.out.println("El elemento " + dato + " no existe en el arreglo.");
return false;
}

ESCUELA POLITCNICA NACIONAL

FACULTAD DE INGENIERA DE SISTEMAS
INGENIERA DE SISTEMAS INFORMTICOS Y DE COMPUTACIN

Problema del agente viajero (cdigo base)

int fx[15][15], crom[16][16], gen[16][16], selec[15][2], pdr[2][16], hj[2][16], select[15], cant ,
validar;
char cityInFin, pob[15]={'A','B','C','D','E','F','G','H','I','J','K','L','M','N','0'};
void ingresar (void)
{
JOptionPane.showInputDialog("INGRESAR CIUDADES");
cant =(Integer)JOptionPane.showInputDialog("Ingrese la cantidad de ciudades ");
int z=12;
for(int i=0;i<cant ;i++)
for(int j=i+1;j<cant ;j++)
{
fx[i][j]=(Integer)JOptionPane.showInputDialog("Recorrido entre "<<pob[i]<<" y "<<pob[j]<<" ";
fx[j][i]=fx[i][j];
z++;
}
}
int definir(void)
{
JOptionPane.showInputDialog("DEFINA CIUDAD DE PARTIDA");
cityInFin=JOptionPane.showInputDialog("Ingrese la Ciudad en Mayusculas ");
for(int i=0;i<cant ;i++)
{
if(cityInFin==pob[i]) return i;
}
}
void algoritmo (void)
{
int ciu, asig; ciu=definir();
for(int i=0;i<cant ;i++) for(int j=1;j<cant ;j++) crom[i][j]=-1;
for(int j=0;j<cant ;j++) crom[j][0]=ciu;
for(int i=0;i<cant ;i++) for(int j=1;j<cant ;j++)

ESCUELA POLITCNICA NACIONAL

FACULTAD DE INGENIERA DE SISTEMAS
INGENIERA DE SISTEMAS INFORMTICOS Y DE COMPUTACIN

{
asig=random(cant ); for(int l=0;l<cant ;l++)
{
if(crom[i][l]==asig)
{
asig++;
if(asig>=cant ) asig=0; l=-1;
}
}
crom[i][j]=asig;
}
for(int i=0;i<cant ;i++)
{
crom[i][cant ]=ciu;
}
}

void seleccion (int crom[16][16])

{
int yendo, yendoa, a, b;
for(int i=0;i<cant ;i++) select[i]=0;
for(int i=0;i<cant ;i++)
{
for(int j=0;j<cant ;j++)
{
a=crom[i][j];
b=crom[i][j+1];
select[i]+=fx[a][b];
}
}
for(int i=0;i<cant ;i++)
{
selec[i][0]=select[i];
selec[i][1]=i;
}
for(int i=0;i<cant ;i++) for(int j=0;j<cant ;j++)
{
if(selec[i][0]<selec[j][0])
{
yendo=selec[i][0]; yendoa=selec[i][1]; selec[i][0]=selec[j][0];
selec[i][1]=selec[j][1]; selec[j][0]=yendo; selec[j][1]=yendoa;
}
}
}

ESCUELA POLITCNICA NACIONAL

FACULTAD DE INGENIERA DE SISTEMAS
INGENIERA DE SISTEMAS INFORMTICOS Y DE COMPUTACIN

void ruleta (int crom[16][16])

{
int med, asig; med=cant /2; int j=selec[0][1];
for(int i=0;i<cant +1;i++)
{
pdr[0][i]=crom[j][i];
}
asig=random(med); if(asig==0) asig++; j=selec[asig][1];
for(int i=0;i<cant +1;i++)
{
pdr[1][i]=crom[j][i];
}
}

void hijos (void)

{
int tmp, x, l, k; int med=cant /2; int cpar=med-1; int cret=cpar*2;
for(x=0;x<2;x++)
for(int j=0;j<cant +1;j++)
{
gen[x][j]=pdr[x][j];
} x=0;
for(l=0;l<med;l++)
{
for(int i=0;i<2;i++) for(int j=0;j<cant +1;j++)
{
hj[i][j]=-1;
} hj[0][0]=pdr[0][0];
hj[0][cant ]=pdr[0][cant ];
hj[1][0]=pdr[1][0];
hj[1][cant ]=pdr[1][cant ]; x+=2;
for(int i=cpar;i<=cret;i++)
{
hj[0][i]=pdr[0][i];
hj[1][i]=pdr[1][i];
}
for(int i=1;i<cpar;i++)
{
tmp=pdr[1][i];
for(int j=0;j<=cret;j++)
{
if(hj[0][j]==tmp)
{
tmp++;
if(tmp>=cant ) tmp=0; j=-1;
}

ESCUELA POLITCNICA NACIONAL

FACULTAD DE INGENIERA DE SISTEMAS
INGENIERA DE SISTEMAS INFORMTICOS Y DE COMPUTACIN

}
hj[0][i]=tmp;
}
for(int i=1;i<cpar;i++)
{
tmp=pdr[0][i];
for(int j=0;j<=cret;j++)
{
if(hj[1][j]==tmp)
{
tmp++;
if(tmp>=cant ) tmp=0; j=-1;
}
}
hj[1][i]=tmp;
}
for(int i=cret+1;i<cant ;i++)
{
tmp=pdr[1][i];
for(int j=0;j<cant ;j++)
{
if(hj[0][j]==tmp)
{
tmp++;
if(tmp>=cant ) tmp=0; j=-1;
}
}
hj[0][i]=tmp;
}
for(int i=cret+1;i<cant ;i++)
Anlisis de resultados:

Para las torres de Hanoi, NP, realizamos un anlisis de complejidad [1] con los siguientes
resultados:
La expresin recursiva del algoritmo es la siguiente:
Tn = 2Tn1 + 1 T0 = 0
Expansin de recurrencias:
Tn = 2Tn1 + 1
Tn= 2(2Tn2 + 1) + 1 = 22Tn2 + 2 + 1
Tn= 2(2(2Tn3 + 1) + 1) + 1 = 23Tn3 + 4 + 2 + 1
Tn= 2(2(2(2Tn4 + 1) + 1) + 1) + 1 = 24Tn4 + 8 + 4 + 2 + 1
Se puede ver, por tanto, que la expresin general es:

ESCUELA POLITCNICA NACIONAL

FACULTAD DE INGENIERA DE SISTEMAS
INGENIERA DE SISTEMAS INFORMTICOS Y DE COMPUTACIN

Se llega al caso base cuando el parmetro de la T es cero. Es decir, cuando ni = 0. Despejando

la i, se obtiene i = n. Sustituyendo en la expresin obtenemos:

Viendo que T(0) = 0 y resolviendo la serie geomtrica queda finalmente:

Tn = 2n 1 (2n)
Lo mismo realizamos para la bsqueda secuencial teniendo como resultado:
T (n)=C1n+C 2
O(n)
Y finalmente para un problema NP completo:
La cantidad de rutas posibles en una red est determinada por la ecuacin:
T(n)=(n-1)!
Es decir que en una red de 5 nodos la cantidad de rutas probables es igual a (5-1) = 24, y a
medida que el nmero de nodos aumente la cantidad de rutas posibles crece factorialmente. En
el caso de que el problema sea simtrico la cantidad de rutas posibles se reduce a la mitad, es
decir:
T(n)=( (n-1)! ) / 2

Conclusiones y recomendaciones:

Como se puede ver analizar los problemas P y NP es dar un recorrido por cada uno de
los distintos algoritmos estudiados en el presente curso, pero desde el punto de vista
de la complejidad para ser separados en estos 2 tipos.

La diferencia entre ambas clases est en su resolucin P son fcilmente solucionables

en tiempo polinmico mientras que NP solo se tiene una solucin en tiempo polinmico
en su fase de verificacin mientras que en la resolucin presenta tiempos exponenciales
capaces de desbordar la memoria y uso del CPU.

ESCUELA POLITCNICA NACIONAL

FACULTAD DE INGENIERA DE SISTEMAS
INGENIERA DE SISTEMAS INFORMTICOS Y DE COMPUTACIN

Bibliografa

vila, E. R. (2010). El Correcto y Completo Desarrollo de un Algoritmo. Obtenido de

https://pastranamoreno.files.wordpress.com/2010/09/algoritmos-hanoi.pdf

Lpez, B. S. (2012). PROBLEMA DEL AGENTE VIAJERO - TSP. Obtenido de Ingenieria

Industrial
Online:
http://www.ingenieriaindustrialonline.com/herramientas-para-elingeniero-industrial/investigaci%C3%B3n-de-operaciones/problema-del-agente-viajerotsp/