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}")

from pulp import *

# データセットの設定
N = 5  # 購入可能な最大のアイテム数
B = 100  # 予算
items = [
    {'name': 'テーブル', 'cost': 30, 'importance': 8},
    {'name': '椅子', 'cost': 20, 'importance': 6},
    {'name': '照明器具', 'cost': 50, 'importance': 9},
    {'name': '本棚', 'cost': 40, 'importance': 7},
    {'name': 'ベッド', 'cost': 60, 'importance': 10}
]

# 問題の定義
prob = LpProblem("MinimalistFurnitureProblem", LpMaximize)

# 変数の作成
x = LpVariable.dicts("Item", range(len(items)), lowBound=0, upBound=1, cat=LpInteger)

# 目的関数の定義
prob += lpSum([items[i]['importance'] * x[i] for i in range(len(items))])

# 制約条件の定義
prob += lpSum([items[i]['cost'] * x[i] for i in range(len(items))]) <= B
prob += lpSum(x) <= N

# 問題の解決
prob.solve()

# 結果の出力
print("Status:", LpStatus[prob.status])
print("最適なアイテムリスト:")
for i in range(len(items)):
    if value(x[i]) > 0:
        print(f"{items[i]['name']}: 重要度 {items[i]['importance']}, コスト {items[i]['cost']}")

from pulp import *

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

# 企業の情報
companies = {
    "A": {"salary": 500, "satisfaction": 100},
    "B": {"salary": 600, "satisfaction": 90},
    "C": {"salary": 400, "satisfaction": 120}
}

# 変数の作成
choices = LpVariable.dicts("Choice", companies, cat="Binary")

# 目的関数の定義
problem += lpSum(choices[company] * (companies[company]["salary"] + companies[company]["satisfaction"]) for company in companies)

# 制約条件の定義
problem += lpSum(choices.values()) == 1  # 1社だけを選択する

# 問題の解決
problem.solve()

# 結果の出力
print("最適解:")
for company in companies:
    if choices[company].varValue == 1:
        print(f"{company}社を選択する")