Trabajo Master Juan Manuel Beltran - Servidor de...

Introducción a la Teoría de NP-Completitud y su Aplicación en

Optimización de Brigadas

Juan Manuel Beltrán Gómez

Trabajo fin de Máster en Sistemas de Energía Eléctrica

Tutor D. José Antonio Rosendo Macías

Máster en Sistemas de Energía Eléctrica. Página 1

ÍNDICE:

1.- Presentación y Objetivos ....................................................................................................... 3

2.- Introducción a la Teoría de NP-Completitud ...................................................................... 6

2.1 Problemas, algoritmos y complejidad ............................................................................. 6

2.2 Algoritmos de tiempo polinomial y problemas intratables............................................ 8

2.3 Problemas de Complejidad NP ...................................................................................... 10

3.- La Teoría de NP-Completitud ............................................................................................ 13

3.1 Problemas de decisión, lenguajes y esquemas de codificación .................................... 13

3.2 Máquina determinista de Turing y la clase P ............................................................... 15

3.3 Computación no-determinista y la clase NP ................................................................. 18

3.4 La relación entre P y NP ................................................................................................. 21

3.5 Transformaciones polinomiales y NP-Completos ........................................................ 22

3.6 Teorema de Cook ............................................................................................................ 28

4.- Demostraciones de resultados NP-Completos ................................................................... 30

4.1 3-Satisfacibilidad (3-SAT) .............................................................................................. 30

4.2 Presentación de Problemas ............................................................................................. 33

4.2.1 Corte y Bisecciones ................................................................................................... 34

4.2.2 Programación Lineal Entera ................................................................................... 35

4.2.3 Enlace 3-Dimensional (3DM) .................................................................................. 35

4.2.4 Conjunto Independiente, Cobertura de Vértices y Clique ................................... 36

4.2.5 Knapsack ................................................................................................................... 36


4.3 Demostraciones ................................................................................................................ 37

4.3.1 De Camino de Rudrata(s,t) a Circuito de Rudrata ............................................... 38

5.- Planes de Contingencia ........................................................................................................ 40

5.1 Análisis del problema ...................................................................................................... 42

5.2 Formulación del VRP para Brigadas ............................................................................ 45

5.3 Reducción de Nodos ........................................................................................................ 50

5.3.1 Subestación operativa por telemando ..................................................................... 51

5.3.2 Subestación sin telemando ....................................................................................... 51

6.- Ejemplo ................................................................................................................................. 56

6.2 Análisis del ejemplo ......................................................................................................... 64

7.- Conclusiones ......................................................................................................................... 65

8.- Futuros Trabajos ................................................................................................................. 68

9.- Epílogo .................................................................................................................................. 70

10.- Anexo................................................................................................................................... 71

11.- Bibliografía ......................................................................................................................... 84


1.- Presentación y Objetivos

El objetivo de este trabajo, es la obtención del título de Máster en Sistemas de Energía

Eléctrica, para ello se va a tratar un problema sin resolver, la optimización del uso de las

Brigadas de la red de Media Tensión. Estas Brigadas son los vehículos y recursos físicos de los

que se disponen para maniobrar en la red de Media Tensión de manera local. Para ello

analizaremos los Planes de Contingencia en la red de Media Tensión. Esta será la segunda parte

de este proyecto y lo recogido en ella se basa en los documentos de la bibliografía [6], [7], [8],

[9] y [10], en mi experiencia personal como trabajador del Centro de Control de Media de

Tensión de Endesa en Sevilla, y lo aprendido tanto en mi Licenciatura en Matemáticas como en

los diferentes cursos de este Máster. Todo esto lo haremos como aplicación a la Clase de

Complejidad NP, y sobre todo de NP-Completos, que será la primera parte de este proyecto.

Dicha parte teórica consta de cuatro puntos y están basados en documentos de la bibliografía

[1], [2], [3], [4] y [5].

Quizás la mejor manera de presentar la Teoría de NP-Completitud sea con un ejemplo.

Supongamos que somos un empleado de una empresa industrial. Un día nuestro jefe nos

llama a su despacho, y nos comunica que nuestra empresa está a punto de entrar en el

competitivo mercado de las “politizadoras”. Para ello, se necesita un buen método que

determine si para cualquier serie de especificaciones dadas, estas se pueden o no encontrar para

las componentes de una nueva politizadora. Y si se puede, diseñar un algoritmo que las

encuentre. Como nosotros somos el diseñador de algoritmos de la empresa, nuestro trabajo será

diseñar un algoritmo que satisfaga esa demanda.

Después de consultar al departamento de politizadoras para concretar cuál es el problema

exactamente, volvemos a nuestra oficina, y nos ponemos manos a la obra con gran entusiasmo.

Unas semanas después, tenemos la oficina llena de papeles con cálculos, y el ordenador lleno de

archivos de pruebas, y además aún no hemos conseguido obtener ningún algoritmo mas allá de

la búsqueda manual de cada una de las posibilidades. Presentar esto a nuestro jefe no es muy

halagüeño, sabiendo que supone un tiempo de computación casi ilimitado y que esto conllevaría


parar totalmente al departamento de politizadoras, con el simple argumento de que no se ha

encontrado nada mejor

Para evitar esta situación con la empresa, sería mucho mejor si pudiésemos probar que el

nivel de dificultad inherente al problema es intratable, es decir que no existe ningún algoritmo

que resuelva nuestro problema de manera rápida. De esta manera le podríamos decir a nuestro

jefe que “no puedo encontrar un algoritmo eficiente, porque no existe dicho algoritmo”.

Por desgracia probar la intratabilidad inherente, puede ser tan difícil como encontrar un

algoritmo eficiente. Incluso grandes teóricos han sucumbido en los intentos de obtener pruebas

de problemas “duros”. De lo que se trata entonces en este trabajo, es de aprender a usar una

herramienta que nos solucione nuestro problema. La Teoría de NP-Completitud nos provee de

muchas técnicas sencillas para probar que un problema dado es tan “duro” como un gran

número de otros problemas, que son ampliamente conocidos por ser muy difíciles de resolver y

que han ocupado a expertos durante años. Con estas herramientas podremos probar que nuestro

problema con las politizadoras es NP-Completo, y de ahí que es equivalente a todos esos

problemas “duros”.

Le podríamos presentar una lista con nombres de eminencias de las ciencias a nuestro

jefe, y decirle: No he podido encontrar un algoritmo eficiente para las politizadoras, pero

ninguno de estos científicos famosos tampoco. Al menos con esto posiblemente no nos echen

para contratar a otro programador.

Por supuesto esto no resolverá la situación laboral en nuestra empresa, y el departamento

de politizadoras no habrá encontrado la solución a sus problemas. Pero saber que nos

enfrentamos a un problema NP-Completo es normalmente el principio para trabajar en el

problema. Ahora tendríamos información valiosa sobre que líneas de aproximación serán más

productivas. En realidad debemos de abandonar la idea de buscar un algoritmo eficiente, por la

de encontrar buenas aproximaciones. Por ejemplo buscar varios algoritmos que resuelvan varios

casos concretos del problema general. Algoritmos que no nos garanticen que serán rápidos

siempre, pero si la mayoría de las veces. O simplemente rebajar el número de las componentes

de las especificaciones.


En resumen, la primera aplicación de la Teoría de NP-Completitud, es ayudar a los

diseñadores de algoritmos a orientar sus esfuerzos sobre las aproximaciones que tienen más

posibilidades de ser viables, y convertirlas en algoritmos útiles.


2.- Introducción a la Teoría de NP-Completitud

Primero vamos a comenzar por la noción de problema. Vamos a considerar un problema

como una cuestión general, con diferentes parámetros y variables libres, a la que se busca una

respuesta. Un problema será descrito dando: 1.- Una descripción de todos sus parámetros y

2.- Las condiciones o propiedades que ha de cumplir la solución.

2.1 Problemas, algoritmos y complejidad

Denominaremos instancia a un caso particular. Dicha instancia es obtenida dándoles

valores concretos a todos los parámetros del problema. Es decir, consideremos por ejemplo el

problema del viajante. Los parámetros de este problema consisten en un conjunto finito

[ ]mcccC ,...,, 21= de ciudades, de manera que para cada par de ciudades ci, cj en C, la distancia

