整数规划 python

2744557306

整数规划是线性规划的一个扩展，其中变量被限制为整数。在Python中，你可以使用多种库来解决整数规划问题，包括：

1.PuLP：PuLP是一个优化建模库，可以用于线性规划、整数规划和混合整数规划。它提供了一种直观的方式来定义优化问题，并支持多种优化算法。

1.   from pulp import LpMaximize, LpProblem, LpVariable
   7 j- Q/ Z\" M4 {1 ]$ l) f4 ~
2. 
   , S; g4 J1 S, L
3. 7 m. G. G, r: \
   
4. / ?9 ^0 Z$ {8 ?  V$ G6 r
   
5.    # 创建问题; @2 K\" _$ L: f) t% x
   
6. 7 k3 Z6 C  W4 z
   
7.    prob = LpProblem("Integer programming problem", LpMaximize)
   \" }( c9 V2 W) Z% |+ \
8. 
   0 [\" @, Z( ]\" k% C2 }$ {
9. 
   . g! f2 v: E+ D2 a( V( R7 |
10. 
    5 j* Y* ?; c, B6 a
11.    # 定义变量
    6 i8 \1 Y( u5 B( o
12. 
      D' ~+ X7 {9 n: e7 C
13.    x = LpVariable("x", lowBound=0, cat="Integer")' E; D) c& ]3 S4 A4 D6 N, _
    
14. 
    1 Y0 ?& U* U* J* F) ?
15.    y = LpVariable("y", lowBound=0, cat="Integer")
    ; d! E$ I  }7 u% m: z
16. - F' ?\" ]4 h) U\" I
    
17. & z; d' t5 `) A/ a4 N/ w
    
18. 
    3 r' G$ q8 b) B5 n, N7 S
19.    # 定义目标函数- n\" r4 ^; \/ b0 W& K4 W
    
20. / F9 X# J1 F% L  T* d
    
21.    prob += 3 * x + 2 * y
    ; z  D/ N2 _0 D6 }3 ?
22. 6 E# w# J1 U$ x# q: |
    
23. $ W8 ]2 L) ?! s  V0 R2 ?3 ~
    
24. 
    \" M* a7 A0 `* \4 a' p$ y- \& t
25.    # 添加约束条件
    7 c/ M9 `8 D5 x
26. 
    4 s6 l: Y6 Q, |\" x; Q! P/ s\" ^6 |
27.    prob += 2 * x + y <= 6
    : d6 w2 {, O: A, L9 o1 j! \$ Z- W
28. 7 j2 M3 z! m& S8 q8 l0 N
    
29.    prob += x + 2 * y <= 8
    # I& s% n1 _/ }& @
30. / \' j8 M) s! ?9 S. H6 h
    
31. 
    7 q1 ~2 d/ w# X8 ]& g; _
32. 
    4 `& i/ P5 Q( r- O3 \
33.    # 求解问题( h* w  E& b5 C. y# H( C8 L5 }
    
34. 
    ' B\" A3 z6 O# `
35.    prob.solve()
    & n, M, }7 P; R: f
36. ( Z4 I! {% r, Y
    
37. 
    / ]/ w+ a  A- f1 {\" Q# {
38. 6 q. ?\" @( I& V8 T  [
    
39.    # 输出结果) d4 }4 Q3 Q) @* q+ B
    
40. 
    7 \) i: ^4 t* H6 s2 ^0 w
41.    print("Optimal value:", prob.objective.value())
    : C& k& k4 l4 N) T/ m
42. 8 {8 i6 o2 I\" u% f
    
43.    for var in prob.variables():
    7 h- ~0 g9 @% n$ ^
44. 6 F2 S3 N2 l! H) [
    
45.        print(var.name, "=", var.value())

复制代码

2.Pyomo：Pyomo是一个用于优化建模的Python库，可以处理线性规划、整数规划、混合整数规划等问题。它提供了一种声明式的建模语言，可以方便地定义优化问题。

1.   from pyomo.environ import ConcreteModel, Var, Objective, Constraint, SolverFactory
   & b\" Z. D( J3 q2 h6 m6 a# o
2. 
   9 B: m: b. g! q1 o7 |2 v
3. 
   6 l9 |9 l6 t$ b  u2 L
4. 
   / H$ Z; Z1 I% Q% R5 ?: M
5.    # 创建模型' G% M) q9 g: ^: c3 P\" R
   
6. 
   / i4 m\" e( O, {/ s8 d
7.    model = ConcreteModel()# W5 o. @% i6 H+ S; W& g  T
   
8. $ J$ w) j, N2 P+ J4 O* }
   
9. # o, a5 h4 m, A: B+ m
   
10. / s% ~# Y7 ~, H
    
11.    # 定义变量6 E4 B, \$ X% d, [; {  p  R4 {3 ?
    
12. 
    ! k6 ?* V7 v0 y\" e' j' f
13.    model.x = Var(within=NonNegativeIntegers)
    0 Q( v! T) P& \
14. 
    6 f! X+ J& F5 \2 d! R  X
15.    model.y = Var(within=NonNegativeIntegers)& _; K' z6 L- _/ Q
    
16. 
    8 `  x# O2 Q0 V/ I1 B( o3 n2 x. W
17. 8 o+ h, N: u0 P
    
18. 9 g; a8 Z$ S# l\" R+ Y. E
    
19.    # 定义目标函数. R1 M) w% b: A6 A- x1 L
    
20. # {; w\" h9 m/ P5 ~! ~
    
21.    model.obj = Objective(expr=3 * model.x + 2 * model.y, sense=maximize)
    . o) p- m0 {2 c
22. 3 J' m6 p( V9 h2 d
    
23. * ?9 T\" u9 Z0 A( P
    
24. 
    : f% Z\" w( |# b. \8 n3 H- q4 C
25.    # 添加约束条件# Z\" T, b1 ^8 Y' f- p
    
26. 
    3 z9 m' c. S) ?, a2 N
27.    model.con1 = Constraint(expr=2 * model.x + model.y <= 6); }) c9 W: _: o/ \
    
28. 
    ( T9 M* \& I% T% w3 F( G
29.    model.con2 = Constraint(expr=model.x + 2 * model.y <= 8)
    / S0 ^2 l( k3 G2 p$ J
30. 
    ' ~$ `7 z\" d6 L# w, J
31. - H* D( e& w7 f4 Z7 c/ T
    
32. 3 n; j8 v& Y% y2 W+ ], |
    
33.    # 求解问题( o4 {5 x6 J/ L2 c  C' f
    
34. 
    \" y- o6 q& R$ Q4 K\" l. Y4 Z
35.    solver = SolverFactory('glpk')8 m- @- F) k% Z
    
36. ! E1 {6 K/ n& u' p' J
    
37.    solver.solve(model), K\" f4 U. I% \- t* W) }* T
    
38. ( F7 M: q- _3 K$ g
    
39. 
    \" P# B- N0 D& U- |! h
40. $ _6 ^% g, Z9 }9 @7 X2 w
    
41.    # 输出结果
    - w* n* k- R3 |9 L5 ]$ K4 h
42. # ^( j1 {' n- Z0 i6 m, L
    
43.    print("Optimal value:", model.obj())
    - H1 `- V; U: L! _& F3 `9 ]3 d
44. 
    . P! T- u# b0 t4 h2 d* S: w
45.    print("x =", model.x())
    $ o$ e( K( a  z% {* E
46. / D  p& D* h3 A! M! ^1 C- r, P
    
47.    print("y =", model.y())

复制代码

) e8 G$ s. t- V