ケーススタディで学ぶ！オペレーションズリサーチ（OR）の実践活用法

import scipy.stats as stats

def calculate_optimal_service_level(stockout_cost, holding_cost):
  """最適サービス水準を計算します."""
  return stockout_cost / (stockout_cost + holding_cost)

def calculate_z_value(service_level):
  """サービス水準に対応するZ値を計算します."""
  return stats.norm.ppf(service_level)

def calculate_safety_stock(z_value, demand_std_dev):
  """安全在庫を計算します."""
  return z_value * demand_std_dev

def calculate_reorder_point(mean_demand, safety_stock):
  """発注点を計算します."""
  return mean_demand + safety_stock

# --- 入力パラメータ ---
mean_demand = 500  # 平均需要 (着)
demand_std_dev = 50  # 需要の標準偏差 (着)
holding_cost = 50   # 在庫保管コスト (円/着/月)
stockout_cost = 200  # 欠品コスト (円/着)

# --- 計算の実行 ---
optimal_service_level = calculate_optimal_service_level(stockout_cost, holding_cost)
z_value = calculate_z_value(optimal_service_level)
safety_stock = calculate_safety_stock(z_value, demand_std_dev)
reorder_point = calculate_reorder_point(mean_demand, safety_stock)

# --- 計算結果の表示 ---
print(f"最適サービス水準: {optimal_service_level:.3f}")
print(f"Z値: {z_value:.3f}")
print(f"安全在庫: {safety_stock:.2f} 着")
print(f"発注点: {reorder_point:.2f} 着")

def calculate_production_plan(product_names, demand, production_time_per_unit, total_available_time):
  """需要比率に基づいた生産計画を計算します."""

  # 合計需要を計算
  total_demand = sum(demand.values())

  # 各製品の計画生産量を格納する辞書
  planned_production_quantity = {}

  # 各製品について計画生産量を計算
  for product_name in product_names:
    # 需要比率を計算
    demand_ratio = demand[product_name] / total_demand

    # 生産時間配分を計算
    allocated_production_time = total_available_time * demand_ratio

    # 計画生産量を計算（端数は切り捨て）
    planned_quantity = int(allocated_production_time / production_time_per_unit[product_name])
    planned_production_quantity[product_name] = planned_quantity

  return planned_production_quantity

# --- 入力パラメータ ---
product_names = ["P1", "P2", "P3"]  # 製品名リスト
demand = {"P1": 100, "P2": 50, "P3": 80}  # 月間需要（個）
production_time_per_unit = {"P1": 1, "P2": 2, "P3": 1.5}  # 生産時間/個（時間）
total_available_time = 200  # 月間稼働時間（時間）

# --- 計算の実行 ---
production_plan = calculate_production_plan(product_names, demand, production_time_per_unit, total_available_time)

# --- 計算結果の表示 ---
print("生産計画（需要比率に基づく）")
total_planned_quantity = 0 # 計画生産量の合計を初期化
for product_name in product_names:
  planned_quantity = production_plan[product_name]
  print(f"  {product_name}: {planned_quantity} 個")
  total_planned_quantity += planned_quantity # 計画生産量を合計に加算

print(f"計画生産量合計: {total_planned_quantity} 個")

# データ定義 (更新)

distances_from_warehouse = { # 倉庫からの距離 (km) - 前回と同様
    '店舗A': 10,
    '店舗B': 15,
    '店舗C': 20,
    '店舗D': 25,
    '店舗E': 30
}

distances_between_stores = { # 店舗間の距離 (km) - ★追加
    ('店舗A', '店舗B'): 5, ('店舗A', '店舗C'): 10, ('店舗A', '店舗D'): 15, ('店舗A', '店舗E'): 20,
    ('店舗B', '店舗A'): 5, ('店舗B', '店舗C'): 7, ('店舗B', '店舗D'): 12, ('店舗B', '店舗E'): 18,
    ('店舗C', '店舗A'): 10, ('店舗C', '店舗B'): 7, ('店舗C', '店舗D'): 8, ('店舗C', '店舗E'): 14,
    ('店舗D', '店舗A'): 15, ('店舗D', '店舗B'): 12, ('店舗D', '店舗C'): 8, ('店舗D', '店舗E'): 6,
    ('店舗E', '店舗A'): 20, ('店舗E', '店舗B'): 18, ('店舗E', '店舗C'): 14, ('店舗E', '店舗D'): 6,
    ('店舗A', '店舗A'): 0, ('店舗B', '店舗B'): 0, ('店舗C', '店舗C'): 0, ('店舗D', '店舗D'): 0, ('店舗E', '店舗E'): 0 # 自己間距離は0
}

demands = { # 各店舗の需要 (個) - 前回と同様
    '店舗A': 20,
    '店舗B': 30,
    '店舗C': 25,
    '店舗D': 15,
    '店舗E': 10
}

truck_capacity = 100 # トラック容量 (個) - 前回と同様
fuel_cost_per_km = 50 # 燃料費 (円/km) - 前回と同様

stores = list(distances_from_warehouse.keys()) # 店舗リスト - 前回と同様

# 最適化ロジック (最近傍法 + 挿入法) - 更新

