Investigación de Operaciones · II Semestre, 2026 · Tecnológico de Costa Rica

Trabajo de Investigación

Cuatro modelos del curso con Python y R, y el problema de transbordo con Python, R y Solver

RutaIntegrantePresenta
AAarón Líos CubilloIntroducción · I.4 Asignación · II.3 Modelo matricial
DDavid Molina GuerreroI.1 Programación lineal · II.4 Solución en R, Python y Solver
JJuan Ignacio Alpízar VillalobosI.2 Programación lineal entera · II.5 Modelos desbalanceados
MMariana De Los Ángeles Acuña RodríguezI.3 Transporte · II.1 y II.2 Transbordo y transporte

Profesor: Esteban José Ballestero Alfaro

Intro

Tres variantes de un mismo problema

AarónIntroducción

Transporte

Minimizar el costo de llevar bienes desde unos orígenes hasta unos destinos.

Asignación

Repartir tareas para minimizar el costo o maximizar el rendimiento de quienes las hacen.

Transbordo

La mercancía puede pasar por puntos intermedios antes de llegar a su destino. Es el tema de la Parte II.

Intro

Las dos partes del trabajo

AarónIntroducción

Parte I · Cuatro modelos con Python y R

PuntoModeloLibreríasRuta
I.1Programación linealSciPy · PuLP · lpSolveDavid
I.2Programación lineal enteraSciPy · PuLP · lpSolveJuan Ignacio
I.3TransportePuLP · OR-Tools · lpSolveMariana
I.4AsignaciónSciPy · PuLP · lpSolve · clueAarón

Cada problema tiene al menos tres restricciones y se resuelve con varias librerías para comparar.

Parte II · El problema de transbordo

PuntoPregunta del enunciadoRuta
II.1Qué es y qué situaciones modelaMariana
II.2Relación y diferencias con transporteMariana
II.3Ejemplo y modelo matricial paso a pasoAarón
II.4Solución con R, Python y SolverDavid
II.5Modelos desbalanceadosJuan Ignacio
I.1

Programación lineal: las librerías

DavidParte I · punto 1

SciPy · linprog [1] Python

El modelo se pasa en matrices: costos, restricciones y lados derechos.

Sólo minimiza: para maximizar se le cambia el signo a la función objetivo y después al resultado.

La llamadalinprog(c, A_ub=A, b_ub=b)

PuLP 4.2 [2] Python

El modelo se escribe casi igual que en el cuaderno, como LpMaximize o LpMinimize.

En la 4.2 las variables se crean con add_variable y el solver se instala aparte (highspy).

La llamadam = pulp.LpProblem("Muebleria", pulp.LpMaximize)

lpSolve · lp() [3] R

Recibe "max" o "min", la función objetivo, la matriz de restricciones, el tipo de cada una y los lados derechos.

Acepta maximizar tal cual, sin cambiar signos.

La llamadalp("max", f.obj, f.con, f.dir, f.rhs)
I.1

El problema de la mueblería

DavidParte I · punto 1

Una mueblería hace mesas y sillas. ¿Cuántas de cada una conviene hacer a la semana?

MesaSillaDisponible
Tablones21100
Horas de trabajo1180
Utilidad (miles de ₡)3020

Además, no se pueden vender más de 40 mesas.

x_1 = mesas por semana, x_2 = sillas por semana

\max\ Z = 30x_1 + 20x_2miles de ₡

sujeto a

2x_1 + x_2 \le 100tablones
x_1 + x_2 \le 80horas
x_1 \le 40máximo de mesas
x_1,\ x_2 \ge 0
I.1

La región factible y su óptimo

DavidParte I · punto 1
Vértice(x_1, x_2)Z (miles de ₡)
O(0, 0)0
A(40, 0)1 200
B(40, 20)1 600
C(20, 60)1 800
D(0, 80)1 600

El máximo está en C, donde se cruzan la recta de tablones y la de horas. Es lo que las librerías tienen que devolver.

I.1

El mismo modelo en tres librerías

DavidParte I · punto 1
SciPyPython · extracto
from scipy.optimize import linprog
c = [-30, -20]  # sólo minimizaA = [[2, 1],
     [1, 1],
     [1, 0]]
b = [100, 80, 40]
r = linprog(c, A_ub=A, b_ub=b,
            method="highs")
