import pulp as pl

# 教師、科目、時間スロットのリスト
teachers = ['T1', 'T2']
subjects = ['Math', 'Science', 'English']
time_slots = ['Monday 9am', 'Monday 11am', 'Wednesday 9am']

# 教師が教えられる科目
teacher_subjects = {
    'T1': ['Math', 'Science'],
    'T2': ['Science', 'English']
}

# 問題の定義
prob = pl.LpProblem("Timetable_Problem", pl.LpMinimize)

# 変数の定義
vars = pl.LpVariable.dicts("Schedule", (teachers, subjects, time_slots), 0, 1, pl.LpBinary)

# 制約条件の定義
# 1. 各科目は1つの時間スロットに配置される
for s in subjects:
    prob += pl.lpSum([vars[t][s][ts] for t in teachers for ts in time_slots]) == 1

# 2. 各教師は1つの時間スロットで1つの科目のみ教える
for t in teachers:
    for ts in time_slots:
        prob += pl.lpSum([vars[t][s][ts] for s in subjects]) <= 1

# 3. 教師は教えられる科目のみ教える
for t in teachers:
    for s in subjects:
        if s not in teacher_subjects[t]:
            for ts in time_slots:
                prob += vars[t][s][ts] == 0

# 問題の解決
prob.solve()

# 結果の表示
print("Status:", pl.LpStatus[prob.status])
for t in teachers:
    for s in subjects:
        for ts in time_slots:
            if vars[t][s][ts].varValue == 1:
                print(f"{t} will teach {s} at {ts}")

import pulp as pl

# 教師、科目、時間スロットのリスト
teachers = ['T1', 'T2']
subjects = ['Math', 'Science', 'English']
time_slots = ['Monday 9am', 'Monday 11am', 'Wednesday 9am']

# 教師が教えられる科目
teacher_subjects = {
    'T1': ['Math', 'Science'],
    'T2': ['Science', 'English']
}

# 問題の定義
prob = pl.LpProblem("Timetable_Problem", pl.LpMinimize)

# 変数の定義
vars = pl.LpVariable.dicts("Schedule", (teachers, subjects, time_slots), 0, 1, pl.LpBinary)

# 1. 各科目は1つの時間スロットに配置される
for s in subjects:
    prob += pl.lpSum([vars[t][s][ts] for t in teachers for ts in time_slots]) == 1

# 2. 各教師は1つの時間スロットで1つの科目のみ教える
for t in teachers:
    for ts in time_slots:
        prob += pl.lpSum([vars[t][s][ts] for s in subjects]) <= 1

# 3. 教師は教えられる科目のみ教える
for t in teachers:
    for s in subjects:
        if s not in teacher_subjects[t]:
            for ts in time_slots:
                prob += vars[t][s][ts] == 0

# 問題の解決
prob.solve()

# 結果の表示
print("Status:", pl.LpStatus[prob.status])
for t in teachers:
    for s in subjects:
        for ts in time_slots:
            if vars[t][s][ts].varValue == 1:
                print(f"{t} will teach {s} at {ts}")

import numpy as np

# 配列の作成
a = np.array([1, 2, 3, 4, 5])
print(a)

# ゼロ配列
b = np.zeros((3, 3))
print(b)

# 1配列
c = np.ones((2, 2))
print(c)

# 連続した数値の配列
d = np.arange(10)
print(d)

# 等間隔の数値の配列
e = np.linspace(0, 1, 5)
print(e)

# 1次元配列を2次元に変更
a = np.array([1, 2, 3, 4, 5, 6])
b = a.reshape((2, 3))
print(b)

# 転置
c = b.T
print(c)

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# 要素ごとの演算
c = a + b
print(c)

d = a * b
print(d)

# ブロードキャスト
e = a + 10
print(e)

a = np.array([1, 2, 3, 4, 5])

# 平均
mean = np.mean(a)
print(mean)

# 中央値
median = np.median(a)
print(median)

