OR-Tools:4-分配问题（Assignment）

最新推荐文章于 2024-04-12 10:27:30 发布
最新推荐文章于 2024-04-12 10:27:30 发布
阅读量1.4k 收藏 4
点赞数 2
分类专栏： 算法优化 文章标签： 算法 python 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AS7062031/article/details/108386071
版权

 OR-Tools 解决的问题类型： 

  1. Linear optimization
  2. Constraint optimization
  3. Mixed-integer optimization
  4. Bin packing
  5. Network flows
  6. Assignment
  7. Scheduling
  8. Routing

分配问题：

假设一组工作人员需要执行一组任务，并且对于每个工作人员和任务，将工作人员分配给该任务需要成本。问题是将每个工作人员最多分配给一个任务，没有两个工作人员执行相同的任务，同时最大限度地降低总成本。

 有五个工作工（编号为 0-4）和四个任务（编号为 0-3）

 0123
090807570
135855565
2125959095
34511095115
45010090100

 

from ortools.linear_solver import pywraplp


def main():
    # Data
    costs = [
        [90, 80, 75, 70],
        [35, 85, 55, 65],
        [125, 95, 90, 95],
        [45, 110, 95, 115],
        [50, 100, 90, 100],
    ]
    num_workers = len(costs)
    num_tasks = len(costs[0])

    # Solver
    # Create the mip solver with the CBC backend.
    solver = pywraplp.Solver.CreateSolver('assignment_mip', 'CBC')


    # Variables
    # x[i, j] is an array of 0-1 variables, which will be 1
    # if worker i is assigned to task j.
    x = {}
    for i in range(num_workers):
        for j in range(num_tasks):
            x[i, j] = solver.IntVar(0, 1, '')

    # Constraints
    # Each worker is assigned to at most 1 task.
    for i in range(num_workers):
        solver.Add(solver.Sum([x[i, j] for j in range(num_tasks)]) <= 1)

    # Each task is assigned to exactly one worker.
    for j in range(num_tasks):
        solver.Add(solver.Sum([x[i, j] for i in range(num_workers)]) == 1)

    # Objective
    objective_terms = []
    for i in range(num_workers):
        for j in range(num_tasks):
            objective_terms.append(costs[i][j] * x[i, j])
    solver.Minimize(solver.Sum(objective_terms))

    # Solve
    status = solver.Solve()

    # Print solution.
    if status == pywraplp.Solver.OPTIMAL or status == pywraplp.Solver.FEASIBLE:
        print('Total cost = ', solver.Objective().Value(), '\n')
        for i in range(num_workers):
            for j in range(num_tasks):
                # Test if x[i,j] is 1 (with tolerance for floating point arithmetic).
                if x[i, j].solution_value() > 0.5:
                    print('Worker %d assigned to task %d.  Cost = %d' %
                          (i, j, costs[i][j]))


if __name__ == '__main__':
    main()
Total cost =  265.0 

Worker 0 assigned to task 3.  Cost = 70
Worker 1 assigned to task 2.  Cost = 55
Worker 2 assigned to task 1.  Cost = 95
Worker 3 assigned to task 0.  Cost = 45

或者使用CP优化的方式

def main():
    # Data
    costs = [
        [90, 80, 75, 70],
        [35, 85, 55, 65],
        [125, 95, 90, 95],
        [45, 110, 95, 115],
        [50, 100, 90, 100],
    ]
    num_workers = len(costs)
    num_tasks = len(costs[0])

    # Model
    model = cp_model.CpModel()

    # Variables
    x = []
    for i in range(num_workers):
        t = []
        for j in range(num_tasks):
            t.append(model.NewBoolVar('x[%i,%i]' % (i, j)))
        x.append(t)

    # Constraints
    # Each worker is assigned to at most one task.
    for i in range(num_workers):
        model.Add(sum(x[i][j] for j in range(num_tasks)) <= 1)

    # Each task is assigned to exactly one worker.
    for j in range(num_tasks):
        model.Add(sum(x[i][j] for i in range(num_workers)) == 1)

    # Objective
    objective_terms = []
    for i in range(num_workers):
        for j in range(num_tasks):
            objective_terms.append(costs[i][j] * x[i][j])
    model.Minimize(sum(objective_terms))

    # Solve
    solver = cp_model.CpSolver()
    status = solver.Solve(model)

    # Print solution.
    if status == cp_model.OPTIMAL or status == cp_model.FEASIBLE:
        print('Total cost = %i' % solver.ObjectiveValue())
        print()
        for i in range(num_workers):
            for j in range(num_tasks):
                if solver.BooleanValue(x[i][j]):
                    print('Worker ', i, ' assigned to task ', j, '  Cost = ',
                          costs[i][j])
    else:
        print('No solution found.')