entre ellas viene dada por ),( ji ccd . Una solución sería una lista ordenada de ciudades

[ ])()2()1( ,...,, mcccC ΠΠΠ= que minimiza:

),(),( )1()(

1

1)1()( ΠΠ

−

=+ΠΠ +

∑ ccdccd m

m

iii

Esta expresión da la longitud total del viaje que empieza en )1(Πc , pasa por todas las

ciudades del conjunto C, y vuelve a la ciudad )1(Πc desde la última ciudad )(mcΠ . Cada

)(icΠ

equivale a una ciudad de la lista de C, de manera que Π nos da el orden en el que se visitarían.


Una instancia del problema del viajante sería por ejemplo la dada por [ ]4321 ,,, ccccC = ,

10),( 21 =ccd , 5),( 31 =ccd , 9),( 41 =ccd , 6),( 32 =ccd , 9),( 42 =ccd y 3),( 43 =ccd . Donde el

camino 3421 ,,, cccc es una solución para esta instancia, ya que ese viaje tiene una longitud de

27, la mínima posible.

Los algoritmos son procedimientos generales para resolver problemas, paso por paso. Un

algoritmo se dice que resuelve el problema Π si ese algoritmo puede ser aplicado a cualquier

instancia Ι de Π , y además tenemos la garantía de que devuelve una solución para la instancia

Ι . El término solución lo entendemos en el sentido del término visto antes, es decir un

algoritmo no resuelve el problema del viajante a menos que siempre sea capaz de construir una

lista ordenada, que dé el viaje de mínima longitud.

Casi siempre lo fundamental suele ser encontrar el algoritmo más eficiente para resolver

un problema. El término eficiencia engloba todo los tipos de recursos que necesitaremos para

ejecutar un algoritmo, aunque realmente cuando nos referimos al algoritmo mas eficiente nos

estamos refiriendo al más rápido. El tiempo necesario para resolver un algoritmo es un factor

dominante para determinar si un algoritmo concreto es lo suficientemente eficiente para ser

usado, por lo que nos debemos centrar en este recurso concreto.

El tiempo que requiere un algoritmo lo expresamos en función de una variable, que es el

tamaño de la instancia de un problema. Esta refleja el número de datos de entrada que se

necesita para describir la instancia. A veces el tamaño se mide de manera poco estricta, como

por ejemplo en el problema del viajante, cuando usamos como tamaño del problema m, el

número de ciudades del problema. En realidad tendríamos que tener en cuenta que el número de

datos de entrada es 2

)1( −mm si queremos hacerlo de manera estricta. También habría que tener

en cuenta la forma de introducir los datos, ya que depende como esté codificado nuestro

problema y la instancia puede variar considerablemente el número de dígitos de entrada

La descripción de la instancia de un problema que introduzcamos en el ordenador, la

vamos a dar con una cadena de símbolos elegida de un alfabeto finito. Hay muchas maneras

para describir una instancia, pero por ahora vamos a suponer que se ha escogido una manera

concreta y que cada problema tiene fijada un esquema de codificación. La longitud de la entrada

de una instancia Ι de Π es el número de símbolos en la descripción de Ι , ese es el número que

se usa como medida del tamaño de la instancia.


Por ejemplo, una instancia del problema del viajante se puede describir con el alfabeto

[ ]{ }9,8,7,6,5,4,3,2,1,0/,,,,c , usando el ejemplo del problema de antes se podría codificar con la

cadena “c[1] c[2] c[3] c[4]//10/5/9//6/9//3”, si usáramos este esquema de codificación, entonces

la longitud de la entrada del ejemplo sería 32.

La función de complejidad temporal para un algoritmo, expresa el mayor tiempo

requerido por el algoritmo para resolver la instancia de un problema de ese tamaño, para cada

longitud de la entrada posible. Por supuesto previamente ha de estar bien definido el esquema

de codificación y el ordenador que vayamos a usar para determinar el tiempo de ejecución.

Aunque como veremos más adelante, estos detalles no nos afectarán apenas al usar la Teoría de

NP-Completitud.

2.2 Algoritmos de tiempo polinomial y problemas intratables

Hay una gran cantidad de funciones de complejidad temporal para los diferentes

algoritmos, que sean ineficientes o no dependerá de que nos encontremos en cada situación

concreta. Pero la computación distingue entre algoritmos de tiempo polinomial y exponencial.

Una función f(n) es O(g(n)) si existe una constante c cualquiera tal que )()( ngcnf ≤

0≥∀n . Un algoritmo de tiempo polinomial se define como aquel cuya función de complejidad

de tiempo es O(p(n)) para alguna función polinomial p, donde n es la longitud de entrada. Todo

aquel algoritmo que no puede ser acotado de esta manera es llamado algoritmo de tiempo

exponencial. La excepción a esta regla la tenemos con la función de complejidad nnlog , sería un

algoritmo de tiempo no polinomial y sin embargo no se considera exponencial como tal.

Cuando consideremos instancias de grandes problemas, que un algoritmo sea de uno u otro tipo

será muy relevante. Todo esto estará relacionado con los ordenadores que usemos, cuanto más

rápido sea éste, menos dificultades tendremos para escoger algoritmos eficientes. Pero por muy

rápidos que sean éstos, siempre es deseable que un algoritmo sea polinomial a exponencial,

aunque para nuestra longitud de entrada no sea un gran problema. Es más, no se considera que

un problema está bien resuelto hasta que se encuentra un algoritmo polinomial para él. Diremos


que un problema es intratable, si es tan denso que ningún algoritmo de tiempo polinomial puede

resolverlo.

También tendremos casos en los que algoritmos exponenciales, que como hemos dicho

son ineficientes, admiten soluciones si su tamaño n es limitado. Por ejemplo un algoritmo de

complejidad n2 es más rápido que 5n sí 20≤n . Hay que tener también en cuenta que cuando

hablamos de tiempo de complejidad n2 para un algoritmo, significa que en el peor de los casos,

para una instancia de tamaño n, tardará ese tiempo como mucho. Sin embargo usamos muchos

algoritmos exponenciales con instancias que son resolubles en un tiempo mucho menor, un

ejemplo claro de esto es el algoritmo del Simplex para programación lineal, es de complejidad

exponencial y sin embargo es muy rápido, o el algoritmo de Branch-and-Bound (ramificación y

acotación). Pero estos ejemplos por desgracia, son una excepción de algoritmos exponenciales

rápidos.

Se conocen una gran cantidad de algoritmos de tiempo exponencial para muchos

problemas y muy pocos son realmente útiles, incluso de los pocos ejemplos que aún siendo

exponencial son útiles, se continúa intentando buscar soluciones polinomiales y mejoras.

Nuestra definición de intratabilidad de un problema, es independiente del sistema de

codificación particular o del modelo de ordenador que usemos para determinar la complejidad

temporal.

Por ejemplo, supongamos que tenemos un problema cuya instancia es un grafo G=(V,A)

donde V es el conjunto de vértices y A es el conjunto de aristas, definidas como un par de

vértices. En este caso podemos definir esta instancia simplemente con una lista de vértices y

aristas, o con una lista formada por las filas de la matriz de adyacencia o haciendo una lista para

cada vértice con el resto de vértices con los que comparte una arista. Y cada uno de estos

sistemas nos dará una entrada de una longitud diferente para el mismo grafo. Es decir

Tomemos el grafo con vértices V={V[1]V[2]V[3]V[4]} , y las aristas

A={(V[1]V[2])(V[2]V[3])}

• Lista de vértices y aristas:

V[1]V[2]V[3]V[4](V[1]V[2])(V[2]V[3]) longitud 36.


• Matriz de adyacencia:

0100/1010/0100/0000 longitud 19.

• Lista de vecinos:

(V[2])(V[1]V[3](V[2])() longitud 24.

Pero cualquier algoritmo que usemos de complejidad temporal polinomial bajo cualquiera

de estos sistemas de codificación, también será de complejidad polinomial bajo las otras. Es

más, el sistema de codificación estándar que usemos para un problema en particular siempre va

a diferir a lo sumo polinomialmente de cualquier otro.

Al hablar de problemas intratables vamos a distinguir entre dos tipos de intratabilidad en

nuestra definición. Primero el caso en el que es tan difícil encontrar una solución al problema

que se necesita tiempo exponencial. El segundo es aquel en el que la solución en si es tan

extensa que no puede ser descrita con una expresión con longitud acotada por una función

polinomial de la longitud de entrada. Este segundo caso se da por ejemplo en el problema del

viajante si añadimos como parámetro un número B, y se piden todos los caminos cuya longitud

sea menor o igual que B. Podemos encontrar instancias fácilmente para este problema en las que

exponencialmente, haya muchos caminos que sean más corto que esa cota dada, así ningún

algoritmo de tiempo polinomial podría listarlos todos. Este tipo de intratabilidad se produce la

mayoría de las veces porque se está requiriendo mas información de la que necesitamos, y suele

deberse a un mal condicionamiento. Por lo que nos centraremos en el primer tipo de

intratabilidad.

2.3 Problemas de Complejidad NP

A la vez que muchos teóricos se han centrado en buscar métodos más potentes para

probar problemas intratables, paralelamente se ha profundizado en la manera en que varios

problemas están relacionados con respecto a sus dificultades, esto ha provisto de mucha

información útil a los diseñadores de algoritmos.


La principal técnica para demostrar que dos algoritmos están relacionados es por

reducción de uno sobre otro, dando una transformación constructiva que nos transforme

cualquier instancia del primer problema en una equivalente del segundo. De esta manera esa

transformación provee de una herramienta para convertir cualquier algoritmo que resuelva el

segundo problema en un algoritmo correspondiente que resuelva el primero.

Aunque no es hasta 1971 cuando Stephen Cook inicia la Teoría de la NP-Completitud,

previamente científicos como Gimpel, Dantzig o Edmonds habían reducido problemas de teoría

de grafos y de optimización combinatoria.

La clase NP (acrónimo en Inglés de nondeterministic polynomial time) es el conjunto de

problemas que pueden ser resueltos en tiempo polinomial por una máquina de Turing no

determinista. Esta genera todas las posibles combinaciones de valores para las variables de la

expresión y en forma no-determinista, intenta verificar si alguna de ellas hace que la expresión

se evalúe en verdadero, en cuyo caso acepta la entrada.

Cook lo tituló “The Complexity of theorem Proving Procedures”.

• Primero, recalcó el significado de reducibilidad en tiempo polinomial. Si tenemos una

reducción en tiempo polinomial de un problema sobre otro, esto nos asegura que cualquier

algoritmo de tiempo polinomial para uno de los problemas se puede convertir en el

correspondiente para el otro.

• Segundo, se centró en los problemas de decisión NP que podían ser resueltos en tiempo

polinomial. La mayoría de problemas intratables, cuando son enunciados como problemas de

decisión, pertenecen a esta clase.

• Tercero, demostró que un problema en particular de NP, el de la satisfacibilidad

booleana (SAT), tiene la propiedad de que cualquier otro problema en NP puede ser reducible

en tiempo polinomial a él . SAT consiste en saber si una cierta expresión booleana con variables

y sin cuantificadores, tiene asociada una asignación de valores para sus variables que hace que

la expresión sea verdadera,.

Finalmente Cook probó que el problema SAT es el problema más duro de la clase NP, y

sugirió que otra serie de problemas compartían esta propiedad. Richard Karp analizo una serie


de problemas tan duros como SAT, entre ellos el del viajante. Estos problemas son tan difíciles

de resolver que es imposible encontrar un algoritmo mejor que simplemente realizar una

búsqueda exhaustiva de la solución, y esta clase se le denominó la clase de los problemas NP-

Completos.

Surge entonces la pregunta ¿Son los problemas NP-Completos intratables?


3.- La Teoría de NP-Completitud

3.1 Problemas de decisión, lenguajes y esquemas de codificación

La Teoría de NP-Completitud está diseñada para ser aplicada solo a problemas de

decisión, aquellos que tiene como respuesta si o no. De manera abstracta, un problema de

decisión consiste simplemente en un conjunto de instancias D y un subconjunto de instancias

positivas Y tal que DY ⊆ . Esto puede contener una gran cantidad de estructuras adicionales,

pero la manera estándar de describir un problema será con dos partes, primero la descripción de

una instancia genérica del problema en función de varias componentes, grafos, funciones,

números… y segundo una cuestión de si o no, en términos de la instancia genérica.

Para empezar, una instancia pertenece a D, si y solo si puede ser obtenida de la instancia

genérica sustituyendo objetos particulares de las componentes originales, y la instancia

pertenece a Y si y solo si la respuesta a la cuestión de estado es positiva. Por ejemplo:

Subgrafos isomorfos:

INSTANCIA: dos grafos, ( )111 , AVG = y ( )222 , AVG = .

CUESTIÓN: ¿contiene 1G un subgrafo isomorfo a 2G ? Es decir ¿existe un subconjunto

1' VV ⊆ y otro 1' AA ⊆ tal que 2' VV = , 2' AA = y existe una función ': 2 VVf → que

cumple que ')}(),({},{ 2 AvfufAvu ∈⇔∈ ?

También podemos transformar un problema de optimización en uno de decisión,

solamente añadiendo una cota y exigiendo, si es de minimización que no se supere esa cota, y

que se al menos esa en el caso de maximización.


Problema del viajante (TSP):

INSTANCIA: Tenemos un conjunto finito de ciudades C = [c1, c2 , …, cm] y de

distancias +∈ Zccd ji ),( para cada par de ciudades ci, cj de C, y una cota +∈ ZB .

CUESTIÓN: ¿existe un recorrido que pase por todas las ciudades de C con una longitud

de cómo mucho B? Es decir, preguntamos si existe una lista C = [c1, c2 , …, cm] de C, tal que:

Bccdccd m

m

iii ≤+

ΠΠ

−

=+ΠΠ∑ ),(),( )1()(

1

1)1()(

Entonces si tenemos una solución al problema de optimización del viajante en tiempo

polinomial, podremos resolver el problema de decisión asociado en tiempo polinomial. Solo

necesitaríamos encontrar el recorrido de mínima longitud, computarlo y compararlo con la cota

B. De manera que si el problema de decisión de viajante es NP-Completo, sabremos que el de

optimización es igual de difícil. Por lo que aunque centremos nuestra atención en los problemas

de decisión en la Teoría de NP-Completitud, las implicaciones se pueden extender a los

problemas de optimización. La razón de centrarnos en los problemas de decisión es porque tiene

un lenguaje muy natural para la teoría de computación. Definámoslo:

Para cualquier conjunto finito Σ de símbolos, denotamos *Σ al conjunto de todas las

cadenas de símbolos de Σ . Por ejemplo si Σ ={0,1} entonces *Σ sería por ejemplo

0,1,00,01,10,11,111,110, y cualquier otra cadena formada por ceros y unos. Si L es un

subconjunto de *Σ decimos que L es un lenguaje en el alfabeto Σ

Nuestro estándar de codificación transformará instancias en cadenas estructuradas en el

alfabeto {0, 1, -, [ ], ( ), ,}. Definimos para ello cadena estructurada:

1. Una cadena estructurada que representa el número entero k , es la

representación binaria de un entero k con una cadena de ceros y unos, precedido de un signo

menos si k es un número negativo.

2. Si x es una cadena estructurada representando al entero k, la cadena estructurada

[x] puede ser usada como una etiqueta.


3. Si mxxx ,...,, 21 son cadenas estructuradas representando los objetos

mXXX ,...,, 21 , entonces ),...,,( 21 mxxx es una cadena estructurada que representa la

secuencia mXXX ,...,, 21 .

3.2 Máquina determinista de Turing y la clase P

Necesitamos ahora fijar un modelo particular de computación para formalizar la noción

de algoritmo, este va a ser la máquina determinista de Turing con una sola cinta (conocida como

DTM). El concepto de máquina de Turing es usado para dar respuesta a la cuestión planteada

por David Hilbert sobre si las matemáticas son “decidibles”, es decir, si hay un método definido

que pueda aplicarse a cualquier sentencia matemática, y que nos diga si esa sentencia es cierta o

no. En 1936, Turing creó un modelo de computador y con ella probó que ciertos problemas eran

irresolubles por una máquina. Esta puede realizar cualquier computación que pueda hacer una

máquina digital.

Para definir un programa de una DTM, se necesita la siguiente información:

1. Un conjunto finito de símbolos Σ , distinto del espacio en blanco, denominado

alfabeto de máquina o de entrada.

2. Un conjunto finito de símbolos de cinta Γ , denominado alfabeto de cinta

)( Γ⊂Σ .

3. Un símbolo Σ−Γ∈b , denominado símbolo blanco. Es el único símbolo que

se puede repetir un número infinito de veces.

4. Un conjunto finito de estados Q, incluyendo un estado inicial 0q y otros dos

Yq y Nq estados finales de aceptación

Máster en Sistemas de Energía Eléctrica.

5. Una función parcial, denominada función de transición

}),{(: →Γ×− QqqQ NYδ

Donde el {-1,+1} representa un movimiento a la izquierda y

La máquina de Turing consta de un cabezal lector/escritor y una cinta infinita en la que el

cabezal lee el contenido, borra el contenido anterior y escribe un nuevo valor. Las operaciones

que se pueden realizar en esta máquina se limitan a avanzar el cabezal lector/escritor hacia la

derecha o avanzar el cabezal lector/escritor hacia la izquierda

Visualización de una má

La función δ de transición nos da el cómputo con una tabla de la forma

(estado, valor) (nuevo estado, nuevo valor, dirección

Esta tabla toma como parámetros el estado actual de la máquina y el carácter leído de la

cinta, dando la dirección para mover el cabezal, el nuevo estado de la máquina y el valor a ser

escrito en la cinta.

La entrada en una DTM es una cadena

manera que cada símbolo de

serán inicialmente símbolos blancos. El programa empieza su operación en el estado

computación entonces comienza paso por paso. Si el estado actual

finalizado, si no, el estado actual

escaneando habrá algún símbolo

),','(),( ∆= sqsqδ . El cabezal lector/escritor borra la

o -1 se desplazará una celda a la

pasa de q a q’, y esto completaría un paso de la computación.

Máster en Sistemas de Energía Eléctrica.

Una función parcial, denominada función de transición

}11{ +−×Γ×

1,+1} representa un movimiento a la izquierda y un movimiento a la derecha.




derecha o avanzar el cabezal lector/escritor hacia la izquierda

Visualización de una máquina de Turing, en la que se ve el cabezal y la cinta que se lee.

nos da el cómputo con una tabla de la forma

(nuevo estado, nuevo valor, dirección).

toma como parámetros el estado actual de la máquina y el carácter leído de la


La entrada en una DTM es una cadena *Σ∈x . Esta cadena se emplazará en la cinta de

manera que cada símbolo de x ocupará una celda de la cinta. El resto de las celdas de la cinta

inicialmente símbolos blancos. El programa empieza su operación en el estado

computación entonces comienza paso por paso. Si el estado actual q es Yq

i no, el estado actual q pertenece a }),{( NY qqQ− , y en la celda que estamos

mbolo Γ∈s , ejecutándose ),( sqδ . Supongamos entonces que

. El cabezal lector/escritor borra la s, y escribe s’ en su lugar,

a la izquierda o a la derecha. Simultáneamente el control de estado

, y esto completaría un paso de la computación.

Página 16

Una función parcial, denominada función de transición

movimiento a la derecha.




quina de Turing, en la que se ve el cabezal y la cinta que se lee.

toma como parámetros el estado actual de la máquina y el carácter leído de la


sta cadena se emplazará en la cinta de

resto de las celdas de la cinta

inicialmente símbolos blancos. El programa empieza su operación en el estado 0q , la

o Nq , habríamos

y en la celda que estamos

. Supongamos entonces que

en su lugar, según sea ∆ 1

imultáneamente el control de estado


Consideremos ahora el siguiente problema de decisión.

Entero divisible por 4:

INSTANCIA: Un numero positivo entero N

CUESTION: ¿Existe un entero positivo m tal que N=4m?

Con nuestro esquema de codificación estándar, el entero N es representado por una

cadena de ceros y unos, su representación binaria. Un número entero positivo es divisible por 4

si y solo si los dos últimos dígitos de su representación binaria son 0, ese programa para la DTM

resolvería nuestro problema de entero divisible por 4, bajo nuestro esquema de codificación

estándar.

Definimos entonces complejidad temporal, como el tiempo necesario para la

computación del programa M de DTM sobre la entrada x, y esto es el número de pasos que se

suceden en la computación hasta que es devuelto un estado final de aceptación.

Para un programa M de DTM que finaliza para todas las entradas *Σ∈x , su función de

complejidad temporal ++ → ZZTM : viene dada por:

max)( =nTM { m: donde m es el tiempo de computación de M sobre la entrada x, con

*Σ∈x y nx = }

Dicho programa M, es llamado de tiempo polinomial DTM, si existe un polinomio p tal

que para todo +∈ Zn , )()( npnTM ≤ . Definimos ahora la primera clase importante de

lenguaje, la clase P.

La clase de Complejidad P es el conjunto de los problemas de decisión para los que

existe un programa de tiempo polinomial en DTM que los resuelve.


3.3 Computación no-determinista y la clase NP

Antes de proceder a la definición formal de la clase NP, vamos a dar una idea intuitiva de

la noción informal de esta clase.

Consideramos el problema del viajante con un conjunto de ciudades, las distancias entre

ellas y la cota B ¿existe un recorrido que pase por todas las ciudades cuya longitud sea igual o

menor que B? No se conoce ningún algoritmo en tiempo polinomial que resuelva dicho

problema

Sin embargo alguien puede decir que para una instancia particular existe una solución

para la que la respuesta sea positiva, tan solo tendríamos que comprobar que esa solución es un

recorrido válido y su longitud es inferior a B, y este caso podría ser de tiempo polinomial, esto

mismo lo podríamos hacer con el problema de los subgrafos isomorfos. Dada una instancia

arbitraria I de este problema, consistente en dos grafos,( )111 , AVG = y ( )222 , AVG = , si

damos los subconjuntos 1' VV ⊆ , 1' AA ⊆ y la función ': 2 VVf → , es fácilmente

comprobable en tiempo polinomial que V’, A’, y f satisfacen todas las condiciones.

Con esto comprobaríamos que la clase NP es verificable en tiempo polinomial, pero esto

no implica que sea resoluble en tiempo polinomial. Podemos verificar si para un recorrido dado

para la instancia I la respuesta a nuestra cuestión es positiva en tiempo polinomial, pero no

buscar entre el exponencial número de posibilidades una solución de la forma deseada.

Definimos NP en términos de lo que llamaremos algoritmos no-deterministas. Veremos

que tales algoritmos están formados por dos escenarios diferentes, el escenario de conjetura y el

de comprobación. El escenario de conjetura se produce porque para ),( sqδ existe mas de una

posibilidad de actuación, y eso es lo que lo diferencia de los algoritmos deterministas. En los

algoritmos determinista para una misma entrada el resulado siempre es el mismo, en los no-

deterministas no es así, no se sabe a priori cual es el resultado. Dado una instancia I del

problema, el primer escenario simplemente plantea una estructura S. Entonces introducimos I y

S en el escenario de comprobación, este procesa de manera determinista normal ambas, y

entonces puede finalizar con una respuesta positiva, con una negativa o no parar y quedarse

procesando infinitamente. Por lo que un algoritmo no-determinista resuelve un problema de


decisión Π , con ΠD el conjunto de todas sus posibles instancias, si cumple para todo Π∈ DI

las siguientes dos propiedades:

1. Si Π∈YI entonces existirá una estructura S, propuesta para la entrada I, que

devolverá una respuesta positiva del escenario de comprobación para I y S.

2. Si Π∉YI entonces no existirá una estructura S, propuesta para la entrada I, que

devolverá una respuesta positiva del escenario de comprobación para I y S

Es decir descartamos el caso en el que no para. La clase NP podemos definirla de manera

informal, como la formada por todos los problemas de decisión Π , que bajo un esquema de

codificación razonable, pueden ser resueltos por un algoritmo no-determinista polinomial, es

decir, que la respuesta en el escenario de comprobación del algoritmo será positiva y en un

tiempo ρ polinomial. Cuando decimos resueltos nos acercamos mas al concepto de verificable

en tiempo polinomial, que al de una solución realista. El subconjunto ΠΠ ⊂ DY estaría formado

por esas instancias positivas.

Otro tema a tratar en los algoritmos no-deterministas es la falta de simetría entre la

respuesta positiva y la negativa. Un algoritmo determinista finaliza para cualquier entrada,

dando una respuesta positiva o negativa, pero esto no es así en los no-determinista, por ejemplo

en el caso del complementario al problema del viajante: Un conjunto de ciudades dadas, las

distancias entre ciudades y una cota ¿Es verdad que no hay ningún recorrido para todas las

ciudades con una longitud B o menor? Pues no hay manera de saber la respuesta hasta analizar

todas los posibles recorridos, es decir no habría ningún algoritmo no-determinista polinomial

para este problema. Esto ocurrirá para otros muchos problemas en NP. Si un problema Π

pertenece a P implica que su complementario también, la analogía en NP no es cierta.

La NDTM (máquina de Turing no-determinista) que vamos a usar, tiene exactamente la

misma estructura que la DTM, aumentada con un módulo de conjetura (que interpreta las

posibles salidas de ),( sqδ ) y un cabezal de solo escritura. Para la NDTM un programa se

especificará igual que para la DTM, la única diferencia es que la computación tiene lugar en dos

escenarios diferentes. Primero en el escenario de conjetura, en el que de la celda 1 en adelante

se escribiría la entrada x, el resto de celdas estarían en blanco, y entonces el cabezal de solo

escritura comienza en la celda -1 a escribir un símbolo del alfabeto de cinta Γ , y pasa a la celda


de la izquierda, en ese momento el módulo de conjetura se puede detener o continuar el proceso,

esto será arbitrario, tanto el parar y permanecer inactivo como el símbolo a escribir. En ese

momento comenzaría el estado de control en 0q , y daría comienzo al escenario de

comprobación, y lo hará siguiendo las mismas reglas que una DTM, y el módulo de conjetura y

su cabezal de solo escritura no intervendrían mas. El proceso de computación para cuando llega

a un estado final de aceptación, si este es Yq será una computación aceptable, si no para o

devuelve Nq será una computación inaceptable. Se puede decir que la NDMT es "el mejor

adivino posible", esto es, que siempre elige la transición que finalmente la llevará a un estado

final de aceptación

Cualquier programa M para una NDTM tendrá infinitas posibles computaciones para cada

entrada x, una por cada posible cadena de *Γ que se conjeture. Un programa M de NDTM

acepta x si al menos una de esas cadenas es una computación aceptable. El lenguaje reconocido

para M sería:

ML ={ *Σ∈x : M acepta a x}

El tiempo requerido por el programa M de NDTM para aceptar la entrada MLx∈ , es el

mínimo de número de pasos totales que se suceden en los escenarios de conjetura y

comprobación hasta que es devuelto el estado final de aceptación Yq , de entre todas las

computaciones aceptables para x de M.

La función de complejidad temporal ++ → ZZTM : para M sería:

max)( =nTM [{1} U { m: donde m es el tiempo de computación de M para aceptar x, con

MLx ∈ y nx = }]

)(nTM dependerá solo del número de pasos de las computaciones aceptables, en caso de

no haber ninguna entrada de longitud n aceptada se fija )(nTM =1.


Dicho programa M es llamado de tiempo polinomial NDTM si existe un polinomio p tal

que para todo +∈ Zn , )()( npnTM ≤ . Definimos ahora la primera clase importante de

lenguaje, la clase NP.

La clase de Complejidad NP es el conjunto de los problemas de decisión para los que

existe un programa de tiempo polinomial en NDTM que los resuelve.

3.4 La relación entre P y NP

Después de los dos apartados previos podemos intuir que NPP ⊆ . Cualquier algoritmo

determinista puede ser usado como escenario de comprobación de uno no-determinista, tan solo

tendríamos que ignorar la conjetura. Todo parece indicar entonces, que esa contención es

estricta y no de igualdad, no conocemos ningún método que convierta NP en P. De hecho el

mejor resultado que podemos dar a este respecto sería:

Teorema: Si NP∈Π , entonces existe un polinomio p tal que Π puede ser resuelto por

un algoritmo determinista con una complejidad temporal de )2( )(npO .

Demostración: Supongamos que tenemos A un algoritmo no-determinista que resuelve

Π , y q(n) una cota polinomial de A. Al ser q una cota polinomial, tomando 1c y 2c lo

suficientemente grandes, podemos asumir que 21)( cncnq = . Sabemos entonces por ser

NP∈Π , que para toda entrada aceptada de longitud n, existe una cadena extraída del

escenario de conjetura, de longitud q(n), que resulta positiva tras el escenario de comprobación

en no más de q(n) pasos. Entonces el número de posibles cadenas de conjetura es al menos

)(nqk , donde Γ=k , cualquier cadena de longitud menor de q(n), puede ser rellenada con

celdas en blanco hasta la longitud q(n). Tenemos pues que en el escenario de comprobación para

A, para una entrada de longitud n la computación será aceptable, al aplicar la comprobación

determinista, como mucho tardará q(n) pasos para cada una de las )(nqk posibles cadenas

conjeturadas. De manera que la computación dará una respuesta positiva, si encuentra una


cadena conjeturada que encabece una computación aceptable dentro del tiempo acotado, si no la

respuesta será negativa. Esto claramente es un algoritmo determinista que resuelve Π , y su

complejidad temporal es q(n) )(nqk , que aunque exponencial, es de orden )2( )(npO para un

cierto polinomio p.■

Realmente no tenemos una demostración estricta de NPP ≠ , pero si podemos afirmar

que parece lo más razonable después del tiempo y las investigaciones empeñadas en probarlo,

pero es un problema aún abierto a demostración.

3.5 Transformaciones polinomiales y NP-Completos

Si NP difiere de P, hay una distinción importante entre P y PNP− , todos los problemas

de P son resolubles en tiempo polinomial, mientras que todos los problemas de PNP− son

intratables. Mientras no probemos que NPP ≠ , no podemos mostrar ningún problema que

pertenezca a PNP− , por eso la Teoría de la NP-Completitud se centra en resultados del tipo si

NPP ≠ entonces PNP−∈Π . La idea clave para ello serán las transformaciones

polinomiales.

Una transformación polinomial de un lenguaje *11 Σ⊆L en otro *

22 Σ⊆L , es una función

*2

*1: Σ→Σf que cumplen las dos condiciones siguientes:

1. Existe una programa polinomial DTM que computa f.

2. Para todo *1Σ∈x , 1Lx∈ si y solo si 2)( Lxf ∈ .

Denotamos una transformación polinomial de 1L en 2L por 21 LL ∝ . La importancia de

esta aplicación viene del siguiente Lema


Lema 3.1: Si 21 LL ∝ , entonces si PL ∈2 implica que PL ∈1 , y de manera equivalente

si PL ∉1 implica PL ∉2 .

Demostración: Sean 1Σ y 2Σ los lenguajes respectivos de 1L y 2L . Sea *2

*1: Σ→Σf

una transformación polinomial de 1L en 2L , fM un programa polinomial DTM que computa a

f, y sea 2M un programa polinomial DTM que reconoce a 2L . Podemos construir entonces un

programa polinomial DTM que reconozca a 1L , haciendo una composición con fM y 2M .

Tomamos *1Σ∈x , y le aplicamos la parte que corresponde a fM , y obtenemos *

2)( Σ∈xf .

Aplicamos entonces la parte de 2M para determinar si 2)( Lxf ∈ . Como 1Lx∈ si y solo si

2)( Lxf ∈ , tendremos un programa DTM que reconoce a 1L . Este programa será polinomial,

consecuencia directa de que fM y 2M lo son, entonces ),()( xpxf f≤ y el tiempo de

ejecución sería )))(()(( 2 xppxpO ff + , que está acotada por un polinomio en x .■

Si tenemos los problemas de decisión 1Π y 2Π , podemos definir una transformación

polinomial del problema 1Π en el problema 2Π , a la función 21

: ΠΠ → DDf que satisface:

1. f es computable por un algoritmo polinomial

2. Para todo 1Π∈ DI ,

1Π∈YI si y solo si2

)( Π∈YIf .

Veamos un ejemplo. En la región de Kashemir, un poeta llamado Rudrata se hizo la

siguiente pregunta ¿Se pueden visitar todos los cuadros de un tablero de ajedrez, sin repetir

ningún cuadro, en un camino que acabe en el cuadro de inicio y realizando tan solos los

movimientos que puede hacer el rey en el ajedrez? Sin saberlo, Rudrata planteó un problema de

teoría de grafos:

Para un grafo G=(V, A) un circuito simple de G, es una secuencia kvvv ,...,, 21 de

distintos vértices de V , tal que { }1, +ii vv es una arista de A para todo i. Un circuito

Hamiltoniano de G, es un circuito cerrado simple que incluye todos los vértices de G.

Definamos un problema, también conocido como Circuito de Rudrata:


Circuito Hamiltoniano (Circuito de Rudrata):

INSTANCIA: Un grafo G=(V, A)

CUESTIÓN: ¿contiene G un circuito Hamiltoniano?

Vamos a demostrar que el problema del Circuito Hamiltoniano (PCH) se puede

transformar en el problema del Viajante (TSP). Para ello vamos a necesitar una función f que

transforme cada instancia de PCH en otra correspondiente de TSP, y probar que esa función

cumple las dos propiedades exigidas a toda transformación polinomial.

Definamos f, supongamos G=(V,A), con mV = , es una instancia del PCH. La instancia

correspondiente del TSP tiene un conjunto de ciudades C, que es exactamente igual que V. Para

cualesquiera dos ciudades Cvv ji ∈, , la distancia ),( ji vvd será 1 si { } Avv ji ∈, y 2 en el caso

contrario. La cota B de longitud del recorrido será m.

Podemos ver fácilmente que f es computable por un algoritmo polinomial, solo habría que

ver que para cada una de las m(m-1)/2 distancias )( ji vvd especificadas,{ } Avv ji ∈, , así se

cumpliría la primera condición. Para la segunda habría que probar que G contiene un Circuito

Hamiltoniano si y solo si existe un recorrido para todas las ciudades en f(G) con una longitud no

superior a B. Supongamos que mvvv ,...,, 21 es un Circuito Hamiltoniano de G, entonces

mvvv ,...,, 21 es también un recorrido de f(G), y este tiene una longitud total de m=B, porque la

distancia recorrida entre cada dos ciudades corresponde con una arista de G por lo que la

distancia es 1. Igualmente supongamos que mvvv ,...,, 21 es un recorrido de f(G) con una

longitud total no superior a B. Como entre dos ciudades la distancia es 1 o 2, y tenemos que m

es la distancia total una vez computado el recorrido, el hecho de que m=B implica que la

distancia entre dos ciudades recorridas es 1 exactamente. Por la propia definición de f(G)

tenemos que { }1, +ii vv , con mi <≤1 y { }1,vvm , son todas aristas de G, y por tanto

mvvv ,...,, 21 es un Circuito Hamiltoniano de G.


Tenemos entonces que TSPPCH ∝ , es decir que si el TSP puede ser resuelto por un

algoritmo en tiempo polinomial, también lo será el PCH, y si PCH es intratable también lo será

el TSP.

En contraposición a esto tendríamos un circuito Euleriano. En 1735 Leonhard Euler,

mientras caminaba por la ciudad Königsberg en Prusia, cruzando el rio a través de sus puentes

se sintió frustrado al notar que por mas vueltas que le daba no le era posible hacer un camino de

manera que cruzara todos los puentes una sola vez, con este problema nació la Teoría de Grafos.

Euler afirmo que la ruta de los puentes era deficiente, consistía en el siguiente grafo:

Como conclusión Euler resolvió que para que tuviera solución, el grafo tenía que ser

conexo, es decir no podía haber vértices con grado 0, y que todos los vértices tenían que tener

grado par, excepto dos, el inicial y el final que pueden tener grado impar. De aquí podemos

obtener un problema de decisión: Dado un Grafo ¿existe un camino que contiene cada arista una

sola vez? Y esto es resoluble en tiempo polinomial.

Siendo un problema muy similar al del Circuito Hamiltoniano, uno es resoluble en tiempo

polinomial y otro no. La diferencia que nos reporta tal disparidad computacional es tan solo que

uno pasa por todas las aristas y otro por todos los vértices.

Hay que destacar que la Transformación polinomial verifica la propiedad transitiva:

Lado Norte

Isla Pequeña

Lado Sur

Isla Grande


Lema 3.2: Si 21 LL ∝ y 32 LL ∝ , entonces 31 LL ∝ .

Demostración: Sean 1Σ , 2Σ y 3Σ los alfabetos de los lenguajes 1L , 2L y 3L ,

respectivamente *2

*11 : Σ→Σf es una transformación polinomial de 1L en 2L y *

3*22 : Σ→Σf

lo es de 2L en 3L . Entonces la función *3

*1: Σ→Σf definida como ))(()( 12 xffxf = para

todo *1Σ∈x nos valdría como transformación de 1L en 3L . Claramente 3)( Lxf ∈ si y solo si

1Lx∈ . Bastaría entonces usar un argumento análogo al del lema anterior, para demostrar que f

es computable por un programa polinomial en DTM.■

Podemos definir entonces dos lenguajes 1L y 2L , que sean polinomialmente equivalentes

ambos 21 LL ∝ y 12 LL ∝ (sería análogo para dos problemas de decisión 1Π y 2Π ). La

relación ""∝ impone un orden entre las clases de lenguaje. De hecho la clase P estaría formada

por los lenguajes de computación más sencillos (problemas de decisión). Igualmente la clase de

lenguajes (problemas) NP-Completos, estaría formada por los lenguajes (problemas de decisión)

más difíciles en NP.

Un lenguaje L se define NP-Completo si NPL∈ , y para cualquier otro lenguaje

NPL ∈' , tenemos que LL ∝' . Informalmente, un problema de decisión Π es NP-Completo si

NP∈Π y para cualquier otro problema de decisión NP∈Π' , tenemos que Π∝Π' . El Lema

3.1 nos identifica entonces a los problemas NP-Completos, como los problemas más difíciles en

NP. Si cualquier problema NP-Completo puede ser resuelto en tiempo polinomial, entonces

todos los problemas de NP podrán ser resueltos. Como conclusión si un problema de decisión

Π es NP-Completo, y con la propiedad vista al principio de esta sección 3.5, NPP ≠ entonces

PNP−∈Π . Es como decir que si Π es NP-Completo, P∈Π si solo si NPP = .

Al principio asumimos que NPP ≠ , junto con la conclusión que hemos obtenido nos

hace pensar que NP no va a estar dividido solo en dos partes en la P y la de NP-Completos.

Existirán problemas que no son resueltos en tiempo polinomial por una DTM pero que tampoco

son NP-Completos.


Al centrarnos en los NP-Completos, nos damos cuenta que tal y como hemos construido

nuestra teoría, no es tan obvio demostrar que cualquier problema en NP se puede transformar en

nuestro futuro problema Π NP-Completo, incluso no es tan evidente que exista ningún

problema NP-Completo. Con el siguiente Lema que vamos a enunciar, consecuencia directa de

la propia definición de ""∝ , se simplificará todo si tenemos un problema que sepamos que es

NP-Completo.

Lema 3.3: Si 1L y 2L pertenecen a NP, 1L es NP-Completo y 21 LL ∝ entonces 2L es

NP-Completo.

Demostración: Como 2L pertenece a NP, solo tendremos que demostrar que para todo

NPL ∈' , se cumple que 2' LL ∝ . Consideramos pues cualquier NPL ∈' , y tenemos que 1L es

NP-Completo, entonces se cumple que 1' LL ∝ . Por la transitividad de ""∝ y la condición de

que 21 LL ∝ entonteces tenemos que 2' LL ∝ .■

Si trasladamos este resultado de lenguajes a problemas de decisión, tenemos una nueva

herramienta para probar nuevos problemas NP-Completo, una vez que tengamos al menos un

problema conocido que se NP-Completo. Para ver que Π es NP-Completo, solo hará falta

probar que:

1. NP∈Π

2. Algún problema conocido 'Π que sea NP-Completo, y se transforma en Π .

Para usar este resultado seguimos necesitando ese problema inicial NP-Completo. Es

Cook en su teorema fundamental quien nos lo aporta.


3.6 Teorema de Cook

Para estudiar el Problema de decisión de la satisfacibilidad booleana, abreviado en

SAT, debemos introducir ciertos conceptos.

Sea { }muuuU ,...,, 21= un conjunto de variables booleanas, definimos una asignación

de valor para U: es una función { }FVUt ,: → . Si t(u)=V decimos que u es verdadero bajo t, si

t(u)=F decimos que u es falsa bajo t. Si u es una variable en U, entonces u y _

uson calificativos

sobre U. El calificativo u es verdadero bajo t si y solo si la variable u es verdadera bajo t. y el

calificativo u es verdadero si y solo si la variable u es falsa.

Una cláusula sobre U es un conjunto de calificativos de U, como { }531 ,, uuu , será

satisfacible por una asignación de valor si y solo si al menos uno de sus miembros es verdad

bajo esa asignación. En el ejemplo anterior la cláusula será satisfactible a menos que Fut =)( 1 ,

Fut =)( 3 y Vut =)( 5 . Una colección C de cláusulas de U puede ser satisfacible si y solo si

existe alguna asignación de valor para U, que satisfaga simultáneamente todas las cláusulas de

C. A esa asignación se le denomina asignación de valor satisfacible para C.

Satisfacibilidad (SAT):

INSTANCIA: Un conjunto U de variables y una colección C de cláusulas sobre U.

CUESTIÓN: ¿existe una asignación de valor satisfacible para C?

Por ejemplo { }21,uuU = y

= 2121 ,,, uuuuC , nos da una instancia SAT para la

que la respuesta es positiva. Una asignación de valor satisfacible sería Vutut == )()( 21 . Si

cambiamos C por

= 12121 ,,,,' uuuuuC , no será satisfacible. Es un problema de

búsqueda muy típico.


Teorema de Cook: SAT es NP-Completo

Podemos encontrar la demostración a éste teorema en “ The Complexity of theorem

Proving Procedures” [2] o en “Computer and Intractability, A Guide to the Theory of NP-

Completeness” [1].

Aunque interesante, la demostración de este teorema se aleja del fin de este trabajo, por lo

que la dejamos aparte, teniendo en cuenta que es una demostración extensa y compleja. Si para

cada problema NP-Completo, hubiese que construir una demostración igual, posiblemente no

habría crecido tan rápido como lo ha hecho, ni tendría tanto interés.

Este problema tiene una gran importancia, en aplicaciones tanto de diseño de

ordenadores, software de ingeniería, para testeo de chips… Como en el ejemplo anterior,

podemos buscar entre todas las asignaciones de valor satisfacibles, una por una, pero cuando

tengamos formulas con n variables el numero de asignaciones posibles será de 2�.

Dada la importancia del problema de decisión SAT, los últimos 50 años numerosos

investigadores han tratado de encontrar maneras eficientes de resolver el problema, pero sin

éxito. Los algoritmos más rápidos que tenemos a día de hoy son todavía exponenciales para sus

entradas más desfavorables. Sin embargo en el camino se han encontrado algoritmos eficientes

para SAT de dos variables naturales. Si todas las clausulas contienen como mucho una variable

positiva, entonces la fórmula booleana es llamada fórmula Horn, y se puede encontrar una

asignación de valor satisfacible en tiempo lineal, si es que existe. Si todas las clausulas tienen

solo dos variables, entonces la teoría de grafos nos puede resolver el problema SAT en tiempo

lineal, un caso particular de este sería 2-SAT. Sin embargo si añadimos una variable mas a todas

las clausulas tendríamos 3-SAT y como veremos este es NP-Completo.


4.- Demostraciones de resultados NP-Completos

Una vez tenemos probado un problema NP-Completo, el procedimiento para probar los

demás se simplifica enormemente. Dado un problema NP∈Π , todo lo que tenemos que hacer

es demostrar que algún problema 'Π que sea NP-Completo puede ser transformado en Π . Por

lo que de ahora en adelante el esquema a seguir en una demostración será el siguiente:

1. Probar que NP∈Π .

2. Seleccionar un problema conocido 'Π NP-Completo.

3. Construir una transformación f de 'Π en Π .

4. Y probar que f es una transformación polinomial.

Veamos ahora uno de los problemas básicos, de los primeros “problemas NP-Completos

conocidos”, y vamos a estudiar a fondo la demostración completa del problema 3-SAT, como

ejemplo para entender los procedimientos y pasos que hay que dar.

4.1 3-Satisfacibilidad (3-SAT)

INSTANCIA: Sea { }mcccC ,...,, 21= una colección de cláusulas, de un conjunto finito

de variables U, tal que 3=ic para mi ≤≤1


CUESTIÓN:¿Existe una asignación de valor satisfacible para C en U?

Este problema no es mas que una restricción de SAT, en el cual hay exactamente 3

calificativos por cláusula, sin embargo está estructura simple, lo hace uno de los problemas mas

usado para probar otros problemas NP-Completos

Teorema 4.1: 3-SAT es un problema NP-Completo.

Demostración: Primero habría que probar que 3-SAT es NP. Esto es fácil de ver, ya que

un algoritmo no-determinista necesitaría solo tomar una asignación de valor para las variables y

comprobar en tiempo polinomial, si la asignación satisface todas las cláusulas 3-calificativas de

C o no.

Ahora transformaremos SAT en 3-SAT. Sea { }nuuuU ,...,, 21= un conjunto de variables

y { }mcccC ,...,, 21= un conjunto de cláusulas que constituyen una instancia arbitraria de SAT.

Construiremos entonces una colección C’ de cláusulas 3-calificativas de un conjunto de

variables U’ , tal que C’ sea satisfacible si y solo si C lo es también.

La construcción de C’ la haremos sustituyendo cada cláusula individual Cc j ∈ por una

colección jC' de cláusulas 3-calificativas, basada en las variables originales de U y algunas

variables adicionales de jU ' , cuyo uso será limitado a las cláusulas de jC' . De manera que nos

quedaría:

∪=

=Um

jjUUU

1

'' y por otro lado Um

jjCC

1

''=

=

De este modo solo nos quedaría probar como podemos construir jC' y jU ' a partir de los

jc . Sea { }kj zzzc ,...,, 21= , donde los elementos iz son calificativos derivados de las variables

de U. La definición de jC' y jU ' va a depender de k, diferenciando 4 casos


1. k = 1. { }21 ,' jjj yyU = y { }{ }{ } { }{ }211

211

211

211 ,,,,,,,,,,,' jjjjjjjjj yyzyyzyyzyyzC =

2. k = 2 { }1' jj yU = y { }{ }{ }121

121 ,,,,,' jjj yzzyzzC =

3. k = 3 φ=jU ' y { }{ }jj cC ='

4. k > 4 { }31:' −≤≤= kiyU ijj y

{ }{ } { }{ } { }{ }kkkj

iji

ijjj zzykiyzyyzzC ,,41:,,,,' 1

312

121 −

−++ ∪−≤≤∪=

Para probar que esto es una transformación en si, tenemos que probar que el conjunto de

cláusulas C’ es satisfacible si y solo si C lo es. Supongamos que { }FVUt ,: → es una

asignación de valor satisfacible para C. Veamos ahora que t se puede hacer extensivo a una

asignación de valor { }FVUt ,':' → satisfacible para C’. Para situarnos, esta t’ sería la f(t), con f

la función que estamos probando que es una transformación polinomial.

Las variables que formarían U’-U , son conjuntos de la forma jU ' , y por definición, las

variables que forman cada jU ' pertenecen solo a jC' , necesitamos entones ver que podemos

extender t a los conjuntos de jU ' para cada caso. Para ello verificaremos que para cada uno de

los casos, todas las cláusulas en la correspondiente jC' , son satisfacibles.

Si jU ' se ha construido como en el caso 1. o el caso 2. las cláusulas en jC' son ya

satisfacibles por t, por lo que podemos extenderlo a jU ' añadiendo variables de este

arbitrariamente, de manera que Tyt =)(' para todo y perteneciente a jU ' .

En el caso 3. jU ' está vacía y la única cláusula que habría en jC' es ya de hecho

satisfacible por t.

Y en el caso 4. Con k > 3, partimos de que t es una asignación de valor satisfacible para

C, es decir que todas las cláusulas de C son satisfacibles. Es decir, como { }mcccC ,...,, 21= , a


su vez esas { }kj zzzc ,...,, 21= y t es una asignación de valor satisfacible para C , existirá al

menos un entero l, tal que el calificativo lz es verdadero bajo t. Si l es 1 o 2 fijamos entonces

Fyt ij =)(' para 31 −≤≤ ki , en la primera cláusula Vzt l =)(' o Vzt =)(' 2 , y para el resto

de cláusulas Fyt ij =)(' pero por el contrario Vyt i

j =− )(' 1 , por lo que serían todas satisfacibles.

Igualmente si l es k – 1 o k, basta tomar Vyt ij =)(' para 31 −≤≤ ki . Para cualquier otro valor

de l, tomaremos Vyt ij =)(' para 21 −≤≤ li y Fyt i

j =)(' para 31 −≤≤− kil . Con esto

nos garantizamos que todas las cláusulas de jC' serán satisfacibles, por lo que C’ satisfacible

por t’ . Nos quedaría ver entonces que si t’ es una asignación válida para C’, también lo es en C.

Es muy fácil ver que la restricción de t’ a las variables de U es una asignación de valor

satisfacible para C. Por lo que C’ sea satisfacible si y solo si C lo es también.

Para ver que esta transformación puede ser ejecutada en tiempo polinomial, es suficiente

con observar que el número de cláusulas 3-calificativas en C’ está acotado por mxn. Ya que el

tamaño deuna instancia 3-SAT está acotada por una función polinómica del tamaño de la

instancia de SAT, y ésta estará acotada por construcción.■

Seguidamente vamos a comentar el resto de problema que podemos considerar básicos

dentro de los NP-Completos.

4.2 Presentación de Problemas

Vamos a ver a continuación una serie de problemas que serían los que completarían lo

que podemos llamar el conjunto básico de problemas de la clase NP-Completos:


4.2.1 Corte y Bisecciones

Un corte es un conjunto de aristas de un grafo de manera que si las quitamos de dicho

grafo, este pasa a ser un grafo disconexo. Un problema interesante es encontrar el Corte

Mínimo, dado un grafo y una cota b encontrar un corte de como mucho b aristas. Pongamos un

ejemplo:

En esta caso el Corte Mínimo sería 3. Este es un problema que puede ser resuelto en

tiempo polinomial, utilizando la computación de lujo máximo n-1: Damos a cada arista un valor

de capacidad 1, y buscamos el flujo máximo entre un vértice fijado y el resto de vértices. El

vértice que tenga menor flujo será la solución al problema de Corte Mínimo.

En la gran mayoría de grafos, como en el del ejemplo, este problema y esta solución lo

que nos deja es un grafo con un vértice menos que el original y por otro lado un vértice aislado,

es decir el corte simplemente sería anular todas las aristas adyacentes al vértice con menor

valencia. Un problema mucho mas interesante que este, encontrar pequeños cortes que dividan

el grafo original en dos grafos de casi el mismo tamaño. Dicho problema se llama Corte

Equilibrado: Dado un grafo con n vértices y una cota b, partir el grafo en dos conjuntos de

vértices S y T, de manera que tanto S como T, son de orden mayor o igual que �/3y a su vez

como mucho existen b aristas entre S y T. Este sería de nuevo un problema NP-Completo.


4.2.2 Programación Lineal Entera

Como ya sabemos el método del simplex para programación lineal no es de tiempo

polinomial, aunque hay otros algoritmos para resolver problemas de programación lineal que si

son algoritmos polinomiales. La situación cambia cuando se le añaden a la función lineal

objetivo y las inecuaciones lineales, la condición de que las variables tiene que tener valores

enteros. Esto es conocido como Programación Lineal de Entera (ILP). Este problema lo

podemos transformar en un problema de búsqueda de la siguiente manera:

Tenemos un sistema de inecuaciones lineales �� , donde A es una matriz mxn y b es

un m-vector, una función objetivo dada por un n-vector c, y por último un valor g, equivalente a

una cota en los problemas de maximización. Buscamos entonces un n-vector x no negativo de

enteros tal �� y �� .

Pero nos encontramos con una redundancia en el sistema, ya que la condición �� es

también una inecuación y puede ser absorbida por el sistema �� . Por lo que podemos

definir directamente el problema de búsqueda ILP como sigue: Dadas A y b, encontrar un vector

entero no negativo x tal que �� o responder que no existe. A día de hoy no hay un

algoritmo eficiente para este problema.

Un caso particular de PLE que es muy complejo en si mismo, es aquel que se pide además

que el vector x buscado sea un vector ceros y unos, satisfaciendo que �� 1 Donde A es una

matriz de mxn, con ceros y unos de entradas y 1 es un m-vector de unos. Este problema es

conocido como ZOE (Zero-OneEquations).

4.2.3 Enlace 3-Dimensional (3DM)

Este problema surge como ampliación del 2-dimensional, que consiste en dado un grafo

bipartito con n vértices en cada lado, y una serie de aristas que van desde los vértices de un

subgrafo a los del otro. Encontrar un conjunto de n aristas, que unan cada vértice de un subgrafo

con solo un vértice del otro subgrafo, devolviendo n parejas de vértices, sin repetir ninguno y


con la condición que entre cada par exista una arista, o concluir que no existe dicho conjunto.

Este problema también es resoluble reduciéndolo a un problema de flujo máximo.

El caso 3-dimensional es igual simplemente añadiendo un subgrafo mas de manera que la

solución sería un lista de n ternas (b, g, p ), compatibles, es decir unidas mediante aristas cada

elemento de cada terna, y sin repetir ningún elemento de las n ternas. Este problema sin

embargo es NP-Completo

4.2.4 Conjunto Independiente, Cobertura de Vértices y Clique

Dado un grafo y un número entero g, En el Conjunto Independiente se trata de buscar g

vértices independientes, es decir, que no existan dos de ellos que estén unidos por una arista. En

el caso de que tengamos que resolver un árbol existen algoritmos eficientes, pero si tomamos un

grafo general, no se conoce algoritmo en tiempo polinomial que lo resuelva

Otro problema de búsqueda sería el de Cobertura de Vértices, que consiste en dado un

grafo y un numero natural b, encontrar b vértices que cubran todas las aristas, es decir que de el

grafo dado no quede ninguna arista sin tocar por alguno de los b vértices. Este problemas está

muy relacionado con el anterior, son complementarios.

Clique consiste en dado un grafo y una cota g, encontrar un conjunto de g vértices del

grafo tal que todas las aristas posibles entre esos g vértices están presentes en el grafo.

4.2.5 Knapsack

Tenemos un conjunto finito U, formado por una serie de elementos u, cada elemento tiene

asociado un peso w(u) y un valor v(u). Se nos da también un peso W y un valor V, todos ellos

enteros positivos. Ahora se trata de encontrar un subconjunto U` de U de manera que para cada

u de U´ , la suma de todos los pesos de U` sea menor igual que W y que la suma de todos lo


valores de los u de U` son mayores o igual que V. Y como siempre, si no existe dicho U`, que

devuelva no existe.

Para la resolución de este problema, tampoco existe a día de hoy un algoritmo polinomial.

Sin embargo como curiosidad, si reformulamos el problema y a la hora de introducir los

números enteros positivos de la instancia lo hacemos en código unario, por ejemplo escribiendo

7 como IIIIIII. Aunque parezca una pérdida de tiempo, este problema, el cual es conocido como

Knapsack Unario, si es resoluble por un algoritmo polinomial.

4.3 Demostraciones

Para demostrar que los Problemas vistos antes pertenecen a la clase de NP-Completos,

usaríamos el esquema siguiente:

SAT

3SAT

CONJUNTO INDEPENDIENTE 3DM

COBERTURA DE VÉRTICES CLIQUE ZOE

KNAPSACK CIRCUITO HAMILTONIANO ILP

TSP

Como vimos, la propiedad transitiva de las transformaciones será la herramienta

principal a usar, y con ella podemos pasar de que SAT es NP-Completo, a probar que los demás

son también NP-Completos. Todas estas demostraciones las podemos encontrar en “Computer

and Intractability, A Guide to the Theory of NP-Completeness” [1] y en “Algorithms” [4]. No

las vamos a analizar ya que se escapan del fin de este proyecto, y algunas son bastante


complejas. Si es interesante saber que nos podemos desplazar de unos problemas a otros, siendo

la mayoría muy diferentes entre ellos, usando transformaciones. Vamos a ver a continuación

uno de los casos mas sencillos que si nos será útil para el siguiente punto de nuestro proyecto,

simplemente como ejemplo.

4.3.1 De Camino de Rudrata(s,t) a Circuito de Rudrata

Vamos a empezar dándole una vuelta de rosca al problema del Circuito de Rudrata.

Teníamos un grafo y buscábamos un circuito que pasara una vez por cada uno de los vértices

del grafo, un problema muy similar sería el Camino de Rudrata (s,t), consiste en encontrar un

camino que vaya de s a t pasando por todos los vértices del grafo dado solo una vez. ¿Será más

fácil el Circuito de Rudrata que el Camino de Rudrata (s,t)? Vamos a demostrar que no.

Vamos a hacer una transformación de una instancia (G=(V,E), s, t) del Camino de

Rudrata (s,t), en una instancia del Circuito de Rudrata G’(V’,E). Para ello construimos G’ como

G añadiéndole un nuevo vértice x y dos nuevas aristas {s,x} y { x,t}.

Tenemos entonces �� y �� , ��, ��, ��, Pasaremos de un Circuito

de Rudrata de G’, al recorrido del Camino de Rudrata (s ,t), y para ello borraremos las aristas

{ s,x}y{ x,t} del circuito. Quedaría el esquema que sigue:

Veamos entonces ambos casos, cuando tenemos solución y cuando no, para ver la

validez de la transformación:

Instancia: G=(V,E) nodos s,t

Añadir x, y las aristas { s,x},{ x,t}

CIRCUITO DE

RUDRATA

Borrar las aristas{s,x},{ x,t}

Camino de Rudrata (s,t)

G’= (V’,E’)

Solución: Circuito

no hay solución

Solución: Camino

No habría solución


• Si el circuito de Rudrata tiene solución, el vértice x tendrá dos vecinos, estos

serán únicos por construcción de G’, y el circuito pasara por las aristas {s,x} y

{ x,s}. El resto del circuito pasará por todas los vértices que restan, haciendo una

ruta desde s a t. Por lo que borrando las dos aristas {s,x} y {x,t}del circuito, nos

deja un camino que va desde s a t en el grafo original G.

• Si el circuito de Rudrata no tiene solución, vamos a ver que la instancia original

del Camino de Rudrata (s,t) tampoco tendrá solución. Lo haremos viendo que si

existiese tal camino existiría el circuito, entonces tendríamos una contradicción.

Esto es muy sencillo, solo tenemos que añadir dos aristas {s,x} y {x,t} al camino

de Rudrata y tendríamos el Circuito y la contradicción

Faltaría por ver un detalle para que la transformación sea valida, y es ver que las

funciones que usamos en los dos procesos de pasar de camino a circuito y viceversa son

polinomiales, en este caso es trivial.

Igual de fácil sería ir en el otro sentido, transformar el Circuito de Rudrata al Camino de

Rudrata (s,t). Con estas dos transformaciones tendríamos que los dos problemas son en esencia

el mismo, parece razonable viendo que los problemas eran muy similares. En los casos que

dejamos pendientes, en apariencia son muy diferentes unos de otros, y sin embargo mediante

transformaciones, se puede ver que son esencialmente iguales.

Una vez hecha la introducción a la Teoría de NP-Completitud, y visto algunos de sus

problemas mas característicos NP-Completos, vamos a pasar a la optimización de brigadas. Para

ello vamos a empezar por explicar en que consiste nuestro problema.


5.- Planes de Contingencia

En el Centro de Control de Media Tensión de la red eléctrica, una de las consignas

principales aparte de la seguridad y la calidad del servicio, es la reducción del Tiepi, es decir, en

la medida de lo posible tener con servicio en todo momento al mayor número de clientes

posibles. En el día a día de un centro de control de la red, hay que hacer una serie de trabajos de

mantenimiento (programados), reparación de averías (imprevistos) y otros de vigilancia de la

red eléctrica. Tanto en los trabajos programados como en las averías, uno de los más delicados

son los Ceros en Subestación, por las afectaciones que pueden producir y porque requieren de

muchas maniobras. Para optimizar, tanto las maniobras como las afectaciones, y la calidad del

servicio dado al cliente, se hacen estudios previos teóricos de las posibles situaciones que nos

podemos encontrar con Ceros en Subestaciones. De manera que llegado el momento de una

avería o defecto en una Subestación, tengamos un plan de actuación definido, y aprovecharlo a

la hora de un Trabajo programado que requiera un Cero de Subestación.

Para los planes de contingencia se tienen previstas diferentes situaciones que se pueden

dar y que tienen diferencias considerables de actuación:

• Que el Cero se produzca en día laborable y hora punta.

• Que el Cero se produzca en día laborable y hora valle.

• Que el Cero se produzca en día festivo y hora punta.

• Que el Cero se produzca en día festivo y hora valle.

A la vez en cada uno de los casos, hay que estudiar dos posibilidades: que se pueda, o no,

usar las barras de Media Tensión de la subestación. Como aclaración, hora punta sería la de


cargas máximas, y valle la de cargas medias o bajas, dependiendo de si las líneas son de zona

residencial, zona comercial o industrial coincidirán con unos horarios u otros.

Haciendo un cálculo rápido a nivel de Centro de Control de la Zona sur de España, en

Andalucía y Badajoz, tenemos del orden de 360 Subestaciones. Si de cada una hay que estudiar

8 escenarios posibles, el total hace unos 2720 estudios de Ceros de Subestaciones. Por supuesto

no se tarda lo mismo en unos que en otros, por las configuraciones de las Subestaciones, y se

podrán reutilizar muchos cálculos de unos a otros, pero aún así el tiempo a dedicar es muy

elevado y costoso.

Una de las metas a la que debemos aspirar, usando las herramientas que tenemos a día de

hoy, es conseguir mediante algoritmos y programación, que estos estudios se puedan hacer de

manera automática y optimizada. Esta es una tarea ardua, y compleja. Además hay que tener en

cuenta que la red eléctrica es una red viva que va cambiando día a día, y habría que actualizar

cada poco tiempo los estudios. Aún así, para un momento concreto que sea necesario, puede que

en la red no nos encontremos el escenario estudiado al cien por cien, que haya alguna línea con

las fronteras cambiadas por cargas, averías o cualquier otra situación intempestiva.

Planteada tal tesitura, parece justificado trabajar en este ámbito. De entre todas las tareas

que hay que considerar, hay una que quizás hasta ahora se ha tenido menos en cuenta por la

complejidad de abarcarla, y porque es difícil de parametrizar, esta es la optimización de la

operación de las brigadas en campo. Ante un Cero en Subestación, dependiendo del caso, hay

varias opciones como hemos visto. Cuando usamos las brigadas de operarios para intervenir,

estas tienen unos tiempos de actuación tanto de desplazamientos como de maniobras, y vamos a

intentar optimizarlos junto con las reducciones de afectaciones que tenemos con estas

intervenciones, de manera que el resultado final sea el tiepi menor posible.

Vamos a ver la aplicación que puede tener lo visto hasta ahora en los puntos anteriores, en

un problema sin abordar en este campo, como es la optimización de las brigadas en la

Reposición de un Cero en Subestación. Para ello vamos a enfocarlo como un caso particular del

TSP.

Como explicamos anteriormente, el objetivo del problema del viajante es encontrar una ruta

que, comenzando y terminando en una ciudad, en este caso denotada por la ciudad 1, pase una

sola vez por cada una de las ciudades y minimice la distancia recorrida. Si definimos las


variables dicotómicas de decisión �� , ! " �, de forma que tomen el valor 1 si el arco ��, !

forma parte de la solución y 0 en otro caso; tenemos que el problema de programación lineal

asociado al problema del viajante, consiste en minimizar la siguiente función objetivo:

# ��

Sujeto a las siguientes restricciones:

# �� 1 �� " ��"$%��!

# �� 1 �� " ��"$&��!

Donde

'(��! � �) � � , �! " �� ; '*��! � �) � ��, ! " ��

La primera restricción se refiere a que sólo un arco puede entrar en cada vértice, mientras

que la segunda se refiere a que sólo un arco puede salir de cada vértice.

Vamos pues a formular nuestro problema, y ver si se puede transformar en el problema del

viajante, o una de sus variantes.

5.1 Análisis del problema

Vamos a centrarnos en uno de los casos que hemos comentado con anterioridad, el caso en el

que en la red en explotación tenemos un Cero en una Subestación de Media Tensión, y hay que

reponer el servicio a través de la red de Media Tensión sin poder usar las barras. No vamos a

tener en cuenta si es día laborable o festivo y horas punta o valle, ya que esto lo que nos

modificará será los datos numéricos de entrada. Tenemos pues, una serie de brigadas y podemos

partir de que todas se encuentran en la base, o cada una en un punto que habría que concretar,

por lo tanto tenemos dos escenarios diferentes dependiendo de cuales sean los nodos que

consideremos iniciales si uno con K vehículos o K nodos con un vehículo cada uno.


Otro detalle a tener en cuenta, es que para nosotros el último paso que sería volver a la base

ya no es importante, puesto que aunque tenga costo económico y de tiempo, sería después de

tenerlo todo restablecido, sin sumar tiepi, que es el factor que realmente nos afecta.

Lo ideal y elegante sería que el algoritmo general abarcase todas las posibilidades de

manera genérica, introduciendo todos los nodos de las líneas, y que nos devuelva una lista con

las maniobras a realizar ordenadas, ya sean estas telemandadas o con operación local, de manera

que tengamos una especie de guión paso por paso, maniobra por maniobra

Según lo dicho antes, tenemos una serie de maniobras que hay que realizar antes que otras,

es decir habrá que aislar antes de dar retorno, primando las reposiciones, es decir habrá que dar

retorno lo antes posible a una línea si esta ya ha sido aislada. Cuando decimos aislada, nos

referimos a que al dar retorno a una línea, esta no llegue a los seccionadores de barra de dicha

línea. Partiendo de esto, es importante tener una serie de datos previos, tenemos que tener

conocimiento de las distancias entre todos los nodos, y entre todos los puntos de maniobras

unos con otros, estas distancias las podemos fijar en unidades de tiempo o de distancia, según

creamos que va a ser mas eficiente, para nuestro caso serán mas efectivos los tiempos, como

elemento base, aunque después los podamos ponderar con otras variables según queramos

destacar unos puntos por su importancia.

Para obtener los tiempos de desplazamientos entre los nodos, podemos usar una herramienta

de navegación comercial, por ejemplo Google Maps, pudiendo incluso usar el localizador para

los puntos sin dirección, y la posibilidad de hacer los cálculos de tramos con vehículo y después

a pie, cuando corresponda cada uno. Partiendo de esos datos construiríamos los �� para nuestro

problema:

�� +�� ! , -�

Donde +�� será la distancia del nodo i al nodo j, y �� será la velocidad media según la vía

para ir del nodo i al nodo j. Estos dos valores como hemos comentado los podemos obtener de

una navegador cualquiera. El tiempo estimado para realizar la maniobra en si es otro concepto a

tener en cuenta. Así en cada centro sumaremos un tiempo de maniobra en cada nodo, de manera

que el peso o coste que tenga ir de un nodo i a otro j, sea el tiempo de desplazamiento mas el de

maniobra, para eso consideraremos la variable -�, para cada maniobra en cada nodo. Pudiendo


esta variar entre maniobras en subestación, en un centro de transformación, interruptor en

apoyo, o en uno telemandado.

Tenemos que concretar que lo importante serán los vértices no las aristas, es decir al

introducir todos los vértices y aristas, lo importante en todos los casos será cubrir todos los

centros, pero no por ello todas las aristas (este sería el caso de Problema del Cartero Chino, el

cual podemos descartar. Como comentario, para este si existe un algoritmo de tiempo

polinomial) es decir uno sería un circuito Hamiltoniano y otro Euleriano.

Por lo tanto nuestro problema es del Tipo TSP, y mas en concreto una variante de este

conocida como El Problema de Rutas de Vehículos (en inglés Vehicle Routing Problem, VRP).

Este es otro de los problemas más estudiados en Investigación Operativa. Definido hace más de

50 años, este problema consiste en diseñar el conjunto óptimo de rutas para una flota de

vehículos que deben visitar a un determinado número de clientes. El gran interés en este tipo de

problemas, como ocurre con el TSP, se debe a su gran utilidad en problemas reales, así como a

su considerable dificultad.

El Problema de Rutas de Vehículos es un nombre genérico que se da a una clase muy

extensa de problemas, consistentes en encontrar rutas óptimas de reparto desde uno o varios

almacenes a un determinado número de ciudades o clientes satisfaciendo ciertas restricciones.

En otras palabras, el objetivo de este tipo de problemas es repartir (o recoger) una cierta

mercancía a un conjunto de clientes con demandas conocidas de manera que el coste total

originado de este reparto sea mínimo.

El problema de rutas de vehículos es un problema de programación entera que también se

encuadra dentro de la categoría de los problemas NP-Completos. Para este tipo de problemas,

como comentamos en las secciones anteriores, cuando el tamaño del mismo es excesivamente

grande, es deseable obtener soluciones aproximadas que puedan ser obtenidas con una rapidez

relativa y que sean lo suficientemente parecidas a la solución óptima. Generalmente, la literatura

sobre VRP se centra en encontrar una solución exacta que no requiera tanto esfuerzo

computacional o encontrar una solución aproximada, que en un tiempo razonable, dé lugar a

soluciones aceptables.

Situados ya en los VRP, teniendo en cuenta que no tenemos que retornar a la base,

podríamos dejarnos llevar e intentar resolver nuestro problema comparándolo con el problema

del camino más corto ( The Shortest Path) al igual que con el Problema del Cartero Chino, de


éste también se han encontrado algoritmos polinomiales. Sin embargo, el Problema del Camino

mas Corto, se plantea para encontrar el camino mas corto entre dos vértices cualesquiera de una

grafo conexo, pero donde estriba la dificultad de nuestro problema, y que es el punto en común

del nuestro con el del TSP, es en que hay que pasar por todos los nodos a maniobrar, por lo

tanto hay que considerar todos los vértices a la hora de resolver el problema.

5.2 Formulación del VRP para Brigadas

Una formulación básica e inicial de nuestro problema es la siguiente:

Vamos a tomar las variables:

.�/ � 01 �� 12 314í�627 8 -)��79) 1� 12 �7:7 �0 �� 7 < ��/ � 01 �� 12 314í�627 8 3�) ) :�91��)-1��1 :1 � ) 0 �� 7 < K= número de vehículos disponibles

