1.

Durante cualquier periodo, un cliente potencial llega a cierta instalación de servicio con pro-
babilidad de 21 . Si se encuentra que hay dos personas en la instalación (incluyendo la que está en
servicio), el cliente potencial deja la instalación de inmediato y nunca regresa. Sin embargo, si hay
una o menos personas, entra y se convierte en un cliente real. El administrador de la instalación
dispone de dos tipos de tasa de servicio. Si utiliza el servicio “lento” a un costo de 3 dólares durante
un periodo, podrá servir a un cliente que llega con probabilidad de 35 . Si utiliza su servicio “rápido”
a un costo de 9$ por periodo, podrá servir a un cliente que llega con probabilidad de 45 . Observe
que la probabilidad de que llegue más de un cliente o se sirva a más de un cliente en un periodo es
cero. Se tienen ganancias de 50 $ cuando se sirve a un cliente.

1. Utilice la enumeración exhaustiva para identificar todas las polı́ticas determinı́sticas estacio-
narias.

2. Formule el problema como un problema de programación lineal.

3. Utilice el algoritmo de mejoramiento de una polı́tica para determinar la polı́tica que debe
seguir el administrador para minimizar su costo promedio esperado a largo plazo por periodo.
Sugerencia: al calcular los costos de servicio cuando hay dos clientes en la instalación no
debe olvidarse el costo de oportunidad de perder un cliente potencial.

Solución:

Apartado (a)
Hacemos las siguientes consideraciones:

• Estado i = hay i clientes en la instalación, i = 0, 1, 2.

• Decisión k = 1 = uso de la tasa de servicio lenta.

• Decisión k = 2 = uso de la tasa de servicio rápida.

• Costo inmediato (diario) neto esperado en el estado i al tomar la acción k = Cik

3 4
C11 = 3 − × 50 = −27, C12 = 9 − × 50 = −31,
5 5
C21 = −27, C22 = −31, C01 = 0, C02 = 0
Para C11 , cuesta 3 por utilizar el servicio con tasa lenta y se resta el posible beneficio de que
realmente sea atendido: 35 × 50. C0k cuesta 0, porque no se utiliza ningún servicio. Para el
resto de valores, se sigue un razonamiento análogo.
En forma matricial, serı́a:  
0 0
Cik =  −27 −31 
−27 −31

Las cuatro polı́ticas estacionarias posibles consideradas son: R1 , R2 , R3 , R4 (Nota: −− significa

que podrı́a considerarse cualquier acción 1 o 2, ya que al no haber nadie no se utiliza el servicio):

Estado i di (R1 ) di (R2 ) di (R3 ) di (R4 )

0 −− −− −− −−
1 1 1 2 2
2 1 2 1 2

1
 Antes de calcular las matrices de transición asociada a cada una de las cuatro polı́ticas, deter-
minamos las probabilidades de transición bajo las distintas acciones (k = 1 y k = 2) de decisión:
1
p00 (k = 1) = P [no entre] =
2
1
p01 (k = 1) = P [entre] =
2
p02 (k = 1) = P [imposible] = 0
1 3 3
p10 (k = 1) = P [entre y sirve] = =
2 5 10
13 12 1
p11 (k = 1) = P [(entre y sirve) o (no entre y no sirve)] = + =
25 25 2
1 2 1
p12 (k = 1) = P [entre y no sirve] = =
2 5 5
p20 (k = 1) = P [imposible] = 0
3
p21 (k = 1) = P [no entre nadie se van y sirve] =
5
2
p22 (k = 1) = P [no entre nadie se van y no sirve] =
5
Decisión 1
0 1 2
pij (k = 1) = 0 12 12 0
3 1 1
1 10 2 5
2 0 53 52

1
p00 (k = 2) = P [no entre] =
2
1
p01 (k = 2) = P [entre] =
2
p02 (k = 2) = P [imposible] = 0
1 4 2
p10 (k = 2) = P [entre y sirve] = =
2 5 5
14 11 1
p11 (k = 2) = P [(entre y sirve) o (no entre y no sirve)] = + =
25 25 2
1 1 1
p12 (k = 2) = P [entre y no sirve] = =
2 5 10
p20 (k = 2) = P [imposible] = 0
4
p21 (k = 2) = P [no entre nadie se van y sirve] =
5
1
p22 (k = 2) = P [no entre nadie se van y no sirve] =
5
Decisión 2
0 1 2
pij (k = 2) = 0 12 21 0
1 25 21 10 1