多人合作的任务：六个工作人员被分成两个团队，每个团队最多可以执行两个任务。

from __future__ import print_function
from ortools.linear_solver import pywraplp

def main():
  solver = pywraplp.Solver('SolveAssignmentProblemMIP',
                           pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)

  cost = [[90, 76, 75, 70],
          [35, 85, 55, 65],
          [125, 95, 90, 105],
          [45, 110, 95, 115],
          [60, 105, 80, 75],
          [45, 65, 110, 95]]

  team1 = [0, 2, 4]
  team2 = [1, 3, 5]
  team_max = 2

  num_workers = len(cost)
  num_tasks = len(cost[1])
  x = {}

  for i in range(num_workers):
    for j in range(num_tasks):
      x[i, j] = solver.BoolVar('x[%i,%i]' % (i, j))

  # Objective
  solver.Minimize(solver.Sum([cost[i][j] * x[i,j] for i in range(num_workers)
                                                  for j in range(num_tasks)]))

  # Constraints

  # Each worker is assigned to at most 1 task.

  for i in range(num_workers):
    solver.Add(solver.Sum([x[i, j] for j in range(num_tasks)]) <= 1)

  # Each task is assigned to exactly one worker.

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

  # Each team takes on two tasks.

  solver.Add(solver.Sum([x[i, j] for i in team1 for j in range(num_tasks)]) <= team_max)
  solver.Add(solver.Sum([x[i, j] for i in team2 for j in range(num_tasks)]) <= team_max)
  sol = solver.Solve()

  print('Total cost = ', solver.Objective().Value())
  print()
  for i in range(num_workers):
    for j in range(num_tasks):
      if x[i, j].solution_value() > 0:
        print('Worker %d assigned to task %d.  Cost = %d' % (
              i,
              j,
              cost[i][j]))

  print()
  print("Time = ", solver.WallTime(), " milliseconds")
if __name__ == '__main__':
  main()

根据任务大小的分配

每个任务都有一个大小，它表示任务需要多少时间或工作量。每个工作人员执行的任务的总大小具有固定的约束。

用CP优化的方式实现：

from __future__ import print_function
from ortools.sat.python import cp_model
import time
import numpy as np

def main():
  model = cp_model.CpModel()

  start = time.time()
  cost = [[90, 76, 75, 70, 50, 74, 12, 68],
          [35, 85, 55, 65, 48, 101, 70, 83],
          [125, 95, 90, 105, 59, 120, 36, 73],
          [45, 110, 95, 115, 104, 83, 37, 71],
          [60, 105, 80, 75, 59, 62, 93, 88],
          [45, 65, 110, 95, 47, 31, 81, 34],
          [38, 51, 107, 41, 69, 99, 115, 48],
          [47, 85, 57, 71, 92, 77, 109, 36],
          [39, 63, 97, 49, 118, 56, 92, 61],
          [47, 101, 71, 60, 88, 109, 52, 90]]

  sizes = [10, 7, 3, 12, 15, 4, 11, 5]
  total_size_max = 15
  num_workers = len(cost)
  num_tasks = len(cost[1])
  # Variables
  x = []
  for i in range(num_workers):
    t = []
    for j in range(num_tasks):
      t.append(model.NewIntVar(0, 1, "x[%i,%i]" % (i, j)))
    x.append(t)
  x_array = [x[i][j] for i in range(num_workers) for j in range(num_tasks)]

  # Constraints

  # Each task is assigned to at least one worker.
  [model.Add(sum(x[i][j] for i in range(num_workers)) >= 1)
  for j in range(num_tasks)]

  # Total size of tasks for each worker is at most total_size_max.

  [model.Add(sum(sizes[j] * x[i][j] for j in range(num_tasks)) <= total_size_max)
  for i in range(num_workers)]
  model.Minimize(sum([np.dot(x_row, cost_row) for (x_row, cost_row) in zip(x, cost)]))
  solver = cp_model.CpSolver()
  status = solver.Solve(model)

  if status == cp_model.OPTIMAL:
    print('Minimum cost = %i' % solver.ObjectiveValue())
    print()

    for i in range(num_workers):

      for j in range(num_tasks):

        if solver.Value(x[i][j]) == 1:
          print('Worker ', i, ' assigned to task ', j, '  Cost = ', cost[i][j])
    print()
    end = time.time()
    print("Time = ", round(end - start, 4), "seconds")


