Es conocido, que los problemas de asignación puros son una variación del problema original del transporte, en cuyos casos las variables de decisión solo pueden tomar valores binarios. ¿Esto qué significa? Pues bien, como algoritmo de red, un problema básico de transporte es un modelo de asignación genérico; modelo en el cual se pretende establecer la asignación entre fuentes y destinos; es decir, cuántas unidades se transportarán desde el origen i hacia el destino j. Se entiende además, que en el caso del transporte, estas variables de asignación no son necesariamente binarias.

El objetivo de este artículo consiste en utilizar las librerías del software Google OR-Tools (Python), para abordar un problema de transporte básico, de acuerdo a un modelo de asignación.

El problema

Con el propósito de evaluar los resultados obtenidos a través del tratamiento de un problema técnicamente formulado y abordado, utilizaremos un caso descrito en el libro Investigación de Operaciones (9na edición), de Hamdy A. Taha (University of Arkansas, Fayetteville), (Ejemplo 5.1-1):

MG Auto cuenta con tres plantas en Los Ángeles, Detroit y Nueva Orleáns, y dos importantes centros de distribución en Denver y Miami. Las capacidades trimestrales de las tres plantas son 1000, 1500 y 1200 automóviles, y las demandas de los dos centros de distribución durante el mismo periodo son de 2300 y 1400 automóviles. La distancia en millas entre las plantas y los centros de distribución aparece en la siguiente tabla: Hamdy A. Taha

Relación de distancias entre plantas y cedis

Distancia dada en millas

El caso también plantea que la compañía de transporte cobra 8 centavos por milla por automóvil. Así entonces, el objetivo del modelo no será minimizar la distancia total, sino minimizar el costo total de transporte. Con base en la distancia dada en millas y el costo de transporte unitario, construimos nuestra tabla de costos (redondeada al dólar más cercano):

Relación de costos de distribución entre plantas y cedis

Costo dado en dólares automóvil

La representación gráfica de la red sería la siguiente:

Resolviendo un problema de transporte mediante Or Tools (Asignación)

De acuerdo a lo mencionado en el artículo de introducción a Google OR-Tools, esta herramienta soporta múltiples lenguajes de programación, así entonces, haremos uso del lenguaje de programación Python.

Utilizaremos un solucionador para programación lineal mixta: SCIP.

Importar librerías

El primer paso consiste en importar la librería de Google Or Tools, esto nos permitirá utilizar todas sus funciones.

from ortools.linear_solver import pywraplp

Declarar el solucionador

Tal como lo mencionamos, vamos a utilizar un solucionador de programación lineal mixta. Esto nos permitirá utilizar tanto variables enteras como variables continuas. Debemos declarar el solucionador SCIP.

solver = pywraplp.Solver.CreateSolver('SCIP')

Crear la data del modelo

La data base del modelo corresponde a la matriz de costos. Debemos de considerar que el orden en el que se ingresa la información corresponda a la relación precisa entre las variables; veamos:

costos = [
    [ 80, 215],
    [100, 108],
    [102,  68],
]

num_plantas = len(costos)
num_cedis = len(costos[0])

Así mismo, utilizaremos el método len para calcular el número de plantas y el número de cedis. En el caso de las plantas, contará el número de filas de la matriz; en el caso de los cedis, contará en número de columnas (para saber que contará las columnas de la matriz se utiliza costos[0]).

Crear las variables del modelo

Este es un problema básico, y como tal las únicas variables necesarias serán las asignaciones. Es decir, las variables x[i, j], donde i representa el origen y j representa el destino. Este proceso es relativamente sencillo y puede generarse cada variable de manera manual, sin embargo, automatizaremos la creación de las variables por medio de ciclos, con el propósito de preparar nuestro código para problemas más robustos:

x = {}
for i in range(num_plantas):
    for j in range(num_cedis):
        x[i, j] = solver.IntVar(0, solver.infinity(), '')

De esta manera se crean las variables de asignación. Es decir, tendremos tantos i como número de plantas (orígenes), asociados a tantos j como número de cedis (destinos). La naturaleza de las variables es entera (solver.IntVar), ya que hace referencia a la distribución de automóviles. Desde la creación de las variables podemos definir su rango, en este caso diremos que será desde 0 hasta infinito (solver.infinity).

Así entonces, se entiende que, por ejemplo, la variable x[0,0] hace referencia al número de automóviles que se enviarán desde el origen 0 (Los Ángeles) hacia el destino 0 (Denver). El orden de la asignación se basa en la matriz de costos.