2 0 45 15
Con esta información, se deducen las matrices de transición para cada polı́tica, observando las
acciones que se llevan a cabo en cada estado de la polı́tica correspondiente:
Polı́tica R1 Polı́tica R2 Polı́tica R3 Polı́tica R4
0 1 2 0 1 2 0 1 2 0 1 2
0 12 12 0 0 12 21 0 0 12 21 0 0 12 21 0
3 1 1 3 1 1
1 10 2 5 1 10 2 5 1 25 21 10 1
1 25 21 10 1

2 0 5 52 3
2 0 5 51 4
2 0 5 25 3
2 0 5 51 4

2
 Para evaluar las 4 polı́ticas, obtenemos el costo promedio esperado (a largo plazo) diario aso-
ciado, E [C], a partir de la expresión:
2
X
E [C]R = Cik πi ,
i=0

donde k = di (R) para cada i = 0, 1, 2, y π0 , π1 , π2 son las probabilidades en estado estacionario,

que podemos calcular al resolver el sistema siguiente:

πt = πtP

donde P = (pij (R)).

Observación: Este sistema se puede escribir en el formato Ax = b, haciendo la siguiente
construcción:
π = (π t P )t = P t π; P t π − π = 0, (P t − I)π = 0
π0 = π0 p00 + π1 p10 + . . . + πn pn0 (p00 − 1)π0 + p10 π1 + . . . + pn0 πn = 0
.. ..
. .
πi = π0 p0i + π1 p1i + . . . + πn pni p0i π0 + p1i π1 + . . . + (pii − 1)πi + . . . + pni πn = 0
.. ..
. .
πn = π0 p0n + π1 p1n + . . . + πn pnn p0n π0 + p1n π1 + . . . + (pnn − 1)πn = 0
Con esta información, el siguiente código R (requiere tener instalado el paquete R: limSolve)
permite determinar los costos promedios esperados para cada polı́tica y encontrar las probabilidades
estacionarias asociadas:

> ## función que calcula para una polı́tica

> ## las probabilidades estacionarias y
> ## costos promedio esperados a largo plazo
> f_costo_largo_plazo = function(m_prob_transicion,v_costos) {
+ numestados <- length(v_costos)
+ m_identidad <- diag(rep(1,numestados))
+ m_identidad
+ v_zeros <- rep(0,numestados)
+ v_zeros
+ (m_A <- t(m_prob_transicion-m_identidad))
+ (m_A <- rbind(m_A,rep(1,numestados)))
+ (v_b <- c(v_zeros,1))
+
+
+ # Solve del paquete limSolve - Resuelve sistema lineal: A x = b
+ require("limSolve")
+ v_prob_estacionarias <- Solve(m_A,v_b)
+ v_prob_estacionarias
+
+ (costos_esperados <- v_costos %*% v_prob_estacionarias)
+ return(list(costos_esperados=costos_esperados,v_prob_estacionarias=v_prob_estacionarias))
+ }
>
> m_prob_transicion_R1 <- matrix(c(0.5,0.5,0,0.3,0.5,0.2,0,0.6,0.4),c(3,3),byrow=T)
> m_prob_transicion_R1
[,1] [,2] [,3]
[1,] 0.5 0.5 0.0
[2,] 0.3 0.5 0.2

3
[3,] 0.0 0.6 0.4
> v_costos_R1 <- c(0,-27,-27)
>
> (res_R1 <- f_costo_largo_plazo(m_prob_transicion_R1,v_costos_R1))
$costos_esperados
[,1]
[1,] -18.62069

$v_prob_estacionarias
[1] 0.3103448 0.5172414 0.1724138

>
> m_prob_transicion_R2 <- matrix(c(0.5,0.5,0,0.3,0.5,0.2,0,0.8,0.2),c(3,3),byrow=T)
> m_prob_transicion_R2
[,1] [,2] [,3]
[1,] 0.5 0.5 0.0
[2,] 0.3 0.5 0.2
[3,] 0.0 0.8 0.2
> v_costos_R2 <- c(0,-27,-31)
>
> (res_R2 <- f_costo_largo_plazo(m_prob_transicion_R2,v_costos_R2))
$costos_esperados
[,1]
[1,] -18.78378

$v_prob_estacionarias
[1] 0.3243243 0.5405405 0.1351351

>
>
> m_prob_transicion_R3 <- matrix(c(0.5,0.5,0,0.4,0.5,0.1,0,0.6,0.4),c(3,3),byrow=T)
> m_prob_transicion_R3
[,1] [,2] [,3]
[1,] 0.5 0.5 0.0
[2,] 0.4 0.5 0.1
[3,] 0.0 0.6 0.4
> v_costos_R3 <- c(0,-31,-27)
>
> (res_R3 <- f_costo_largo_plazo(m_prob_transicion_R3,v_costos_R3))
$costos_esperados
[,1]
[1,] -18.05085