n= número de nodos que hay q visitar

Y quedaría:

=�� # ��/ ��/

Sujeto a:

# ��/� � .�/ � � 0,1, … , � �1!

# ��/� � .�/ � 0,1, … , � �2!

# .�// � 0? � � 01 �� @ 0< �3!

# # ��/ |B| C 1, �"D�"D � �6�7� 6��7 B :1 �1, … , �� . 2 |B| � C 1 �4!

��/ F�0,1� (5)

.�/F�0,1� (6)


Con la restricción (1) y la (3) imponemos que de cada nodo salga un solo vehículo, excepto

en el caso de la base en el que imponemos que salgan K vehículos. Con la (2) y la (3)

imponemos que en todos los nodos entre como mucho un solo vehículo, excepto en el caso de la

base en el que imponemos que entren K vehículos.

Para conseguir que no influya el retorno a la base, al introducir costes imponemos que ��G � 0, para que no se contabilicen los costes de retorno.

La variable ��/ presentes en las restricciones (1) y (2) indican la activación del arco (i,j), por

el vehículo k, lo que determina un recorrido de i a j. Además se asegura que todo cliente es un

nodo intermedio de alguna ruta, es decir que de cada nodo que no es la base, sale una y solo una

arista y entra una y solo una arista. La restricción (3) a la vez indica que K es la cantidad de