print("utilidad =", -r.fun)
Resultado de la corridamesas = 20.0 sillas = 60.0 utilidad = 1800.0
PuLPPython
import pulp
m = pulp.LpProblem("Muebleria",
                  pulp.LpMaximize)x1 = m.add_variable("mesas", lowBound=0)
x2 = m.add_variable("sillas", lowBound=0)
m += 30 * x1 + 20 * x2
m += 2 * x1 + x2 <= 100
m += x1 + x2 <= 80
m += x1 <= 40
m.solve(pulp.HiGHS(msg=False))
Resultado de la corridamesas = 20.0 sillas = 60.0 utilidad = 1800.0
lpSolveR
library(lpSolve)
f.obj <- c(30, 20)
f.con <- matrix(c(2, 1,
                  1, 1,
                  1, 0),
                nrow = 3, byrow = TRUE)
f.dir <- c("<=", "<=", "<=")
f.rhs <- c(100, 80, 40)
sol <- lp("max", f.obj, f.con,
          f.dir, f.rhs)
Resultado de la corridamesas = 20 sillas = 60 utilidad = 1800
I.1

Resultado: 20 mesas y 60 sillas

DavidParte I · punto 1
LibreríaMesasSillasUtilidad (miles de ₡)
SciPy20601 800
PuLP20601 800
lpSolve20601 800

Utilidad máxima de ₡1 800 000 por semana.

Comprobación de las restricciones

RestricciónUsadoLímiteEstado
Tablones2(20) + 60 = 100100se agota
Horas20 + 60 = 8080se agota
Mesas2040sobran 20
I.2

Programación lineal entera: las librerías

Juan IgnacioParte I · punto 2

Mismas restricciones lineales, pero algunas o todas las variables tienen que ser enteras [14].

CasoQué es entero
Entera puratodas las variables
Entera mixtasólo algunas

Se usa cuando las decisiones son unidades indivisibles. Redondear la solución continua puede violar restricciones o quedar lejos del óptimo.

SciPy · milp [15] y PuLP [2] Python

integrality=[1, 1] marca las variables enteras; milp minimiza, así que se cambia el signo. En PuLP, cat="Integer" con HiGHS.

lpSolve · lp() [3] R

all.int = TRUE si todas son enteras, o int.vec si sólo algunas.

I.2

El taller de kits electrónicos

Juan IgnacioParte I · punto 2

Dos tipos de kits, A y B. Cada kit se fabrica completo: no hay fracciones.

RecursoKit AKit BDisponible
Horas de ensamble4635
Componentes3425
Horas de pruebas2112
Utilidad (miles de ₡)4560

x_1 = kits A por semana, x_2 = kits B por semana

\max\ Z = 45x_1 + 60x_2miles de ₡

sujeto a

4x_1 + 6x_2 \le 35ensamble
3x_1 + 4x_2 \le 25componentes
2x_1 + x_2 \le 12pruebas
x_1,\ x_2 \ge 0 \text{ y enteros}
I.2

Por qué no basta con redondear

Juan IgnacioParte I · punto 2

Relajación lineal

x_1 = 4{,}625,\ x_2 = 2{,}75, con ₡373 125. No es un plan que se pueda fabricar.

Redondear a (5, 3)

4(5) + 6(3) = 38 > 35. Se sale de la región.

Óptimo entero

x_1 = 4,\ x_2 = 3, con ₡360 000: el mejor de los 29 puntos enteros factibles, comprobado también enumerándolos.

I.2

El modelo entero en tres librerías

Juan IgnacioParte I · punto 2
SciPy · milpPython
from scipy.optimize import (
    milp, LinearConstraint)
c = [-45, -60]  # milp minimiza
A = [[4, 6], [3, 4], [2, 1]]
b = [35, 25, 12]
r = milp(c=c, integrality=[1, 1],    constraints=LinearConstraint(
        A, -np.inf, b))
x1, x2 = np.rint(r.x).astype(int)
Resultado de la corridakits A = 4 kits B = 3 utilidad = 360
PuLPPython
m = pulp.LpProblem("Kits_enteros",
                  pulp.LpMaximize)
x1 = m.add_variable("kit_A", lowBound=0,
                    cat="Integer")x2 = m.add_variable("kit_B", lowBound=0,
                    cat="Integer")m += 45 * x1 + 60 * x2
