Ejercicio de evaluación (ITIS). Ramificación y poda

Ejercicio de evaluación (ITIS). Ramificación y poda 

Recubrimiento de los vértices de un grafo 

Un recubrimiento de los vértices de un grafo no dirigido G = 〈V , A〉 es un 

subconjunto de vértices R ⊆ V cuyos elementos son adyacentes a todos 

los demás vértices del grafo: Por cada vértice v del grafo, existe una arista 

en A que lo une con algún vértice de R, o bien v ∈ R. 

Diseña un algoritmo de ramificación y poda que obtenga un recubrimiento 

de vértices de tamaño mínimo de un grafo. Detalla lo siguiente: 

1. El árbol de búsqueda: significado de las aristas, los niveles y el 

contenido de cada nodo. 

2. El pseudocódigo del algoritmo. 

3. La función o funciones de cálculo de cotas. 

Yolanda García, Jesús Correas (DSIC - UCM) 1 / 18

Solución ej. evaluación (ITIS). Ramificación y poda 

Como debemos proporcionar un subconjunto de los vértices, podemos 

utilizar una tupla de valores booleanos 〈x1, . . . , xn〉, donde xi tiene 

valor cierto si el vértice i pertenece al conjunto, o falso en caso 

contrario. 

El grafo puede venir representado mediante su matriz de adyacencia, 

ya que debemos recorrer los vértices uno por uno. 

Cada nivel del árbol corresponde a un vértice del grafo. 

Cada nodo del árbol tiene dos descendientes. 

Las soluciones están en el nivel N, número de vértices del grafo 

(podrían estar antes del nivel N si determinamos que todos los 

vértices ya están recubiertos). 

Restricciones explícitas: xi ∈ {0, 1} 

Restricciones implícitas: no tiene 

La solución debe cumplir que todos los vértices del grafo son 

seleccionados o adyacentes a alguno de los vértices seleccionados. 



Cada nodo del árbol tiene la siguiente estructura: 

Solución parcial (sol[1..N]) 

etapa 

número de vértices de la solución (num) 

número de vértices pendientes de recubrir (vPendientes) 

vértices recubiertos (vRecubiertos[1..N]) 

cota inferior (cinf) 

cota superior (csup) 

Con la forma del árbol descrita, pueden existir nodos intermedios del 

árbol desde los que no se pueda obtener ninguna solución. 



Sin embargo, si podemos determinar que desde un nodo del árbol de 

expansión no se llega a ninguna solución, podríamos evitar la 

generación de estos nodos. 

Si tenemos una solución parcial factible (que permite llegar a un 

recubrimiento de los vértices del grafo) hasta la etapa k, se pueden 

tomar dos decisiones posibles sobre el vértice k+1: 

a) Si decidimos incluir el vértice k+1 en el conjunto, la solución parcial 

seguirá siendo factible; 

b) Si decidimos no incluirlo, la solución puede dejar de ser factible, si 

algún vértice queda no recubierto por ningún otro vértice que se pueda 

seleccionar en alguna etapa posterior a k+1 

La comprobación de factibilidad se puede realizar con un algoritmo 

con coste cuadrático en el caso peor. En caso de resultar no factible, 

no se genera el nodo correspondiente en el árbol: se puede utilizar 

un esquema de poda basado en dos cotas. 

Si no se hace esta comprobación de factibilidad, entonces 

deberá utilizarse un esquema de poda basado en una sola cota. 


Solución ej. evaluación (ITIS). Ramificación y poda (cont.) 

proc recub-vertices(D[1..n,1..n],mejorSol[1..n], Cota) 

Cota ← ∞ ; nodoRaiz(raiz,D) ; introducir(Lnv, raiz) 

mientras not(vacia(Lnv)) hacer 

sacar(Lnv,x) 

si x.cinf ≤ Cota entonces 

generarHijos(x, hijos, numhijos, calles) 

desde i ← 1 hasta numhijos hacer 

si (hijos[i].cinf ≤ Cota) entonces 

si hijos[i].vPendientes = 0 entonces 

mejorSol ← hijos[i].sol ; Cota ← hijos[i].num 

si no si hijos[i].etapa < N entonces 

Cota ← min(Cota,hijos[i].csup) ; introducir(Lnv,hijos[i]) 

fin si 

fin si 

fin desde 

fin si 

fin mientras 

fin proc 



proc generarHijos(nodo, hijos[1..2], numhijos, D[1..N,1..N]) 

newEtapa ← nodo.etapa +1 

// primer caso: se elige el vértice newEtapa 

crear hijos[1] ; hijos[1].etapa ← newEtapa ; hijos[1].sol ← nodo.sol 

hijos[1].sol[newEtapa] ← cierto ; hijos[1].num ← nodo.num + 1 

hijos[1].vPendientes ← nodo.vPendientes ; hijos[1].vRecubiertos ← nodo.vRecubiertos 

desde i ← 1 hasta N hacer 

si D[newEtapa,i] ∨ i = newEtapa entonces 

si ¬hijos[1].vRecubiertos[i] entonces hijos[1].vPendientes ← hijos[1].vPendientes-1 