# 標準偏差
std = np.std(a)
print(std)

# 和
sum_ = np.sum(a)
print(sum_)

a = np.array([1, 2, 3, 4, 5])

# インデックス
print(a[0])
print(a[-1])

# スライシング
print(a[1:3])
print(a[:2])
print(a[::2])

a = np.array([1, 2, 3, 4, 5])

# 条件を使ったフィルタリング
b = a[a > 2]
print(b)

# ブールインデックス
c = np.array([True, False, True, False, True])
d = a[c]
print(d)

# 行列の作成
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

# 行列積
C = np.dot(A, B)
print(C)

# 逆行列
D = np.linalg.inv(A)
print(D)

# 固有値と固有ベクトル
eigvals, eigvecs = np.linalg.eig(A)
print(eigvals)
print(eigvecs)

from pyomo.environ import *

# モデルの作成
model = ConcreteModel()

# 変数の定義
model.x = Var(within=NonNegativeReals)
model.y = Var(within=NonNegativeReals)

# 目的関数の定義
model.objective = Objective(expr=2*model.x + 3*model.y, sense=maximize)

# 制約条件の定義
model.constraint1 = Constraint(expr=model.x + 2*model.y <= 20)
model.constraint2 = Constraint(expr=3*model.x + model.y <= 15)

# 求解器の呼び出し
solver = SolverFactory('glpk')
solver.solve(model)

# 結果の表示
print("Optimal value for x:", model.x())
print("Optimal value for y:", model.y())
print("Optimal objective value:", model.objective())

from pyomo.environ import *

# モデルの作成
model = ConcreteModel()

# データの定義
N = 5  # 変数の数
coefficients = [1, 2, 3, 4, 5]
constraints = [
    [2, 1, 2, 1, 1, 10],
    [1, 3, 2, 2, 1, 15]
]

# 変数の定義
model.x = Var(range(N), within=NonNegativeReals)

# 目的関数の定義
model.objective = Objective(expr=sum(coefficients[i] * model.x[i] for i in range(N)), sense=maximize)

# 制約条件の定義
model.constraints = ConstraintList()
for con in constraints:
    model.constraints.add(sum(con[i] * model.x[i] for i in range(N)) <= con[-1])

# 求解器の呼び出し
solver = SolverFactory('glpk')
solver.solve(model)

# 結果の表示
for i in range(N):
    print(f"Optimal value for x[{i}]:", model.x[i]())
print("Optimal objective value:", model.objective())

from pyomo.environ import *

# モデルの作成
model = ConcreteModel()

# 変数の定義
model.x = Var(within=NonNegativeIntegers)
model.y = Var(within=NonNegativeIntegers)

# 目的関数の定義
model.objective = Objective(expr=2*model.x + 3*model.y, sense=maximize)

# 制約条件の定義
model.constraint1 = Constraint(expr=model.x + 2*model.y <= 20)
model.constraint2 = Constraint(expr=3*model.x + model.y <= 15)

# 求解器の呼び出し
solver = SolverFactory('glpk')
solver.solve(model)

# 結果の表示
print("Optimal value for x:", model.x())
print("Optimal value for y:", model.y())
print("Optimal objective value:", model.objective())

!apt-get update
!apt-get install -y coinor-cbc
!pip install -q pyomo

from pyomo.environ import *

# モデルの作成
model = ConcreteModel()

# データの定義
N = 5  # 変数の数
coefficients = [1, 2, 3, 4, 5]
constraints = [
    [2, 1, 2, 1, 1, 10],
    [1, 3, 2, 2, 1, 15]
]

# 変数の定義
model.x = Var(range(N), within=NonNegativeReals)

# 目的関数の定義
model.objective = Objective(expr=sum(coefficients[i] * model.x[i] for i in range(N)), sense=maximize)

# 制約条件の定義
model.constraints = ConstraintList()
for con in constraints:
    model.constraints.add(sum(con[i] * model.x[i] for i in range(N)) <= con[-1])