m += 4 * x1 + 6 * x2 <= 35
m += 3 * x1 + 4 * x2 <= 25
m += 2 * x1 + x2 <= 12
m.solve(pulp.HiGHS(msg=False))
Resultado de la corridakits A = 4 kits B = 3 utilidad = 360
lpSolveR
library(lpSolve)
f.obj <- c(45, 60)
f.con <- matrix(c(4, 6,
                  3, 4,
                  2, 1),
                nrow = 3, byrow = TRUE)
f.dir <- c("<=", "<=", "<=")
f.rhs <- c(35, 25, 12)
sol <- lp("max", f.obj, f.con,
          f.dir, f.rhs,
          all.int = TRUE)
Resultado de la corridakits A = 4 kits B = 3 utilidad = 360
I.2

Resultado: 4 kits A y 3 kits B

Juan IgnacioParte I · punto 2
LibreríaKits AKits BUtilidad (miles de ₡)
SciPy (milp)43360
PuLP43360
lpSolve43360
RestricciónUsadoLímite
Ensamble4·4 + 6·3 = 3435
Componentes3·4 + 4·3 = 2425
Pruebas2·4 + 1·3 = 1112

Entero contra continuo

ModeloPlanUtilidad (₡)
Relajación lineal(4,625; 2,75)373 125
Entero(4; 3)360 000
Diferencia13 125

Es lo que cuesta que los kits sean indivisibles. Por eso se resuelve el problema entero y no se redondea [14][15].

I.3

Transporte: las librerías

MarianaParte I · punto 3

lpSolve · lp.transport [4] R

El transporte también es programación lineal. lp.transport recibe la matriz de costos, la oferta, la demanda y el signo de cada restricción.

La llamadalp.transport(costos, direction = "min", row.signs = rep("<=", 2), row.rhs = oferta, col.signs = rep("=", 3), col.rhs = demanda)

PuLP y OR-Tools [5] Python

Dos de las librerías de optimización de código abierto más usadas. Modelan un objetivo sujeto a restricciones de oferta (capacidad de las plantas) y de demanda (lo que necesita cada cliente).

La llamadaPuLP: LpProblem(..., LpMinimize) OR-Tools: Solver.CreateSolver("GLOP")
I.3

El arroz de dos plantas

MarianaParte I · punto 3

Costo de llevar un saco de arroz de cada planta a cada supermercado.

Súper ASúper BSúper COferta
Planta 1200300400≤ 100
Planta 2250150350≤ 150
Demanda8012050250

x_{ij} = sacos de la planta i al súper j

\min\ Z = \sum_i \sum_j c_{ij}\,x_{ij}costo total

sujeto a

\textstyle\sum_j x_{ij} \le s_i2 de oferta
\textstyle\sum_i x_{ij} = d_j3 de demanda
x_{ij} \ge 0
I.3

El modelo de transporte en tres librerías

MarianaParte I · punto 3
PuLPPython
m = pulp.LpProblem("Transporte_arroz",
                   pulp.LpMinimize)
x = pulp.LpVariable.dicts("x",
        (plantas, supers), lowBound=0)
m += pulp.lpSum(costos[i][j] * x[i][j]
     for i in plantas for j in supers)
for i in plantas:
    m += pulp.lpSum(x[i][j] for j
         in supers) <= oferta[i]for j in supers:
    m += pulp.lpSum(x[i][j] for i
         in plantas) == demanda[j]
Resultado de la corridaCosto total: 52500.0
OR-ToolsPython
solver = pywraplp.Solver.CreateSolver(
             "GLOP")
x = [[solver.NumVar(0, solver.infinity(),
       f"x_{i}_{j}") for j in range(3)]
       for i in range(2)]
for i in range(2):
    solver.Add(sum(x[i][j] for j in
        range(3)) <= oferta[i])for j in range(3):
    solver.Add(sum(x[i][j] for i in
        range(2)) == demanda[j])solver.Minimize(sum(costos[i][j] *
    x[i][j] for i in range(2)
    for j in range(3)))
Resultado de la corridaCosto total: 52500.0
lpSolveR
costos <- matrix(c(200, 300, 400,
                   250, 150, 350),
                 nrow = 2, byrow = TRUE)
