from pulp import *

# ①問題の定義
prob = LpProblem("Food Distribution", LpMinimize)

# ②供給地域と需要地域のリスト
供給地域のリスト = ["地域A", "地域B", "地域C"]
需要地域のリスト = ["地域X", "地域Y", "地域Z"]

# ③供給量と需要量のデータ
供給量 = {
    "地域A": 100,
    "地域B": 200,
    "地域C": 150
}

需要量 = {
    "地域X": 120,
    "地域Y": 180,
    "地域Z": 150
}

# ④変数の設定
x = LpVariable.dicts("x", (供給地域のリスト, 需要地域のリスト), lowBound=0, cat="Continuous")

# ⑤目的関数の定義
prob += lpSum(x[i][j] for i in 供給地域のリスト for j in 需要地域のリスト)

# ⑥制約条件の定義
for i in 供給地域のリスト:
    prob += lpSum(x[i][j] for j in 需要地域のリスト) <= 供給量[i]

for j in 需要地域のリスト:
    prob += lpSum(x[i][j] for i in 供給地域のリスト) >= 需要量[j]

# ⑦最適化の実行
prob.solve()

# ⑧結果の表示
print("Status:", LpStatus[prob.status])

for v in prob.variables():
    print(v.name, "=", v.varValue)

print("Optimal Cost:", value(prob.objective))

import pulp

# 問題を初期化
problem = pulp.LpProblem("WeatherForecastOptimization", pulp.LpMinimize)

# 地域の数
N = 5

# 観測ステーションの数
K = 2

# 地域の座標
coordinates = [(0, 0), (1, 2), (3, 1), (4, 3), (5, 0)]

# 予測エラーの係数
error_coefficients = [1.0, 0.8, 1.2, 0.9, 1.1]

# 予測エラーの変数
errors = [pulp.LpVariable(f"error_{i}", lowBound=0) for i in range(N)]

# 観測ステーションの設置変数
stations = [pulp.LpVariable(f"station_{i}", cat=pulp.LpBinary) for i in range(K)]

# 目的関数を定義
problem += pulp.lpSum(errors[i] * error_coefficients[i] for i in range(N))

# 各地域の予測エラーを計算
for i in range(N):
    # 地域の予測エラーを観測ステーションの影響で制約
    for j in range(K):
        problem += errors[i] >= pulp.lpSum(stations[j] * distance(coordinates[i], coordinates[k]) for k in range(N))

# 観測ステーションの数制約
problem += pulp.lpSum(stations) == K

# 問題を解く
problem.solve()

# 最適解を表示
print("Optimization Status:", pulp.LpStatus[problem.status])
print("Minimum Prediction Error:", pulp.value(problem.objective))

# 観測ステーションの配置を表示
for j in range(K):
    if stations[j].value() == 1:
        print("Station", j+1, "is located at", coordinates[j])

import pulp

# 地点間の距離を計算する関数
def distance(coord1, coord2):
    return ((coord1[0] - coord2[0]) ** 2 + (coord1[1] - coord2[1]) ** 2) ** 0.5

# 問題を初期化
problem = pulp.LpProblem("WeatherForecastOptimization", pulp.LpMinimize)

# 地域の数
N = 5

# 観測ステーションの数
K = 2

# 地域の座標
coordinates = [(0, 0), (1, 2), (3, 1), (4, 3), (5, 0)]

# 予測エラーの係数
error_coefficients = [1.0, 0.8, 1.2, 0.9, 1.1]

# 予測エラーの変数
errors = [pulp.LpVariable(f"error_{i}", lowBound=0) for i in range(N)]

# 観測ステーションの設置変数
stations = [pulp.LpVariable(f"station_{i}", cat=pulp.LpBinary) for i in range(K)]

# 目的関数を定義
problem += pulp.lpSum(errors[i] * error_coefficients[i] for i in range(N))