vehículos máximos utilizados en la solución y que todos los vehículos parten de la base, y que

cada vértice es visitado por un solo vehículo. La restricción (4) vigila que la solución no

contenga ciclos o islas, usando los nodos 1,2,…n, de otra manera los arcos de A contendrían

algún ciclo pasando a través de un conjunto de nodos Q y la solución violaría la restricción,

porque el lado izquierdo de la restricción sería al menos |Q|. Las restricciones (5) y (6) indican

que tanto la variable xkij como la variable .�/ son binarias.

Para el caso en el que cada coche parta de un nodo diferente habría q variar la formulación

en varios detalles. No consideraríamos al nodo 0, y tomaríamos los K primeros nodos, como

base de cada vehículo, es decir:

# ��/�

� .�/ � � 1,2, … , � �1!

# ��/�

� .�/ � 1,2, … , � �2!

# .�//

� 1 � � �3!

Con la restricción (1) y la (3) imponemos que de cada nodo salga un solo vehículo. Con la

(2) y la (3) imponemos que en todos los nodos entre como mucho un solo vehículo. En la

programación es donde hay que imponer que los puntos iniciales de los K coches sean lo nodos

en los que estos se encuentran y no otros. Con esta idea de plantear el problema así, estamos

trasladando gran parte de las posibles variables a la introducción de los costes, en este caso