oferta  <- c(100, 150)
demanda <- c(80, 120, 50)
res <- lp.transport(costos,
         direction = "min",
         row.signs = rep("<=", 2),         row.rhs = oferta,
         col.signs = rep("=", 3),         col.rhs = demanda)
Resultado de la corridaCosto total mínimo: 52500
I.3

Resultado: costo total de 52 500

MarianaParte I · punto 3
EnvíosSúper ASúper BSúper CTotal
Planta 180020100
Planta 2012030150
Recibido8012050250

PuLP, OR-Tools y lpSolve dan el mismo plan.

Usar la planta 1 en vez de la 2 cuesta por saco: A −50, B +150, C +50.

Z = 80(200) + 20(400) + 120(150) + 30(350) = 52\,500

Las dos plantas usan toda su capacidad (100 y 150 sacos) y los tres supermercados reciben exactamente lo que piden.

I.4

Asignación: las librerías

AarónParte I · punto 4

SciPy · linear_sum_assignment [6] Python

Recibe la matriz de costos y devuelve qué fila queda con qué columna. Usa una variante del método húngaro y minimiza por defecto.

La llamadafilas, cols = ( linear_sum_assignment(d))

PuLP [2] Python

Programación lineal con variables binarias, una restricción por fila y una por columna, creadas con add_variable_dicts.

La llamadax = m.add_variable_dicts("x", (T, C), cat="Binary")

lp.assign [3] y solve_LSAP [7] R

Ninguna acepta más filas que columnas, así que, igual que en clase, se agrega una columna ficticia de ceros.

La llamadad <- cbind(d, C6 = 0) lp.assign(d, direction = "min") solve_LSAP(d, maximum = FALSE)
I.4

Seis tráileres para cinco comunidades

AarónParte I · punto 4

Kilómetros entre cada tráiler y cada comunidad; el transporte cuesta $8 por km. Ejemplo 2 del material del curso [8].

kmC1C2C3C4C5C6
A17221543270
B12262843180
C30341621160
D32214136410
E27433929120
F1461317220

C6, con costo 0, vuelve la matriz 6 × 6 para SciPy y R. El tráiler que quede ahí no se usa.

PuLP · modelo 6 × 5, sólo C1 a C5

x_{ij} = 1 si el tráiler i \in \{A,\dots,F\} va a la comunidad j \in \{C_1,\dots,C_5\}

\min\ Z = \sum_i \sum_j d_{ij}\,x_{ij}km

sujeto a

\textstyle\sum_j x_{ij} \le 16 tráileres
\textstyle\sum_i x_{ij} = 15 comunidades
x_{ij} \in \{0, 1\}30 variables

11 restricciones · costo = 8Z

I.4

La asignación en cuatro librerías

AarónParte I · punto 4
SciPyPython
d = np.hstack([d, np.zeros(
      (6, 1), dtype=int)])filas, cols = (
  linear_sum_assignment(d))km = d[filas, cols].sum()
print("km =", km,
      " costo =", km * 8)
Resultado de la corridaD -> C6 (ficticia) km = 66 costo = 528
PuLPPython
x = m.add_variable_dicts("x",
      (T, C), cat="Binary")for t in T:
  m += pulp.lpSum(x[t][c]
         for c in C) <= 1
for c in C:
  m += pulp.lpSum(x[t][c]
         for t in T) == 1
Resultado de la corridaD -> sin uso km = 66.0 costo = 528.0
lpSolveR
d <- cbind(d, C6 = 0)sol <- lp.assign(d,
         direction = "min")
km <- sol$objval
cat("km =", km,
    " costo =", km * 8)
Resultado de la corridaD: 1 en C6 km = 66 costo = 528
clueR
d <- cbind(d, 0)
a <- solve_LSAP(d,
       maximum = FALSE)km <- sum(d[cbind(1:6, a)])
Resultado de la corridaD -> C6 km = 66 costo = 528
I.4

Resultado: 66 km y $528

AarónParte I · punto 4
kmC1C2C3C4C5C6
A17221543270
B12262843180
C30341621160
D32214136410
E27433929120
F1461317220
Z = 15 + 12 + 21 + 12 + 6 = 66\ \text{km}
\text{costo} = 8 \times 66 = \$528

SciPy, PuLP, lpSolve y clue dan la misma asignación, la misma que da el método húngaro del material del curso. D queda en la ficticia: no se usa.