# 各地域の予測エラーを計算するための制約条件
for i in range(N):
    for j in range(K):
        problem += errors[i] >= pulp.lpSum(stations[j] * distance(coordinates[i], coordinates[k]) for k in range(N))

# 観測ステーションの数制約
problem += pulp.lpSum(stations) == K

# 問題を解く
problem.solve()

# 最適解を表示
print("Optimization Status:", pulp.LpStatus[problem.status])
print("Minimum Prediction Error:", pulp.value(problem.objective))

# 観測ステーションの配置を表示
for j in range(K):
    if stations[j].value() == 1:
        print("Station", j+1, "is located at", coordinates[j])

from pulp import *

# ①問題の初期化
prob = LpProblem("MetaVerse Store Placement", LpMaximize)

# ②変数の定義
store_locations = ['Location1', 'Location2', 'Location3']  # M個の配置可能な場所
stores = ['Store1', 'Store2', 'Store3']  # N個の店舗

# ③各店舗の配置場所の収益データ
revenues = {
    'Store1': {
        'Location1': 10,
        'Location2': 5,
        'Location3': 8
    },
    'Store2': {
        'Location1': 6,
        'Location2': 9,
        'Location3': 3
    },
    'Store3': {
        'Location1': 7,
        'Location2': 4,
        'Location3': 2
    }
}

# ④各配置場所間の距離データ
distances = {
    'Location1': {
        'Location1': 0,
        'Location2': 10,
        'Location3': 5
    },
    'Location2': {
        'Location1': 10,
        'Location2': 0,
        'Location3': 7
    },
    'Location3': {
        'Location1': 5,
        'Location2': 7,
        'Location3': 0
    }
}

# ⑤変数の作成
store_vars = LpVariable.dicts("StoreLocation", (stores, store_locations), cat='Binary')

# ⑥目的関数の定義
prob += lpSum([revenues[store][location] * store_vars[store][location] for store in stores for location in store_locations])

# ⑦制約条件の追加
# 各店舗は1つの場所に配置される
for store in stores:
    prob += lpSum([store_vars[store][location] for location in store_locations]) == 1

# ⑧各場所には1つの店舗しか配置されない
for location in store_locations:
    prob += lpSum([store_vars[store][location] for store in stores]) <= 1

# ⑨PuLPで最適化問題を解く
prob.solve()

# ⑩結果の出力
print("Status:", LpStatus[prob.status])
print("Optimal Solution:")
for store in stores:
    for location in store_locations:
        if store_vars[store][location].value() == 1:
            print(f"{store} is placed at {location}")

from pulp import *

# 問題の定義
problem = LpProblem("MiningOptimization", LpMaximize)

# マイナーのハッシュレートとマイニング時間
miners = {
    "Miner1": {"hashrate": 10, "max_time": 60},
    "Miner2": {"hashrate": 15, "max_time": 90},
    "Miner3": {"hashrate": 20, "max_time": 120}
}

# 変数の定義
mining_times = LpVariable.dicts("MiningTime", miners.keys(), lowBound=0, upBound=180)

# 目的関数の定義
total_reward = lpSum(mining_times[miner] * miners[miner]["hashrate"] for miner in miners)
problem += total_reward

# 制約条件の定義
problem += lpSum(mining_times.values()) == 180

for miner in miners:
    problem += mining_times[miner] <= miners[miner]["max_time"]

# 問題の解決
problem.solve()

# 結果の表示
print("Optimization Status:", LpStatus[problem.status])
for miner in miners:
    print(f"{miner}: Mining Time = {mining_times[miner].varValue:.2f} seconds")

# 各マイナーの報酬
rewards = {miner: mining_times[miner].varValue * miners[miner]["hashrate"] for miner in miners}
print("Rewards:")
for miner, reward in rewards.items():
    print(f"{miner}: {reward:.2f}")

from pulp import *

# ①従業員の数と曜日のリスト
employees = range(5)
weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