El código anterior crea todas las variables de asignación necesarias.

Crear las restricciones

#Restricciones de disponibilidad (oferta en plantas)
solver.Add(solver.Sum([x[0, j] for j in range(num_cedis)]) <= 1000)
solver.Add(solver.Sum([x[1, j] for j in range(num_cedis)]) <= 1500)
solver.Add(solver.Sum([x[2, j] for j in range(num_cedis)]) <= 1200)

#Restricciones de demanda (cedis)
solver.Add(solver.Sum([x[i, 0] for i in range(num_plantas)]) >= 2300)
solver.Add(solver.Sum([x[i, 1] for i in range(num_plantas)]) >= 1400) 

El método Add de solver, nos servirá para agregar las restricciones al modelo. Las restricciones de oferta y demanda necesarias se adicionan tal cual el código anterior. Explicaremos la primera de ellas:

solver.Add(solver.Sum([x[0, j] for j in range(num_cedis)]) <= 80)

La anterior restricción indica que, la sumatoria de todas las variables x[0, j], para los j del conjunto cedis deberá ser menor o igual a 1000. Esto significa que la cantidad enviada desde el nodo (planta) 0 hacia los destinos j (Denver y Miami) no puede ser mayor que su disponibilidad de automóviles.

Crear la función objetivo

Tal como lo planteamos desde la formulación del problema, el criterio de optimización des este modelo corresponde a minimizar el costo total de distribución. El siguiente fragmento calcula el producto entre cada variable x[i, j] y su respectivo costo c[i, j] (obtenida desde la matriz de costos). La sumatoria de productos corresponde a la ecuación objetivo.

for i in range(num_plantas):
    for j in range(num_cedis):
        objective_terms.append(costos[i][j] * x[i, j])
solver.Minimize(solver.Sum(objective_terms))

Luego se declara el criterio de optimización: Minimize (para minimizar) y Maximize (para maximizar). En este caso minimizará la sumatoria de los productos.

Invocar al solucionador

La siguiente línea indica que el modelo debe solucionarse.

status = solver.Solve()

Configurar las salidas del modelo

if status == pywraplp.Solver.OPTIMAL or status == pywraplp.Solver.FEASIBLE:
    print('Costo total = ', solver.Objective().Value(), '\n')

    for i in range(num_plantas):
        for j in range(num_cedis):
            print('|Planta {} -> Cedi {} - Cantidad: {}|'.format(
            i,
            j,
            x[i, j].solution_value()))

En el caso en el que el modelo encuentre una solución óptima, hemos configurado las salidas de tal manera que nos muestre la relación solución entre fuentes > destinos y cantidades. Al ejecutar el modelo obtendremos la siguiente solución:

Podemos también detallar mucho mejor las salidas del modelo, de acuerdo al nombre de las plantas y los cedis. Para ello, en la data de entrada creamos las listas correspondientes, veamos:

costos = [
    [ 80, 215],
    [100, 108],
    [102,  68],
]

num_plantas = len(costos)
num_cedis = len(costos[0])

plantas = ['Los Ángeles', 'Detroit', 'New Orleans']
cedis = ['Denver', 'Miami']

La información de las listas debe guardar correspondencia con el orden de la matriz de costos.

Ahora, configuramos nuevamente las salidas del modelo:

if status == pywraplp.Solver.OPTIMAL or status == pywraplp.Solver.FEASIBLE:
    print('Costo total = ', solver.Objective().Value(), '\n')

    for i in range(num_plantas):
        for j in range(num_cedis):
            print('|{:^20} -> {:^20} | Cantidad: {:^20}|'.format(
            plantas[i],
            cedis[j],
            x[i, j].solution_value()))

En este caso hemos remplazado el índice solo de plantas y cedis, por el índice dentro del listado de plantas y cedis. Así entonces, tendremos la siguiente salida del modelo:

Pueden cotejar los resultados obtenidos los cuales corresponden a los mismos resultados presentados por Taha, quien utiliza TORA como solucionador.

¿Cómo ejecutar el modelo?

Alternativa 1, ejecución en nuestro equipo:

Lo primero que debemos considerar, en el caso de que queramos ejecutar este código en nuestro equipo, es que es preciso contar con la instalación de Python en nuestro equipo de cómputo y por supuesto, el software OR-Tools. Una guía detallada de la instalación de estos requerimientos la podrás encontrar en el siguiente enlace:

Instalación de OR-Tools para Python

Ahora, lo recomendable es trabajar con algún editor de código práctico (IDE), por ejemplo: Sublime Text, o Spyder (Una herramienta más completa y por ende más robusta y pesada).

Alternativa 2, ejecución en un entorno virtual (Recomendado):

Podemos utilizar del mismo modo, un entorno virtual. En este caso recomendamos el uso de Colaboratory de Google, un entorno que cuenta con todas las herramientas necesarias para nuestros desarrollos. No tendremos que instalar nada en nuestro equipo, y aprovecharemos la potencia de las máquinas de Google.

El código completo de nuestro desarrollo lo presentamos a continuación.

# Importar la librería de Google OR-Tools
from ortools.linear_solver import pywraplp

# Declarar el solucionador que abordará el modelo
solver = pywraplp.Solver.CreateSolver('SCIP')

# Data del modelo
costos = [
    [ 80, 215],
    [100, 108],
    [102,  68],
]

plantas = ['Los Ángeles', 'Detroit', 'New Orleans']
cedis = ['Denver', 'Miami']

num_plantas = len(costos)
num_cedis = len(costos[0])

# Variables del modelo
x = {}
for i in range(num_plantas):
    for j in range(num_cedis):
        x[i, j] = solver.IntVar(0, solver.infinity(), '')
        
#Restricciones de disponibilidad (oferta en plantas) 
solver.Add(solver.Sum([x[0, j] for j in range(num_cedis)]) <= 1000) 
solver.Add(solver.Sum([x[1, j] for j in range(num_cedis)]) <= 1500) 
solver.Add(solver.Sum([x[2, j] for j in range(num_cedis)]) <= 1200) 

#Restricciones de demanda (cedis) 
solver.Add(solver.Sum([x[i, 0] for i in range(num_plantas)]) >= 2300) 
solver.Add(solver.Sum([x[i, 1] for i in range(num_plantas)]) >= 1400)      



# Función objetivo con criterio de optimización: minimizar
objective_terms = []
for i in range(num_plantas):
    for j in range(num_cedis):
        objective_terms.append(costos[i][j] * x[i, j])

solver.Minimize(solver.Sum(objective_terms))

# Invoca el solucionador
status = solver.Solve()

# Configura los parámetros de impresión, las salidas del modelo
if status == pywraplp.Solver.OPTIMAL or status == pywraplp.Solver.FEASIBLE:
    print('Costo total = ', solver.Objective().Value(), '\n')

    for i in range(num_plantas):
        for j in range(num_cedis):
            print('|{:^20} -> {:^20} | Cantidad: {:^20}|'.format(
            plantas[i],
            cedis[j],
            x[i, j].solution_value()))

También es posible integrar nuestro desarrollo con data proveniente de fuentes externas, como por ejemplo Excel.

En próximos artículos, resolveremos el problema de transporte básico mediante un algoritmo de flujo mínimo.

La entrada Solución de un modelo de transporte mediante un algoritmo de asignación se publicó primero en Ingenieria Industrial Online.

Tal como se ha abordado en artículos anteriores, dentro de la investigación de operaciones, el problema de asignación corresponde a una variación del problema original de transporte. Es uno de los problemas de optimización combinatoria más popularizados debido a su alto grado de aplicación práctica.

Suponga que es necesario llevar a cabo un conjunto de tareas, y que para ello se cuenta con un conjunto de operarios; además, cada trabajador en particular ejecutando una tarea en particular tiene un costo específico. Pues bien, el problema consiste en asignar a cada trabajador como máximo una tarea específica, sin que dos trabajadores puedan realizar la misma tarea, mientras se minimiza el costo total.

En el modelo de asignación, la idea fundamental de resolución es ¿Qué conjunto de fuentes satisface mejor el conjunto de destinos?

En artículos anteriores hemos planteado la resolución de problemas de asignación mediante el método húngaro (manual) y mediante programación lineal, haciendo uso de WinQSB.

El objetivo de este artículo consiste en utilizar las librerías del software Google OR-Tools para abordar un problema de asignación clásico y una variación del modelo mediante un criterio de maximización.

El problema

Con el propósito de evaluar los resultados obtenidos mediante distintos métodos y solucionadores, utilizaremos el mismo problema que abordamos mediante el método húngaro.