Revisamos las 720 asignaciones posibles: sólo esta da 66 km, y la siguiente mejor da 77 km.

II.1

¿Qué es un problema de transbordo?

MarianaParte II · punto 1

Una extensión del transporte en la que los envíos pueden pasar por puntos intermedios antes de llegar a su destino [10].

NodoQué haceEjemplo
Origentiene ofertafábrica
Transbordorecibe y vuelve a enviaralmacén
Destinotiene demandatienda

Modela redes de distribución, cadenas de suministro y sistemas de comunicación [10][11].

Conservación del flujo [16]

II.2

Relación y diferencias con el transporte

MarianaParte II · punto 2

Transporte

Transbordo

CriterioTransporteTransbordo
Rutasdirectasdirectas o con paradas
Nodosoferta y demandaoferta, demanda y paso
Variablespares origen-destinoarcos de una red dirigida
Clavecumplir oferta y demandabalance de flujo en cada nodo

Los dos minimizan casi siempre el costo. El transporte es un caso particular del transbordo: el caso sin nodos intermedios. El transbordo además permite rutas de varios tramos [11][12][13][16].

II.3

El ejemplo 5.5-1 de Taha

AarónParte II · punto 3

Dos plantas, P1 y P2, producen 1 000 y 1 200 autos. Tres concesionarios, D1, D2 y D3, necesitan 800, 900 y 500 [9].

Los envíos pueden pasar por los centros de tránsito T1 y T2, y de D1 a D2 y de D2 a D3. Cada flecha lleva su costo por auto, en cientos de dólares.

La idea: convertir la red en un problema de transporte balanceado, resoluble con una solución inicial (esquina noroeste, costo mínimo o Vogel) y el cruce del arroyo, o con Solver.

II.3

Nodos, balance y colchón

AarónParte II · punto 3
Paso1

Clasificar los nodos

TipoNodosPor qué
Origen puroP1, P2sólo envían
TransbordoT1, T2, D1, D2reciben y envían
Destino puroD3sólo recibe
Paso2

Revisar el balance y calcular el colchón

\text{Oferta} = 1000 + 1200 = 2200
\text{Demanda} = 800 + 900 + 500 = 2200

B = 2200\ \text{autos}

B toma la oferta total como cota de lo que un nodo puede reenviar.

Paso3

Definir filas y columnas

\text{Orígenes: } P_1, P_2, T_1, T_2, D_1, D_2 \quad (m = 6)
\text{Destinos: } T_1, T_2, D_1, D_2, D_3 \quad (n = 5)

II.3

Oferta, demanda y matriz de costos

AarónParte II · punto 3
Paso4
Nodos_id_j
P11 000—
P21 200—
T10 + 2 2000 + 2 200
T20 + 2 2000 + 2 200
D10 + 2 200800 + 2 200
D20 + 2 200900 + 2 200
D3—500
Total11 00011 000

Se suma lo mismo a los dos lados (4 × 2 200): sigue balanceada.

Paso5

Ruta que existe: su costo · de un nodo a sí mismo: 0 · ruta que no existe: M.

Paso6
T1T2D1D2D3s_i
P134MMM1 000
P225MMM1 200
T10786M2 200
T2M0M492 200
D1MM05M2 200
D2MMM032 200
d_j2 2002 2003 0003 10050011 000

Cientos de dólares por auto. Transporte balanceado de 6 × 5.

II.3

El modelo matemático

AarónParte II · punto 3
Paso7

x_{ij} = cantidad en la casilla i, j (en la diagonal, colchón sin usar)

\min\ Z = \sum_{i=1}^{6} \sum_{j=1}^{5} c_{ij}\,x_{ij}cientos de $

sujeto a

\textstyle\sum_j x_{ij} = s_i,\quad i = 1,\dots,66 de oferta
\textstyle\sum_i x_{ij} = d_j,\quad j = 1,\dots,55 de demanda
x_{ij} \ge 0
CasillasCantidad
Total (6 × 5)30
Rutas inexistentes (M)15
Rutas de la red11
Diagonal (colchón)4
Restricciones11

No degeneración

m + n - 1 = 6 + 5 - 1 = 10

Una solución básica no degenerada tiene 10 casillas básicas positivas.

II.3

Por qué funciona el colchón

AarónParte II · punto 3
Paso8

Balance de rutas reales: las casillas con M se toman en cero.

