import networkx as nx

# ツイッターユーザーのフォロー関係を表現するグラフを作成する
G = nx.DiGraph()
G.add_edges_from([('A', 'B'), ('A', 'C'), ('B', 'C'), ('B', 'D'), ('C', 'A'), ('C', 'B'), ('C', 'D'), ('D', 'A'), ('D', 'C')])

# pagerankアルゴリズムを用いて、各ユーザーの影響力を計算する
pagerank = nx.pagerank(G)

# 影響力が高い順にユーザーを並び替える
sorted_pagerank = sorted(pagerank.items(), key=lambda x: x[1], reverse=True)

# 結果を表示する
for user, score in sorted_pagerank:
    print(f'{user}: {score}')

import networkx as nx

G = nx.Graph()

G.add_edges_from([('A', 'B'), ('A', 'D'), ('B', 'C'), ('B', 'E'), ('C', 'F'), ('D', 'E'), ('E', 'F')])

if nx.has_path(G, 'A', 'E'):
    print("頂点Aと頂点Eの間にパスが存在します。")
else:
    print("頂点Aと頂点Eの間にパスは存在しません。")

import networkx as nx

G = nx.DiGraph()

G.add_nodes_from([1, 2, 3, 4, 5])

G.add_weighted_edges_from([(1, 2, 3), (1, 3, 4), (2, 3, 1), (2, 4, 6), (3, 4, 2), (3, 5, 7), (4, 5, 8)])

longest_path = nx.dag_longest_path(G)
print(longest_path)

import networkx as nx

# ①グラフの作成
G = nx.DiGraph()

# ②ノードの追加
G.add_nodes_from([1, 2, 3, 4, 5])

# ③エッジの追加
G.add_weighted_edges_from([(1, 2, 3), (1, 3, 4), (2, 3, 1), (2, 4, 6), (3, 4, 2), (3, 5, 7), (4, 5, 8)])

# ④最長経路の計算
longest_path = nx.dag_longest_path(G)

# ⑤結果の出力
print("最長経路: ", longest_path)

import networkx as nx

# グラフを定義する
G = nx.Graph()
G.add_edge('A', 'B', weight=5)
G.add_edge('A', 'C', weight=3)
G.add_edge('B', 'D', weight=2)
G.add_edge('C', 'D', weight=3)

# ノードAからノードDまでの最短経路を求める
path = nx.shortest_path(G, 'A', 'D', weight='weight')
print(path)  # 結果：['A', 'C', 'D']

from pulp import *

# 問題の定義
prob = LpProblem("Meal Planning", LpMinimize)

# 変数の定義
chicken = LpVariable("Chicken", lowBound=0.1)
beef = LpVariable("Beef", lowBound=0.1)
fish = LpVariable("Fish", lowBound=0.1)

# 制約条件の設定
prob += 3 * chicken + 4 * beef + 2 * fish >= 7.5
prob += 2 * chicken + 3 * beef + 1.5 * fish >= 6
prob += 0.5 * chicken + beef + 0.3 * fish >= 1.5
prob += 3 * chicken + 4 * beef + 2 * fish <= 30
prob += 2 * chicken + 3 * beef + 1.5 * fish <= 25
prob += 0.5 * chicken + beef + 0.3 * fish <= 5

# 目的関数の設定
prob += 5 * chicken + 7 * beef + 6 * fish

# 問題の解法
status = prob.solve()

# 結果の出力
print("Status:", LpStatus[status])
print("Optimal Solution:")
for var in prob.variables():
    print(var.name, "=", var.varValue)
print("Total Cost of Ingredients = ", value(prob.objective))

import pulp

# ①問題を定義する
problem = pulp.LpProblem("Job Scheduling", pulp.LpMinimize)