La compañía de manufactura «Jiménez y Asociados» desea realizar una jornada de mantenimiento preventivo a sus tres máquinas principales A, B y C. El tiempo que demanda realizar el mantenimiento de cada máquina es de 1 día, sin embargo la jornada de mantenimiento no puede durar más de un día, teniendo en cuenta que la compañía cuenta con tres proveedores de servicios de mantenimiento debe de asignarse un equipo de mantenimiento a cada máquina para poder cumplir con la realización del mantenimiento preventivo. Teniendo en cuenta que según el grado de especialización de cada equipo prestador de servicios de mantenimiento el costo de la tarea varía para cada máquina en particular, debe de asignarse el equipo correcto a la máquina indicada con el objetivo de minimizar el costo total de la jornada. Los costos asociados se pueden observar en la siguiente tabla:

Tabla 1

Resolviendo un problema de asignación mediante Google OR-Tools

De acuerdo a lo mencionado en el artículo de introducción a Google OR-Tools, esta herramienta soporta múltiples lenguajes de programación, así entonces, haremos uso del lenguaje de programación Python.

Del mismo modo, OR-Tools cuenta con un par de solucionadores para abordar problemas de asignación:

En este caso, utilizaremos el solucionador MIP.

Paso 1: Importar la librería

El siguiente fragmento de código importa las librerías necesarias:

# Importar la librería de Google OR-Tools
from ortools.linear_solver import pywraplp

Paso 2: Declarar el solucionador (MIP)

El siguiente fragmento de código declara el solucionador mediante el que se abordará el problema:

# Declarar el solucionador que abordará el modelo
solver = pywraplp.Solver.CreateSolver('SCIP')

Paso 3: Crear la data del modelo

El siguiente fragmento de código crea la data del modelo de asignación:

# Crear la data del modelo de asignación
costs = [
    [10, 9, 5],
    [9, 8, 3],
    [6, 4, 7],
]
num_teams = len(costs)
num_machines = len(costs[0])

La matriz de costos corresponde a los valores de la tabla 1 para asignar los equipos de mantenimiento a las máquinas.

El número de equipos de mantenimiento y el número de máquinas (tareas) los calcula mediante la función len  a partir de la matriz de costos. En un sentido práctico, cuenta el número de elementos de la matriz.

Paso 4: Crear las variables

El siguiente fragmento de código crea las variables binarias enteras del problema de asignación (x[i, j]):

# x[i, j] es una matriz de variables binarias 0-1, que será 1
# si un equipo de mantenimiento i es asignado a la máquina j.
x = {}
for i in range(num_teams):
    for j in range(num_machines):
        x[i, j] = solver.IntVar(0, 1, '')

Paso 5: Crear las restricciones

El siguiente fragmento de código crea las restricciones del problema de asignación:

# Cada equipo de mtto. podrá ser asignado a un máximo de una máquina
for i in range(num_teams):
    solver.Add(solver.Sum([x[i, j] for j in range(num_machines)]) <= 1)
# Cada máquina será asignada exactamente a un equipo de mantenimiento
for j in range(num_machines):
    solver.Add(solver.Sum([x[i, j] for i in range(num_teams)]) == 1)

Paso 6: Crear la función objetivo

El siguiente fragmento de código crea la función objetivo con un criterio de optimización minimizar

# Función objetivo con criterio de optimización: minimizar
objective_terms = []
for i in range(num_teams):
    for j in range(num_machines):
        objective_terms.append(costs[i][j] * x[i, j])
solver.Minimize(solver.Sum(objective_terms))

Paso 7: Invocar el solucionador

# Invoca el solucionador
status = solver.Solve()

Paso 8: Imprimir la solución

# Configura los parámetros de impresión, las salidas del modelo
if status == pywraplp.Solver.OPTIMAL or status == pywraplp.Solver.FEASIBLE:
    print('Costo total = ', solver.Objective().Value(), '\n')
    for i in range(num_teams):
        for j in range(num_machines):
            # Test if x[i,j] is 1 (con tolerancia de punto flotante)
            if x[i, j].solution_value() > 0.5:
                print('Equipo %d asignado a la máquina %d. Costo = %d' %
                      (i, j, costs[i][j]))

Es posible que el desarrollo de los ocho pasos anteriores demande algún grado de complejidad subyacente del uso de un lenguaje de programación; sin embargo, es preciso mencionar que, el modelo anterior queda perfectamente configurado, y puede replicarse con modificaciones menores en múltiples problemas de asignación.