# ②テレワーク希望日の設定
telework_preferences = [
    [1, 1, 0, 0, 1],  # 従業員0の希望日
    [0, 1, 0, 1, 0],  # 従業員1の希望日
    [1, 0, 1, 0, 1],  # 従業員2の希望日
    [1, 0, 1, 1, 0],  # 従業員3の希望日
    [0, 1, 0, 0, 1]   # 従業員4の希望日
]

# ③問題の定義
prob = LpProblem("Telework Optimization", LpMinimize)

# ④変数の定義
# telework[(i, j)] = 1 の場合、従業員 i は曜日 j にテレワークを行う
telework = LpVariable.dicts("telework", (employees, weekdays), 0, 1, LpInteger)

# ⑤目的関数の定義
# テレワークを行う日数を最小化する
prob += lpSum([telework[i][j] for i in employees for j in weekdays])

# ⑥制約条件の定義
# 各従業員は週に1日オフィス勤務を行う
for i in employees:
    prob += lpSum([telework[i][j] for j in weekdays]) == 4

# ⑦各従業員の希望日にテレワークを行う
for i in employees:
    for j in weekdays:
        prob += telework[i][j] >= telework_preferences[i][weekdays.index(j)]

# ⑧問題の解決
prob.solve()

# ⑨結果の出力
print("Status:", LpStatus[prob.status])
print("Optimal Schedule:")
for i in employees:
    print("Employee", i)
    for j in weekdays:
        if value(telework[i][j]) == 1:
            print(j, "- Telework")
        else:
            print(j, "- Office")
    print()

from pulp import *

# 顧客の情報
customers = [
    {"name": "顧客A", "time": 2, "cost": 200, "image": 8},
    {"name": "顧客B", "time": 3, "cost": 150, "image": 7},
    {"name": "顧客C", "time": 1, "cost": 50, "image": 3},
    {"name": "顧客D", "time": 4, "cost": 100, "image": 5},
    {"name": "顧客E", "time": 2, "cost": 120, "image": 6}
]

# インデックスのリスト
indices = range(len(customers))

# 最適化問題の定義
prob = LpProblem("Apology Optimization Problem", LpMaximize)

# 変数の定義
selections = LpVariable.dicts("Selection", indices, cat='Binary')

# 目的関数の定義
prob += lpSum([customers[i]["image"] * selections[i] for i in indices])

# 制約条件の定義
prob += lpSum([customers[i]["time"] * selections[i] for i in indices]) <= 6  # 時間制約
prob += lpSum([customers[i]["cost"] * selections[i] for i in indices]) <= 300  # コスト制約

# 最適化の実行
prob.solve()

# 結果の表示
print("最適化結果:")
for i in indices:
    if selections[i].varValue == 1:
        print(f"{customers[i]['name']}: 送る")

# 目的関数値の表示
print("目的関数値:", value(prob.objective))

from pulp import *

# 問題の定義
problem = LpProblem("アイドルメンバー選択", LpMaximize)

# 変数の定義
members = ['メンバー1', 'メンバー2', 'メンバー3', 'メンバー4', 'メンバー5', 'メンバー6', 'メンバー7', 'メンバー8', 'メンバー9', 'メンバー10']
selected = LpVariable.dicts('選択', members, 0, 1, LpBinary)

# メンバーのポテンシャルとバランスの値を追加で定義
potential = {'メンバー1': 0.8, 'メンバー2': 0.7, 'メンバー3': 0.9, 'メンバー4': 0.6, 'メンバー5': 0.8, 'メンバー6': 0.9, 'メンバー7': 0.7, 'メンバー8': 0.8, 'メンバー9': 0.6, 'メンバー10': 0.7}
balance = {'メンバー1': 0.4, 'メンバー2': 0.6, 'メンバー3': 0.5, 'メンバー4': 0.7, 'メンバー5': 0.6, 'メンバー6': 0.8, 'メンバー7': 0.7, 'メンバー8': 0.5, 'メンバー9': 0.6, 'メンバー10': 0.7}