# ②各ジョブをどのマシンで実行するかを決定する変数を作成する
# ジョブAをマシン1で実行する場合、変数A_1の値は1になる
# ジョブAをマシン2で実行する場合、変数A_2の値は1になる
A_1 = pulp.LpVariable("A_1", lowBound=0, cat='Binary')
A_2 = pulp.LpVariable("A_2", lowBound=0, cat='Binary')
B_1 = pulp.LpVariable("B_1", lowBound=0, cat='Binary')
B_2 = pulp.LpVariable("B_2", lowBound=0, cat='Binary')
C_1 = pulp.LpVariable("C_1", lowBound=0, cat='Binary')
C_2 = pulp.LpVariable("C_2", lowBound=0, cat='Binary')
D_1 = pulp.LpVariable("D_1", lowBound=0, cat='Binary')
D_2 = pulp.LpVariable("D_2", lowBound=0, cat='Binary')

# ③目的関数を定義する（すべてのジョブが完了するのに必要な時間を最小化する）
problem += 2*A_1 + 2*A_2 + 3*B_1 + 3*B_2 + 2*C_1 + 2*C_2 + 4*D_1 + 4*D_2

# ④制約条件(1)を定義する（各ジョブは1つのマシンで実行されなければならない）
problem += A_1 + A_2 == 1
problem += B_1 + B_2 == 1
problem += C_1 + C_2 == 1
problem += D_1 + D_2 == 1

# ⑤制約条件(2)を定義する（各マシンは同時に実行できるジョブの数に制限がある）
problem += A_1 + B_1 + C_1 + D_1 <= 2
problem += A_2 + B_2 + C_2 + D_2 <= 2

# ⑥問題を解く
status = problem.solve()

# ⑦結果を表示する
print("Status:", pulp.LpStatus[status])
print("Minimum Time:", pulp.value(problem.objective))
print("A_1:", pulp.value(A_1))
print("A_2:", pulp.value(A_2))
print("B_1:", pulp.value(B_1))
print("B_2:", pulp.value(B_2))
print("C_1:", pulp.value(C_1))
print("C_2:", pulp.value(C_2))
print("D_1:", pulp.value(D_1))
print("D_2:", pulp.value(D_2))

import pulp

# ①問題を初期化
problem = pulp.LpProblem("マーケティング最適化問題", pulp.LpMaximize)

# ②変数を定義
a = pulp.LpVariable("Aの広告費用", lowBound=0)
b = pulp.LpVariable("Bの広告費用", lowBound=0)
c = pulp.LpVariable("Cの広告費用", lowBound=0)

# ③目的関数を定義
problem += 300*a + 200*b + 150*c, "利益の合計"

# ④制約条件を定義
problem += a + b + c <= 10000, "広告予算の合計"
problem += a <= 2000, "Aの広告費用の上限"
problem += b <= 1500, "Bの広告費用の上限"
problem += c <= 1000, "Cの広告費用の上限"

# ⑤問題を解く
status = problem.solve()

# ⑥結果を出力
print(f"ステータス: {pulp.LpStatus[status]}")
print(f"最大利益: {problem.objective.value()}")
print(f"Aの広告費用: {a.value()}")
print(f"Bの広告費用: {b.value()}")
print(f"Cの広告費用: {c.value()}")

# 必要なライブラリをインポートする
import pulp

# 問題を定義する
problem = pulp.LpProblem('Construction Project', pulp.LpMinimize)

# 変数を定義する
a = pulp.LpVariable('a', lowBound=0, cat='Continuous')
b = pulp.LpVariable('b', lowBound=0, cat='Continuous')
c = pulp.LpVariable('c', lowBound=0, cat='Continuous')
d = pulp.LpVariable('d', lowBound=0, cat='Continuous')
e = pulp.LpVariable('e', lowBound=0, cat='Continuous')
f = pulp.LpVariable('f', lowBound=0, cat='Continuous')

# 制約式を定義する

# 各作業の所要日数
problem += a >= 2
problem += b >= 3
problem += c >= 4
problem += d >= 2
problem += e >= 3
problem += f >= 4

# 作業A, B, Cは同時に開始することができる
# a + 2 <= dは、作業Dを開始する前に、作業Aが完了している必要があることを表している
# b + 3 <= cは、作業Cを開始する前に、作業Bが完了している必要があることを表している
problem += a + 2 <= d
problem += b + 3 <= c

# 作業Cが完了した後、作業Eを開始する
# c + 4 <= eは、作業Eを開始する前に、作業Cが完了している必要があることを表している
problem += c + 4 <= e