tiempos. Con lo que vamos a denotarlos para ver cómo sería la manera propuesta:


Una vez comentadas las diferentes excepciones que nos van a afectar habría que

computabilizarlas de alguna manera. Para ello suponemos que tenemos la matriz H " �� I �!

donde tenemos todos los tiempos de desplazamiento entre los nodos de nuestro problema:

�� · �KLK� !

Donde �� es el tiempo de desplazamiento entre el nodo i y el nodo j como hemos detallado

previamente. K�es una variable que corresponde con la potencia instalada en la línea a la que

pertenece el vértice j, y para que el factor quede proporcionado lo que hacemos es normalizar el

factor potencia instalada, de manera que tomamos KL como máximo de las potencias instaladas

de las línea con posibilidad de retorno del Cero de Subestación estudiado:

KL � max K�

Pero el problema que nos vamos a encontrar con esta manera de considerar los costes, es

que en la mayoría de los casos vamos a tener costes no enteros, lo cual no nos va a funcionar a

la hora de computabilizarlos para ejecutarlos en nuestro programa, debido a las limitaciones del

algortimo bintprog de Matlab, a no trabajar con números no enteros. Con lo que como punto de

partida vamos a usar los costes simplificados:

�� · K�

Cabe señalar que para nosotros lo importante son las maniobras mas que los nodos o