Nodo T1

x_{P_1T_1} + x_{P_2T_1} + x_{T_1T_1} = 2200demanda
x_{T_1T_1} + x_{T_1T_2} + x_{T_1D_1} + x_{T_1D_2} = 2200oferta
x_{P_1T_1} + x_{P_2T_1} + \cancel{x_{T_1T_1}} = 2200demanda
\cancel{x_{T_1T_1}} + x_{T_1T_2} + x_{T_1D_1} + x_{T_1D_2} = 2200oferta
\Rightarrow\ x_{P_1T_1} + x_{P_2T_1} = x_{T_1T_2} + x_{T_1D_1} + x_{T_1D_2}

lo que entra a T1 = lo que sale de T1

Nodo D2, con demanda propia

x_{T_1D_2} + x_{T_2D_2} + x_{D_1D_2} + \cancel{x_{D_2D_2}} = 3100demanda
\cancel{x_{D_2D_2}} + x_{D_2D_3} = 2200oferta
\Rightarrow\ (x_{T_1D_2} + x_{T_2D_2} + x_{D_1D_2}) - x_{D_2D_3} = 900

lo que entra − lo que sale = la demanda de D2

La diagonal es el colchón sin usar: si de T1 salen 1 200 autos, x_{T_1T_1} = 2200 - 1200 = 1000. Por eso su costo es 0.

II.4

Cómo lo resolvimos

DavidParte II · punto 4

La matriz balanceada del paso 6, tal como quedó. Cada M se carga con un costo de 1 000, muy por encima del mayor costo real (9). En las tres soluciones, las 15 casillas con M quedaron en cero.

HerramientaFunciónRestricciones
PythonPuLP [2]todas con igualdad
RlpSolve · lp.transport [3]todas con igualdad
ExcelSolver [17]todas con igualdad

Cada fila envía exactamente su oferta y cada columna recibe exactamente su demanda:

\textstyle\sum_j x_{ij} = s_i \qquad \sum_i x_{ij} = d_j
II.4

PuLP y lpSolve

DavidParte II · punto 4
PuLPPython
M = 1000
oferta = [1000, 1200, 2200, 2200, 2200, 2200]
demanda = [2200, 2200, 3000, 3100, 500]
m = pulp.LpProblem("Transbordo", pulp.LpMinimize)
x = m.add_variable_dicts("x", (O, D), lowBound=0)
m += pulp.lpSum(c[i][j] * x[O[i]][D[j]]
        for i in range(6) for j in range(5))
for i in range(6):
    m += pulp.lpSum(x[O[i]][d] for d in D) == oferta[i]for j in range(5):
    m += pulp.lpSum(x[o][D[j]] for o in O) == demanda[j]m.solve(pulp.HiGHS(msg=False))
Resultado de la corrida (sin la diagonal)costo = 20700.0 cientos de dólares P1 -> T2 = 1000.0 T1 -> D2 = 400.0 P2 -> T1 = 1200.0 T2 -> D2 = 1000.0 T1 -> D1 = 800.0 D2 -> D3 = 500.0
lpSolveR
sol <- lp.transport(costos, direction = "min",    row.signs = rep("=", 6), row.rhs = oferta,
    col.signs = rep("=", 5), col.rhs = demanda)
T1T2D1D2D3
P101000000
P212000000
T1100008004000
T201200010000
D100220000
D20001700500

costo = 20700 · gris = diagonal (colchón sin usar). T1 reenvía 2 200 − 1 000 = 1 200. D2 recibe 1 400, se queda 900 y reenvía 2 200 − 1 700 = 500.

II.4

Solver de Excel

DavidParte II · punto 4
Hoja de Excel resuelta con Solver: tabla de costos arriba, tabla de envíos abajo y costo total de 20 700
Hoja resuelta. Arriba, costos en cientos de dólares por auto; abajo, envíos en autos.
Recorte de la hoja de Excel: envíos, columnas Enviado y Oferta, filas Recibido y Demanda, y costo total de 20 700
Envíos, balances y costo total.
ParámetroValor
ObjetivoB22, costo total · Mín
VariablesB13:F18
OfertaG13:G18 = H13:H18
DemandaB19:F19 = B20:F20
No negatividadB13:F18 ≥ 0
MétodoSimplex LP