if __name__ == '__main__':
  main()

用线性优化的方式：

from __future__ import print_function
import time
from ortools.linear_solver import pywraplp

def main():
  solver = pywraplp.Solver('SolveAssignmentProblem',
                           pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)

  start = time.time()
  cost = [[90, 76, 75, 70, 50, 74, 12, 68],
          [35, 85, 55, 65, 48, 101, 70, 83],
          [125, 95, 90, 105, 59, 120, 36, 73],
          [45, 110, 95, 115, 104, 83, 37, 71],
          [60, 105, 80, 75, 59, 62, 93, 88],
          [45, 65, 110, 95, 47, 31, 81, 34],
          [38, 51, 107, 41, 69, 99, 115, 48],
          [47, 85, 57, 71, 92, 77, 109, 36],
          [39, 63, 97, 49, 118, 56, 92, 61],
          [47, 101, 71, 60, 88, 109, 52, 90]]

  task_sizes = [10, 7, 3, 12, 15, 4, 11, 5]

  # Maximum total of task sizes for any worker
  total_size_max = 15
  num_workers = len(cost)
  num_tasks = len(cost[1])
  # Variables
  x = {}

  for i in range(num_workers):
    for j in range(num_tasks):
      x[i, j] = solver.IntVar(0, 1, 'x[%i,%i]' % (i, j))

  # Constraints
  # The total size of the tasks each worker takes on is at most total_size_max.

  for i in range(num_workers):
    solver.Add(solver.Sum([task_sizes[j] * x[i, j] for j in range(num_tasks)]) <= total_size_max)

  # Each task is assigned to at least one worker.

  for j in range(num_tasks):
    solver.Add(solver.Sum([x[i, j] for i in range(num_workers)]) >= 1)

  solver.Minimize(solver.Sum([cost[i][j] * x[i,j] for i in range(num_workers)
                                                  for j in range(num_tasks)]))
  sol = solver.Solve()

  print('Minimum cost = ', solver.Objective().Value())
  print()
  for i in range(num_workers):
    for j in range(num_tasks):
      if x[i, j].solution_value() > 0:
        print('Worker', i,' assigned to task', j, '  Cost = ', cost[i][j])
  print()
  end = time.time()
  print("Time = ", round(end - start, 4), "seconds")
if __name__ == '__main__':
  main()
# cpsat 
Minimum cost = 326

Worker  0  assigned to task  6   Cost =  12
Worker  1  assigned to task  0   Cost =  35
Worker  1  assigned to task  2   Cost =  55
Worker  4  assigned to task  4   Cost =  59
Worker  5  assigned to task  5   Cost =  31
Worker  5  assigned to task  7   Cost =  34
Worker  6  assigned to task  1   Cost =  51
Worker  8  assigned to task  3   Cost =  49

Time =  11.847 seconds
# MIP
Minimum cost =  326.0

Worker 0  assigned to task 6   Cost =  12
Worker 1  assigned to task 0   Cost =  35
Worker 1  assigned to task 2   Cost =  55
Worker 4  assigned to task 4   Cost =  59
Worker 5  assigned to task 5   Cost =  31
Worker 5  assigned to task 7   Cost =  34
Worker 6  assigned to task 1   Cost =  51
Worker 8  assigned to task 3   Cost =  49

Time =  0.031 seconds

线性优化耗时短一些