vértices en sí. Por lo que se podrá repetir un vértice varias veces si en ese punto hay varias

posibles maniobras, entonces solo habría que tener en cuenta la maniobra en si, siempre que se

hagan de manera consecutiva. Esto se hará de manera automática al introducir los datos ya que

tendríamos:

< +�� 0 �� +�� ! , -� P Q �� -�

El sistema que vamos a usar no es un sistema telemandado exacto, sino que está totalmente

ligado a factores temporales incontrolables, como tiempos en realizar una maniobra,

comunicaciones, problemas con vehículos…. Todos los cómputos temporales que se hacen son


muy aproximados, pero nunca serán exactos. Habrá pequeños tiempos de espera por solape de

maniobras, es decir, que dos vehículos lleguen a la vez a nodos diferentes, o que uno llegue

cuando otro aún nos tiene ocupado haciendo una maniobra en otro nodo, no olvidemos que la

coordinación de todo lo hará un solo operador en el Centro de Control. Se podrán dar estas

situaciones y otras parecidas, pero esos tiempos los asumiremos y despreciaremos.

Por lo general, lo óptimo sería abrir una línea, ya sea en subestación o en el primer elemento

que fijemos en la línea, y que la maniobra consecutiva sea dar retorno a esta línea, recordemos

que lo que prima es reducir tiepi, pero no tiene porque ser así. También hay que tener en cuenta

que lo que estamos buscando precisamente es optimizar los recursos, eso implica que no tendrá

porque ni mucho menos, el mismo coche abrir y dar retorno a la misma línea, o si coinciden los

retornos de dos líneas en un mismo centro que antes se hayan abierto las dos líneas.

Precisamente esa optimización es lo que buscamos, pero para ello tenemos que añadirle

condiciones y restricciones a la formulación general.

Como comentario, el elemento para aislar la línea, será la propia cabecera en subestación de

cada línea, pero esta puede estar operativa en ese momento por telemando o no, y estar

operativa de modo local o ni tan siquiera eso, con lo que la primera maniobra tendría que ser en

el primer elemento de la línea maniobrable, y lo fijaremos previamente.

Diferenciaríamos en este punto los nodos en dos grupos, los que pertenecen a líneas que no

tengan telemandadas las fronteras o los primeros elementos de aislamiento, o ninguno de los

dos. Y los que tienen todos los elementos telemandados. En ambos casos podemos introducirlos

colocando primero los l nodos que corresponden a las primeras maniobras y los l siguientes sus

fronteras.

En el caso que no están ambos telemandados, consideraremos que si tiene uno de los dos

telemandados estará a distancia cero respecto de su nodo asociado. Y las distancias de los nodos

telemandados respecto al resto de nodos se tomaran como las distancias de su asociado.

Imaginariamente lo que hacemos es colocar los telemandados justo en el mismo sitio que su

nodo asociado, es decir:

Si tenemos que el nodo i o i’ son telemandados, impondremos que:

+�� 0, +�� +�� y +�� +��


En el caso que ambos elementos de la línea sean telemandados, introducimos el concepto

del vehículo forzado, es decir, que de las maniobras de las líneas que tengan ambos elementos

telemandados, se encargará un vehículo que solo hará esas maniobra. Imponemos:

.�RS � 1 T i y su i’ son telemandados, en caso contrario .�RS � 0

Donde ?G, es un coche adicional a los K coches dados cuyo desplazamiento es 0, es decir �� -�, para todo i, j nodos pertenecientes a las líneas con sus dos elementos telemandados,

con lo que tendríamos K = n+1, y ese vehículo sería el propio operador del Centro de Control de

Media realizando las maniobras por telemando cuando el resultado del algoritmo lo indique. Y

como punto de partida le podemos poner el Centro de Control, ya que las distancias serán

siempre 0, pero tendremos referenciadas dichas maniobras.

Teniendo en cuenta lo comentado, se trata de exigir que antes de ejecutar el mando sobre el

vértice i que está sobre la línea l para dar retorno, se haya hecho la maniobra sobre el otro

vértice i’ que también pertenece a la línea l y aísla a la subestación del retorno. De manera que

si tenemos l líneas habrá en principio 2 · 2 , 1 nodos, donde el 1 representa a la base, y en el

caso de cada uno salga de un punto diferente 2 · 2 , ? nodos.

Es decir, Para cada par de nodos i e i’, imponemos:

∑ �VW�VW/� X ∑ �YZ�YZ/YZVW �7� �[, \! " ], �9, �! " ]�, . 8, 8��)21� \61 .�/ � 1 1 .��/�=1

Donde I e I’ serán respectivamente, los conjuntos de aristas por los que pasa el vehículo K

y K’ antes de llegar al nodo i e i’ respectivamente. Para ello, por ejemplo para I, a la hora de

programar consideramos el resto de nodos para los que .Y/ � 1 una vez tenemos esa lista de

nodos, buscamos cuál de esos p es aquel tal que �GY/ � 1 y añadimos (0,p) a I. Ahora con esa p

fijada, buscamos el �YY^/ � 1 siendo p* uno de los nodos que hacían .Y/̂ � 1 y así

sucesivamente hasta llegar al nodo i’

Con esta formulación podríamos acometer la reposición de todas las líneas, siempre que

tengan posibilidad de retorno con la capacidad suficiente, sean telemandadas o no las primeras

maniobras o los retornos. Pero el costo computacional va a ser enorme, para solo 9 nodos nos

acercaríamos a los 4 millones de rutas posibles, con un solo coche y sin tener en cuenta el

aumento que algunas restricciones supondrán al Simplex normal.


Si no supiésemos que nuestro problema pertenece a la clase de NP-Completos, podríamos

ponernos de nuevo a replantear los condicionamientos o las matrices de incógnitas, o repartir los

costes de otra manera, pero ahora sabemos que el problema va a estar en el algoritmo de

resolución de la optimización en sí. Tenemos dos maneras de reducir costes de computación del

problema: uno es reduciendo los nodos lo más posible, para lo que tendríamos que estudiar las

posibles situaciones que se nos pueden dar. Y otro es abordando el problema por Heurísticas, u

otro sistemas de algoritmos no exactos, que no nos darían la solución exacta, pero conseguirían

una aproximación bastante buena dependiendo de la que usemos, y una reducción de tiempo

considerable con lo cual podríamos ampliar el número de nodos, e incluso usar ambas

posibilidades a la vez.

5.3 Reducción de Nodos

Con el planteamiento que hemos hecho en el apartado anterior para aplicar el VRP, nuestro

algoritmo, recorrería todos los puntos de maniobra pasando por los 2 · 2 , 1 7 2 · 2 , ? nodos

según el caso, asignando a los telemandados distancias ceros, respecto a otro nodos. Puesto que

debemos de tratar de reducir el número de nodos nos replanteamos nuestro problema. El punto

donde más podemos incidir es en los telemandados, hemos planteado estas maniobras como

nodos de distancias cero a otros, pero que entraban dentro del algoritmo VRP, por lo que

intentaremos extraerlos para hacerlos de manera independiente, pero que sigan cumpliendo los

condicionamientos.

Partimos de que los K vehículos se encuentran en K nodos al empezar, en caso de estar

todos en la base, se modificaría esa condición con las distancias como vimos. Y ahora

diferenciaríamos varios casos:


5.3.1 Subestación operativa por telemando

En este caso las maniobras de aislamiento serían todas en la subestación sin necesidad de

desplazamientos. Tomaríamos entonces todos los i nodos frontera telemandados de las l líneas y

los ordenaríamos según la potencia instalada de la línea a la que dan retorno. Entonces nos

ordenaría las maniobras de manera que la primera maniobra óptima sería abrir la cabecera de la

línea de KL, y después cerrar la frontera de dicha línea. Eliminaríamos esa línea, y repetiríamos

el proceso i-1 veces, hasta agotar las líneas con nodos de retorno telemandados. Una vez

acabado ese proceso, seguiríamos abriendo las l-i líneas restantes en cabecera, hasta que

estuvieran todas abiertas (llamaremos a esto Proceso Telemandado). Ahora si nos quedaría

ejecutar nuestro VRP con tan solo los l-i nodos fronteras no telemandados mas los nodos

iniciales (sea 1 o K). Con:

�� · K�

�� +�� ! , -�

Para tener en cuenta: de ahora en adelante siempre que haya que hacer varias maniobras

telemandadas seguidas, se usará siempre el criterio de la KL.

5.3.2 Subestación sin telemando

Para empezar tomaríamos primero las líneas que tengan telemandados tanto los nodos de

primera maniobra como los frontera, y repetiríamos el mismo Proceso Telemandado que en el

punto anterior, realizando la maniobra en lugar de en subestación en los nodos primeras

maniobras telemandados. El siguiente paso sería abrir el resto de primeras maniobras que estén

telemandadas, aunque no lo estén las fronteras. Después de esto habría que diferenciar entre dos

casos:


1.- Subestación operativa:

Los otros nodos singulares que nos faltarían por tener en cuenta serían las fronteras

telemandadas con primeras maniobras locales. En este caso lo que hacemos es contabilizar solo

la subestación como nodo de primera maniobra, y ejecutar el Proceso Telemandado, pero de

manera local con la brigada ejecutando las maniobras una vez se encuentre en la subestación.

Nos quedarían entonces por tener en cuenta para nuestro VRP los nodos iniciales, las

fronteras que no estén telemandadas y la subestación. A la subestación le asignamos el nodo s,

de manera que los costes serán los genéricos que hemos establecido, excepto para la subestación

que serán:

��W � ��W · KW

��W � �+�W��W ! , -W · 2W

KW � # K��"_`

Donde 2W son las líneas cuyas primeras maniobras vamos a hacer en la subestación. Con esto

unificamos todos las primeras maniobras que quedan por realizar, por no estar telemandadas, en

un nodo en la subestación, con el coste equivalente a la suma de las maniobras que se van a

realizar y el tiempo de desplazamiento.

2.- Subestación inoperativa:

Con los nodos fronteras telemandados de las líneas que nos faltan por tener en cuenta para

este caso, haremos lo mismo que en el caso anterior, asociarlos a las primeras maniobras no

telemandados de su propia línea. En este caso los telemandados los ejecutaríamos de uno en uno

después de cada primera maniobra asociado, y la optimización de ir a un nodo de primera

maniobra u otro ya estará hecha. Para ejecutar esa maniobra será suficiente con lanzar un

mensaje, justo después de la primera maniobra asociada, con el texto ejecutar maniobra en el

telemando correspondiente.

Dicho esto para nuestro VRP habría que considerar los nodos iniciales, las fronteras que no

estén telemandadas y los primera maniobra que no estén telemandados, usando los costes


genéricos que hemos establecido. Habría que tener en cuenta las líneas cuyos ambos elementos

la primera maniobra y la frontera no estén telemandadas, porque para introducir la recuperación

de potencia no la podemos asociar a realizar una maniobra, ya que ambas asilar y dar retorno,

deben estar realizadas. Por lo que volveríamos a aplicar la condicionante vista en el punto 5.2.

Una vez analizados los puntos 5.3.1 y 5.3.2, podemos plantear un caso particular que se nos

va a plantear muy a menudo, cuando necesitemos que se realicen primero todas las maniobras

de subestación, sean estas telemandadas o no. Para ello cuando ejecutamos el Proceso

Telemandado en lugar de asignar a cada primera maniobra la K� de esa línea, bastaría con

asignarles la suma de todas las potencias instaladas de la subestación.

KW � # K��"a

Con lo visto en este punto habríamos reducido el número de nodos a tener en cuenta en los

diferentes casos, para ejecutar el VRP. Hemos tenido un ahorro computacional muy alto, de

manera que si antes teníamos un margen de actuación de mas o menos 4 líneas con sus

respectivos nodos, debido al coste computacional, ahora podemos considerar bastantes más

líneas ya que lo que nos va a limitar el problema son los desplazamiento reales, no los nodos de

nuestro problema. Habiendo eliminado de la computación todos los telemandados.

Posiblemente esto no haya sido suficiente. Nos faltaría pues dejar de lado el camino de las

soluciones exactas, y adentrarnos en las aproximadas. Por lo general necesitaremos poder

ejecutar nuestro problema con más de 9 desplazamientos. Se impone pues, conociendo bien

cuáles son las características particulares de nuestro problema, estudiar cual es la mejor opción:

Heurísticas, Metaheurísticas, Algoritmos Genéticos, Greedy, Ventanas Temporales, Algoritmos

Genéticos …. Esto lo tratamos en el punto 8, Futuros trabajos. En ese punto también planteamos

el resto de temas analizados con anterioridad y sus casuísticas, estos serán puntos a tener en

cuenta en un algoritmo mas general, del cual también haremos referencia. Lo interesante como

objetivo de este trabajo, es la parte en la que la optimización real entra en escena, y es la parte

en la que nos vamos a centrar en adelante.

A continuación vamos a programar nuestro modelo para el caso mas sencillo de los que

hemos descrito, y lo usaríamos como base. En el Anexo tenemos las 9 funciones que se han

usado para calcular la solución a dicho problema, con comentarios para hacernos idea de la

dificultad con la que estamos tratando. Vamos a considerar las potencias todas iguales, de


manera que no nos influirán en el resultado final, y que todos los vehículos parten de la base.

Nos situamos en el punto en que ya tenemos introducidos los datos de costes temporales de los

nodos, habiendo eliminado ya los telemandados, y sin condicionantes, no habrá que realizar

maniobras previas a otras. Vamos a programar un algoritmo en el que se den como entrada los

costes temporales de ir de un nodo a otro y el número de coches disponibles, tomando todas las

potencias 1, y evaluaremos los resultados. Para ello comenzamos con un organigrama de

nuestro algoritmo, seguido de un ejemplo práctico.


VRPIN T, P, K

VRBP T, P, A , B, K

Creamos C matriz costes

Crea S con bintprog

VRP

T, P, A, B, K, w,

V2, TC2, CST2, K2

¿se han generado

islas?

si

Añade filas a A y B, imponiendo que no se produzcan esas islas

no Crea

Restricciones Aeq, Beq

VRPCOM

T, P, A, B, K, w,

V, TC, V2, TC2, CST2

Crea función de costes F

COSTES C, K

RESTRIC C, K

Calcula los costes reales de nuestra posible solución

A, B de RECOM TC2=TC,

CST2=CST y ejecuta VRP

¿se pueden redistribuir vehículos?

Se añaden filas a A y B, forzando

una nueva posible solución

si

Crea la matriz

de tiempos empleados

no

Devuelve la solución

RECOM A, B, K, w, V, I, n, m

PRINT V,TC,CST,V2, TC2,CST2

COM MTT, V, K

¿permite matlab

redistribuir

CST2=0

¿se pueden redistribuir trayectos?

si ¿CST2? no PRINT

V,TC,CST,V2, TC2,CST2 Devuelve

la solución SOLUCIÓN

V2 TC2

CST2<=CST

no

si


Se añaden filas a A y B, forzando una nueva posible

solución

A, B de RECOM K2=K2+1

y ejecuta VRP

CST2>CST

A, B de RECOM K2=0, V2=V, CST2=CST

y ejecuta VRP



6.- Ejemplo