Costo total = SUMAPRODUCTO(B3:F8;B13:F18) = 20 700.

II.4

El plan de envíos óptimo

DavidParte II · punto 4
NodoEntraSaleSe queda
T11 200800 + 4000
T21 0001 0000
D18000800
D2400 + 1 000500900
D35000500
P1→T2P2→T1T1→D1T1→D2T2→D2D2→D3Costo*
PuLP1 0001 2008004001 00050020 700
lpSolve1 0001 2008004001 00050020 700
Solver1 0001 2008004001 00050020 700

Z = 4(1000) + 2(1200) + 8(800) + 6(400) + 4(1000) + 3(500) = 20\,700

* Cientos de dólares: $2 070 000.

Cinco rutas quedan sin envío. Por ejemplo, T2→D2→D3 cuesta 4 + 3 = 7 por auto, contra 9 de T2→D3 directo.

Prueba de no degeneración

6 \text{ rutas} + 4 \text{ diagonales} = 10 = m + n - 1

Diagonal positiva: T1 1 000 · T2 1 200 · D1 2 200 · D2 1 700. Las 10 conectan filas y columnas sin formar ciclo.

II.5

¿Hay desbalances en transbordo? Sí

Juan IgnacioParte II · punto 5

La oferta total puede superar la demanda o no alcanzarla. Además de ajustar los totales, hay que respetar el balance de flujo en cada nodo intermedio y usar sólo rutas que existen [16].

Balance general de la red

\textstyle\sum_j x_{ij} - \sum_j x_{ji} = b_ipara cada nodo i
b_i > 0 \text{ oferta},\quad b_i < 0 \text{ demanda}
b_i = 0 \text{ transbordo puro}
\textstyle\sum_i b_i = 0red balanceada
II.5

Caso 1: la oferta supera la demanda

Juan IgnacioParte II · punto 5

El excedente se queda sin enviar. Con envíos ≤ oferta basta no usarla toda; con igualdades se agrega un destino ficticio por la diferencia, con arcos de costo 0 o el costo de almacenar [9][16].

Si D3 pidiera 400 en vez de 500

800 + 900 + 400 = 2100 < 2200 \Rightarrow \text{sobran } 100

…D3Fs_i
P1…M01 000
P2…M01 200
d_j…4001002 200

F es el destino ficticio: el sobrante se queda en las plantas y el total vuelve a 2 200, antes de sumar el colchón.

II.5

Caso 2: la demanda supera la oferta

Juan IgnacioParte II · punto 5

Si se exige atender todo, no hay solución factible. Se agrega un origen ficticio por la diferencia o, lo que es igual, faltantes h_j: pedidos sin cubrir, no autos transportados, con una penalización p_j [16].

\text{entra} - \text{sale} + h_j = d_j^{\,\text{real}}
\min\ Z = \textstyle\sum c_{ij}x_{ij} + \sum_j p_j h_j

Si D3 pidiera 600 en vez de 500

800 + 900 + 600 = 2300 > 2200 \Rightarrow \text{faltan } 100

Si se despachan los 2 200 autos disponibles:

h_{D_1} + h_{D_2} + h_{D_3} = 100,\quad h_j \ge 0

Si todo el faltante se carga a D3, h_{D_3} = 100: recibe 500 autos reales y le quedan 100 sin atender. Cuál conviene dejar depende de las rutas y las penalizaciones.

En la matriz equivale a un origen ficticio O con oferta 100, unido sólo a los concesionarios donde se permite faltante.

II.5

Resumen de ajustes

Juan IgnacioParte II · punto 5
SituaciónAjuste al modeloInterpretación
Oferta > demandadestino ficticio por el excedenteinventario no despachado
Demanda > ofertaorigen ficticio o faltantes h_jdemanda no satisfecha
Oferta = demandano hace falta un nodo ficticiototales reales iguales

Primero se balancea, después se calcula B

Con el método del colchón, B sale del total ya ajustado: 2 200 con el excedente y 2 300 con el origen ficticio. El ajuste no quita el balance de flujo ni permite rutas que no existen [9][16].

IEEE

Fuentes consultadas