# 作業DとEは同時に開始することができる
# d + 2 <= fは、作業Fを開始する前に、作業Dが完了している必要があることを表している
# e + 3 <= fは、作業Fを開始する前に、作業Eが完了している必要があることを表している
problem += d + 2 <= f
problem += e + 3 <= f

# 目的関数を定義する
problem += f

# 問題を解く
status = problem.solve()

# 結果を表示する
print(f"Status: {pulp.LpStatus[status]}")
print(f"Optimal Solution:")
print(f"\ta: {a.value():.2f}")
print(f"\tb: {b.value():.2f}")
print(f"\tc: {c.value():.2f}")
print(f"\td: {d.value():.2f}")
print(f"\te: {e.value():.2f}")
print(f"\tf: {f.value():.2f}")

# それぞれの作業の開始時期を計算する
start_a = a.value()
start_b = b.value()
start_c = c.value()
start_d = d.value()
start_e = e.value()
start_f = f.value()

# 結果を表示する
print("Task Schedule:")
print(f"\tTask A starts at day {start_a:.2f}")
print(f"\tTask B starts at day {start_b:.2f}")
print(f"\tTask C starts at day {start_c:.2f}")
print(f"\tTask D starts at day {start_d:.2f}")
print(f"\tTask E starts at day {start_e:.2f}")
print(f"\tTask F starts at day {start_f:.2f}")

# 必要なライブラリをインポート
import pulp

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

# 工場と市場の数
factories = ["Factory 1", "Factory 2", "Factory 3", "Factory 4", "Factory 5"]
markets = ["Market 1", "Market 2", "Market 3", "Market 4", "Market 5"]

# 各工場の製品の生産量（変数）
production = pulp.LpVariable.dicts("Production", factories, lowBound=0)

# 各市場に必要な製品の量（定数）
demand = {"Market 1": 20, "Market 2": 25, "Market 3": 30, "Market 4": 20, "Market 5": 15}

# 各工場が各市場に供給する製品の量（変数）
shipments = pulp.LpVariable.dicts("Shipments", (factories, markets), lowBound=0)

# 目的関数を設定
problem += pulp.lpSum([500 * production[i] for i in factories]) + pulp.lpSum([300 * shipments[i][j] for i in factories for j in markets])

# 制約条件を追加
for j in markets:
    problem += pulp.lpSum([shipments[i][j] for i in factories]) == demand[j]

for i in factories:
    problem += pulp.lpSum([shipments[i][j] for j in markets]) <= production[i]

# 問題を解く
problem.solve()

# 結果を表示
for i in factories:
    for j in markets:
        if shipments[i][j].value() > 0:
            print(f"{i} から {j} へ {shipments[i][j].value()} だけ製品を供給します。")

from pulp import *

# ①各果物の単価、在庫、需要量を設定
prices = {"apple": 100, "banana": 80, "orange": 120}
inventory = {"apple": 200, "banana": 150, "orange": 100}
demand = {"apple": 100, "banana": 50, "orange": 75}

# ②変数
apple_qty = LpVariable("apple_qty", lowBound=0, cat='Integer')
banana_qty = LpVariable("banana_qty", lowBound=0, cat='Integer')
orange_qty = LpVariable("orange_qty", lowBound=0, cat='Integer')

# ③問題の定義
prob = LpProblem("Fruit Buying Problem", LpMaximize)

# ④目的関数
prob += prices["apple"] * apple_qty + prices["banana"] * banana_qty + prices["orange"] * orange_qty

# ⑤制約条件
prob += apple_qty <= inventory["apple"]
prob += banana_qty <= inventory["banana"]
prob += orange_qty <= inventory["orange"]
prob += apple_qty + banana_qty + orange_qty >= demand["apple"] + demand["banana"] + demand["orange"]
prob += apple_qty >= demand["apple"]
prob += banana_qty >= demand["banana"]
prob += orange_qty >= demand["orange"]

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

# ⑦結果の表示
print("Apple quantity: ", apple_qty.value())
print("Banana quantity: ", banana_qty.value())
print("Orange quantity: ", orange_qty.value())
print("Maximum profit: ", value(prob.objective))