Post on 02-Oct-2018
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
Máster en Sistemas de Energía Eléctrica. Página 2
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
Máster en Sistemas de Energía Eléctrica. Página 3
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
Máster en Sistemas de Energía Eléctrica. Página 4
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.
Máster en Sistemas de Energía Eléctrica. Página 5
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.
Máster en Sistemas de Energía Eléctrica. Página 6
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.
Máster en Sistemas de Energía Eléctrica. Página 7
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.
Máster en Sistemas de Energía Eléctrica. Página 8
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
Máster en Sistemas de Energía Eléctrica. Página 9
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.
Máster en Sistemas de Energía Eléctrica. Página 10
• 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.
Máster en Sistemas de Energía Eléctrica. Página 11
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
Máster en Sistemas de Energía Eléctrica. Página 12
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?
Máster en Sistemas de Energía Eléctrica. Página 13
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.
Máster en Sistemas de Energía Eléctrica. Página 14
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.
Máster en Sistemas de Energía Eléctrica. Página 15
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.
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á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
cinta, dando la dirección para mover el cabezal, el nuevo estado de la máquina y el valor a ser
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.
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
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
cinta, dando la dirección para mover el cabezal, el nuevo estado de la máquina y el valor a ser
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
Máster en Sistemas de Energía Eléctrica. Página 17
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.
Máster en Sistemas de Energía Eléctrica. Página 18
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
Máster en Sistemas de Energía Eléctrica. Página 19
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
Máster en Sistemas de Energía Eléctrica. Página 20
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.
Máster en Sistemas de Energía Eléctrica. Página 21
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
Máster en Sistemas de Energía Eléctrica. Página 22
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
Máster en Sistemas de Energía Eléctrica. Página 23
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:
Máster en Sistemas de Energía Eléctrica. Página 24
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.
Máster en Sistemas de Energía Eléctrica. Página 25
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
Máster en Sistemas de Energía Eléctrica. Página 26
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.
Máster en Sistemas de Energía Eléctrica. Página 27
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.
Máster en Sistemas de Energía Eléctrica. Página 28
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.
Máster en Sistemas de Energía Eléctrica. Página 29
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.
Máster en Sistemas de Energía Eléctrica. Página 30
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
Máster en Sistemas de Energía Eléctrica. Página 31
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
Máster en Sistemas de Energía Eléctrica. Página 32
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
Máster en Sistemas de Energía Eléctrica. Página 33
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:
Máster en Sistemas de Energía Eléctrica. Página 34
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.
Máster en Sistemas de Energía Eléctrica. Página 35
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
Máster en Sistemas de Energía Eléctrica. Página 36
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
Máster en Sistemas de Energía Eléctrica. Página 37
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
Máster en Sistemas de Energía Eléctrica. Página 38
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
Máster en Sistemas de Energía Eléctrica. Página 39
• 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.
Máster en Sistemas de Energía Eléctrica. Página 40
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
Máster en Sistemas de Energía Eléctrica. Página 41
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
Máster en Sistemas de Energía Eléctrica. Página 42
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.
Máster en Sistemas de Energía Eléctrica. Página 43
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
Máster en Sistemas de Energía Eléctrica. Página 44
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
Máster en Sistemas de Energía Eléctrica. Página 45
é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)
Máster en Sistemas de Energía Eléctrica. Página 46
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:
Máster en Sistemas de Energía Eléctrica. Página 47
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
Máster en Sistemas de Energía Eléctrica. Página 48
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 +��� � +�� �
Máster en Sistemas de Energía Eléctrica. Página 49
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.
Máster en Sistemas de Energía Eléctrica. Página 50
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:
Máster en Sistemas de Energía Eléctrica. Página 51
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:
Máster en Sistemas de Energía Eléctrica. Página 52
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
Máster en Sistemas de Energía Eléctrica. Página 53
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
Máster en Sistemas de Energía Eléctrica. Página 54
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.
Máster en Sistemas de Energía Eléctrica. Página 55
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
RECOM A, B, K, w, V, I, n, m
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
RECOM A, B, K, w, V, I, n, m
Máster en Sistemas de Energía Eléctrica. Página 56
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
Máster en Sistemas de Energía Eléctrica. Página 57
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
Máster en Sistemas de Energía Eléctrica. Página 58
Para dos vehículos:
>> CREA(2)
ans =
Tabla de vehículos y nodos por los que pasan
V2 =
1 4 5 2 0
2 6 3 7 8
Máster en Sistemas de Energía Eléctrica. Página 59
Para tres vehículos:
>> CREA(3)
ans =
Tabla de vehículos y nodos por los que pasan
V2 =
1 4 5 3 7
2 2 0 0 0
3 6 8 0 0
Máster en Sistemas de Energía Eléctrica. Página 60
Para cuatro vehículos:
>> CREA(4)
ans =
Tabla de vehículos y nodos por los que pasan
V2 =
1 4 5 7
2 8 0 0
3 2 0 0
4 6 3 0
Máster en Sistemas de Energía Eléctrica. Página 61
Para cinco vehículos:
>> CREA(5)
ans =
Tabla de vehículos y nodos por los que pasan
V2 =
1 4 5 7
2 6 0 0
3 8 0 0
4 3 0 0
5 2 0 0
Máster en Sistemas de Energía Eléctrica. Página 62
Para seis vehículos:
>> CREA(6)
ans =
Tabla de vehículos y nodos por los que pasan
V =
1 8 0
2 3 7
3 5 0
4 4 0
5 6 0
6 2 0
Máster en Sistemas de Energía Eléctrica. Página 63
Para siete vehículos:
>> CREA(7)
ans =
Tabla de vehículos y nodos por los que pasan
V =
1 8
2 7
3 6
4 5
5 4
6 3
7 2
Máster en Sistemas de Energía Eléctrica. Página 64
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.
Máster en Sistemas de Energía Eléctrica. Página 65
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.
Máster en Sistemas de Energía Eléctrica. Página 66
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.
Máster en Sistemas de Energía Eléctrica. Página 67
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.
Máster en Sistemas de Energía Eléctrica. Página 68
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
Máster en Sistemas de Energía Eléctrica. Página 69
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.
Máster en Sistemas de Energía Eléctrica. Página 70
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.
Máster en Sistemas de Energía Eléctrica. Página 71
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.
Máster en Sistemas de Energía Eléctrica. Página 72
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;
Máster en Sistemas de Energía Eléctrica. Página 73
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;
Máster en Sistemas de Energía Eléctrica. Página 74
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
Máster en Sistemas de Energía Eléctrica. Página 75
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';
Máster en Sistemas de Energía Eléctrica. Página 76
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
Máster en Sistemas de Energía Eléctrica. Página 77
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;
Máster en Sistemas de Energía Eléctrica. Página 78
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;
Máster en Sistemas de Energía Eléctrica. Página 79
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
Máster en Sistemas de Energía Eléctrica. Página 80
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
Máster en Sistemas de Energía Eléctrica. Página 81
% 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
Máster en Sistemas de Energía Eléctrica. Página 82
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
Máster en Sistemas de Energía Eléctrica. Página 83
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
Máster en Sistemas de Energía Eléctrica. Página 84
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