python线性规划(linear programming)与分配问题(assignment problem)

37 篇文章 3 订阅

软件库:scipy.optimize
相关函数:
1.scipy.optimize.linprog(c, A_ub=None, b_ub=None, A_eq=None, b_eq=None, bounds=None, method='simplex', callback=None, options=None)

2.scipy.optimize.linear_sum_assignment(cost_matrix)

第一点线性规划问题,考虑下面优化问题:

Minimize: f = -1*x[0] + 4*x[1]

Subject to: -3*x[0] + 1*x[1] <= 6
1*x[0] + 2*x[1] <= 4
x[1] >= -3
where: -inf <= x[0] <= inf

求解代码如下:

c = [-1, 4]
A = [[-3, 1], [1, 2]]
b = [6, 4]
x0_bounds = (None, None)
x1_bounds = (-3, None)
from scipy.optimize import linprog
res = linprog(c, A_ub=A, b_ub=b, bounds=(x0_bounds, x1_bounds),
              options={"disp": True})

print(res)

第二点问题,分配问题,帮助文档给出的参考文献是http://csclab.murraystate.edu/bob.pilgrim/445/munkres.html,大体意思如下:假设有3个工人(workers)a,b,c,d,有三项任务(job)p,q,r,s,每个工人干每一项活的成本都不同(可以理解为不同工人的技术能力不同,薪资待遇也不同),那么便可构造一个代价矩阵(cost matrix)C
在这里插入图片描述
(注:图片来源于http://csclab.murraystate.edu/~bob.pilgrim/445/munkres.html)
下面使用linear_sum_assignment求解最佳任务分配问题:

import numpy as np
from scipy.optimize import linear_sum_assignment

# 代价矩阵
cost = np.array([[4, 1, 3], [2, 0, 5], [3, 2, 2]])

r, c = linear_sum_assignment(cost) # 得到最佳分配下的行列索引值
print(cost[r,c])

print("最小成本:",cost[r, c].sum())

结果:

[[4 1 3]
 [2 0 5]
 [3 2 2]]
[1 2 2]
最小成本: 5

当工人数大于任务数的时候,也会计算出最佳分配结果:

import numpy as np
from scipy.optimize import linear_sum_assignment

# 代价矩阵
cost = np.array([[4, 1, 3], [2, 0, 5], [3, 6, 5], [3, 5, 3]])
print(cost)
r, c = linear_sum_assignment(cost) # 得到最佳分配下的行列索引值
print(cost[r,c])

print("最小成本:",cost[r, c].sum())

结果如下:

[[4 1 3]
 [2 0 5]
 [3 6 5]
 [3 5 3]]
[1 2 3]
最小成本: 6

当任务数大于工人数时,如果要求任务数都要完成,那么有些工人可能就要完成多个任务,这种情况下如果任然使用该方法求解是不行的,因为该方法总是返回某一工人对应某一任务最佳分配的结果,需要另找其他方法实现。

参考链接:
[1]https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.linear_sum_assignment.html#scipy.optimize.linear_sum_assignment
[2]http://csclab.murraystate.edu/~bob.pilgrim/445/munkres.html

  • 3
    点赞
  • 32
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
线性规划是一种优化问题的求解方法,可以用来解决工作分配问题。下面是一个 Java 实现的工作分配示例: 假设有三个工人,可以完成三种工作,每个工人的工作效率不同,每种工作需要的时间也不同。现在需要确定每个工人分别完成哪些工作,以使得总工作时间最短。 首先,我们定义每个工人的效率和每种工作需要的时间: ```java double[] efficiency = {0.5, 0.8, 0.6}; //每个工人的效率 double[][] time = {{2, 3, 1}, {4, 1, 2}, {2, 5, 3}}; //每种工作需要的时间 ``` 然后,我们使用 Apache Commons Math 库中的 SimplexSolver 类来求解线性规划问题: ```java import org.apache.commons.math3.optim.linear.LinearConstraint; import org.apache.commons.math3.optim.linear.LinearObjectiveFunction; import org.apache.commons.math3.optim.linear.Relationship; import org.apache.commons.math3.optim.linear.SimplexSolver; import org.apache.commons.math3.optim.linear.UnboundedSolutionException; import org.apache.commons.math3.optim.linear.UnboundedSolutionException; //定义目标函数和约束条件 LinearObjectiveFunction objective = new LinearObjectiveFunction(new double[]{time[0][0], time[0][1], time[0][2], time[1][0], time[1][1], time[1][2], time[2][0], time[2][1], time[2][2]}, 0); ArrayList<LinearConstraint> constraints = new ArrayList<>(); for (int i = 0; i < 3; i++) { constraints.add(new LinearConstraint(new double[]{1, 1, 1, 0, 0, 0, 0, 0, 0}, Relationship.EQ, 1)); constraints.add(new LinearConstraint(new double[]{0, 0, 0, 1, 1, 1, 0, 0, 0}, Relationship.EQ, 1)); constraints.add(new LinearConstraint(new double[]{0, 0, 0, 0, 0, 0, 1, 1, 1}, Relationship.EQ, 1)); constraints.add(new LinearConstraint(new double[]{1, 0, 0, 1, 0, 0, 1, 0, 0}, Relationship.LEQ, efficiency[i])); constraints.add(new LinearConstraint(new double[]{0, 1, 0, 0, 1, 0, 0, 1, 0}, Relationship.LEQ, efficiency[i])); constraints.add(new LinearConstraint(new double[]{0, 0, 1, 0, 0, 1, 0, 0, 1}, Relationship.LEQ, efficiency[i])); } //求解线性规划问题 SimplexSolver solver = new SimplexSolver(); try { PointValuePair solution = solver.optimize(objective, new LinearConstraintSet(constraints), GoalType.MINIMIZE); double[] values = solution.getPoint(); System.out.println("Worker 1: Job " + (int) values[0] + ", Job " + (int) values[1] + ", Job " + (int) values[2]); System.out.println("Worker 2: Job " + (int) values[3] + ", Job " + (int) values[4] + ", Job " + (int) values[5]); System.out.println("Worker 3: Job " + (int) values[6] + ", Job " + (int) values[7] + ", Job " + (int) values[8]); } catch (UnboundedSolutionException e) { System.out.println("The solution is unbounded!"); } catch (NoFeasibleSolutionException e) { System.out.println("There is no feasible solution!"); } ``` 上述代码中,目标函数为总工作时间,约束条件包括每个工人完成的工作数量、每种工作的完成数量以及每个工人的工作效率。使用 SimplexSolver 求解线性规划问题,得到最优解后输出每个工人分配的工作。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值