¿Cómo ejecutar el modelo?

Alternativa 1, ejecución en nuestro equipo:

Lo primero que debemos considerar, en el caso de que queramos ejecutar este código en nuestro equipo, es que es preciso contar con la instalación de Python en nuestro equipo de cómputo, así mismo debemos contar con la última versión del comando pip y por supuesto, el software OR-Tools. Una guía detallada de la instalación de estos requerimientos la podrás encontrar en el siguiente enlace:

Instalación de OR-Tools para Python

Ahora, lo recomendable es trabajar con algún editor de código práctico (IDE), por ejemplo: Sublime Text, o Spyder (Una herramienta más completa y por ende más robusta y pesada).

Alternativa 2, ejecución en un entorno virtual (Recomendado):

Podemos utilizar del mismo modo, un entorno virtual. En este caso recomendamos el uso de Colaboratory de Google, un entorno que cuenta con todas las herramientas necesarias para nuestros desarrollos. No tendremos que instalar nada en nuestro equipo, y aprovecharemos la potencia de las máquinas de Google.

El código completo de nuestro desarrollo lo presentamos a continuación. También puedes ver el cuaderno de este módulo en nuestro Colaboratory: Asignación.

# Importar la librería de Google OR-Tools
from ortools.linear_solver import pywraplp

# Declarar el solucionador que abordará el modelo
solver = pywraplp.Solver.CreateSolver('SCIP')

# Data del modelo
costs = [
    [10, 9, 5],
    [9, 8, 3],
    [6, 4, 7],
]
num_teams = len(costs)
num_machines = len(costs[0])

# Variables del modelo
x = {}
for i in range(num_teams):
    for j in range(num_machines):
        x[i, j] = solver.IntVar(0, 1, '')

# Restricciones del modelo
for i in range(num_teams):
    solver.Add(solver.Sum([x[i, j] for j in range(num_machines)]) <= 1)
# Cada máquina será asignada exactamente a un equipo de mantenimiento
for j in range(num_machines):
    solver.Add(solver.Sum([x[i, j] for i in range(num_teams)]) == 1)

# Función objetivo con criterio de optimización: minimizar
objective_terms = []
for i in range(num_teams):
    for j in range(num_machines):
        objective_terms.append(costs[i][j] * x[i, j])
solver.Minimize(solver.Sum(objective_terms))

# Invoca el solucionador
status = solver.Solve()

# Configura los parámetros de impresión, las salidas del modelo
if status == pywraplp.Solver.OPTIMAL or status == pywraplp.Solver.FEASIBLE:
    print('Costo total = ', solver.Objective().Value(), '\n')
    for i in range(num_teams):
        for j in range(num_machines):
            # Test if x[i,j] is 1 (con tolerancia de punto flotante)
            if x[i, j].solution_value() > 0.5:
                print('Equipo %d asignado a la máquina %d. Costo = %d' %
                      (i, j, costs[i][j]))

Ejecutamos:

Y bien, tenemos la solución a este problema simple de asignación en menos de 1 segundo.

Podemos observar que se ha obtenido la misma respuesta que la lograda mediante el método húngaro y programación lineal (WinQSB).

Ahora bien, el modelo de asignación y el script del solucionador quedaron desarrollados en un lenguaje de programación estándar y ampliamente utilizado. Desde luego, las posibilidades de integrar datos de entrada y procesar los datos de salidas son interesantes. Por ejemplo, es posible desarrollar un script mediante el cual el código ya desarrollado tome los datos de entrada desde un archivo de Excel, o desde un servidor externo.

También, es posible desarrollar una interfaz amigable desde la cual se ingrese la información; o vincular los datos de salida con algún modelo o documento determinado.

Ahora, podemos evidenciar una de las bondades de este tipo de modelamiento, y es la flexibilidad. Pues bien, vamos a modificar muy fácilmente la información de entrada y el criterio de optimización, para desarrollar un modelo de asignación cuyo criterio sea maximizar. Para ello, vamos a abordar un problema de asignación planteado anteriormente, con el propósito de contrastar los resultados.

Modelamiento y solución de un problema de maximización mediante Google OR-Tools

El problema