Juan IgnacioFuentes del equipo
  1. The SciPy Community, “scipy.optimize.linprog,” SciPy v1.18 Manual. [En línea]. Disponible en: https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.linprog.html. [Accedido: 25-oct-2026].
  2. S. A. Mitchell y F. Peschiera, PuLP: A Linear Programming Modeler for Python. (ver. 4.2.0). COIN-OR Foundation. [En línea]. Disponible en: https://coin-or.github.io/pulp/. [Accedido: 25-oct-2026].
  3. M. Berkelaar y G. Csárdi, lpSolve: Interface to ‘Lp_solve’ v. 5.5 to Solve Linear/Integer Programs. (R package ver. 5.6.23), 2024. [En línea]. Disponible en: https://cran.r-project.org/package=lpSolve. [Accedido: 25-oct-2026].
  4. M. Patil, “Efficient Transportation Planning using R: Solving Transportation Problems with Linear Programming,” Medium, May 4, 2023. [En línea]. Disponible en: https://medium.com/@patilmanojkumar/efficient-transportation-planning-using-r-solving-transportation-problems-with-linear-programming-4931f34d050f
  5. Firdaus, “Solving Vehicle Routing Problems with Python & Heuristics Algorithm,” Medium, Jul. 21, 2023. [En línea]. Disponible en: https://medium.com/@writingforara/solving-vehicle-routing-problems-with-python-heuristics-algorithm-2cc57fe7079c
  6. The SciPy Community, “scipy.optimize.linear_sum_assignment,” SciPy v1.18 Manual. [En línea]. Disponible en: https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.linear_sum_assignment.html. [Accedido: 28-oct-2026].
  7. K. Hornik, clue: Cluster Ensembles. (R package ver. 0.3-65). [En línea]. Disponible en: https://cran.r-project.org/package=clue. [Accedido: 28-oct-2026].
  8. E. J. Ballestero Alfaro, “Problemas de asignación,” Investigación de Operaciones, material del curso, II Semestre, 2026.
  9. H. A. Taha, “Transshipment Model,” en Operations Research: An Introduction, sec. 5.5. [En línea]. Disponible en: https://www.brainkart.com/article/Transshipment-Model_11223/. [Accedido: 14-nov-2026].
  10. Universidad de Sevilla, “El problema de transporte y sus extensiones,” [En línea]. Disponible en: https://idus.us.es/server/api/core/bitstreams/6708210d-7b65-4788-b7a0-f2cd5091c411/content. [Accedido: 14-nov-2026].
  11. Universidad de los Andes, “Fundamentos de Investigación de Operaciones: El problema de transporte,” sec. 4, “El problema de transbordo,” [En línea]. Disponible en: https://laboratoriomatematicas.uniandes.edu.co/metodos/contenido/contenido/transporte.pdf. [Accedido: 14-nov-2026].
  12. Universidad de Chile, “Material docente sobre problemas de transporte,” Facultad de Ciencias Físicas y Matemáticas. [En línea]. Disponible en: https://www.u-cursos.cl/ingenieria/2010/1/IN47A/1/material_docente/bajar?id=286594. [Accedido: 14-nov-2026].
  13. Yelky99, “Problema de transbordo – Programación matemática,” RPubs. [En línea]. Disponible en: https://rpubs.com/Yelky99/ptransbordo_pmai. [Accedido: 14-nov-2026].
  14. Massachusetts Institute of Technology, “Lecture Notes: Introduction to Integer Programming; Integer Programming Formulations; Branch and Bound,” 15.053, MIT OpenCourseWare, 2013. [En línea]. Disponible en: https://ocw.mit.edu/courses/15-053-optimization-methods-in-management-science-spring-2013/pages/lecture-notes/. [Accedido: 16-nov-2026].
  15. The SciPy Community, “scipy.optimize.milp,” SciPy v1.18.0 Manual. [En línea]. Disponible en: https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.milp.html. [Accedido: 16-nov-2026].
  16. R. K. Ahuja, T. L. Magnanti y J. B. Orlin, Network Flows: Theory, Algorithms, and Applications. Prentice Hall, 1993, ISBN: 978-0-13-617549-0. [En línea]. Disponible en: https://mitmgmtfaculty.mit.edu/jorlin/network-flows/. [Accedido: 16-nov-2026].
  17. Microsoft, “Definir y resolver un problema con Solver,” Microsoft Support. [En línea]. Disponible en: https://support.microsoft.com/es-es/excel/define-and-solve-a-problem-by-using-solver. [Accedido: 17-nov-2026].