基于Jump/Julia的多产品运输问题建模技术问询（含成本矩阵示例）

Hey there! Let's walk through how to extend your homogeneous transportation problem setup to handle multiple product types in JuMP. The core idea is to add a product dimension to your variables, constraints, and cost data—since each product has its own supply, demand, and transportation rules that don't overlap with others.

Step 1: Formalize Your Multi-Product Data #

First, let's structure the inputs you'll need for this scenario:

• Core Sets:
  • I: List of source points (e.g., warehouses)
  • J: List of destination points (e.g., retail locations)
  • P: List of distinct product types
• Key Parameters:
  • supply[i,p]: Maximum quantity of product p available at source i
  • demand[j,p]: Exact quantity of product p required at destination j
  • cost[i,j,p]: Cost to ship one unit of product p from source i to destination j (this replaces your single homogeneous tr matrix—each product gets its own cost matrix)

Using your original cost matrix as a baseline for product 1, here's how you might define sample data for two products:

# Define your core sets
I = 1:5  # 5 source points
J = 1:6  # 6 destination points
P = 1:2  # 2 product types

# Cost matrices (one per product)
cost = Dict(
    # Product 1 uses your original cost matrix
    (i,j,1) => [0 2.82 4.24 5.83 4.12 0;
                2.82 0 1.41 3.16 2.23 2.82;
                4.24 1.41 0 2 2.23 4.24;
                5.83 3.16 2 0 2.23 5.83;
                4.12 2.23 2.23 2.23 0 4.12][i,j],
    # Example cost matrix for product 2 (adjust as needed)
    (i,j,2) => [0 3.1 4.5 6.0 4.3 0;
                3.1 0 1.5 3.3 2.4 3.1;
                4.5 1.5 0 2.1 2.4 4.5;
                6.0 3.3 2.1 0 2.4 6.0;
                4.3 2.4 2.4 2.4 0 4.3][i,j]
)

# Sample supply and demand values (customize these to your actual data)
supply = Dict((i,p) => 100 for i in I, p in P)  # Each source has 100 units of each product
demand = Dict((j,p) => 80 for j in J, p in P)   # Each destination needs 80 units of each product

Step 2: Build and Solve the JuMP Model #

Now let's construct the optimization model with the product dimension baked in:

using JuMP, GLPK  # Use GLPK as a free solver; replace with Gurobi/CPLEX for large-scale problems

# Initialize the model
model = Model(GLPK.Optimizer)

# Decision variables: x[i,j,p] = quantity of product p shipped from source i to destination j
@variable(model, x[i in I, j in J, p in P] >= 0)

# Supply constraints: Total shipped from source i for product p can't exceed available supply
@constraint(model, supply_limit[i in I, p in P],
    sum(x[i,j,p] for j in J) <= supply[i,p]
)

# Demand constraints: Total received at destination j for product p must meet required demand
@constraint(model, demand_fulfillment[j in J, p in P],
    sum(x[i,j,p] for i in I) == demand[j,p]
)

# Objective: Minimize total transportation cost across all products and routes
@objective(model, Min, sum(cost[i,j,p] * x[i,j,p] for i in I, j in J, p in P))

# Run the solver
optimize!(model)

# Extract and print results
if termination_status(model) == OPTIMAL
    println("Optimal solution found!")
    # Print shipping quantities per product
    for p in P
        println("\n--- Product $p Shipping Details ---")
        for i in I
            for j in J
                # Only print non-zero shipments to keep output clean
                if value(x[i,j,p]) > 1e-6
                    println("Source $i → Destination $j: $(round(value(x[i,j,p]), digits=2)) units")
                end
            end
        end
    end
    println("\nTotal Transportation Cost: $(round(objective_value(model), digits=2))")
else
    println("No optimal solution exists—check supply/demand balances or constraints.")
end

Quick Tips for Customization #

• Product-Specific Rules: If certain products can't be shipped between specific source-destination pairs, add a constraint like @constraint(model, x[3,5,2] == 0) or set cost[3,5,2] = Inf (solvers will automatically avoid these routes).
• Data Efficiency: For contiguous integer sets (like our I, J, P), use a 3-dimensional array instead of a Dict for costs—e.g., cost = Array{Float64}(undef, length(I), length(J), length(P))—for faster access.
• Solver Scaling: For large problems with hundreds of sources/destinations/products, switch to commercial solvers like Gurobi or CPLEX—they handle big datasets much more efficiently than open-source options.

内容的提问来源于stack exchange，提问作者bhawesh sah