Una organización de recolección de café cuenta con tres equipos de siembra y cosecha del mismo (equipos 1, 2, 3). Estos equipos de trabajo se encuentran entrenados para trabajar en condiciones particulares del proceso, condiciones como lo son el tipo de suelo, las condiciones del clima y el tipo de grano. La organización cuenta con cuatro terrenos disponibles para efectuar el proceso de siembra y cosecha (terrenos A, B, C, D), estos terrenos tienen condiciones particulares de suelo, clima y tipo de grano. Cada equipo cuenta con la capacidad de efectuar el proceso en solo uno de los terrenos disponibles, salvo el equipo 2, que cuenta con una serie de herramientas tecnológicas que le permiten realizar la siembra y cosecha del grano en dos de los terrenos disponibles.

Se ha contratado a un Ingeniero Industrial con el objetivo de realizar las asignaciones precisas que maximicen la cantidad de sacos de café cosechados en total. El siguiente tabulado muestra la capacidad (en cientos de sacos) de cosecha de café de cada uno de los equipos dependiendo de cada uno de los terrenos.

Dado que existe un equipo que cuenta con la capacidad de trabajar en dos de los terrenos disponibles (desarrollar dos tareas), renombraremos los equipos partiendo desde el 0, así mismo los terrenos, y el equipo 1 y 2 corresponderán a una misma flotilla (misma capacidad de producción) que puede desarrollar dos tareas (atender dos terrenos). Así entonces, el tabulado con las capacidades de producción se muestra a acontinuación:

Tabla 2

# Crear la data del modelo de asignación
capacidad = [
    [13, 7, 12, 12],
    [10, 13, 15, 7],
    [10, 13, 15, 7],
    [13, 10, 8, 8],
]
num_equipos = len(capacidad)
num_terrenos = len(capacidad[0])

# Función objetivo con criterio de optimización: maximizar
objective_terms = []
for i in range(num_equipos):
    for j in range(num_terrenos):
        objective_terms.append(capacidad[i][j] * x[i, j])
solver.Maximize(solver.Sum(objective_terms))

El código completo, con algunas modificaciones de acuerdo al renombre de las variables y a los textos que acompañarán los resultados se presenta a continuación (también puedes encontrarlo en nuestro Colaboratory):

# Importar la librería de Google OR-Tools
from ortools.linear_solver import pywraplp

# Declarar el solucionador que abordará el modelo
solver = pywraplp.Solver.CreateSolver('SCIP')

# Data del modelo
capacidad = [ 
[13, 7, 12, 12], 
[10, 13, 15, 7], 
[10, 13, 15, 7],
[13, 10, 8, 8], 
] 
num_equipos = len(capacidad) 
num_terrenos = len(capacidad[0])

# Variables del modelo
x = {}
for i in range(num_equipos):
    for j in range(num_terrenos):
        x[i, j] = solver.IntVar(0, 1, '')

# Restricciones del modelo
for i in range(num_equipos):
    solver.Add(solver.Sum([x[i, j] for j in range(num_terrenos)]) <= 1)

for j in range(num_terrenos):
    solver.Add(solver.Sum([x[i, j] for i in range(num_equipos)]) == 1)

# Función objetivo con criterio de optimización: maximizar
objective_terms = []
for i in range(num_equipos):
    for j in range(num_terrenos):
        objective_terms.append(capacidad[i][j] * x[i, j])
solver.Maximize(solver.Sum(objective_terms))

# Invoca el solucionador
status = solver.Solve()

# Configura los parámetros de impresión, las salidas del modelo
if status == pywraplp.Solver.OPTIMAL or status == pywraplp.Solver.FEASIBLE:
    print('Producción total = ', solver.Objective().Value(), '\n')
    for i in range(num_equipos):
        for j in range(num_terrenos):
            # Test if x[i,j] is 1 (con tolerancia de punto flotante)
            if x[i, j].solution_value() > 0.5:
                print('Equipo %d asignado al terreno %d. Producción = %d' %
                      (i, j, capacidad[i][j]))

La entrada Problemas de asignación en Google OR-Tools se publicó primero en Ingenieria Industrial Online.

Múltiples son los casos en los que como ingenieros industriales podemos hacer uso del problema de asignación para resolver diversas situaciones, entre los que cabe mencionar se encuentran la asignación de personal a maquinas, herramientas a puestos de trabajos, horarios a maestros, candidatos a vacantes, huéspedes a habitaciones, comensales a mesas, vendedores a zonas territoriales etc.

La entrada Problemas de asignación se publicó primero en Ingenieria Industrial Online.