Pasamos a ver un ejemplo concreto, para ello usamos la función siguiente CREA en la

que introducimos una matriz de tiempos de ocho nodos y otra de potencias todas 1 como hemos

comentado, y vamos variando el número de coches.

function CREA(K) % Esta función se ha creado para iniciar el % algoritmo con varios ejemplos. Tenemos las % limitaciones de VRPCOM de la línea 50 que no nos % permite que m<=1, y de la línea 86 que lo tenemos

% que limitar a K-1, y que comentaremos mas adelant e. P=[1 1 1 1 1 1 1 1 1]; T=[0 25 30 15 35 18 40 30; 1 0 10 15 5 9 10 18; 1 15 0 15 10 5 5 10; 1 10 20 0 5 10 15 8; 1 10 5 15 0 20 5 8; 1 9 3 15 18 0 10 5; 1 15 7 12 5 14 0 8; 1 16 12 10 5 10 15 0]; VRPIN(T,P,K); % Llamamos a la matriz que inicia el algoritmo, % introduciendo la matriz de tiempos, de potencias y el

% número de vehículos


6.1 Resultados el Ejemplo

Para un vehículo:

>> CREA(1)

Tabla de vehículos y nodos por los que pasan

V2 =

1 4 2 5 7 3 6 8


Para dos vehículos:

>> CREA(2)

ans =


V2 =

1 4 5 2 0

2 6 3 7 8


Para tres vehículos:

>> CREA(3)

ans =


V2 =

1 4 5 3 7

2 2 0 0 0

3 6 8 0 0


Para cuatro vehículos:

>> CREA(4)

ans =


V2 =

1 4 5 7

2 8 0 0

3 2 0 0

4 6 3 0


Para cinco vehículos:

>> CREA(5)

ans =


V2 =

1 4 5 7

2 6 0 0

3 8 0 0

4 3 0 0

5 2 0 0


Para seis vehículos:

>> CREA(6)

ans =


V =

1 8 0

2 3 7

3 5 0

4 4 0

5 6 0

6 2 0


Para siete vehículos:

>> CREA(7)

ans =


V =

1 8

2 7

3 6

4 5

5 4

6 3

7 2


6.2 Análisis del ejemplo

Todos los casos funcionan a la perfección, y es en el caso de seis vehículos donde no nos

da el resultado esperado, el recorrido al nodo 7 lo debería realizar el vehículo 4 o 5, con estos

vehículos los costes totales serían iguales y menores, a si lo hace el vehículo 2 que es el

resultado que nos da el algoritmo. Esto es por las dos limitaciónes que hemos tenido que añadir

para que bintprog no se bloquee (función de matlab que hemos usado para resolver nuestro

problema interno de programación lineal binaria). Si no tuviéramos esa limitación la función

VRPCOM (ver anexo) tendría que haber seguido ejecutando posibilidades de mejora hasta dar

con la correcta. Teniendo en cuenta esas limitaciones podemos afirmar que los resultados son

muy buenos, y que es un buen punto de partido para abordar el problema que se ha planteado y

que aún está pendiente de ser resuelto

Las dos limitaciones insertadas en nuestro algoritmo se encuentran ambas en la función

VRPCOM, estas son:

1. if m-1<=1 % Si no se pueden redistribuir mas vehículos finali zamos PRINT(V,TC,CST,V2,TC2,CST2) else

Realmente deberíamos haber bajado hasta - 1, pero bintprog no es capaz de trabajar

con ese nivel de restricciones ya que estás empiezan a aumentar muy rápido, sobre todo en los

casos de mas vehículos, que es cuando realmente esta condición entraría en ejecución, sobre

todo cuando el número de vehículos es próximo al de nodos.

2. if CST2<=CST

if K2==K-1 % en tal caso devolvemos la solución de

% la iteración previa como buena. 'Tabla de vehículos y nodos por los que pasan' V2 bar(TC2, 'stack' ); title VRP; xlabel( 'Vehículos' ); ylabel( 'Tiempos' );

En este caso el punto para detener el proceso no debería haber sido K2==K-1, ya que

con esta limitación no valoramos todos los casos posibles de mejora, pero igualmente si no

incluimos esta limitación a un número menor, bintprog se bloquea ante el número de casos a

valorar.


7.- Conclusiones

Como Conclusiones podemos decir que sin conocer la clase de NP-Completos, al abordar

nuestro problema, habríamos invertido mucho mas tiempo hasta darnos cuenta de que los

resultados incoherentes no son problemas de la programación si no las optimizaciones en sí. No

habríamos tenido la base para desarrollar las formulaciones que hemos ido usando, y estas no

son fáciles de crear de la nada, y una vez obtenidas, podríamos haber dedicado meses a

desarrollar y modificar los condicionamientos y los futuros algoritmos viendo que no eran

eficientes. Sin embargo hemos parado a tiempo, y en adelante el enfoque de nuestro problema

debe de orientarse de manera muy diferente.

Por otro lado, viendo las futuras líneas de trabajo tenemos mucho adelantado, al ser un

campo muy estudiado que comparte mucho entre todos los problemas que pertenecen a él.

Tenemos también claro que después de todo, no estamos optimizando el problema que

realmente queremos solucionar, este es bastante mas complejo aún. Hay dos puntos en concreto

que nos conducen a otras líneas de estudio:

1. No estamos considerando los costos temporales reales de nuestro problema. Aunque

los resultados sean bastante buenos por lo general, no siempre nos van a resolver de

la mejor manera posible nuestro problema, aunque den una solución aceptable.

�� · K�

Pero los �� no deberían de ser solo el tiempo que se tarde del nodo i al nodo j.

habría que sumar los costes temporales que tiene el vehículo que llega a ese nodo

previamente y sumarlos todos, es decir:

�� ∑ �YZYZ donde [p,q] son los trayectos y nodos que recorre el vehículo k hasta

llegar al nodo j.


2. Si introducimos las potencias a la vez que los tiempos en la optimización para

priorizar los nodos con mas potencias respecto a los tiempos, estamos adulterando

los tiempos, con lo cual la optimización temporal no será real. Esto nos llevará a

que en el cronograma final los vehículos estén en sitios antes o después de lo que

los tiempos nos van a permitir. Con lo que la manera de priorizar nodos en función

de sus potencias habrá que abordarla de otro modo.

Hemos podido corregir estas diferencias temporales entre nuestros costes reales y los que

usamos al optimizar, pero ha sido a posteriori, es decir primero optimizamos con los tiempos

que podemos introducir, que son los de un nodo a otro, y una vez tenemos esa posible solución

la evaluamos con los costes que deberían ser realmente. Después imponemos que esa solución

no sea posible y volvemos a ejecutar la optimización, obteniendo la mejor solución posible con

esa restricción, y la evaluamos con los costes temporales reales. A continuación la comparamos

con la solución anterior y nos quedamos con la mejor de ambas. Repetimos de nuevo entonces

el proceso, pero esto solo lo podemos hacer un número limitado de veces, por lo que no siempre

tendremos la solución óptima. Esta es una de las limitaciones de nuestro algoritmo, ya que la

evaluación la hacemos a posteriori.

También otro punto importante ha sido obligar al algoritmo a repartir los viajes de manera

mas solidaria entre todos los vehículos, esto reduce los costes reales finales de nuestro

problema. Para bintprog, es igual si un nodo es visitado por un vehículo u otro, es decir: Un

vehículo suma el nodo 10º visitado, y 60 minutos de tiempo total del vehículo en trayectoria,

pero el coste que tiene ir del nodo 9 a 10 para ese vehículo es el mismo que para otro vehículo

aunque sea el nodo visitado 3º nodo para ese otro vehículo y lleve 20 minutos de trayectoria tan

solo. Pues bien bintprog se lo asignará al primer vehículo, sin tener nada mas en cuenta. Por lo

que hay que obligarle a hacer otro reparto. También este otro reparto se tiene que hacer a

posteriori de la optimización. Este problema de no reparto solidario de bintprog se debe a

nuestra función objetivo, ya que estamos minimizando la suma de los costes de todos los

vehículos, como un todo, y no de cada vehículo en concreto, ya que para ello tendríamos que

plantear como función objetivo una muy diferente:

=��=)�/ # �� / !

Y esto tampoco lo podemos utilizar en nuestro sistema de optimización.


Después de haber avanzado y analizado todo lo anterior, teniendo en cuenta que nuestro

punto de partida era utilizar como base para resolver nuestro problema uno de la clase de NP-

Completos, podemos decir que es el momento de usar todo lo que se ha estudiado sobre estos

problemas para dar un cambio drástico a nuestro enfoque.


8.- Futuros Trabajos

En este Trabajo se ha tenido en cuenta un caso muy concreto y común, interesante de

abordar. Una vez planteado este problema y analizado, lo primero es replantearnos el enfoque

una vez sabemos que no vamos a conseguir lo resultados esperados siguiendo esta línea. Como

ya hemos comentado nuestro problema es aún más complejo que el VRP clásico, ya que

tenemos variables en los propios costes. Para nosotros, los costes no son una constante que

dependa del nodo del que sale y al que se llega, es mas profunda, depende de todos los nodos

previos que se han recorrido con lo que el número de variables se vuelve a multiplicar de

manera alarmante y además pasan a ser inabordables por un modelo de programación lineal.

Descartada pues la opción de obtener una solución exacta, y sin saber si la que obtenemos

es única, nos centraremos en obtener la mejor posible, y que sobre todo se adapte y tenga en

cuenta nuestro problema real y sus particularidades. Por lo que para trabajos futuros como punto

de inicio planteamos trabajar con Algoritmos Genéticos, para tener en cuenta los costes reales

de nuestro problema, y hacer una optimización de ellos. Y a partir de ahí, profundizar tanto

como creamos necesario o seamos capaces. Por ejemplo:

Tener en cuenta los retornos que estén en elementos que haya que dejar sin tensión antes de

cerrar, con lo cual añadiríamos un nodo mas a cada línea. Líneas con varios posibles retornos,

totales o parciales. Líneas con elementos telemandados intermedios, de manera que podamos

dar retorno a parte de la línea por una frontera y otra parte por otra frontera, o simplemente

traslademos la frontera de la natural a ese telemando intermedio. Un punto bastante complicado,

que sería considerar tiempos de espera una vez llegado a un nodo. Antes de hacer la maniobra,

para dar tiempo a ejecutar otra maniobra permanecer en espera en un nodo, anteponiendo la

maniobra que queremos hacer a otra.

Otro detalle es reutilizar estos mismos estudios, adaptándolos, para ceros programados.

Habría que ver si las líneas son acoplables, en ese caso el orden entre el primera maniobra de

cada línea y su retorno sería inverso, primero impondremos el retorno y después la apertura del


primer maniobra, y no haría falta las ponderaciones al no haber afectaciones, solo se tendrían en

cuenta optimizar trayectos.

Y quizás uno de los más interesantes, es no contar con la imposición de que cada línea que

introducimos tiene una posibilidad de retorno, y solo una, que puede con toda la carga. De esta

manera nos iríamos acercando cada vez más a no tener límites a la hora de calcular planes de

contingencias. El último paso, debería ser poder usar las barras de subestación para las

maniobras necesarias, con lo que cerraríamos el círculo de los trabajos requeridos. Y aún así

continuaremos pudiendo añadir restricciones de situaciones que merece la pena contemplar, y

hemos pasado por alto, asuntos que serán objetos de futuros trabajos como se ha comentado.


9.- Epílogo

En 1965 Gordon E. Moore, uno de los pioneros en el estudio de los chips de ordenadores,

concluyó que la densidad de transistor de los chips se había doblado cada año a principios de la

década de los sesenta, y predijo que esto seguiría ocurriendo. Esta predicción, se cumplió

durante muchos años, y después se pasó a doblarse cada año y medio, y además es extensible a

la velocidad computacional, esta es la conocida como Ley de Moore. Esto, junto con algoritmos

más eficientes cada vez es lo que ha provocado la explosión de información tecnológica

acontecida en las últimas décadas.

Teniendo lo anterior en cuenta podemos pensar que no tiene mucho sentido dedicar

tiempo a construir algoritmos polinomiales, si tenemos un algoritmo exponencial, según la Ley

de Moore será solo cuestión de tiempo que se pueda resolver sin problemas. Sin embargo ocurre

justo lo opuesto, a la velocidad que aumentan los datos y variables con los que nos interesa

trabajar, nos daremos cuenta que la cantidad de información a manejar crece mucho más rápida

que la de la velocidad computacional. Con lo cual esta ley es un incentivo para trabajar en

mejorar los algoritmos.

Por ejemplo si tenemos un algoritmo SAT de orden O�2�! y le damos una hora de

tiempo, este podría resolver instancias de 25 variables en 1975, en 1985 con el ordenador más

rápido que había podría con 31 variables, con 38 en1995, 45 en 2005 y en unos años deberíamos

llegar a las 52 variables. Es decir en aumentar cada variable tardamos un año y medio más o

menos, sin embargo la velocidad de crecimiento de nuevas aplicaciones es voraz, y mucho más