某些允许的工作组分配给任务。在示例中有 12 个工作人员，编号为 0 - 11。允许的组是以下工作项对的组合。

  group1 =  [[2, 3],       # Subgroups of workers 0 - 3
             [1, 3],
             [1, 2],
             [0, 1],
             [0, 2]]

  group2 =  [[6, 7],       # Subgroups of workers 4 - 7
             [5, 7],
             [5, 6],
             [4, 5],
             [4, 7]]

  group3 =  [[10, 11],     # Subgroups of workers 8 - 11
             [9, 11],
             [9, 10],
             [8, 10],
             [8, 11]]

允许的组可以是三对工作人员的任意组合，每组 1、组 2 和组 3 各一对。例如，组合 [2，3]、[6、7] 和 [10，11] 会导致允许的组 [2，3，6，7，10，11]。由于三个组都包含五个元素，因此允许的组总数为 5 * 5 * 5 = 125。

方法1 CPSAT

from __future__ import print_function
from ortools.sat.python import cp_model
import time
import numpy as np

def main():
  model = cp_model.CpModel()
  start = time.time()
  cost = [[90, 76, 75, 70, 50, 74],
          [35, 85, 55, 65, 48, 101],
          [125, 95, 90, 105, 59, 120],
          [45, 110, 95, 115, 104, 83],
          [60, 105, 80, 75, 59, 62],
          [45, 65, 110, 95, 47, 31],
          [38, 51, 107, 41, 69, 99],
          [47, 85, 57, 71, 92, 77],
          [39, 63, 97, 49, 118, 56],
          [47, 101, 71, 60, 88, 109],
          [17, 39, 103, 64, 61, 92],
          [101, 45, 83, 59, 92, 27]]
  num_workers = len(cost)
  num_tasks = len(cost[1])
  group1 =  [[0, 0, 1, 1],      # Workers 2, 3
             [0, 1, 0, 1],      # Workers 1, 3
             [0, 1, 1, 0],      # Workers 1, 2
             [1, 1, 0, 0],      # Workers 0, 1
             [1, 0, 1, 0]]      # Workers 0, 2

  group2 =  [[0, 0, 1, 1],      # Workers 6, 7
             [0, 1, 0, 1],      # Workers 5, 7
             [0, 1, 1, 0],      # Workers 5, 6
             [1, 1, 0, 0],      # Workers 4, 5
             [1, 0, 0, 1]]      # Workers 4, 7

  group3 =  [[0, 0, 1, 1],      # Workers 10, 11
             [0, 1, 0, 1],      # Workers 9, 11
             [0, 1, 1, 0],      # Workers 9, 10
             [1, 0, 1, 0],      # Workers 8, 10
             [1, 0, 0, 1]]      # Workers 8, 11

  # Declare the variables.
  x = []
  for i in range(num_workers):
    t = []
    for j in range(num_tasks):
      t.append(model.NewIntVar(0, 1, "x[%i,%i]" % (i, j)))
    x.append(t)
  x_array = [x[i][j] for i in range(num_workers) for j in range(num_tasks)]
  # Constraints

  # Each task is assigned to at least one worker.
  [model.Add(sum(x[i][j] for i in range(num_workers)) == 1)
  for j in range(num_tasks)]

  # Each worker is assigned to at most one task.
  [model.Add(sum(x[i][j] for j in range(num_tasks)) <= 1)
  for i in range(num_workers)]

  # Create variables for each worker, indicating whether they work on some task.
  work = []
  for i in range(num_workers):
    work.append(model.NewIntVar(0, 1, "work[%i]" % i))

  for i in range(num_workers):
    for j in range(num_tasks):
      model.Add(work[i] == sum(x[i][j] for j in range(num_tasks)))

  # Define the allowed groups of worders
  model.AddAllowedAssignments([work[0], work[1], work[2], work[3]], group1)
  model.AddAllowedAssignments([work[4], work[5], work[6], work[7]], group2)
  model.AddAllowedAssignments([work[8], work[9], work[10], work[11]], group3)
  model.Minimize(sum([np.dot(x_row, cost_row) for (x_row, cost_row) in zip(x, cost)]))
  solver = cp_model.CpSolver()
  status = solver.Solve(model)

  if status == cp_model.OPTIMAL:
    print('Minimum cost = %i' % solver.ObjectiveValue())
    print()
    for i in range(num_workers):

      for j in range(num_tasks):

        if solver.Value(x[i][j]) == 1:
          print('Worker ', i, ' assigned to task ', j, '  Cost = ', cost[i][j])
    print()
    end = time.time()
    print("Time = ", round(end - start, 4), "seconds")