# CBCソルバーを使用する場合
solver = SolverFactory('cbc', executable='/usr/bin/cbc')
result = solver.solve(model)

# 結果の表示
print("CBC solver results:")
for i in range(N):
    print(f"Optimal value for x[{i}]:", model.x[i]())
print("Optimal objective value:", model.objective())

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# データの読み込み
iris = load_iris()
X, y = iris.data, iris.target

# トレーニングセットとテストセットに分割
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

from sklearn.ensemble import RandomForestClassifier

# モデルの構築
model = RandomForestClassifier(n_estimators=100, random_state=42)

# モデルのトレーニング
model.fit(X_train, y_train)

from sklearn.metrics import accuracy_score, classification_report

# 予測
y_pred = model.predict(X_test)

# 精度の評価
accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy: {accuracy}')

# 詳細な評価
report = classification_report(y_test, y_pred)
print(report)

from sklearn.model_selection import cross_val_score

# クロスバリデーションの実行
scores = cross_val_score(model, X, y, cv=5)

# 平均スコアと標準偏差
print(f'Cross-validation scores: {scores}')
print(f'Mean score: {scores.mean()}')
print(f'Standard deviation: {scores.std()}')

from sklearn.model_selection import GridSearchCV

# ハイパーパラメータの候補を設定
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [None, 10, 20, 30]
}

# グリッドサーチの実行
grid_search = GridSearchCV(model, param_grid, cv=5)
grid_search.fit(X_train, y_train)

# 最良のパラメータとスコア
best_params = grid_search.best_params_
best_score = grid_search.best_score_

print(f'Best parameters: {best_params}')
print(f'Best cross-validation score: {best_score}')

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

# パイプラインの構築
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('classifier', RandomForestClassifier(n_estimators=100, random_state=42))
])

# パイプラインでのトレーニングと評価
pipeline.fit(X_train, y_train)
y_pred = pipeline.predict(X_test)

accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy: {accuracy}')

from sklearn.decomposition import PCA

# PCAの適用
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)

# トレーニングセットとテストセットに分割
X_train, X_test, y_train, y_test = train_test_split(X_pca, y, test_size=0.2, random_state=42)

# モデルのトレーニングと評価
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy with PCA: {accuracy}')

import scipy.integrate as integrate

# 定義する関数
def f(x):
    return x ** 2

# 数値積分
result, error = integrate.quad(f, 0, 1)
print("積分の結果:", result)

import numpy as np
import scipy.optimize as optimize

# 定義する関数
def f(x):
    return x ** 2 + 10 * np.sin(x)

# 最小化
result = optimize.minimize(f, x0=0)
print("最適化の結果:", result.x)

# 定義する方程式
def equation(x):
    return x ** 2 - 2

# 解を求める
solution = optimize.root(equation, x0=1)
print("方程式の解:", solution.x)

import scipy.linalg as linalg
import numpy as np

# 行列の定義
A = np.array([[3, 2], [1, 4]])
B = np.array([1, 2])

# 線形方程式の解を求める
x = linalg.solve(A, B)
print("方程式の解:", x)

# 行列の逆行列を求める
A_inv = linalg.inv(A)
print("逆行列:", A_inv)

from scipy.signal import butter, filtfilt
import numpy as np

# バターワースフィルタの設計
b, a = butter(N=4, Wn=0.2)