rápido. El tamaño de una instancia resuelta por un algoritmo de O(n) u O(� log �! se puede

multiplicar por un factor de 100 cada década. En el caso de un algoritmo de O(�e! el tamaño de

una instancia resoluble en un tiempo concreto se puede multiplicar por 10 en cada década, y por

ejemplo en el caso de uno O(�f! podría doblar el tamaño de una instancia resoluble cada

década. Cuando se trata del tamaño de problemas a resolver por un algoritmo, sería justo a la

inversa, algoritmos exponenciales hacen progresos polinomiales, mientras que algoritmos

polinomiales hacen progresos exponenciales. Podemos concluir que a día de hoy son

imprescindibles algoritmos cada vez más eficientes, porque la expansión exponencial no puede

sostenerse en nuestro mundo finito, al menos basada en las estructuras hoy conocidas.


10.- Anexo

Función VRPIN.

function VRPIN(T,P,K) % Esta función es la inicial del algoritmo, en % ella entran como datos la matriz de tiempos, % potencias y el número de vehículos. n=size(T,1); % Creamos la Matriz A y el vector B de ceros de las Kn=K*n; % dimensiones correspondientes para poder rellenarl os, % y que sean dos de los grupos de restricciones % de nuestro problema, en concreto las desigualdade s. dim2=Kn*(n+1); A=zeros(1,dim2); B=zeros(1,1); V2=zeros(K+1,1+n); % En estas matrices vamos a ir insertando las TC2=zeros(K+1,1+n); % posibles soluciones en las distintas iteraciones VRP(T,P,A,B,K,1,V2,TC2,0,0); %Llamamos ahora a la función VRP, que %crea las restricciones de igualdad %y ejecuta el algoritmo bintprog, que nos %proporciona la solución inicial.


Función VRP.

function VRP(T,P,A,B,K,w,V2,TC2,CST2,K2) %En esta función tenemos las matrices de tiempos, p otencias, de %restricciones A y B, el número de vehículos K, w q ue lo vamos a usar %de contador de filas de las matrices de filas A y B, la solución %provisional que se ha calculado en la etapa anteri or V2 y TC2, matriz %de vehículos y tiempos respectivamente, el costo d e esta en CT2, y un %contador K2 de iteraciones para calcular mejoras. n=size(T,1); V=zeros(K,1+n); % Dimensionamos las matrices TC=zeros(K,1+n); w4=zeros(1,1+n); % Vector de recurso para fijar dimensiones [S]=VRPBP(T,P,A,B,K); % Ejecutamos el bintprog, obteniendo una posible % solución S y a continuación vamos a % intentar mejorar la solución según las % particularidades de nuestro problema. w1=0; % Contador de coches while w1~=K; % Creamos una matriz de nodo para cada coche K w2=0; % a partir de la solución S S1=zeros(n,n+1); while w2~=n; S1(w2+1,1:(n+1))=S((1+w2*(n+1)*K+w1*(n+1)):(1+n+w2* (n+1)*K+w1*(n+1))); w2=w2+1; end S2=S1(1:n,1:n); %Dejamos la matriz sin la fila de las incógnitas Y %de manera que nos quedan solo los nodos que %visita el coche K i=0; S3=(w1+1); % Introducimos los nodos que visita el vehículo K, que ST=(w1+1); % lo tenemos en la matriz de antes en un vector, y en % otro hacemos lo mismo con los tiempos. while i~=1; %Creamos un bucle de manera que en S3 quedará en el %primer puesto el coche y a continuación los nodos que

%este recorre, en ST los tiempos empleados j=1; if i~=0;


i=i-1; end while j~=n+1; if S2(i+1,j)==1; S2(i+1,j)=0; %Notar que conforme vamos anotando que el S3=[S3,j]; %vehículo pasa por un nodo, lo mandamos ST=[ST, T(i+1,j)]; %al siguiente, y lo sustituimos por i=j; %0 en la matriz de recorridos del vehículo j=n; %K, hasta que vuelva a la base end j=j+1; end end L=length(S3)-1; %L será el número de nodos que recorre el vehículo K V(w1+1,1:L)=S3(1:L); %Retiramos de ambas listas el último nodo y TC(w1+1,1:L)=ST(1:L); %costo que corresponden con el de volver a la %base, y es 0. w4(1,w1+1)=L; %En este vector vamos guardando el numero de %nodos por los que pasas cada vehículo. w0=1; % Contador de inicio de isla i=1; % Comprobamos si se ha formado alguna isla %viendo si quedan nodos por visitar por el %vehículo K una vez ha regresado a la base. while i~=n+1; j=1; while j~=n+1; if S2(i,j)==1; w0=i; j=n; i=n; end j=j+1; end i=i+1; end % En w0 hemos guardado el primer elemento de la % de la primera isla localizada del vehículo K, y a % continuación buscamos la Isla Completa. i=1; w3=0; while i~=w0; % Construimos la isla completa que hemos detectado, j=1; % de la misma manera que lo hicimos con el recorrid o if i==1; %que salía de la base, y lo introducimos en la matr iz A while j~=n+1; if S2(w0,j)==1; A(w,(w0-1)*K*(n+1)+(w1)*(n+1)+j)=1; w3=w3+1; i=j; j=n; end j=j+1;


end end %Hemos tenido que crear este doble bucle porque al j=1; %al contrario que en el bucle del recorrido que while j~=n+1; %partía de la base, ahora lo hace del nodo w0 if S2(i,j)==1; A(w,(i-1)*K*(n+1)+(w1)*(n+1)+j)=1; w3=w3+1; i=j-1; j=n; end j=j+1; end i=i+1; end if w0~=1; %Si había una isla en la primera solución que B(1,w)=(w3-1); %obtenemos, imponemos que no se vuelva a w1=K-1; %producir añadiendo la condición a la matriz V=zeros(1,1); %de inecuaciones A y B y ejecutamos la función VRP(T,P,A,B,K,w+1,V2,TC2,CST2,K2); %VRP de nuevo. end w1=w1+1; end if V(1,1)~=0; % Una vez eliminadas las posibles islas, pasamos a L=max(w4); % ejecutar la función de comprobación de optimalida d TC=TC(1:K,2:L); % para nuestro problema en concreto V=V(1:K,1:L); VRPCOM(T,P,A,B,K,w,V,TC,V2,TC2,CST2,K2); end


Función VRPBP.

function [S]=VRPBP(T,P,A,B,K) % Vamos a ejecutar bintprog con la matriz % de costes que vamos a crear n=size(T,1); % Primero vemos el número de nodos que tenemos C=zeros(n,n); % creamos una matriz cuadrada de nxn i=0; while i~=n; % Introducimos los tiempos en la nueva matriz j=0; % y para nuestro estudio inicial no vamos a while j~=n; % usar las potencias, si queremos ponderar los C(i+1,j+1)=T(i+1,j+1); %tiempos solo añadiríamos *P(j+1); en esta j=j+1; % fila end i=i+1; end C(1:n,1)=0; % Con esto imponemos que el coste de regresar desde % cualquier nodo a la base es 0, con lo que el ulti mo % viaje no se tendrá en cuenta, y lo podrá hacer de sde % cualquier nodo en el que se acabe, pero es necesa rio % incluirlo para cerrar los bucles. F=COSTES(C,K); % Transformamos la matriz de Costes en un vector % llamando a la función COSTES [Aeq,Beq]= RESTRIC(C,K); % Creamos la matriz de Restricciones de % nuestro problema VRP según la formulación % que hemos detallado previamente, y el vector asoc iado. S=(bintprog(F,A,B,Aeq,Beq))'; % Calculamos la solución provisional de % nuestro problema con la función bintprog % de programación lineal binaria. %Podríamos calcular el coste total de la optimizaci ón añadiendo F*S';


Función COSTES.

function [F]= COSTES(C,K) %Vamos a transformar nuestra matriz de costes %en un vector de tamaño n*(n+1)*K, es decir, %crearemos un vector con el número de %elementos que son incógnitas de nuestro %problema. n=size(C,1); m=size(C,2); if n~=m; disp( '-------> La matriz introducida no es cuadrada <--- --------------' ) return end if K<=0; disp( '-------> valor de coches no validos <------------- ----' ) return end C1=zeros(n,K*(n+1)); % Creamos una matriz de la dimensional total que % necesitamos de 0, teniendo en cuenta que vamos a % introducir las variables Yj de nuestro problema % con costes 0, y la rellenamos con los costes C % para cada K vehículo. w1=0; % Contador a 0. Introducimos los Costes, como comen tamos % antes, en este caso serán realmente solo los tiem pos de % desplazamientos de un nodo a otro. while w1~=K; C1(1:n,(1+w1+w1*n):w1+(w1+1)*n)=C; w1=w1+1; end % Transformamos ahora esta matriz en un vector, con catenando % las filas de la traspuesta de C1 C2=C1'; dim=size(C1,1)*size(C1,2); F=C2(1:dim); %Ya tenemos el vector Cij de costes para nuestro pr oblema


Función RESTRIC.

function [Aeq,Beq]= RESTRIC(C,K) % Vamos a crear la matriz Aeq y el % vector Beq para nuestro problema n=size(C,1); % Creamos la Matriz Aeq y el vector Beq de ceros de las Kn=K*n; % dimensiones correspondientes para poder rellenarl os, dim1=(2*Kn)+n; % y serán las restricciones de nuestro problema seg ún la dim2=Kn*(n+1); % formulación. Aeq=zeros(dim1,dim2); Beq=zeros(1,dim1); w=0; % Usamos un contador w, y rellenamos las primeras K *n filas % con las ecuaciones correspondientes, para que de cada nodo % salga solo un vehículo colocando un 1 en cada pos ición Xij, y % un -1 en las correspondientes a las Yj while Kn~=w; Aeq(w+1,(w*(n+1)+1):(n+1)*(w+1)-1)=1; Aeq(w+1,(n+1)*(w+1))=-1; w=w+1; end w4=0; %Necesitamos 4 contadores para generar las K*n fila s en el bucle w3=0; %siguiente para las restricciones correspondientes a que en cada %nodo entre solo un vehículo. while w3~=n; w2=0; while w2~=K; w1=0; while w1~=n; Aeq(Kn+w4+1,(w3+1)+((n+1)*w1*K)+(n+1)*w 2)=1; w1=w1+1; end w2=w2+1; w4=w4+1; end w3=w3+1; end w=0; %Necesitamos ahora tres contadores que inician en 0 y otro en 1, v1=1; %para rellenar con -1 las K*n filas en las posicion es de las Yj v2=1; %para las entradas de vehículos en nodos v3=1; while Kn~=w; Aeq(Kn+w+1,v1*(n+1))=-1; w=w+1; v2=v2+1; v1=v1+1; if w==n*v3;


v2=v2+1; v3=v3+1; end if w==n*v3; v1=w+v3; v3=v3+1; end end w1=0; %Volvemos a necesitar 4 contadores, iniciados en 0, para colocar %0 en todas posiciones correspondientes a incógnit as de la %forma Xii, en caso de que al introducir los datos no se haya %tenido en cuenta esto while 2*Kn~=w1; w2=0; w3=0; while n~=w3; w4=0; while K~=w4; Aeq(w1+1,(w3+1+w2*(n+1)))=0; w4=w4+1; w2=w2+1; end w3=w3+1; end w1=w1+1; end w1=0; %Ponemos el contador a 0, y en este bucle vamos a i ntroducir %las restricciones de nuestra formulación correspon dientes a que %cada nodo sea visitado por un solo vehículo, y la base por K. while w1~=n; w2=0; while w2~=K Aeq((2*Kn)+w1+1,(w1*(n+1)*K)+(w2+1)*(n+1))= 1; w2=w2+1; end w1=w1+1; end % Terminamos rellenado el vector Beq para las restr icciones, % con K y 1 en las últimas n posiciones, ya que en el resto son % 0, y ya están introducidos al generar Beq. Beq(1,(2*Kn)+1)=K; Beq(1,(2*Kn)+2:dim1)=1;


Función VRPCOM.

function VRPCOM(T,P,A,B,K,w,V,TC,V2,TC2,CST2,K2) % Pasamos ahora a comprobar si podemos encontrar un a solución mejor, % adaptada a nuestro problema n=size(T,1); m=size(TC,2); TT=zeros(K,m); % Matriz para rellenar con los costos temporales. C=zeros(K,m); % En esta introducimos los costos temporales % multiplicados por las potencias

% En ambos casos la diferencia es que en cada nod o vamos % a tener en cuenta los tiempos que lleva recorri do cada % vehículo antes de llegar a dicho nodo.

i=0; while i~=K % Rellenamos la matriz de costos temporales j=1; while j~=m+1 if j==1 TT(i+1,j)=TC(i+1,1); else TT(i+1,j)=TT(i+1,j-1)+TC(i+1,j); % Sumamos el tiempo que lleva end % empleado cada K vehículo antes j=j+1; % de llagar a dicho nodo. end i=i+1; end i=1; while i~=K+1 %A dichos costos temporales modificados los multipl icamos j=1; %por las potencia y creamos la matriz C. Para nuest ro caso while j~=m+1 %Como ya hemos comentado, estas serán 1. if V(i,j+1)~=0 C(i,j)=TT(i,j)*P(V(i,j+1)); else C(i,j)=0; end j=j+1; end i=i+1; end CS=sum(C,2); % Nos da la suma de los costes que tiene cada vehíc ulo. CST=sum(CS); % Y este nos da el coste total de todos los vehícul os. % Vemos si podemos adaptar mejor el reparto de vehí culos que ha hecho % bintprog a nuestro problema concreto. if m-1<=1 % Si no se pueden redistribuir mas vehículos finali zamos


PRINT(V,TC,CST,V2,TC2,CST2) else % Buscamos el camino mas costoso que aún es reducib le MTT=TT(1:K,m); % Esta será la matriz de los tiempos empleados. I=COM(MTT,V,K); % es la fila del vehículo que emplea mas tiempo, % para ello hemos usado una función auxiliar. TI=TT(I,1:m); [mcs,m]=max(TI); % La m representa la columna última de la fila

% más costosa, que no tiene porque coincidir % con la m creada antes

if I==0 %Si I es 0 no hay posibilidad de mejorar los recorr idos PRINT(V,TC,CST,V2,TC2,CST2) %se evalúan las soluciones actuales. else % Si es el primer caso no hay comparación posible, creamos % las restricciones para obligar a que en la próxim a % iteración, el recorrido que hace uno de los % vehículos no se vuelva a dar if CST2==0 [A,B]=RECOM(A,B,K,w,V,I,n,m); %Para ello usamos esta función w=w+K; V2=V; % Guardamos dichos resultados en las tres variables TC2=TC; % creadas para ellos, que son V2, TC2 y CST2 CST2=CST; VRP(T,P,A,B,K,w,V2,TC2,CST2,K2) % y vemos que nuevos else % recorridos nos propone

% nuestro algoritmo % Si el coste de la iteración previa es menor que e l de está % significa que esta no es válida, en tal caso vemo s si ya % hemos probado todas las posibilidades que nos per mite % Matlab por capacidad temporal de ejecución. if CST2<=CST if K2==K-1 % en tal caso devolvemos la solución de % la iteración previa como buena. 'Tabla de vehículos y nodos por los que pasan' V2 bar(TC2, 'stack' ); title VRP; xlabel( 'Vehículos' ); ylabel( 'Tiempos' ); % Si no volvemos a eliminar esta posible solución % llamando a RECOM y creando las inecuaciones que % no permitan esta solución, y buscamos otra % solución ejecutando de nuevo VRP, sumando el % caso a K2 para no bloquear el equipo y parar ante s else [A,B]=RECOM(A,B,K,w,V,I,n,m); w=w+K; K2=K2+1; VRP(T,P,A,B,K,w,V2,TC2,CST2,K2) end else % En caso de que esta solución sea mejor que la % previa la sustituye como solución en memoria y


% volvemos a buscar otra que la mejore para % nuestro problema.

[A,B]=RECOM(A,B,K,w,V,I,n,m); w=w+K; V2=V; TC2=TC; CST2=CST; K2=0; % Ponemos el contador de intentos a 0 VRP(T,P,A,B,K,w,V2,TC2,CST2,K2) end end end end end


Función PRINT.

function PRINT(V,TC,CST,V2,TC2,CST2) % Es la función que ejecuta la última evaluación y devuelve la matriz % con los recorridos y una gráfica con los costos temporales. if CST2==0 % Caso en el que no haya mas posibles soluciones, y % esta se haya obtenido a la primera 'Tabla de vehículos y nodos por los que pasan' V bar(TC, 'stack' ); title VRP; xlabel( 'Vehículos' ); ylabel( 'Tiempos' ); else if CST2<CST % si el coste de la ultima iteración es mayor que % el de la anterior se devuelve el resultado de % la asignación previa. 'Tabla de vehículos y nodos por los que pasan' V2 bar(TC2, 'stack' ); title VRP; xlabel( 'Vehículos' ); ylabel( 'Tiempos' ); else % si no es así el mejor resultado es el de la % última iteración. 'Tabla de vehículos y nodos por los que pasan' V bar(TC, 'stack' ); title VRP; xlabel( 'Vehículos' ); ylabel( 'Tiempos' ); end end


Función COM.

function [I]=COM(MTT,V,K) % Función que usamos para ir viendo si nos quedan filas por comprobar % que se puedan redistribuir sus nodos entre las otras, minimizando % los costes. i=1; I=0; while i~=K+1 [MCS,IT]=max(MTT); % IT es el vehículo que hace el camino mas costoso. if V(IT,3)~=0 % De esta manera vemos si el camino mas I=IT; % costoso, tiene mas de un nodo para intentar i=K+1; % redistribuirlos. else MTT(IT)=0; i=i+1; end end end

Función RECOM.

function [A,B]=RECOM(A,B,K,w,V,I,n,m) % Esta función rellena la matriz A y B de inecuacio nes, % para que la solución que da los vehículos V y que tiene % la fila I como mas costosa, no se pueda dar como solución.

% Para ello usamos los siguientes bucles w2=0; while w2~=K w1=0; while w1~=m+1 if w1==0 A(w+w2,V(I,w1+2)+w2*(n+1))= 1; end if w1==m A(w+w2,(V(I,w1+1)-1)*K*(n+1 )+w2*(n+1)+1)=1; else A(w+w2,(V(I,w1+1)-1)*K*(n+1)+V(I,w1+2)+w2*(n+1))=1; end w1=w1+1; end w2=w2+1; end B(1,w:w+K-1)=(m-1); end


11.- Bibliografía

• [1] Garey, M. R.; Johnson, D. S. Computer and Intractability: A Guide to the Theory of

NP-Completenes. W. H. Freeman and Company (1979).

• [2] Cook, S. A. The complexity of theorem-proving procedures.

En Proceedings of the Third ACM Symposium on Theory of Computing. Páginas 151-

158. (1971).

• [3] Papadimitriou C. H. y Steigiltz K. Combinatorial optimization: Algorithms and

complexity. Prentice-Hall. (1982).

• [4] Dasgupta S.; Papadimitriou C. H. y Vazira U. V. Algorithm. McGraw-Hill. (2006).

• [5] Cormen T. H.; Leiserson C. E.; Rivest R. L.; y Stein C. “Introduction to Algorithms”

. (2009).

• [6] Vásquez Morales M.A. Desarrollo de un framework para el VRP. (2007).

• [7] Golden B. y Assad A. Perspectives on Vehicle Routing: Exciting New Developments.

Páginas 803-810. [1986].

• [8] Eibl P. Computerized Vehicle Routing and Scheduling in Road Transport. England.

Averbury. (1996).

• [9] Web de VRP. http://neo.lcc.uma.es/radi-aeb/WebVRP/

• [10] Web de ayuda de Matlab http://www.mathworks.es/es/help/optim/ug/bintprog.html

Trabajo Master Juan Manuel Beltran - Servidor de...

Documents

Transcript of Trabajo Master Juan Manuel Beltran - Servidor de...