# 目的関数の定義
problem += lpSum(selected[member] for member in members)

# 制約条件の定義
problem += lpSum(selected[member] for member in members) == 5  # 5人を選ぶ
problem += lpSum(selected[member] * potential[member] for member in members) >= 0.7  # ポテンシャルの合計が0.7以上
problem += lpSum(selected[member] * balance[member] for member in members) >= 0.5  # バランスの合計が0.5以上

# 問題の解決
problem.solve()

# 結果の表示
print("選択されたメンバー:")
for member in members:
    if selected[member].varValue == 1:
        print(member)

from pulp import *

# 難民と再定住先のデータ
refugees = {
    'Refugee1': {'happiness': 5},
    'Refugee2': {'happiness': 8},
    'Refugee3': {'happiness': 3}
}

resettlement = {
    'Resettlement1': {'capacity': 2},
    'Resettlement2': {'capacity': 1}
}

# 問題の定義
problem = LpProblem("Refugee Resettlement Problem", LpMaximize)

# 問題の変数
x = LpVariable.dicts("RefugeeResettlement", 
                     [(r, s) for r in refugees for s in resettlement], 
                     cat='Binary')

# 目的関数
problem += lpSum(refugees[r]['happiness'] * x[r, s] for r in refugees for s in resettlement)

# 制約条件
for r in refugees:
    problem += lpSum(x[r, s] for s in resettlement) == 1  # 難民は1つの再定住先にのみ割り当てられる

for s in resettlement:
    problem += lpSum(x[r, s] for r in refugees) <= resettlement[s]['capacity']  # 再定住先の定員制約

# 問題を解く
problem.solve()

# 結果を表示
print("最適化結果:")
for r in refugees:
    for s in resettlement:
        if value(x[r, s]) == 1:
            print(f"{r} を {s} に再定住")

# 目的関数の値（難民の幸福度の合計）を表示
print("目的関数の値:", value(problem.objective))

from pulp import *

# 問題の定義
problem = LpProblem("Nuclear Power Plant Fuel Optimization", LpMinimize)

# 変数の定義
uranium = LpVariable("Uranium", lowBound=500, upBound=1500)
plutonium = LpVariable("Plutonium", lowBound=100, upBound=300)

# 目的関数の定義
cost = 500 * uranium + 1000 * plutonium
problem += cost

# 制約条件の定義
problem += uranium + plutonium >= 600  # ウラン+プルトニウムの合計の最低制約
problem += uranium + plutonium <= 1800  # ウラン+プルトニウムの合計の最大制約

# 問題の解決
problem.solve()

# 結果の表示
print("Optimization Status:", LpStatus[problem.status])
print("Optimal Solution:")
print("Uranium:", value(uranium), "kg")
print("Plutonium:", value(plutonium), "kg")
print("Total Cost: $", value(problem.objective))

from pulp import *

# 問題を作成
problem = LpProblem("Class Scheduling", LpMinimize)

# 変数の定義
days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
time_slots = ['Slot 1', 'Slot 2', 'Slot 3']
classes = ['Math', 'Science', 'History']

# 変数の作成
variables = LpVariable.dicts("Class", (days, time_slots, classes), cat='Binary')

# 目的関数の定義（ここでは最小化）
problem += 0

# 制約条件の追加
# 各授業は1つの時間帯で開講される
for d in days:
    for c in classes:
        problem += lpSum([variables[d][t][c] for t in time_slots]) == 1

# 各時間帯には1つの授業のみが開講される
for d in days:
    for t in time_slots:
        problem += lpSum([variables[d][t][c] for c in classes]) <= 1

# 解く
problem.solve()

# 結果の表示
print("最適解:")
for d in days:
    for t in time_slots:
        for c in classes:
            if value(variables[d][t][c]) == 1:
                print(f"{d}: {t} - {c}")