def optimize_route_with_inter_store_distance(distances_warehouse, distances_inter_store, demands, capacity):
    """
    店舗間距離を考慮した最近傍法 + 挿入法で配送ルートを最適化する関数

    Args:
        distances_warehouse (dict): 倉庫からの距離辞書
        distances_inter_store (dict): 店舗間距離辞書
        demands (dict): 各店舗の需要辞書
        capacity (int): トラック容量

    Returns:
        list: 最適化された店舗リスト (訪問順)
        float: 総距離
        int: 総需要
    """
    remaining_capacity = capacity
    route = []
    total_distance = 0
    total_demand = 0
    unvisited_stores = set(stores) # 未訪問の店舗集合

    current_location = '倉庫' # 現在地を倉庫に設定

    # 最初の店舗を倉庫から最も近い店舗に設定 (最近傍法的な初期化)
    if unvisited_stores:
        nearest_store = min(unvisited_stores, key=lambda store: distances_warehouse[store])
        route.append(nearest_store)
        total_distance += distances_warehouse[nearest_store] # 倉庫 -> 店舗 の距離を加算
        remaining_capacity -= demands[nearest_store]
        total_demand += demands[nearest_store]
        unvisited_stores.remove(nearest_store)
        current_location = nearest_store

    # 残りの店舗をルートに挿入 (挿入法)
    while unvisited_stores:
        best_store_to_insert = None
        min_insertion_cost = float('inf')

        for store_to_insert in unvisited_stores:
            if demands[store_to_insert] <= remaining_capacity: # 容量制約を満たす場合のみ検討
                for i in range(len(route)): # 既存ルートの各区間に挿入を試みる
                    insertion_cost = 0
                    if current_location == '倉庫': # 最初の店舗挿入時
                        insertion_cost = distances_warehouse[store_to_insert] + distances_inter_store[(store_to_insert, route[i])] - distances_warehouse[route[i]]
                    else: # 2番目以降の店舗挿入時
                         prev_store_in_route = route[i-1] if i > 0 else current_location # i=0 の場合は倉庫を起点とする
                         distance_before_insertion = distances_inter_store.get((prev_store_in_route, route[i]), distances_warehouse[route[i]] if prev_store_in_route == '倉庫' else distances_inter_store[(route[i], prev_store_in_route)]) if i > 0 or current_location != '倉庫' else distances_warehouse[route[i]]

                         distance_after_insertion = distances_inter_store.get((prev_store_in_route, store_to_insert), distances_warehouse[store_to_insert] if prev_store_in_route == '倉庫' else distances_inter_store[(store_to_insert, prev_store_in_route)])  + distances_inter_store[(store_to_insert, route[i])]


                         insertion_cost = distance_after_insertion - distance_before_insertion

                    if insertion_cost < min_insertion_cost:
                        min_insertion_cost = insertion_cost
                        best_store_to_insert = (store_to_insert, i) # 挿入する店舗と位置を記録

        if best_store_to_insert: # 最適な挿入位置が見つかった場合
            store_to_insert, insert_index = best_store_to_insert
            route.insert(insert_index, store_to_insert) # ルートに挿入
            total_distance += min_insertion_cost # 距離を加算
            remaining_capacity -= demands[store_to_insert] # 容量を減らす
            total_demand += demands[store_to_insert] # 需要を加算
            unvisited_stores.remove(store_to_insert) # 未訪問リストから削除
            current_location = store_to_insert # 現在地を更新
        else:
            break # 容量制約で挿入できる店舗がない場合は終了

    # 最後に倉庫に戻る
    total_distance += distances_warehouse[current_location] # 最後の店舗 -> 倉庫 の距離を加算 (current_location は最後に訪問した店舗)

    return route, total_distance, total_demand


# ルート最適化実行 (店舗間距離考慮版)
optimized_route_distance_aware, total_distance_distance_aware, total_demand_distance_aware = optimize_route_with_inter_store_distance(distances_from_warehouse, distances_between_stores, demands, truck_capacity)

# 結果出力 (店舗間距離考慮版)
print("■ 最適化ルート (店舗間距離考慮)")
print("訪問順:", optimized_route_distance_aware)
print("総距離:", total_distance_distance_aware, "km")
print("総燃料費:", total_distance_distance_aware * fuel_cost_per_km, "円")
print("総需要:", total_demand_distance_aware, "個")

print("\n■ 現状ルート、前回ルートとの比較")
current_distance = 150 # 現状ルートの総距離 (提示データ)
current_fuel_cost = 7500 # 現状ルートの燃料費 (提示データ)
previous_total_distance = 110 # 前回の最適化ルート総距離 (前回のコード実行例) - 前回のコード実行結果に合わせてください
previous_total_fuel_cost = 5500 # 前回の最適化ルート燃料費 (前回のコード実行例) - 前回のコード実行結果に合わせてください


print("現状ルート総距離:", current_distance, "km")
print("現状ルート燃料費:", current_fuel_cost, "円")
print("前回ルート総距離 (倉庫起点):", previous_total_distance, "km") # 前回の結果を追記
print("前回ルート燃料費 (倉庫起点):", previous_total_fuel_cost, "円") # 前回の結果を追記
print("店舗間距離考慮ルート総距離:", total_distance_distance_aware, "km")
print("店舗間距離考慮ルート燃料費:", total_distance_distance_aware * fuel_cost_per_km, "円")

print("\n■ 燃料費削減効果")
print("現状ルートからの燃料費削減額:", current_fuel_cost - (total_distance_distance_aware * fuel_cost_per_km), "円 (削減)")
print("現状ルートからの削減率:", round((current_fuel_cost - (total_distance_distance_aware * fuel_cost_per_km)) / current_fuel_cost * 100, 1), "% 削減")
print("前回ルートからの燃料費削減額:", previous_total_fuel_cost - (total_distance_distance_aware * fuel_cost_per_km), "円 (削減)")
print("前回ルートからの削減率:", round((previous_total_fuel_cost - (total_distance_distance_aware * fuel_cost_per_km)) / previous_total_fuel_cost * 100, 1), "% 削減")