if __name__ == '__main__':
  main()

方法2 MIP

from __future__ import print_function
from ortools.linear_solver import pywraplp
import time

def main():
  start = time.time()
  cost = [[90, 76, 75, 70, 50, 74],
          [35, 85, 55, 65, 48, 101],
          [125, 95, 90, 105, 59, 120],
          [45, 110, 95, 115, 104, 83],
          [60, 105, 80, 75, 59, 62],
          [45, 65, 110, 95, 47, 31],
          [38, 51, 107, 41, 69, 99],
          [47, 85, 57, 71, 92, 77],
          [39, 63, 97, 49, 118, 56],
          [47, 101, 71, 60, 88, 109],
          [17, 39, 103, 64, 61, 92],
          [101, 45, 83, 59, 92, 27]]

  num_tasks = len(cost[1])
  # Allowed groups of workers:
  group1 =  [[2, 3],       # Subgroups of workers 0 - 3
             [1, 3],
             [1, 2],
             [0, 1],
             [0, 2]]

  group2 =  [[6, 7],       # Subgroups of workers 4 - 7
             [5, 7],
             [5, 6],
             [4, 5],
             [4, 7]]

  group3 =  [[10, 11],     # Subgroups of workers 8 - 11
             [9, 11],
             [9, 10],
             [8, 10],
             [8, 11]]

  allowed_groups = []

  for i in range(len(group1)):
    for j in range(len(group2)):
      for k in range(len(group3)):
        allowed_groups.append(group1[i] + group2[j] + group3[k])
  min_val = 1e6
  total_time = 0

  for i in range(len(allowed_groups)):
    group = allowed_groups[i]
    res = assignment(cost, group)
    solver_tmp = res[0]
    x_tmp = res[1]
    total_time = total_time + solver_tmp.WallTime()

    if solver_tmp.Objective().Value() < min_val:
      min_val = solver_tmp.Objective().Value()
      min_index = i
      min_solver = solver_tmp
      min_x = x_tmp
      min_group = group

  print('Minimum cost = ', min_val)
  print()
  for i in min_group:
    for j in range(num_tasks):
      if min_x[i, j].solution_value() > 0:
        print('Worker', i,' assigned to task', j, '  Cost = ', cost[i][j])
  print()
  end = time.time()
  print("Time = ", round(end - start, 4), "seconds")