$v_prob_estacionarias
[1] 0.40677966 0.50847458 0.08474576

>
> m_prob_transicion_R4 <- matrix(c(0.5,0.5,0,0.4,0.5,0.1,0,0.8,0.2),c(3,3),byrow=T)
> m_prob_transicion_R4
[,1] [,2] [,3]
[1,] 0.5 0.5 0.0
[2,] 0.4 0.5 0.1
[3,] 0.0 0.8 0.2

4
 > v_costos_R4 <- c(0,-31,-31)
>
> (res_R4 <- f_costo_largo_plazo(m_prob_transicion_R4,v_costos_R4))
$costos_esperados
[,1]
[1,] -18.11688

$v_prob_estacionarias
[1] 0.41558442 0.51948052 0.06493506

>
> res_minimo_R <- min(c(res_R1$costos_esperados,res_R2$costos_esperados,
res_R3$costos_esperados,res_R4$costos_esperados))
> res_minimo_R
[1] -18.78378
> res_donde_minimo_R <- which.min(c(res_R1$costos_esperados,res_R2$costos_esperados,
res_R3$costos_esperados,res_R4$costos_esperados))
> res_donde_minimo_R
[1] 2

Apartado (b)
La resolución con ayuda de un problema de programación lineal serı́a la siguiente:
P2 P2
M in C yik
i=0 k=1P2ik P 2
s.a. k=1 yik =1
P2 P2 Pi=02
k=1 yjk − i=0 k=1 yik pij (k) = 0, j = 0, 1, 2(estado j)
yik = 0, ∀i, ∀k
Disponemos de los datos necesarios para escribir nuestro problema particular:

Decisión 1 Decisión 2  
0 1 2 0 1 2 0 0
pij (k = 1) = 0 12 12 0 pij (k = 2) = 0 12 21 0 , Cik =  −27 −31 
3 1 1
1 10 2 5 1 25 21 10 1
−27 −31
2 0 5 253
2 0 5 15
4

El problema lineal serı́a el siguiente:

M in −27y11 − 31y12 − 27y21 − 31y22

s.a. y01 + y02 + y11 + y12 + y21 + y22
=1
y01 + y02 − 21 y01 + 10 3
y11 + 21 y02 + 25 y12
=0
y11 + y12 − 2 y01 + 2 y11 + 5 y21 + 2 y02 + 12 y12 + 45 y22

1 1 3 1
=0
2
y21 + y22 − 10 y11 + 52 y21 + 10
1
y12 + 15 y22 =0
yik = 0, ∀i, ∀k

El siguiente código R permite resolver el problema lineal asociado:

> ## función que resuelve el problema de programación lineal

> f_prob_lineal_resolucion = function(m_pl_Cik,m_prob_transicion) {
+
+ numestados <- dim(m_pl_Cik)[1]
+ numpoliticas <- dim(m_pl_Cik)[2]
+ numvariables <- numestados * numpoliticas
+ v_c <- c(array(t(m_pl_Cik),c(numvariables,1)))

5
+ v_c
+ m_A_temp <- rep(1,numvariables)
+ for (i in 1:numestados) {
+ v_temp1 <- rep(0,numvariables)
+ ind_ini <- 1+numpoliticas*(i-1)
+ v_temp1[ind_ini:(ind_ini+numpoliticas-1)] <- rep(1,numpoliticas)
+ v_temp2 <- c(array(t(m_prob_transicion[,i,]),c(numvariables,1)))
+ v_fila_estadoi <- v_temp1-v_temp2
+ m_A_temp <- rbind(m_A_temp,v_fila_estadoi)
+
+ }
+ m_A_temp
+ v_b <- c(1,rep(0,numestados))
+ f.des <- rep("=",(numestados+1))
+ sol_plineal <- lp ("min", v_c, m_A_temp, f.des, v_b)
+ sol_plineal
+ v_temp4 <- sol_plineal$solution
+ m_y_solucion <- matrix(v_temp4,c(numestados,numpoliticas),byrow=T)
+
+ return(list(var_decision=m_y_solucion,valor_objetivo=sol_plineal,
vc=v_c,mA=m_A_temp,vb=v_b))
+
+
+ }
>
>
> ##Problema 1:
> m_pl_Cik <- matrix(c(0,0,-27,-31,-27,-31),c(3,2),byrow=T)
> m_prob_transicion_d1 <- matrix(c(0.5,0.5,0,0.3,0.5,0.2,0,0.6,0.4),c(3,3),byrow=T)
> m_prob_transicion_d2 <- matrix(c(0.5,0.5,0,0.4,0.5,0.2,0,0.8,0.2),c(3,3),byrow=T)
>
>
> m_prob_transicion <- array(0,c(3,3,2))
> m_prob_transicion[,,1] <- m_prob_transicion_d1
> m_prob_transicion[,,2] <- m_prob_transicion_d2
> m_prob_transicion
, , 1