# 信号の定義（繰り返し）
signal = np.tile([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 3)  # 繰り返して長さを増やす

# フィルタリング
filtered_signal = filtfilt(b, a, signal)
print("フィルタリング後の信号:", filtered_signal)

from scipy import stats

# データの定義
data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 平均と標準偏差
mean = np.mean(data)
std_dev = np.std(data)
print("平均:", mean, "標準偏差:", std_dev)

# 正規分布のフィッティング
param = stats.norm.fit(data)
print("正規分布のパラメータ:", param)

from scipy.interpolate import interp1d
import matplotlib.pyplot as plt

# データの定義
x = np.linspace(0, 10, 10)
y = np.sin(x)

# 線形補間
f = interp1d(x, y, kind='linear')

# 新しいデータ点の生成
x_new = np.linspace(0, 10, 100)
y_new = f(x_new)

# プロット
plt.plot(x, y, 'o', label='Original data')
plt.plot(x_new, y_new, '-', label='Interpolated data')
plt.legend()
plt.show()

import pulp

# 問題の定義
model = pulp.LpProblem("Maximize_Profit", pulp.LpMaximize)

# 変数の定義
x = pulp.LpVariable("x", lowBound=0, cat='Continuous')
y = pulp.LpVariable("y", lowBound=0, cat='Continuous')

# 目的関数の定義
model += 40 * x + 30 * y, "Total Profit"

# 制約条件の定義
model += 2 * x + y <= 20, "Constraint 1"
model += 4 * x + 3 * y <= 45, "Constraint 2"

# 問題を解く
model.solve()

# 結果の表示
print(f"Status: {pulp.LpStatus[model.status]}")
print(f"x: {pulp.value(x)}")
print(f"y: {pulp.value(y)}")
print(f"Total Profit: {pulp.value(model.objective)}")

# 変数の定義 (整数)
x = pulp.LpVariable("x", lowBound=0, cat='Integer')
y = pulp.LpVariable("y", lowBound=0, cat='Integer')

# 問題の定義、目的関数、制約条件は前述の通り

# 目的関数の定義 (例: 50% の重みを持つ2つの目的関数)
model += 0.5 * (40 * x + 30 * y) + 0.5 * (30 * x + 20 * y), "Combined Objective"

constraints = [
    (2 * x + y <= 20, "Raw Material Constraint"),
    (4 * x + 3 * y <= 45, "Labor Constraint")
]

for constraint, name in constraints:
    model += constraint, name

# CBCソルバーを使用
solver = pulp.PULP_CBC_CMD()
model.solve(solver)

import pulp

# 問題の定義
model = pulp.LpProblem("Minimize_Transportation_Cost", pulp.LpMinimize)

# サプライチェーンの定義
warehouses = ["A", "B"]
stores = ["X", "Y", "Z"]
supply = {"A": 300, "B": 400}
demand = {"X": 250, "Y": 350, "Z": 100}

# 輸送コストの定義
costs = {"A": {"X": 2, "Y": 4, "Z": 5}, "B": {"X": 3, "Y": 1, "Z": 3}}

# 変数の定義
vars = pulp.LpVariable.dicts("Route", (warehouses, stores), lowBound=0, cat='Continuous')

# 目的関数の定義
model += pulp.lpSum([vars[w][s] * costs[w][s] for w in warehouses for s in stores]), "Total Cost"

# 制約条件の定義
for w in warehouses:
    model += pulp.lpSum([vars[w][s] for s in stores]) <= supply[w], f"Supply_{w}"

for s in stores:
    model += pulp.lpSum([vars[w][s] for w in warehouses]) >= demand[s], f"Demand_{s}"

# 問題を解く
model.solve()

# 結果の表示
print(f"Status: {pulp.LpStatus[model.status]}")
for w in warehouses:
    for s in stores:
        print(f"Route {w} to {s}: {pulp.value(vars[w][s])} units")
print(f"Total Cost: {pulp.value(model.objective)}")

import polars as pl

data = {
    "name": ["Alice", "Bob", "Charlie"],
    "age": [25, 30, 35],
    "city": ["New York", "Los Angeles", "Chicago"]
}

df = pl.DataFrame(data)
print(df)

df = pl.read_csv("your_file.csv")
print(df)

# 列の選択
df = df.select(["name", "age"])

# フィルタリング
df = df.filter(pl.col("age") > 30)

# 列の追加
df = df.with_column((pl.col("age") * 2).alias("age_doubled"))

print(df)

# 欠損値の処理
df = df.fill_null("unknown")

# 重複の削除
df = df.unique(subset=["name"])

print(df)

# グループ化して集計
df = df.groupby("city").agg([
    pl.sum("age").alias("total_age"),
    pl.mean("age").alias("average_age")
])

print(df)

data1 = {"name": ["Alice", "Bob"], "age": [25, 30]}
data2 = {"name": ["Charlie", "David"], "city": ["Chicago", "San Francisco"]}

df1 = pl.DataFrame(data1)
df2 = pl.DataFrame(data2)

df = df1.join(df2, on="name", how="left")
print(df)

import time
import pandas as pd

data = {
    "a": range(100000000),
    "b": range(100000000, 0, -1)
}

# Pandasでの処理
start = time.time()
pdf = pd.DataFrame(data)
pdf["c"] = pdf["a"] + pdf["b"]
print("Pandas処理時間:", time.time() - start)

# Polarsでの処理
start = time.time()
pldf = pl.DataFrame(data)
pldf = pldf.with_column((pl.col("a") + pl.col("b")).alias("c"))
print("Polars処理時間:", time.time() - start)

from constraint import *

# 問題を定義
problem = Problem()

# 変数の追加
problem.addVariable('x', range(10))  # xは0から9までの値をとる
problem.addVariable('y', range(10))  # yは0から9までの値をとる

# 制約条件の追加
def constraint_func(x, y):
    return x + y == 5

problem.addConstraint(constraint_func, ['x', 'y'])

# 解を取得
solutions = problem.getSolutions()

# 解の表示
for solution in solutions:
    print(solution)

problem.addVariable('z', [1, 2, 4, 8, 16])

# 全ての変数の値が異なるように制約を追加
problem.addConstraint(AllDifferentConstraint(), ['x', 'y', 'z'])

# すべての変数が異なる値を持つ
problem.addConstraint(AllDifferentConstraint(), ['x', 'y', 'z'])

# 変数の合計が10になるように制約する
problem.addConstraint(ExactSumConstraint(10), ['x', 'y', 'z'])

def custom_constraint(a, b):
    return a * b <= 20

problem.addConstraint(custom_constraint, ['x', 'y'])

problem.addConstraint(lambda x: x != 5, ['x'])  # xは5を取らない

from constraint import *

# 問題を定義
problem = Problem()

# 変数の追加
rows = range(1, 10)
cols = range(1, 10)

# 各セルに1から9の値を割り当てる
for row in rows:
    for col in cols:
        problem.addVariable((row, col), range(1, 10))

# 各行に対して全ての数が異なるように制約
for row in rows:
    problem.addConstraint(AllDifferentConstraint(), [(row, col) for col in cols])

# 各列に対して全ての数が異なるように制約
for col in cols:
    problem.addConstraint(AllDifferentConstraint(), [(row, col) for row in rows])

# 各3x3のボックスに対して全ての数が異なるように制約
for box_row in range(3):
    for box_col in range(3):
        cells = [(row, col) for row in range(box_row*3+1, box_row*3+4) for col in range(box_col*3+1, box_col*3+4)]
        problem.addConstraint(AllDifferentConstraint(), cells)

# 解を取得
solutions = problem.getSolutions()

# 解の表示（最初の解のみ）
if solutions:
    solution = solutions[0]
    for row in rows:
        print([solution[(row, col)] for col in cols])
else:
    print("No solution found.")

from ortools.sat.python import cp_model

def job_shop_scheduling():
    # Create the model.
    model = cp_model.CpModel()

    jobs_data = [  # (machine_id, processing_time).
        [(0, 3), (1, 2), (2, 2)],
        [(0, 2), (2, 1), (1, 4)],
        [(1, 4), (2, 3)]
    ]

    machines_count = 3
    all_tasks = {}
    machine_to_intervals = [[] for _ in range(machines_count)]
    horizon = sum(task[1] for job in jobs_data for task in job)

    # Create job variables and constraints.
    for job_id, job in enumerate(jobs_data):
        for task_id, task in enumerate(job):
            machine = task[0]
            duration = task[1]
            suffix = '_%i_%i' % (job_id, task_id)
            start_var = model.NewIntVar(0, horizon, 'start' + suffix)
            end_var = model.NewIntVar(0, horizon, 'end' + suffix)
            interval_var = model.NewIntervalVar(start_var, duration, end_var, 'interval' + suffix)
            all_tasks[job_id, task_id] = (start_var, end_var, interval_var)
            machine_to_intervals[machine].append(interval_var)

    # Create and add disjunctive constraints.
    for machine_intervals in machine_to_intervals:
        model.AddNoOverlap(machine_intervals)

    # Precedences inside a job.
    for job_id, job in enumerate(jobs_data):
        for task_id in range(len(job) - 1):
            model.Add(all_tasks[job_id, task_id + 1][0] >= all_tasks[job_id, task_id][1])

    # Makespan objective.
    obj_var = model.NewIntVar(0, horizon, 'makespan')
    model.AddMaxEquality(obj_var, [all_tasks[job_id, len(job) - 1][1] for job_id, job in enumerate(jobs_data)])
    model.Minimize(obj_var)

    # Solve the model.
    solver = cp_model.CpSolver()
    status = solver.Solve(model)

    # Print solution.
    if status == cp_model.OPTIMAL or status == cp_model.FEASIBLE:
        print('Optimal Schedule Length: %i' % solver.ObjectiveValue())
        print()
        for job_id, job in enumerate(jobs_data):
            print('Job %i:' % job_id)
            for task_id, task in enumerate(job):
                start_var, end_var, _ = all_tasks[job_id, task_id]
                print('Task %i starts at %i and ends at %i' % (
                    task_id, solver.Value(start_var), solver.Value(end_var)))
    else:
        print('No solution found.')

job_shop_scheduling()

from ortools.sat.python import cp_model

def job_shop_scheduling():
    # Create the model.
    model = cp_model.CpModel()

jobs_data = [  # (machine_id, processing_time).
    [(0, 3), (1, 2), (2, 2)],
    [(0, 2), (2, 1), (1, 4)],
    [(1, 4), (2, 3)]
]

machines_count = 3
all_tasks = {}
machine_to_intervals = [[] for _ in range(machines_count)]
horizon = sum(task[1] for job in jobs_data for task in job)

# Create job variables and constraints.
for job_id, job in enumerate(jobs_data):
    for task_id, task in enumerate(job):
        machine = task[0]
        duration = task[1]
        suffix = '_%i_%i' % (job_id, task_id)
        start_var = model.NewIntVar(0, horizon, 'start' + suffix)
        end_var = model.NewIntVar(0, horizon, 'end' + suffix)
        interval_var = model.NewIntervalVar(start_var, duration, end_var, 'interval' + suffix)
        all_tasks[job_id, task_id] = (start_var, end_var, interval_var)
        machine_to_intervals[machine].append(interval_var)

# Create and add disjunctive constraints.
for machine_intervals in machine_to_intervals:
    model.AddNoOverlap(machine_intervals)

# Precedences inside a job.
for job_id, job in enumerate(jobs_data):
    for task_id in range(len(job) - 1):
        model.Add(all_tasks[job_id, task_id + 1][0] >= all_tasks[job_id, task_id][1])

# Makespan objective.
obj_var = model.NewIntVar(0, horizon, 'makespan')
model.AddMaxEquality(obj_var, [all_tasks[job_id, len(job) - 1][1] for job_id, job in enumerate(jobs_data)])
model.Minimize(obj_var)

# Solve the model.
solver = cp_model.CpSolver()
status = solver.Solve(model)

    # Print solution.
    if status == cp_model.OPTIMAL or status == cp_model.FEASIBLE:
        print('Optimal Schedule Length: %i' % solver.ObjectiveValue())
        print()
        for job_id, job in enumerate(jobs_data):
            print('Job %i:' % job_id)
            for task_id, task in enumerate(job):
                start_var, end_var, _ = all_tasks[job_id, task_id]
                print('Task %i starts at %i and ends at %i' % (
                    task_id, solver.Value(start_var), solver.Value(end_var)))
    else:
        print('No solution found.')

job_shop_scheduling()

from ortools.constraint_solver import pywrapcp
from ortools.constraint_solver import routing_enums_pb2

def create_data_model():
    data = {}
    data['distance_matrix'] = [
        [0, 2, 9, 10],
        [1, 0, 6, 4],
        [15, 7, 0, 8],
        [6, 3, 12, 0],
    ]
    data['num_vehicles'] = 1
    data['depot'] = 0
    return data

def print_solution(manager, routing, solution):
    print('Objective: {}'.format(solution.ObjectiveValue()))
    index = routing.Start(0)
    plan_output = 'Route for vehicle 0:\n'
    route_distance = 0
    while not routing.IsEnd(index):
        plan_output += ' {} ->'.format(manager.IndexToNode(index))
        previous_index = index
        index = solution.Value(routing.NextVar(index))
        route_distance += routing.GetArcCostForVehicle(previous_index, index, 0)
    plan_output += ' {}\n'.format(manager.IndexToNode(index))
    plan_output += 'Distance of the route: {}m\n'.format(route_distance)
    print(plan_output)

def vehicle_routing_problem():
    data = create_data_model()
    manager = pywrapcp.RoutingIndexManager(len(data['distance_matrix']), data['num_vehicles'], data['depot'])
    routing = pywrapcp.RoutingModel(manager)
    def distance_callback(from_index, to_index):
        from_node = manager.IndexToNode(from_index)
        to_node = manager.IndexToNode(to_index)
        return data['distance_matrix'][from_node][to_node]
    transit_callback_index = routing.RegisterTransitCallback(distance_callback)
    routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)
    search_parameters = pywrapcp.DefaultRoutingSearchParameters()
    search_parameters.first_solution_strategy = (routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC)
    solution = routing.SolveWithParameters(search_parameters)
    if solution:
        print_solution(manager, routing, solution)