hijos[1].vRecubiertos[i] ← cierto 

fin si 


hijos[1].cinf ← calcCinf(hijos[1],D) ; hijos[1].csup ← calcCsup(hijos[1],D) 

// segundo caso: no se elige el vértice newEtapa 

si factible(nodo,D,newEtapa) entonces 

crear hijos[2] ; numHijos ← 2 ; hijos[2].etapa ← newEtapa ; hijos[2].sol ← nodo.sol 

hijos[2].num ← nodo.num ; hijos[2].vPendientes ← nodo.vPendientes 

hijos[2].cinf ← calcCinf(hijos[2],D) ; hijos[2].csup ← calcCsup(hijos[2],D) 

si no 

numHijos ← 1 

fin si 

fin proc 



fun factible(padre, D[1..N,1..N], newEtapa) 

// Comprueba si no eligiendo el vértice newEtapa la solución 

// es factible (se puede llegar al recubrimiento de todos los vértices) 

esFactible ← cierto ; i ← 1 

mientras i ≤ newEtapa ∧ esFactible hacer 

// en el bucle externo se buscan los vértices conectados con newEtapa 

// (incluyendo el propio vértice newEtapa) que no se han seleccionado 

si (D[newEtapa,i] ∧¬padre.sol[i]) ∨ newEtapa = i entonces 

j ← 1 

// Se comprueba si el vértice i está cubierto por algún otro vértice seleccionado 

mientras j ≤ newEtapa-1 ∧¬(D[i,j] ∧ padre.sol[j]) hacer j ← j+1 

// Si el vértice i no está cubierto por ningún vértice seleccionado, 

// se comprueba si se podría cubrir por algún otro vértice no considerado todavía 

si j = newEtapa entonces 

mientras j ≤ N ∧¬D[i,j] hacer j ← j+1 

// Si no se puede cubrir por ningún otro vértice, entonces no es factible 

si j > N entonces esFactible ← falso 

fin si 

fin si 

i ← i + 1 

fin mientras 

devolver esFactible 

fin fun 



proc NodoRaiz(raiz,D[1..n,1..n]) 

crearNodo(raiz) 

desde i ← 1 hasta n hacer 

raiz.sol[i] ← falso ; raiz.vRecubiertos[i] ← falso 


raiz.etapa ← 0 

raiz.num ← 0 

raiz.cinf ← calcCinf(raiz, D) 

raiz.csup ← calcCsup(raiz, D) 

raiz.vPendientes ← n // Inicialmente ningún vértice está recubierto 

fin proc 



Como cota inferior, se va a considerar la suma de: 

◮ los vértices seleccionados hasta el momento 

◮ más el número de vértices no cubiertos dividido por el grado máximo 

de los vértices no considerados todavía: La suposición optimista es que, 

de los nodos pendientes, no van a existir dos nodos que recubran los 

mismos vértices, y todos los nodos tienen el mismo grado máximo. 

Como cota superior, se puede considerar la suma de: 


◮ más el número de vértices pendientes (suponemos que todos los 

vértices que quedan son elegidos) 



fun calcCinf(nodo, D[1..N,1..N]) 

gradoMax ← 0 

desde i ← nodo.etapa+1 hasta N hacer 

grado ← 0 

desde j ← 1 hasta N hacer 

si ¬nodo.vRecubiertos[j] ∧ D[i,j] entonces grado ← grado + 1 


si grado > gradoMax entonces gradoMax ← grado 


devolver nodo.num + nodo.numPendientes / (gradoMax + 1) 

// Se consideran los vértices que pueden recubrir tantos vértices distintos 

// como indica el grado máximo 

fin fun 

fun calcCsup(nodo, D[1..N,1..N]) 

devolver nodo.num + (N - nodo.etapa) 

fin fun 


Ejercicio de evaluación (ITIG). Ramificación y Poda 

VERTEX-COVER 

En un grafo no dirigido G = 〈V , A〉, un recubrimiento de vértices 

(vertex-cover) es un subconjunto de vértices V ′ ⊆ V tal que, para todas 

las aristas (u, v) ∈ A, entonces u ∈ V ′ o bien v ∈ V ′ (o ambos). 

Diseña un algoritmo de ramificación y poda que proporcione el 

recubrimiento de vértices (vertex-cover) de tamaño mínimo. Detalla lo 

siguiente: 

1. El árbol de búsqueda: significado de las aristas, los niveles y el 

contenido de cada nodo. 

2. El pseudocódigo del algoritmo. 

3. La función o funciones de cálculo de cotas. 


Solución ej. evaluación (ITIG). Ramificación y poda 

El grafo de entrada se puede representar mediante una matriz de 

adyacencia booleana. 

Como el resultado del algoritmo consiste en un subconjunto de los 

vértices del grafo, la solución puede estar formada por un vector 

booleano de n elementos que contiene cierto si el vértice pertenece al 

conjunto. 

El árbol tiene grado 2, y cada una de las aristas corresponde a si se 

elige o no el vértice correspondiente a ese nivel. 