def assignment(cost, group):
  # Solve assignment problem for given group of workers.
  num_tasks = len(cost[1])
  # Clear values in x
  solver = None
  # Instantiate a mixed-integer solver
  solver = pywraplp.Solver('AssignmentProblemGroups',
                           pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
  x = None
  x = {}

  for i in group:
    for j in range(num_tasks):
      x[i, j] = solver.IntVar(0, 1, 'x[%i,%i]' % (i, j))

  # Each worker is assigned to exactly one task.

  for i in group:
    solver.Add(solver.Sum([x[i, j] for j in range(num_tasks)]) <= 1)

  # Each task is assigned to at least one worker.

  for j in range(num_tasks):
    solver.Add(solver.Sum([x[i, j] for i in group]) >= 1)
  # Objective
  solver.Minimize(solver.Sum([cost[i][j] * x[i,j] for i in group
                                                  for j in range(num_tasks)]))
  solver.Solve()
  res = [solver, x]
  return res

if __name__ == '__main__':
  main()
MIP
Minimum cost =  239.0

Worker 0  assigned to task 4   Cost =  50
Worker 1  assigned to task 2   Cost =  55
Worker 5  assigned to task 5   Cost =  31
Worker 6  assigned to task 3   Cost =  41
Worker 10  assigned to task 0   Cost =  17
Worker 11  assigned to task 1   Cost =  45

Time =  0.8036 seconds
CP-SAT
Minimum cost = 239

Worker  0  assigned to task  4   Cost =  50
Worker  1  assigned to task  2   Cost =  55
Worker  5  assigned to task  5   Cost =  31
Worker  6  assigned to task  3   Cost =  41
Worker  10  assigned to task  0   Cost =  17
Worker  11  assigned to task  1   Cost =  45

Time =  0.3831 seconds

CPSAT速度快一些

线性赋值解算器 据说比CPSAT,MIP都快

from __future__ import print_function
from ortools.graph import pywrapgraph
import time

def main():
  cost = create_data_array()
  rows = len(cost)
  cols = len(cost[0])

  assignment = pywrapgraph.LinearSumAssignment()
  for worker in range(rows):
    for task in range(cols):
      if cost[worker][task]:
        assignment.AddArcWithCost(worker, task, cost[worker][task])
  solve_status = assignment.Solve()
  if solve_status == assignment.OPTIMAL:
    print('Total cost = ', assignment.OptimalCost())
    print()
    for i in range(0, assignment.NumNodes()):
      print('Worker %d assigned to task %d.  Cost = %d' % (
            i,
            assignment.RightMate(i),
            assignment.AssignmentCost(i)))
  elif solve_status == assignment.INFEASIBLE:
    print('No assignment is possible.')
  elif solve_status == assignment.POSSIBLE_OVERFLOW:
    print('Some input costs are too large and may cause an integer overflow.')
def create_data_array():
  cost = [[90, 76, 75, 70],
          [35, 85, 55, 65],
          [125, 95, 90, 105],
          [45, 110, 95, 115]]
  return cost
if __name__ == "__main__":
  start_time = time.clock()
  main()
  print()
  print("Time =", time.clock() - start_time, "seconds")

我们假设所有工作人员都可以执行所有任务。但情况并非总是如此 - 工作人员可能由于各种原因无法执行一个或多个任务。但是，很容易修改上面的程序来处理这个问题。假设辅助角色 0 无法执行任务 3。

cost = [[90, 76, 75, 'NA'],
        [35, 85, 55, 65],
        [125, 95, 90, 105],
        [45, 110, 95, 115]]

在将成本分配给解算器的代码部分中，添加行 ，如下所示。if cost[worker][task] != 'NA'

for worker in range(0, rows):
    for task in range(0, cols):
      if cost[worker][task] != 'NA':
        assignment.AddArcWithCost(worker, task, cost[worker][task])

图形理论--婚姻定理Hall's Marriage

婚姻定理应用的标准例子是设想两组;一个男人， 和一个女人。对于每个女人，有一个子集的男人，任何一个她很乐意结婚;任何男人都会很乐意嫁给一个想嫁给他的女人考虑是否有可能（在婚姻中）配对男女，使每个人都幸福。

  1. 我们有1-N号女嘉宾，和1-N号男嘉宾。
  2. 每个女嘉宾在属于自己的小卡片上写下中意的男嘉宾们的号码（没有数量限制，甚至可以全写）。
  3. 把这些小卡片收集起来。

 如何通过收集的小卡片来判断，是否存在一种配对，使得所有女嘉宾都选到自己中意的男嘉宾。

例如：N=3时候，女1喜欢男2和男3，可以看出男2收到了三个女士的欢迎

女1：男2，男3

女2：男1，男2

女3：男2

当女1只写男2，女3只写男2的时候就有抢男人的操作因此就配对不成功

假如任取k个女嘉宾，把她们的卡片合起来，这些卡片上写到的所有男嘉宾个数（重复的只算一次）必须至少是k，否则这些女嘉宾们就会抢起来，就不存在配对。意思是男人要比选择人也就是女人的数目多。这样才能挑嘛。

如果严格的阐述Hall's Marriage定理，记 [公式] 为所有女嘉宾集合, [公式] 为所有男嘉宾集合, 记 [公式] 为女嘉宾到所选男嘉宾集的映射，这里 [公式] 表示M所有子集的集合。若对任意F的子集S满足以下不等式

[公式]

则存在配对

关于这个定理的证明请网上自己搜索，我现在还没有时间搞得那么详细。等我过段时间把各种有趣的算法整理好后再细分。然后加上有趣的例子和实现。

关于算法这部分学习我认为是每一个计算机领域的研发人员需要了解的。我会把很多我看到的算法集中到一个专栏《算法优化》里面。到何时方便查找和学习。

说回婚姻定理，这个和分配的关系就是，让左边的节点全都分配到右边节点。也就是都有男士接受，且各个接受的男士是不同的，不然就重婚了，哈哈。

关于婚姻问题这部分还有个The Stable Marriage Problem。留着以后写。

 

 

夏天望月兔
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ortools解决tsp_ortools系列：分配问题
weixin_39612499的博客
12-19 460
ortools系列：分配问题1. 分配问题组合优化中最重要的问题之一是分配问题，其中一组工作者必须执行一组任务。对于每个工人和任务，该工人执行任务的成本是固定的。问题是给每个工人分配不同的任务，以使总成本最小化。分配问题的一个典型就是工作排班，对于工厂这种三班倒或者公交司机两班倒，该怎么排班，才能照顾到每个人的工作和休息时间。这里有一个例子，假设一家出租车公司有四个客户在等车，四个出租车司机(工人...
任务分配问题
仰望星空的麦兜
03-11 2050
详述[编辑] 分为以下几类： 线性任务分配问题：是二元组的集合，其中和分别是集合和中的元素。是某一函数，并满足特定约束条件，例如：的每一个元素必须在中出现一次，或者的每一个元素必须在中出现一次，或者以上二者都必须满足。线性任务分配问题的目标就是最大化或者最小化之和。 该问题是线性的因为代价函数只取决于特定的二元组而与其它的二元组没有任何关系。 二次任务分配问题：给定家工厂和
OR-TOOL 背包算法
最新发布
正怒月神的博客
04-12 397
起因：最近公司要发票自动匹配，比如财务输入10000W块，找到发票中能凑10000的。然后可以快速核销。废话不多，
OR-Tools:5-调度问题（Scheduling）
AS7062031的博客
09-04 1490
OR-Tools 解决的问题类型： Linear optimization Constraint optimization Mixed-integer optimization Bin packing Network flows Assignment Scheduling Routing 调度问题： 调度：在特定时间为任务分配人员和资源。例如 安排员工进行多班制，但须遵守一系列复杂的约束和人员配置要求 安排一个制造流程，该流程涉及在一组有限的计算机上执行许多任务，每台计算机一次.
调用 OR-Tools GLOP 求解器的简单模型实例
星海浮生
04-06 1283
Python 语言调用 OR-Tools 求解器；线性规划模型（Klee-Minty Cube）；整数规划模型（选址问题）
运筹系列14：Assignment问题模型与python代码求解
kittyzc的博客
11-16 2289
1. 问题描述 分配问题可以简单描述为：有数个人和数个任务，人做任务有不同的费用。每个人最多只能做一项任务，每个任务只能由一个人做。如何将任务分配给人可以使总费用最小？ 用数学语言表示为： minminmin Σi∈I,j∈Jcijxij\Sigma_{i\in I,j\in J}c_{ij}x_{ij}Σi∈I,j∈J​cij​xij​ s.t. Σi∈Ixij=1,∀j∈J\Sigma_{i\...
ORtools求解软时间窗车辆路径规划问题
dipsyliu549的博客
02-08 1195
ORTools本身有求解CVRP和加入硬时间窗的方法，如果需要求解软时间窗的，在原本CVRP基础上难以修改，所以可以自己建模~相关语法比较少，小公主这里用python调包辣，java的maven配了半天还是不行，所以用了python，体验还不错嘻嘻嘻。 import math import re from ortools.linear_solver import pywraplp solver = pywraplp.Solver('SolveVRPSTW', pywraplp.Solver.CBC_
assignment-problem:匈牙利方法的分配问题
04-06
《匈牙利方法解决分配问题》 在计算机科学和运筹学中，分配问题是一个经典的问题，它涉及到如何有效地将一组资源或任务分配给另一组等效的接收者，使得某些目标函数达到最优。其中，匈牙利算法是解决这类问题的一种...
cruise-queen-assignment:JavaScript分配
05-24
【文件名称列表解析】：“cruise-queen-assignment-master”通常是一个GitHub仓库的克隆或下载文件名，表示这是项目的主分支或源代码。这个文件夹可能包含以下内容：源代码文件（.js）、HTML文件（.html）、CSS样式...
DS-assignment:Coursera数据结构课程分配
05-15
压缩包子文件的文件名称列表“DS-assignment-master”可能包含以下几个部分： - 代码文件：可能是用C++编写的实现不同数据结构的源代码。 - 测试文件：用于测试数据结构功能的测试用例。 - 解释文档：详细解释每个...
Coursera-Assignment:模块2编码分配
05-07
在本节中，我们将深入探讨"Coursera-Assignment:模块2编码分配"这一主题，主要关注HTML（超文本标记语言）的相关知识点。HTML是构建网页的基础，它定义了网页的结构和内容。在这个课程作业中，你可能需要掌握HTML的...
generalized-assignment:广义分配问题的近似算法
04-27
从压缩包文件名"generalized-assignment-master"来看，这可能是一个开源项目或教程的主目录，其中可能包含了源代码、数据集、示例和文档，帮助学习者理解和实现广义分配问题的近似算法。 在实际应用中，广义分配...
基于OR-Tools的指派问题建模求解（PythonAPI）
博客简介
10-28 657
指派问题（又称为分配问题，assignment problem）可以抽象概括为：将n个任务（或物品）分配给m个员工（或背包）的问题。其中，最简单的平衡指派模型是指任务数量和员工数量相等的情形。然而，现实生活中的问题大多是任务数量大于员工数量且员工能力有限的广义指派问题（generalized assignment problem，GAP）。GAP是经典的组合优化问题，许多领域的容量约束问题都可以被抽象为GAP进行求解，如机器调度问题、有容量约束的设施选址问题、供应链问题及车辆路径问题等。
scipy求解指派问题
南军Opt的博客
06-18 528
python调用科学计算库scipy求解运筹学中的指派问题
OR-Tools:1-线性优化，整数优化和约束优化（Linear optimization，Mixed-integer optimization，Constraint optimization）
AS7062031的博客
09-03 3631
算法优化一般目标是：缩小搜索范围，以找到最佳（或接近最佳）的解决方案。 算法优化不得不提软件是OR-Tools：https://developers.google.com/optimization 安装： python -m pip install --upgrade --user ortools OR-Tools是一个用于优化的开源软件套件，可解决世界上最棘手的问题，包括车辆路线，流量，整数和线性编程以及约束编程。vehicle routing, flows, integer and line.
常见规划问题
u013052732的专栏
05-30 1378
一、规划问题 LP：Linear Programming 线性规划 研究线性约束条件下线性目标函数的极值问题 ILP：Integer Linear Programming 整数线性规划 全部决策变量必须为整数 MIP：Mixed Integer Programming 混合整数规划 混合整数规划是LP的一种，其中部分的决策变量是整数（不要求全部都是整数） VRP：Vehicle Routing Problem 车辆路径问题 二、规划工具 pulp 只用于线性模型，包括如整数规划、01规划，还是混
python混合整数线性规划_【Python代码】混合整数规划MIP/线性规划LP+python(ortool库)实现...
weixin_42513870的博客
02-21 3422
相关知识点LP线性规划问题Linear Problem[百度百科]：研究线性约束条件下线性目标函数的极值问题的数学理论和方法。学过运筹学的小伙伴，可以看这个LP问题的标准型来回顾一下：不太熟悉的朋友可以看这个例题，再结合上面的标准型，来感受一下：MIP混合整数规划Mixed Integar Planing混合整数规划是LP的一种，决策变量部分是整数，不要求全部都是整数的规划问题。这里MIP的求解器...
OR-Tools:2-包装问题，箱包问题（bin packing）
AS7062031的博客
09-03 1777
OR-Tools 解决的问题类型： Linear optimization Constraint optimization Mixed-integer optimization Bin packing Network flows Assignment Scheduling Routing 包装问题： 包装一组给定大小的项目到容器与固定容量。典型的应用是有效地将箱子装到送货卡车上。通常，由于容量限制，无法打包所有项目。在这种情况下，问题是查找最大总大小的项的子集，该子集将适合容器。两.
ortools学习
weixin_52640415的博客
10-13 202
ortools sage矩阵求解

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值