vehicle_routing_problem()

from ortools.constraint_solver import pywrapcp
from ortools.constraint_solver import routing_enums_pb2

def create_data_model():
    data = {}
    data['distance_matrix'] = [
        [0, 2, 9, 10],
        [1, 0, 6, 4],
        [15, 7, 0, 8],
        [6, 3, 12, 0],
    ]
    data['num_vehicles'] = 1
    data['depot'] = 0
    return data

def print_solution(manager, routing, solution):
    print('Objective: {}'.format(solution.ObjectiveValue()))
    index = routing.Start(0)
    plan_output = 'Route for vehicle 0:\n'
    route_distance = 0
    while not routing.IsEnd(index):
        plan_output += ' {} ->'.format(manager.IndexToNode(index))
        previous_index = index
        index = solution.Value(routing.NextVar(index))
        route_distance += routing.GetArcCostForVehicle(previous_index, index, 0)
    plan_output += ' {}\n'.format(manager.IndexToNode(index))
    plan_output += 'Distance of the route: {}m\n'.format(route_distance)
    print(plan_output)

def vehicle_routing_problem():
    data = create_data_model()
    manager = pywrapcp.RoutingIndexManager(len(data['distance_matrix']), data['num_vehicles'], data['depot'])
    routing = pywrapcp.RoutingModel(manager)

    def distance_callback(from_index, to_index):
        from_node = manager.IndexToNode(from_index)
        to_node = manager.IndexToNode(to_index)
        return data['distance_matrix'][from_node][to_node]

    transit_callback_index = routing.RegisterTransitCallback(distance_callback)
    routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)

    search_parameters = pywrapcp.DefaultRoutingSearchParameters()
    search_parameters.first_solution_strategy = (routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC)

    solution = routing.SolveWithParameters(search_parameters)
    if solution:
        print_solution(manager, routing, solution)

vehicle_routing_problem()