[,1] [,2] [,3]

[1,] 0.5 0.5 0.0
[2,] 0.3 0.5 0.2
[3,] 0.0 0.6 0.4

, , 2

[,1] [,2] [,3]

[1,] 0.5 0.5 0.0
[2,] 0.4 0.5 0.2
[3,] 0.0 0.8 0.2

>
>
> f_prob_lineal_resolucion(m_pl_Cik,m_prob_transicion)

6
 $var_decision
[,1] [,2]
[1,] 0.3243243 0.0000000
[2,] 0.5405405 0.0000000
[3,] 0.0000000 0.1351351

$valor_objetivo
Success: the objective function is -18.78378

$vc
[1] 0 0 -27 -31 -27 -31

$mA
[,1] [,2] [,3] [,4] [,5] [,6]
m_A_temp 1.0 1.0 1.0 1.0 1.0 1.0
v_fila_estadoi 0.5 0.5 -0.3 -0.4 0.0 0.0
v_fila_estadoi -0.5 -0.5 0.5 0.5 -0.6 -0.8
v_fila_estadoi 0.0 0.0 -0.2 -0.2 0.6 0.8

$vb
[1] 1 0 0 0

Apartado (c)
Consideramos de nuevo los datos de nuestro problema:

Decisión 1 Decisión 2  
0 1 2 0 1 2 0 0
pij (k = 1) = 0 12 12 0 pij (k = 2) = 0 12 21 0 , Cik =  −27 −31 
3 1 1
1 10 2 5 1 25 21 10 1
−27 −31
2 0 5 253
2 0 5 15
4

Consideramos como polı́tica inicial: d0 (R1 ) = 1, d1 (R1 ) = 1 y d2 (R1 ) = 2.

Paso 1 (determinación del valor): Vamos a encontrar los valores de la polı́tica considerada
R1 resolviendo el siguiente sistema, donde las variables son g(R), v0 (R), v1 (R), ya que definimos
v2 (R) = 0:
X2
g(R) + vi (R) = Cik + pij (k) vi (R), i = 0, 1, 2
j=0

O también:  
2
X
g(R) = Cik +  pij (k) vi (R) − vi (R), i = 0, 1, 2
j=0

En nuestro caso es:

g(R) = 0 + 0.5v0 (R) + 0.5v1 (R) + 0v2 (R) − v0 (R)
g(R) = −27 + 0.3v0 (R) + 0.5v1 (R) + 0.2v2 (R) − v1 (R)
g(R) = −31 + 0v0 (R) + 0.8v1 (R) + 0.2v2 (R) − v2 (R)

Cuya solución es:

g(R) = −18.8, v0 (R) = 52.84, v1 (R) = 15.27, v2 (R) = 0

7
 En el paso 2 (mejoramiento de la polı́tica): utilizando los valores actuales de vi (R1 ), encontramos
la polı́tica alternativa R2 , que para cada estado i, di (R2 ) = k2 es la que minimiza:
2
X
Cik2 + pij (k2 )vj (R1 ) − vi (R1 ), k2 = 1, 2
j=0

En nuestro caso:

• Estado 0:
0 + 0.5(52.84) + 0.5(15.27) + (0) − (52.84) = −18.8∗ (k2 = 1)
0 + 0.5(52.84) + 0.5(15.27) + (0) − (52.84) = −18.8 (k2 = 2)

• Estado 1:
−27 + 0.3(52.84) + 0.5(15.27) + (0) − (15.27) = −18.8∗ (k2 = 1)
−31 + 0.4(52.84) + 0.5(15.27) + (0) − (15.27) = −17.5 (k2 = 2)

• Estado 2:
−27 + 0(52.84) + 0.6(15.27) + (0) − (0) = −17.8 (k2 = 1)
−31 + 0(52.84) + 0.8(15.27) + (0) − (15.27) = −18.8∗ (k2 = 2)

Luego la polı́tica óptima serı́a: d0 (R2 ) = 1, d1 (R2 ) = 1 y d2 (R2 ) = 2.

Como coincide, termina el algoritmo, siendo esta la polı́tica óptima (igual que con el procedi-
miento de programación lineal).
El siguiente código R facilita los cálculos necesarios para llevar a cabo este algoritmo:

> ## función que calcula datos algoritmo de mejoramiento

> f_iteracion_alg_mejoramiento = function(v_politica,m_prob_transicion,m_costos_cik) {
+
+ numestados <- length(v_politica)
+ numpoliticas <- dim(m_costos_cik)[2]
+ m_identidad <- diag(rep(1,numestados-1))
+ m_identidad
+ m_temp <- rbind(m_identidad,rep(0,numestados-1))
+ m_temp
+
+ m_prob_temp <- matrix(rep(0,numestados*(numestados-1)),
c(numestados,(numestados-1)),byrow=T)
+
+ for(estado in 1:numestados) {
+ m_prob_temp[estado,] <- m_prob_transicion[estado,1:(numestados-1),
v_politica[estado]]
+ }
+ m_prob_temp
+
+ m_temp2 <- m_temp - m_prob_temp
+ m_temp2
+ m_A <- cbind(m_temp2,rep(1,numestados))
+ m_A
+
+ m_costos_cik
+
+ v_b <- rep(0,numestados)

8
+ for(i in 1:numestados) {
+ v_b[i] <- m_costos_cik[i,v_politica[i]]
+ }
+ v_b
+
+ # Solve del paquete limSolve - Resuelve sistema lineal: A x = b
+ require("limSolve")
+ v_valores_estados <- Solve(m_A,v_b)
+ v_valores_estados <- c(v_valores_estados[1:(numestados-1)],0,
v_valores_estados[numestados])
+
+ m_final <- c()
+ for(politica in 1:numpoliticas) {
+ v_temp1 <- m_costos_cik[,politica]
+ m_temp2 <- m_prob_transicion[,,politica]
+ v_temp2 <- v_valores_estados[1:(numestados)]
+ v_temp3 <- m_temp2 %*% v_temp2
+ v_temp4 <- c(v_valores_estados[1:numestados])
+ v_final <- v_temp1 + v_temp3 - v_temp4
+ m_final <- cbind(m_final,v_final)
+ }
+ m_final
+
+ v_politica_siguiente <- c()
+ v_min_politica <- c()
+ for (i in 1:numestados) {
+ j <- which.min(m_final[i,])
+ jmin <- min(m_final[i,])
+ v_politica_siguiente <- c(v_politica_siguiente,j)
+ v_min_politica <- c(v_min_politica,jmin)
+ }
+ v_politica_siguiente
+ v_min_politica
+
+ return(list(vpolitica=v_politica_siguiente,
vvalores=v_valores_estados,m_costos=m_final))
+
+ } # final function
>
>
> v_politica <- c(1,1,2)
> m_costos_cik <- matrix(c(0,0,-27,-31,-27,-31),c(3,2),byrow=T)
> m_prob_transicion_d1 <- matrix(c(0.5,0.5,0,0.3,0.5,0.2,0,0.6,0.4),c(3,3),byrow=T)
> m_prob_transicion_d2 <- matrix(c(0.5,0.5,0,0.4,0.5,0.2,0,0.8,0.2),c(3,3),byrow=T)
>
>
> m_prob_transicion <- array(0,c(3,3,2))
> m_prob_transicion[,,1] <- m_prob_transicion_d1
> m_prob_transicion[,,2] <- m_prob_transicion_d2
> m_prob_transicion
, , 1

[,1] [,2] [,3]

9
 [1,] 0.5 0.5 0.0
[2,] 0.3 0.5 0.2
[3,] 0.0 0.6 0.4

, , 2

[,1] [,2] [,3]

[1,] 0.5 0.5 0.0
[2,] 0.4 0.5 0.2
[3,] 0.0 0.8 0.2

>
>
> f_iteracion_alg_mejoramiento(v_politica,m_prob_transicion,m_costos_cik)
$vpolitica
[1] 1 1 2

$vvalores
[1] 52.83784 15.27027 0.00000 -18.78378

$m_costos
[,1] [,2]
[1,] -18.78378 -18.78378
[2,] -18.78378 -17.50000
[3,] -17.83784 -18.78378

El código R ha considerado una transformación del sistema original, para conseguir el sistema de
ecuaciones en el formato Ax = b.
La transformación para la ecuación asociada al estado i-ésimo podrı́a escribirse como
M
X −1
g(R) + vi (R) − pij (k)vj (R) = Cik + piM (k)vM (R)
j=0

de donde, como vM (R) = 0:

M
X −1
g(R) + (1 − pii (k))vi (R) + (−pij (k))vj (R) = Cik
j=0,6=i

10