{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Investigación de Operaciones · Clase 5\n",
    "## Cuando el problema crece más que la hoja de cálculo\n",
    "\n",
    "**Universidad Jorge Tadeo Lozano** · Elkin Rodríguez E.\n",
    "\n",
    "---\n",
    "\n",
    "### Antes de empezar: esto NO es una clase de programación\n",
    "\n",
    "Ustedes ya saben la parte difícil. Llevan cuatro clases haciéndola.\n",
    "\n",
    "| Clase | Lo que aprendieron | Sigue valiendo hoy |\n",
    "|---|---|---|\n",
    "| **1** | Traducir un problema de empresa a **variables, objetivo y restricciones** | ✅ Es exactamente lo que van a escribir aquí |\n",
    "| **2** | Ver la región factible y entender que el óptimo vive en una esquina | ✅ El solver sigue buscando esa esquina |\n",
    "| **3** | Resolver con Solver y leer el **análisis de sensibilidad** | ✅ Excel sigue siendo la herramienta del día a día |\n",
    "| **4** | El **símplex por dentro**: quién entra, quién sale, el pivoteo | ✅ Es el motor que corre debajo de este cuaderno |\n",
    "\n",
    "**Lo único que cambia hoy es quién hace las cuentas.** El modelo es el mismo.\n",
    "\n",
    "---\n",
    "\n",
    "### Y no, Excel no se muere\n",
    "\n",
    "Excel va a seguir siendo la herramienta que usen todos los días:\n",
    "\n",
    "- Es lo que **lee y entiende un gerente**\n",
    "- Se comparte, se imprime, se discute en un comité\n",
    "- Para modelos de menos de 200 decisiones, **es más rápido de armar**\n",
    "\n",
    "Lo que van a ver hoy es **la evolución natural**: qué se hace cuando el problema ya no cabe. Y eso pasa más pronto de lo que parece."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## El diccionario de cinco palabras\n",
    "\n",
    "Es todo el Python que necesitan hoy. Nada más.\n",
    "\n",
    "| Lo que ven | Qué significa | Dónde lo vieron antes |\n",
    "|---|---|---|\n",
    "| `x = pulp.LpVariable(\"Clasico\")` | **Declaro una variable de decisión** | Es la fila *Producir* de su Excel |\n",
    "| `prob += 30*x + 50*y` | **Esta es la función objetivo** | Es la celda Z de su Excel |\n",
    "| `prob += x + 2*y <= 41` | **Esta es una restricción** | Es una fila *Usado ≤ Disponible* |\n",
    "| `lpSum(...)` | **Sumatoria** — el símbolo Σ | Es `SUMAPRODUCTO` |\n",
    "| `for i in range(4)` | **\"Para cada i de 0 a 3\"** | Es arrastrar una fórmula hacia abajo |\n",
    "\n",
    "**Cómo se ejecuta una celda:** clic en el ▶ de la izquierda, o `Shift + Enter`.\n",
    "\n",
    "**Si algo falla:** menú *Entorno de ejecución → Reiniciar y ejecutar todo*. Casi siempre es porque una celda se corrió fuera de orden.\n",
    "\n",
    "---\n",
    "\n",
    "---\n",
    "\n",
    "### Cómo funcionan los espacios en blanco\n",
    "\n",
    "Algunas celdas tienen un bloque así al principio:\n",
    "\n",
    "```\n",
    "# ---- COMPLETE ESTAS LINEAS ----\n",
    "SENTIDO = ___      # ¿maximizamos o minimizamos?\n",
    "# -------------------------------\n",
    "```\n",
    "\n",
    "**Reemplacen cada `___` por la respuesta** y corran la celda.\n",
    "\n",
    "Si la corren sin llenarlos, el cuaderno **se los avisa en español**:\n",
    "\n",
    "> `FALTA COMPLETAR: SENTIDO -> reemplace el ___ por la respuesta y vuelva a correr la celda.`\n",
    "\n",
    "Eso **no es un error del cuaderno**: es el recordatorio. Llenen el espacio y vuelvan a correr.\n",
    "\n",
    "**Ninguno de los espacios requiere saber programar.** Todos son decisiones de modelado — las mismas que llevan cuatro clases tomando."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Paso 0 · Preparar el ambiente\n",
    "\n",
    "Corran esta celda y esperen unos 20 segundos. Solo se hace una vez por sesión."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install pulp -q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pulp\n",
    "\n",
    "# ---- marcador de los espacios en blanco ----------------------------\n",
    "___ = None\n",
    "\n",
    "def completar(**campos):\n",
    "    faltan = [k for k, v in campos.items() if v is None]\n",
    "    if faltan:\n",
    "        raise ValueError(\n",
    "            \"FALTA COMPLETAR: \" + \", \".join(faltan) +\n",
    "            \"  ->  reemplace el ___ por la respuesta y vuelva a correr la celda.\"\n",
    "        )\n",
    "# --------------------------------------------------------------------\n",
    "\n",
    "print(\"Listo. PuLP version:\", pulp.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Paso 1 · Los morrales, por quinta vez\n",
    "\n",
    "Este es el modelo que llevan resolviendo desde la clase 1:\n",
    "\n",
    "```\n",
    "max Z = 30x + 50y\n",
    "s.a.   x + 2y <= 41     (horas de corte)\n",
    "      2x +  y <= 50     (horas de costura)\n",
    "```\n",
    "\n",
    "Ya lo resolvieron **a mano** (clase 1), **en GeoGebra** (clase 2), **con Solver** (clase 3) y **con el tableau** (clase 4).\n",
    "\n",
    "Miren la celda de abajo y **reconozcan cada línea**. No hay nada nuevo: es el mismo modelo, escrito con otra sintaxis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "prob = pulp.LpProblem(\"morrales\", pulp.LpMaximize)\n",
    "\n",
    "# las variables de decision  ->  la fila \"Producir\" de su Excel\n",
    "x = pulp.LpVariable(\"Clasico\", lowBound=0)\n",
    "y = pulp.LpVariable(\"Pro\", lowBound=0)\n",
    "\n",
    "# la funcion objetivo  ->  la celda Z de su Excel\n",
    "prob += 30*x + 50*y\n",
    "\n",
    "# las restricciones  ->  las filas \"Usado <= Disponible\"\n",
    "prob += x + 2*y <= 41      # corte\n",
    "prob += 2*x + y <= 50      # costura\n",
    "\n",
    "prob.solve(pulp.PULP_CBC_CMD(msg=0))\n",
    "\n",
    "print(\"Clasico =\", x.value())\n",
    "print(\"Pro     =\", y.value())\n",
    "print(\"Z       =\", pulp.value(prob.objective))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Salieron con decimales\n",
    "\n",
    "Es el mismo resultado que les dio el tableau de la clase 4: **19,67 y 10,67**.\n",
    "\n",
    "Y el mismo problema: **no se venden 19,67 morrales.**\n",
    "\n",
    "Para exigir números enteros solo se agrega `cat=\"Integer\"` al declarar la variable.\n",
    "**Complete los dos espacios** y corra la celda."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ---- COMPLETE ESTA LINEA -------------------------------------------\n",
    "TIPO = ___          # escriba:  \"Integer\"\n",
    "# --------------------------------------------------------------------\n",
    "completar(TIPO=TIPO)\n",
    "\n",
    "prob = pulp.LpProblem(\"morrales_enteros\", pulp.LpMaximize)\n",
    "\n",
    "x = pulp.LpVariable(\"Clasico\", lowBound=0, cat=TIPO)\n",
    "y = pulp.LpVariable(\"Pro\",     lowBound=0, cat=TIPO)\n",
    "\n",
    "prob += 30*x + 50*y\n",
    "prob += x + 2*y <= 41\n",
    "prob += 2*x + y <= 50\n",
    "\n",
    "prob.solve(pulp.PULP_CBC_CMD(msg=0))\n",
    "print(\"Clasico =\", x.value(), \" Pro =\", y.value(), \" Z =\", pulp.value(prob.objective))\n",
    "print()\n",
    "print(\"Control: debe dar 19, 11 y 1120.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Fíjense bien en la respuesta: 19 y 11.**\n",
    "\n",
    "No es el redondeo hacia arriba (20 y 11 no cabe) ni hacia abajo (19 y 10 da menos).\n",
    "**El óptimo entero baja la x y sube la y.** Ninguna regla de redondeo llega ahí.\n",
    "\n",
    "> En Excel esto también se puede hacer: en el Solver, al agregar la restricción, se elige **`ent`** en el menú del medio. **Mismo resultado.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Paso 2 · La red de Distrialimentos\n",
    "\n",
    "Ahora el problema nuevo de hoy: **cuatro centros de distribución, ocho ciudades.**\n",
    "\n",
    "La empresa necesita saber **cuántas toneladas manda desde cada centro a cada ciudad** para que el costo total de fletes sea el mínimo.\n",
    "\n",
    "Son `4 × 8 = 32` variables de decisión. En Excel esto cabe perfectamente — de hecho ya lo resolvieron ahí hace un rato. **Ahora vamos a escribir el mismo modelo aquí.**\n",
    "\n",
    "Los datos ya están cargados. Corra la celda para verlos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ==========================================================\n",
    "#  BLOQUE DE DATOS  ·  es lo UNICO que hay que cambiar\n",
    "#  para usar este cuaderno con otro problema de transporte\n",
    "# ==========================================================\n",
    "\n",
    "CENTROS = [\"Bogota\", \"Medellin\", \"Cali\", \"Barranquilla\"]\n",
    "CIUDADES = [\"Bucaramanga\",\"Pereira\",\"Ibague\",\"Cartagena\",\"Cucuta\",\"Villavicencio\",\"Pasto\",\"Neiva\"]\n",
    "\n",
    "# costo de enviar UNA tonelada desde el centro i hasta la ciudad j (miles de $)\n",
    "COSTO = [\n",
    "    [ 40, 32, 20, 100,  56,   9,  80,  30],   # desde Bogota\n",
    "    [ 39, 22, 35,  64,  64,  54,  70,  55],   # desde Medellin\n",
    "    [ 80, 21, 30, 110, 100,  56,  38,  35],   # desde Cali\n",
    "    [ 57, 89, 95,  12,  70, 100, 140, 105],   # desde Barranquilla\n",
    "]\n",
    "\n",
    "CAPACIDAD = [900, 700, 600, 400]                        # toneladas que puede despachar cada centro\n",
    "DEMANDA   = [280, 240, 180, 300, 150, 120, 200, 130]    # toneladas que necesita cada ciudad\n",
    "\n",
    "print(\"Oferta total :\", sum(CAPACIDAD), \"toneladas\")\n",
    "print(\"Demanda total:\", sum(DEMANDA), \"toneladas\")\n",
    "print(\"Sobra capacidad:\", sum(CAPACIDAD) - sum(DEMANDA), \"toneladas\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ahora el modelo · las mismas tres piezas de la clase 1\n",
    "\n",
    "**Variables:** cuántas toneladas van de cada centro a cada ciudad.\n",
    "**Objetivo:** minimizar el costo total de fletes.\n",
    "**Restricciones:**\n",
    "- ningún centro puede despachar más de su capacidad → es la fila *Despachado ≤ Capacidad* de su Excel\n",
    "- toda ciudad debe recibir al menos su demanda → es la columna *Recibido ≥ Demanda*\n",
    "\n",
    "Complete los **tres espacios**. Son decisiones de modelado, no de programación."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ---- COMPLETE ESTAS TRES LINEAS ------------------------------------\n",
    "SENTIDO = ___       # ¿maximizamos o minimizamos el costo?  ->  pulp.LpMinimize\n",
    "TOPE    = ___       # lo que limita a cada centro           ->  CAPACIDAD\n",
    "MINIMO  = ___       # lo que exige cada ciudad              ->  DEMANDA\n",
    "# --------------------------------------------------------------------\n",
    "completar(SENTIDO=SENTIDO, TOPE=TOPE, MINIMO=MINIMO)\n",
    "\n",
    "m = len(CENTROS)     # 4 centros\n",
    "n = len(CIUDADES)    # 8 ciudades\n",
    "\n",
    "prob = pulp.LpProblem(\"red\", SENTIDO)\n",
    "\n",
    "# una variable por cada ruta centro -> ciudad  (32 en total)\n",
    "env = pulp.LpVariable.dicts(\"env\", (range(m), range(n)), lowBound=0)\n",
    "\n",
    "# OBJETIVO: sumar costo x toneladas sobre todas las rutas  ->  es el SUMAPRODUCTO de Excel\n",
    "prob += pulp.lpSum(COSTO[i][j] * env[i][j] for i in range(m) for j in range(n))\n",
    "\n",
    "# RESTRICCION 1: lo que despacha cada centro no puede pasar de su capacidad\n",
    "for i in range(m):\n",
    "    prob += pulp.lpSum(env[i][j] for j in range(n)) <= TOPE[i]\n",
    "\n",
    "# RESTRICCION 2: lo que recibe cada ciudad debe cubrir su demanda\n",
    "for j in range(n):\n",
    "    prob += pulp.lpSum(env[i][j] for i in range(m)) >= MINIMO[j]\n",
    "\n",
    "prob.solve(pulp.PULP_CBC_CMD(msg=0))\n",
    "\n",
    "print(\"Estado:\", pulp.LpStatus[prob.status])\n",
    "print(\"COSTO TOTAL:\", f\"{pulp.value(prob.objective):,.0f}\", \"miles de pesos\")\n",
    "print()\n",
    "print(\"Control: debe dar 44.140, exactamente lo mismo que les dio en Excel.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ver el plan como lo vería un jefe de logística\n",
    "\n",
    "Esta celda ya está lista. Solo córranla."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mostrar(variables, m, n, titulo=\"PLAN DE DESPACHO\"):\n",
    "    print(titulo)\n",
    "    print(f\"{'':14}\" + \"\".join(f\"{c[:9]:>12}\" for c in CIUDADES))\n",
    "    for i in range(m):\n",
    "        fila = \"\"\n",
    "        for j in range(n):\n",
    "            v = variables[i][j].value()\n",
    "            fila += f\"{v:>12,.0f}\" if v and v > 0.5 else f\"{'-':>12}\"\n",
    "        usado = sum(variables[i][j].value() for j in range(n))\n",
    "        print(f\"{CENTROS[i]:<14}{fila}   | {usado:,.0f} t\")\n",
    "\n",
    "mostrar(env, m, n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Miren la forma de la respuesta:** de las 32 rutas posibles, **solo se usan 8**. Todas las demás quedan en cero.\n",
    "\n",
    "Eso pasa siempre en los problemas de transporte, y tiene explicación: es la misma idea de **solución básica** que vieron en el tableau de la clase 4. Las variables que no están en la base valen cero.\n",
    "\n",
    "**Anoten también:** Medellín queda usando solo 280 de sus 700 toneladas. Guarden ese dato."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Paso 3 · Hay paro y Cali no despacha\n",
    "\n",
    "**La situación:** bloqueo en el Valle. Cali no puede sacar un solo camión esta semana.\n",
    "\n",
    "La pregunta que le van a hacer a ustedes en la reunión de crisis del lunes a las 7 a.m. no es *\"¿es grave?\"*.\n",
    "Es: **\"¿cuánto nos cuesta?\"**\n",
    "\n",
    "Cambien **un solo número** y vuelvan a resolver."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ---- COMPLETE ESTA LINEA -------------------------------------------\n",
    "CAP_CALI = ___      # ¿cuanto puede despachar Cali durante el paro?\n",
    "# --------------------------------------------------------------------\n",
    "completar(CAP_CALI=CAP_CALI)\n",
    "\n",
    "CAP_PARO = [900, 700, CAP_CALI, 400]\n",
    "\n",
    "prob2 = pulp.LpProblem(\"paro\", pulp.LpMinimize)\n",
    "env2 = pulp.LpVariable.dicts(\"e2\", (range(m), range(n)), lowBound=0)\n",
    "\n",
    "prob2 += pulp.lpSum(COSTO[i][j] * env2[i][j] for i in range(m) for j in range(n))\n",
    "for i in range(m):\n",
    "    prob2 += pulp.lpSum(env2[i][j] for j in range(n)) <= CAP_PARO[i]\n",
    "for j in range(n):\n",
    "    prob2 += pulp.lpSum(env2[i][j] for i in range(m)) >= DEMANDA[j]\n",
    "\n",
    "prob2.solve(pulp.PULP_CBC_CMD(msg=0))\n",
    "\n",
    "costo_paro = pulp.value(prob2.objective)\n",
    "print(\"Costo normal     :\", f\"{44140:,}\")\n",
    "print(\"Costo con el paro:\", f\"{costo_paro:,.0f}\")\n",
    "print(\"SOBRECOSTO       :\", f\"{costo_paro - 44140:,.0f}\", \"miles de pesos\")\n",
    "print()\n",
    "mostrar(env2, m, n, \"PLAN DE CONTINGENCIA\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ahora miren Medellín otra vez.**\n",
    "\n",
    "En el plan normal despachaba 280 toneladas de 700. Ahora despacha **700 de 700**: se va al tope.\n",
    "\n",
    "Esa capacidad que parecía sobrar era **lo que salva la operación**. Guarden esa observación — vuelve en la dinámica."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Paso 4 · ¿Dónde abrimos un centro nuevo?\n",
    "\n",
    "La junta evalúa **abrir un quinto centro de distribución**. Hay tres ciudades candidatas.\n",
    "\n",
    "### Qué cambia y qué NO cambia\n",
    "\n",
    "| | ¿Cambia? | Por qué |\n",
    "|---|---|---|\n",
    "| **La demanda de las 8 ciudades** | ❌ **NO** | Abrir una bodega **no hace que la gente compre más**. Las tiendas piden lo mismo. Lo que cambia es **desde dónde** se les despacha. |\n",
    "| **La capacidad total** | ✅ Sí | Se suman **500 toneladas** nuevas. La red pasa de 2.600 a 3.100. |\n",
    "| **La tabla de costos** | ✅ Sí | Aparece **una fila nueva**: el costo de despachar desde el centro nuevo a cada una de las 8 ciudades. |\n",
    "| **El costo fijo** | ✅ Sí | **12.000 (miles) por periodo**, se pague o no se use. |\n",
    "\n",
    "### Los dos tipos de costo, que es lo que confunde\n",
    "\n",
    "Esta decisión mezcla dos cosas que hasta ahora no habíamos mezclado:\n",
    "\n",
    "- **Costo variable** — el flete. Depende de cuántas toneladas mueva. Es lo que el modelo minimiza.\n",
    "- **Costo fijo** — arriendo, nómina de bodega, servicios. **Son 12.000 así el centro despache 500 toneladas o cero.**\n",
    "\n",
    "El modelo de transporte **solo ve el flete**. Por eso el costo fijo se le suma **después**, por fuera:\n",
    "\n",
    "```\n",
    "costo total de la opcion  =  flete optimo con el centro nuevo  +  12.000\n",
    "```\n",
    "\n",
    "Y se compara contra los **44.140** de la red actual. Si el ahorro en flete no alcanza a pagar los 12.000, **la opción destruye valor**.\n",
    "\n",
    "**Antes de correr la celda: ¿cuál escogerían ustedes?** Escríbanlo en su hoja."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "CANDIDATAS = {\n",
    "    \"Villavicencio\": [45, 65, 34, 112, 70,  0, 72, 24],\n",
    "    \"Bucaramanga\":   [ 0, 70, 60,  60, 20, 47,100, 70],\n",
    "    \"Pereira\":       [32,  0, 18,  90, 78, 54, 42, 27],\n",
    "}\n",
    "# costo FIJO de abrir cualquiera de los tres: se paga asi despache poco o nada\n",
    "COSTO_FIJO = 12000\n",
    "\n",
    "# el costo de la red actual, sin centro nuevo (lo calculamos en el paso 2)\n",
    "BASE = 44140\n",
    "\n",
    "# OJO: la DEMANDA no cambia. Abrir una bodega no hace que las tiendas pidan mas.\n",
    "#      Lo unico que cambia es que hay 500 toneladas mas de capacidad disponible.\n",
    "\n",
    "for nombre, costos_nuevos in CANDIDATAS.items():\n",
    "    C2   = COSTO + [costos_nuevos]\n",
    "    CAP2 = CAPACIDAD + [500]\n",
    "\n",
    "    p = pulp.LpProblem(\"nuevo\", pulp.LpMinimize)\n",
    "    e = pulp.LpVariable.dicts(\"e\", (range(m+1), range(n)), lowBound=0)\n",
    "    p += pulp.lpSum(C2[i][j]*e[i][j] for i in range(m+1) for j in range(n))\n",
    "    for i in range(m+1):\n",
    "        p += pulp.lpSum(e[i][j] for j in range(n)) <= CAP2[i]\n",
    "    for j in range(n):\n",
    "        p += pulp.lpSum(e[i][j] for i in range(m+1)) >= DEMANDA[j]\n",
    "    p.solve(pulp.PULP_CBC_CMD(msg=0))\n",
    "\n",
    "    flete  = pulp.value(p.objective)          # solo el flete, sin el fijo\n",
    "    total  = flete + COSTO_FIJO               # flete + el arriendo de la bodega nueva\n",
    "    ahorro = BASE - total                     # comparado con no abrir nada\n",
    "    veredicto = \"CONVIENE\" if ahorro > 0 else \"destruye valor\"\n",
    "    print(f\"{nombre:<16} flete = {flete:>8,.0f}  + fijo {COSTO_FIJO:,}  =  total {total:>9,.0f}\"\n",
    "          f\"   |  vs {BASE:,} actual  ->  {ahorro:>+8,.0f}   {veredicto}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**¿Coincidió con lo que habían escrito?**\n",
    "\n",
    "Dos de las tres **destruyen valor**: el ahorro en fletes no alcanza a pagar los 12.000 fijos.\n",
    "\n",
    "Es el mismo fenómeno que vieron con la mesa de Muebles Tadeo en la clase 3 y con Doña Rosa en la clase 2: **lo que parece bueno por separado no siempre lo es para el conjunto.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Paso 5 · El punto donde Excel se queda sin aire\n",
    "\n",
    "Hasta aquí todo lo que hicimos **cabía en Excel**. La red son 32 variables: Solver la resuelve sin problema, y de hecho ya la resolvieron ahí.\n",
    "\n",
    "Ahora un problema distinto: **asignación**.\n",
    "\n",
    "Hay **60 conductores** y **60 rutas**. Cada conductor tiene un costo distinto en cada ruta (por experiencia, ubicación, tipo de licencia).\n",
    "\n",
    "- Cada conductor va a **exactamente una** ruta\n",
    "- Cada ruta recibe **exactamente un** conductor\n",
    "\n",
    "Eso son `60 × 60 = 3.600` variables binarias.\n",
    "\n",
    "> **El Solver de Excel en su versión gratuita acepta máximo 200 variables de decisión.**\n",
    ">\n",
    "> Este problema no cabe. Y una flota de 60 conductores no es una empresa grande: es una empresa mediana de Bogotá.\n",
    "\n",
    "### Por qué los costos son inventados\n",
    "\n",
    "No tenemos la tabla real de 60 conductores por 60 rutas — nadie la tiene a mano, son 3.600 datos.\n",
    "\n",
    "Así que la generamos al azar con `random.randint(20, 200)`: cada conductor cuesta entre 20 y 200 en cada ruta.\n",
    "\n",
    "**El punto de este paso no son los números. Es el tamaño.** Con datos reales el modelo sería idéntico; solo cambiaría la tabla.\n",
    "\n",
    "`random.seed(7)` hace que los números sean **siempre los mismos** cada vez que corran la celda. Así todos en el salón obtienen la misma respuesta y se puede comparar.\n",
    "\n",
    "Corran la celda y miren el reloj."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random, time\n",
    "random.seed(7)\n",
    "\n",
    "N = 60\n",
    "costo = [[random.randint(20, 200) for j in range(N)] for i in range(N)]\n",
    "\n",
    "t0 = time.time()\n",
    "\n",
    "p = pulp.LpProblem(\"asignacion\", pulp.LpMinimize)\n",
    "asig = pulp.LpVariable.dicts(\"a\", (range(N), range(N)), cat=\"Binary\")\n",
    "\n",
    "p += pulp.lpSum(costo[i][j]*asig[i][j] for i in range(N) for j in range(N))\n",
    "\n",
    "for i in range(N):\n",
    "    p += pulp.lpSum(asig[i][j] for j in range(N)) == 1     # cada conductor, una ruta\n",
    "for j in range(N):\n",
    "    p += pulp.lpSum(asig[i][j] for i in range(N)) == 1     # cada ruta, un conductor\n",
    "\n",
    "p.solve(pulp.PULP_CBC_CMD(msg=0))\n",
    "t = time.time() - t0\n",
    "\n",
    "print(f\"Variables binarias : {N*N:,}\")\n",
    "print(f\"Estado             : {pulp.LpStatus[p.status]}\")\n",
    "print(f\"Costo optimo       : {pulp.value(p.objective):,.0f}\")\n",
    "print(f\"TIEMPO             : {t:.2f} segundos\")\n",
    "print()\n",
    "print(f\"Excel Solver (version gratuita): tope de 200 variables  ->  {N*N:,} no cabe.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cómo se lee esa respuesta\n",
    "\n",
    "El solver acaba de decidir **una cosa por cada conductor**: a qué ruta va.\n",
    "\n",
    "De las 3.600 casillas de la matriz, **exactamente 60 quedaron en 1** (una por conductor) y las otras 3.540 en 0.\n",
    "\n",
    "La celda de abajo recorre la matriz y muestra, para cada conductor, **cuál fue su ruta y cuánto costó**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Conductor  ->  Ruta      costo\")\n",
    "print(\"-\" * 34)\n",
    "\n",
    "total_verificado = 0\n",
    "asignaciones = []\n",
    "\n",
    "for i in range(N):\n",
    "    for j in range(N):\n",
    "        if asig[i][j].value() and asig[i][j].value() > 0.5:\n",
    "            asignaciones.append((i, j, costo[i][j]))\n",
    "            total_verificado += costo[i][j]\n",
    "            break\n",
    "\n",
    "for i, j, c in asignaciones[:10]:\n",
    "    print(f\"   C{i+1:<3}    ->  R{j+1:<4}    {c:>5}\")\n",
    "print(f\"   ... y {N-10} asignaciones mas\")\n",
    "print(\"-\" * 34)\n",
    "print(f\"   Asignaciones hechas : {len(asignaciones)}   (deben ser {N})\")\n",
    "print(f\"   Suma de los costos  : {total_verificado:,}\")\n",
    "print(f\"   Lo que dijo el solver: {pulp.value(p.objective):,.0f}\")\n",
    "print()\n",
    "print(\"Si los dos ultimos numeros coinciden, la respuesta esta bien leida.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Cierre · qué pasó hoy\n",
    "\n",
    "| Problema | Variables | En Excel | Aquí |\n",
    "|---|---|---|---|\n",
    "| Morrales | 2 | ✅ funciona | 8 líneas |\n",
    "| Red de Distrialimentos | 32 | ✅ funciona | 10 líneas |\n",
    "| Asignación 60 × 60 | **3.600** | ❌ **no cabe** | **menos de 1 segundo** |\n",
    "\n",
    "---\n",
    "\n",
    "### Lo que NO cambió en ninguno de los tres\n",
    "\n",
    "**El modelo.** Variables, objetivo y restricciones — exactamente las tres piezas que aprendieron en la clase 1.\n",
    "\n",
    "Lo único que cambió fue **quién hace las cuentas**.\n",
    "\n",
    "---\n",
    "\n",
    "### Cuándo usar qué\n",
    "\n",
    "| Situación | La herramienta |\n",
    "|---|---|\n",
    "| Presentarle un plan a un gerente | **Excel.** Se ve, se imprime, se discute |\n",
    "| Un modelo de menos de 200 decisiones | **Excel.** Más rápido de armar |\n",
    "| Una red real, con miles de decisiones | **Python.** Excel no puede |\n",
    "| Correr el mismo modelo todos los días | **Python.** Se automatiza |\n",
    "| Explicarle el modelo a alguien | **Papel.** Sigue siendo el mejor |\n",
    "\n",
    "**En la industria se usan las tres.** Lo que nunca cambia es saber modelar — y eso ninguna herramienta lo hace por ustedes.\n",
    "\n",
    "---\n",
    "\n",
    "## Guarden este cuaderno: es una plantilla\n",
    "\n",
    "**No lo cierren y lo olviden.** Este cuaderno resuelve *cualquier* problema de transporte, no solo el de Distrialimentos.\n",
    "\n",
    "Para usarlo con otro caso, **solo se cambia el bloque de datos** del Paso 2. Nada más:\n",
    "\n",
    "```python\n",
    "CENTROS   = [...]      # sus origenes\n",
    "CIUDADES  = [...]      # sus destinos\n",
    "COSTO     = [[...]]    # cuanto cuesta cada ruta\n",
    "CAPACIDAD = [...]      # cuanto puede dar cada origen\n",
    "DEMANDA   = [...]      # cuanto pide cada destino\n",
    "```\n",
    "\n",
    "**El resto del código no se toca.** Sirve igual para:\n",
    "\n",
    "| En vez de… | Pongan… |\n",
    "|---|---|\n",
    "| Centros de distribución | Plantas, bodegas, proveedores |\n",
    "| Ciudades | Clientes, tiendas, obras |\n",
    "| Toneladas | Unidades, litros, horas, pedidos |\n",
    "| Costo de flete | Costo de producción, tiempo, distancia |\n",
    "\n",
    "**Guárdenlo en su Drive** (Archivo → Guardar una copia en Drive). Lo van a necesitar en la práctica, en el proyecto final, y probablemente en su primer trabajo.\n",
    "\n",
    "---\n",
    "\n",
    "### Qué se llevan de hoy (y qué NO)\n",
    "\n",
    "**NO se llevan:** saber programar en Python. Eso no se aprende en una clase y no es el objetivo.\n",
    "\n",
    "**Sí se llevan tres cosas:**\n",
    "\n",
    "1. **Saber que Excel tiene un techo** — 200 variables — y reconocer cuándo se está acercando a él.\n",
    "2. **Saber que hay salida, y cómo se llama.** Si mañana en un trabajo les dicen *\"esto ya no cabe en el Excel\"*, ustedes saben qué responder.\n",
    "3. **Poder leer un modelo escrito en código** y verificar si está bien planteado. Eso es una habilidad de ingeniero, no de programador.\n",
    "\n",
    "**Lo que sí aprendieron a fondo —modelar— es lo que no se automatiza.**"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": [],
   "toc_visible": true
  },
  "kernelspec": {
   "display_name": "Python 3",
   "name": "python3"
  },
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}