El nodo del árbol de búsqueda tiene los siguientes atributos: 

Solución actual (sol[1..n]) 

Núm. vértices seleccionados en la solución actual (num) 

Núm. aristas pendientes de cubrir (numPendientes) 

etapa 

cota inferior (cinf) 

cota superior (csup) 


Solución ej. evaluación (ITIG). Ramificación y poda (cont.) 

proc vertex-cover(D[1..n,1..n],mejorSol[1..n], Cota) 

Cota ← ∞ ; nodoRaiz(raiz,D) ; introducir(Lnv, raiz) 

mientras not(vacia(Lnv)) hacer 

sacar(Lnv,x) 

si x.cinf ≤ Cota entonces 

generarHijos(x, hijos, numhijos, D) 

desde i ← 1 hasta numhijos hacer 

si (hijos[i].cinf ≤ Cota) entonces 

si hijos[i].numPendientes = 0 entonces 

mejorSol ← hijos[i].sol ; Cota ← hijos[i].num 

si no si hijos[i].etapa < N entonces 

Cota ← min(Cota,hijos[i].csup) ; introducir(Lnv,hijos[i]) 

fin si 

fin si 


fin si 

fin mientras 

fin proc 



proc generarHijos(nodo, hijos[1..2], numhijos, D[1..n,1..n]) 

newEtapa ← nodo.etapa +1 

// primer caso: se elige el vértice newEtapa 

crear hijos[1] 

hijos[1].etapa ← newEtapa ; hijos[1].sol ← nodo.sol 

hijos[1].sol[newEtapa] ← cierto 

hijos[1].num ← nodo.num + 1 

hijos[1].numPendientes ← numAristasPtes(hijos[1],D) 

hijos[1].cinf ← calcCinf(hijos[1],D) 

hijos[1].csup ← calcCsup(hijos[1],D) 

// primer caso: no se elige el vértice 

si factible(nodo,D) entonces 

crear hijos[2] 


hijos[2].etapa ← newEtapa ; hijos[2].sol ← nodo.sol 

hijos[2].num ← nodo.num 

hijos[2].numPendientes ← nodo.numPendientes 

hijos[2].cinf ← calcCinf(hijos[2],D) 

hijos[2].csup ← calcCsup(hijos[2],D) 

si no 


fin si 

fin proc 



fun numAristasPtes(nodo,D[1..n,1..n]) 

// calcula el número de aristas pendientes de cubrir 

numAristas ← 0 

desde j ← 1 hasta n hacer 

si ¬nodo.sol[j] ∧ D[j,nodo.etapa] entonces 

numAristas ← numAristas + 1 

fin si 


devolver nodo.numPendientes - numAristas 

fin fun 

fun factible(nodo, D[1..n,1..n]) 

// Comprueba si no eligiendo el vértice nodo.etapa+1 la solución 

// es factible (se puede llegar al recubrimiento de todas las aristas) 

desde i ← 1 hasta nodo.etapa hacer 

si ¬nodo.sol[i] ∧ D[i,nodo.etapa+1] entonces devolver falso 


devolver cierto 

fin fun 



proc NodoRaiz(raiz,D[1..n,1..n]) 

crearNodo(raiz) 


raiz.sol[i] ← falso 


raiz.etapa ← 0 

raiz.num ← 0 

raiz.cinf ← calcCinf(raiz, D) 

raiz.csup ← calcCsup(raiz, D) 

raiz.numPendientes ← 0 


desde j ← i+1 hasta n hacer 

si D[i,j] entonces raiz.numPendientes ← raiz.numPendientes + 1 



fin proc 



Se pueden utilizar el esquema de poda basado en dos cotas porque, 

según está definido el algoritmo, no pueden existir hojas que no sean 

solución: 

◮ La función factible garantiza que si no se selecciona un nodo, no 

quedan aristas que ya no se podrán recubrir con ningún otro nodo; 

◮ Por otra parte, si una solución parcial es factible, existe al menos una 

solución posible (por ejemplo, seleccionando todos los vértices 

pendientes de considerar). 

Como cota inferior, se va a considerar la suma de: 


◮ más el número de aristas no cubiertas dividido por el grado máximo de 

los vértices pendientes: La suposición optimista es que, de los vértices 

pendientes, no van a existir dos vértices que recubran la misma arista. 

Como cota superior, se puede considerar la suma de: 


◮ más el número de vértices pendientes (suponemos que todos los 

vértices que quedan son elegidos) 



fun calcCinf(nodo, D[1..n,1..n]) 

maxGrado ← 0 


si ¬nodo.sol[i] entonces 

grado ← 0 

desde j ← i+1 hasta n hacer 

si ¬nodo.sol[j] ∧ D[i,j] entonces grado ← grado + 1 


si grado > maxGrado entonces maxGrado ← grado 

fin si 


devolver nodo.num + ⌊ nodo.numPendientes / maxGrado ⌋ 

fin fun 

fun calcCsup(nodo, D[1..n,1..n]) 

devolver nodo.num + (n - nodo.etapa) 

fin fun

Ejercicio de evaluación (ITIS). Ramificación y poda

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?