CS_learn/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-06-15 14:48:05 +08:00
Code Issues Packages Projects Releases Wiki Activity

Re-translate the Japanese version (#1871)

Browse Source 
* Retranslate Japanese docs with GPT-5.4

* Retranslate Japanese code with GPT-5.4
This commit is contained in:
Yudong Jin
2026-03-30 07:30:15 +08:00
committed by GitHub
parent fe6443235b
commit d7b2277d2b
1444 changed files with 83312 additions and 8363 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
ja/codes/python/.gitignore vendored Normal file
View File

@@ -0,0 +1 @@
__pycache__

54
ja/codes/python/chapter_array_and_linkedlist/array.py
View File

@@ -8,21 +8,21 @@ import random
def random_access(nums: list[int]) -> int:
"""要素へのランダムアクセス"""
# 区間 [0, len(nums)-1] から数値をランダムに選択
"""要素へランダムアクセス"""
# 区間 [0, len(nums)-1] からランダムに数字を 1 つ選ぶ
random_index = random.randint(0, len(nums) - 1)
# ランダムな要素を取得して返す
random_num = nums[random_index]
return random_num
# PythonのlistはextendできるDynamic Arrayであることに注意
# 学習を容易にするため、この関数ではlistをStatic Arrayとして扱う
# Python の list は動的配列であり、直接拡張できます
# 学習しやすいよう、本関数では list を長さ不変の配列として扱います
def extend(nums: list[int], enlarge: int) -> list[int]:
"""配列の長さを拡張"""
# 拡張された長さの配列を初期化
"""配列長を拡張する"""
# 拡張後の長さを持つ配列を初期化する
res = [0] * (len(nums) + enlarge)
# 元の配列のすべての要素を新しい配列にコピー
# 元の配列の全要素を新しい配列にコピー
for i in range(len(nums)):
res[i] = nums[i]
# 拡張後の新しい配列を返す
@@ -30,38 +30,38 @@ def extend(nums: list[int], enlarge: int) -> list[int]:
def insert(nums: list[int], num: int, index: int):
"""インデックス index に要素 num を挿入"""
# インデックス index より後のすべての要素を1つ後ろに移動
"""配列の index 番目に要素 num を挿入"""
# インデックス index 以降の全要素を 1 つ後ろへ移動する
for i in range(len(nums) - 1, index, -1):
nums[i] = nums[i - 1]
# num を index の位置の要素に代入
# index の要素に num を代入する
nums[index] = num
def remove(nums: list[int], index: int):
"""インデックス index の要素を削除"""
# インデックス index より後のすべての要素を1つ前に移動
"""index の要素を削除する"""
# インデックス index より後ろの全要素を 1 つ前へ移動する
for i in range(index, len(nums) - 1):
nums[i] = nums[i + 1]
def traverse(nums: list[int]):
"""配列の走査"""
"""配列を走査"""
count = 0
# インデックスによる配列の走査
# インデックスで配列を走査
for i in range(len(nums)):
count += nums[i]
# 配列要素の走査
# 配列要素を直接走査
for num in nums:
count += num
# データのインデックスと要素の両方を走査
# データのインデックスと要素を同時に走査する
for i, num in enumerate(nums):
count += nums[i]
count += num
def find(nums: list[int], target: int) -> int:
"""配列内の指定された要素を検索"""
"""配列内で指定要素を探す"""
for i in range(len(nums)):
if nums[i] == target:
return i
@@ -78,23 +78,23 @@ if __name__ == "__main__":
# ランダムアクセス
random_num: int = random_access(nums)
print("nums のランダムな要素を取得", random_num)
print("nums からランダムな要素を取得", random_num)
# 長さの拡張
# 長さを拡張
nums: list[int] = extend(nums, 3)
print("配列の長さを 8 に拡張、結果は nums =", nums)
print("配列の長さを 8 に拡張し、nums =", nums)
# 要素の挿入
# 要素を挿入する
insert(nums, 6, 3)
print("インデックス 3 に数値 6 を挿入、結果は nums =", nums)
print("インデックス 3 に数値 6 を挿入し、nums =", nums)
# 要素の削除
# 要素を削除
remove(nums, 2)
print("インデックス 2 の要素を削除、結果は nums =", nums)
print("インデックス 2 の要素を削除し、nums =", nums)
# 配列の走査
# 配列を走査
traverse(nums)
# 要素の検索
# 要素を探索する
index: int = find(nums, 3)
print("nums で要素 3 を検索、結果は index =", index)
print("nums で要素 3 を検索し、インデックス =", index)

24
ja/codes/python/chapter_array_and_linkedlist/linked_list.py
View File

@@ -12,14 +12,14 @@ from modules import ListNode, print_linked_list
def insert(n0: ListNode, P: ListNode):
"""連結リストのノード n0 の後にノード P を挿入"""
"""連結リストでノード n0 の後ろにノード P を挿入する"""
n1 = n0.next
P.next = n1
n0.next = P
def remove(n0: ListNode):
"""連結リストのノード n0 の後の最初のノードを削除"""
"""連結リストでノード n0 の直後のノードを削除する"""
if not n0.next:
return
# n0 -> P -> n1
@@ -29,7 +29,7 @@ def remove(n0: ListNode):
def access(head: ListNode, index: int) -> ListNode | None:
"""連結リストのインデックス index のノードにアクセス"""
"""連結リスト内で index 番目のノードにアクセス"""
for _ in range(index):
if not head:
return None
@@ -38,7 +38,7 @@ def access(head: ListNode, index: int) -> ListNode | None:
def find(head: ListNode, target: int) -> int:
"""連結リストで値 target を持つ最初のノードを検索"""
"""連結リストで値が target の最初のノードを探す"""
index = 0
while head:
if head.val == target:
@@ -50,36 +50,36 @@ def find(head: ListNode, target: int) -> int:
"""Driver Code"""
if __name__ == "__main__":
# 連結リストを初期化
# 各ノードを初期化
# 連結リストを初期化する
# 各ノードを初期化する
n0 = ListNode(1)
n1 = ListNode(3)
n2 = ListNode(2)
n3 = ListNode(5)
n4 = ListNode(4)
# ノード間の参照を構築
# ノード間の参照を構築する
n0.next = n1
n1.next = n2
n2.next = n3
n3.next = n4
print("初期化された連結リスト")
print("初期化した連結リストは")
print_linked_list(n0)
# ノードを挿入
p = ListNode(0)
insert(n0, p)
print("ノード挿入後の連結リスト")
print("ノード挿入後の連結リストは")
print_linked_list(n0)
# ノードを削除
remove(n0)
print("ノード削除後の連結リスト")
print("ノード削除後の連結リストは")
print_linked_list(n0)
# ノードにアクセス
node: ListNode = access(n0, 3)
print("連結リストのインデックス 3 のノードの値 = {}".format(node.val))
# ノードを検索
# ノードを探索
index: int = find(n0, 2)
print("連結リストで値 2 を持つノードのインデックス = {}".format(index))
print("連結リスト内で値が 2 のノードのインデックス = {}".format(index))

24
ja/codes/python/chapter_array_and_linkedlist/list.py
View File

@@ -12,15 +12,15 @@ if __name__ == "__main__":
# 要素にアクセス
x: int = nums[1]
print("\nインデックス 1 の要素にアクセス、結果は x =", x)
print("\nインデックス 1 の要素にアクセスし、x =", x)
# 要素を更新
nums[1] = 0
print("\nインデックス 1 の要素を 0 に更新、結果は nums =", nums)
print("\nインデックス 1 の要素を 0 に更新し、nums =", nums)
# リストをクリア
# リストを空にする
nums.clear()
print("\nリストをクリア後、nums =", nums)
print("\nリストを空にした後 nums =", nums)
# 末尾に要素を追加
nums.append(1)
@@ -28,29 +28,29 @@ if __name__ == "__main__":
nums.append(2)
nums.append(5)
nums.append(4)
print("\n要素を追加後、nums =", nums)
print("\n要素追加後 nums =", nums)
# 中間に要素を挿入
nums.insert(3, 6)
print("\nインデックス 3 に数値 6 を挿入、結果は nums =", nums)
print("\nインデックス 3 に数値 6 を挿入すると、nums =", nums)
# 要素を削除
nums.pop(3)
print("\nインデックス 3 の要素を削除、結果は nums =", nums)
print("\nインデックス 3 の要素を削除すると、nums =", nums)
# インデックスによるリストの走査
# インデックスでリストを走査
count = 0
for i in range(len(nums)):
count += nums[i]
# リスト要素の走査
# リスト要素を直接走査
for num in nums:
count += num
# 2つのリストを連結
# 2 つのリストを連結する
nums1 = [6, 8, 7, 10, 9]
nums += nums1
print("\nリスト nums1 を nums に連結、結果は nums =", nums)
print("\nリスト nums1 を nums の後ろに連結すると、nums =", nums)
# リストをソート
nums.sort()
print("\nリストをソート後、nums =", nums)
print("\nリストをソートすると nums =", nums)

48
ja/codes/python/chapter_array_and_linkedlist/my_list.py
View File

@@ -10,35 +10,35 @@ class MyList:
def __init__(self):
"""コンストラクタ"""
self._capacity: int = 10 # リストの容量
self._capacity: int = 10 # リスト容量
self._arr: list[int] = [0] * self._capacity # 配列（リスト要素を格納）
self._size: int = 0 # リストの長さ（現在の要素数）
self._extend_ratio: int = 2 # 各リスト拡張の倍数
self._extend_ratio: int = 2 # リスト拡張時の増加倍率
def size(self) -> int:
"""リストの長さ（現在の要素数）を取得"""
"""リストの長さを取得（現在の要素数）"""
return self._size
def capacity(self) -> int:
"""リストの容量を取得"""
"""リスト容量を取得する"""
return self._capacity
def get(self, index: int) -> int:
"""要素にアクセス"""
# インデックスが範囲外の場合、以下のように例外をスロー
# インデックスが範囲外なら例外を送出する。以下同様
if index < 0 or index >= self._size:
raise IndexError("Index out of bounds")
raise IndexError("インデックスが範囲外です")
return self._arr[index]
def set(self, num: int, index: int):
"""要素を更新"""
if index < 0 or index >= self._size:
raise IndexError("Index out of bounds")
raise IndexError("インデックスが範囲外です")
self._arr[index] = num
def add(self, num: int):
"""末尾に要素を追加"""
# 要素数が容量を超える場合、拡張メカニズムをトリガー
# 要素数が容量を超えると、拡張機構が発動する
if self.size() == self.capacity():
self.extend_capacity()
self._arr[self._size] = num
@@ -47,11 +47,11 @@ class MyList:
def insert(self, num: int, index: int):
"""中間に要素を挿入"""
if index < 0 or index >= self._size:
raise IndexError("Index out of bounds")
# 要素数が容量を超える場合、拡張メカニズムをトリガー
raise IndexError("インデックスが範囲外です")
# 要素数が容量を超えると、拡張機構が発動する
if self._size == self.capacity():
self.extend_capacity()
# インデックス index より後のすべての要素を1つ後ろに移動
# index 以降の要素をすべて 1 つ後ろへずらす
for j in range(self._size - 1, index - 1, -1):
self._arr[j + 1] = self._arr[j]
self._arr[index] = num
@@ -61,9 +61,9 @@ class MyList:
def remove(self, index: int) -> int:
"""要素を削除"""
if index < 0 or index >= self._size:
raise IndexError("Index out of bounds")
raise IndexError("インデックスが範囲外です")
num = self._arr[index]
# インデックス index より後のすべての要素を1つ前に移動
# インデックス index より後の要素をすべて 1 つ前に移動する
for j in range(index, self._size - 1):
self._arr[j] = self._arr[j + 1]
# 要素数を更新
@@ -72,14 +72,14 @@ class MyList:
return num
def extend_capacity(self):
"""リストを拡張"""
# 元の配列の _extend_ratio 倍の長さの新しい配列を作成し、元の配列を新しい配列にコピー
"""リストの拡張"""
# 元の配列の `_extend_ratio` 倍の長さを持つ新しい配列を作成し、元の配列を新しい配列にコピーする
self._arr = self._arr + [0] * self.capacity() * (self._extend_ratio - 1)
# リストの容量を更新
self._capacity = len(self._arr)
def to_array(self) -> list[int]:
"""有効な長さのリストを返す"""
"""有効長のリストを返す"""
return self._arr[: self._size]
@@ -93,26 +93,26 @@ if __name__ == "__main__":
nums.add(2)
nums.add(5)
nums.add(4)
print(f"リスト nums = {nums.to_array()} ，容量 = {nums.capacity()} ，長さ = {nums.size()}")
print(f"リスト nums = {nums.to_array()} 、容量 = {nums.capacity()} 、長さ = {nums.size()}")
# 中間に要素を挿入
nums.insert(6, index=3)
print("インデックス 3 に数値 6 を挿入、結果は nums =", nums.to_array())
print("インデックス 3 に数値 6 を挿入すると、nums =", nums.to_array())
# 要素を削除
nums.remove(3)
print("インデックス 3 の要素を削除、結果は nums =", nums.to_array())
print("インデックス 3 の要素を削除すると、nums =", nums.to_array())
# 要素にアクセス
num = nums.get(1)
print("インデックス 1 の要素にアクセス、結果は num =", num)
print("インデックス 1 の要素にアクセスすると、num =", num)
# 要素を更新
nums.set(0, 1)
print("インデックス 1 の要素を 0 に更新、結果は nums =", nums.to_array())
print("インデックス 1 の要素を 0 に更新すると、nums =", nums.to_array())
# 拡張メカニズムのテスト
# 拡張機構をテストする
for i in range(10):
# i = 5 のとき、リストの長さがリストの容量を超え、この時点で拡張メカニズムがトリガーされる
# i = 5 のとき、リスト長が容量を超えるため、この時点で拡張機構が発動する
nums.add(i)
print(f"拡張後、リスト {nums.to_array()} ，容量 = {nums.capacity()} ，長さ = {nums.size()}")
print(f"拡張後のリスト {nums.to_array()} 、容量 = {nums.capacity()} 、長さ = {nums.size()}")

32
ja/codes/python/chapter_backtracking/n_queens.py
View File

@@ -14,49 +14,49 @@ def backtrack(
diags1: list[bool],
diags2: list[bool],
):
"""バックトラッキングアルゴリズム：n クイーン"""
# すべての行が配置されたら、解を記録
"""バックトラッキング：N クイーン"""
# すべての行への配置が完了したら、解を記録する
if row == n:
res.append([list(row) for row in state])
return
# すべての列を走査
for col in range(n):
# セルに対応する主対角線と副対角線を計算
# このマスに対応する主対角線と副対角線を計算
diag1 = row - col + n - 1
diag2 = row + col
# 枝刈り：セルの列、主対角線、副対角線にクイーンを配置しない
# 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない
if not cols[col] and not diags1[diag1] and not diags2[diag2]:
# 試行：セルにクイーンを配置
# 試行：そのマスにクイーンを置く
state[row][col] = "Q"
cols[col] = diags1[diag1] = diags2[diag2] = True
# 次の行を配置
# 次の行に配置する
backtrack(row + 1, n, state, res, cols, diags1, diags2)
# 撤回：セルを空のスポットに復元
# 戻す：そのマスを空きマスに戻す
state[row][col] = "#"
cols[col] = diags1[diag1] = diags2[diag2] = False
def n_queens(n: int) -> list[list[list[str]]]:
"""n クイーンを解く"""
# n*n サイズのチェスボードを初期化、'Q' はクイーンを表し、'#' は空のスポットを表す
"""N クイーンを解く"""
# n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す
state = [["#" for _ in range(n)] for _ in range(n)]
cols = [False] * n # クイーンがある列を記録
diags1 = [False] * (2 * n - 1) # クイーンがある主対角線を記録
diags2 = [False] * (2 * n - 1) # クイーンがある副対角線を記録
cols = [False] * n # 列にクイーンがあるか記録
diags1 = [False] * (2 * n - 1) # 主対角線にクイーンがあるかを記録
diags2 = [False] * (2 * n - 1) # 副対角線にクイーンがあるかを記録
res = []
backtrack(0, n, state, res, cols, diags1, diags2)
return res
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
n = 4
res = n_queens(n)
print(f"チェスボードの寸法入力：{n}")
print(f"クイーン配置解の総数は {len(res)}")
print(f"入力された盤面の縦横の長さは {n} です")
print(f"クイーンの配置パターンは全部で {len(res)} 通りです")
for state in res:
print("--------------------")
for row in state:
print(row)
print(row)

16
ja/codes/python/chapter_backtracking/permutations_i.py
View File

@@ -8,8 +8,8 @@ Author: krahets (krahets@163.com)
def backtrack(
state: list[int], choices: list[int], selected: list[bool], res: list[list[int]]
):
"""バックトラッキングアルゴリズム：順列 I"""
# 状態の長さが要素数と等しいとき、解を記録
"""バックトラッキング：順列 I"""
# 状態の長さが要素数に等しければ、解を記録
if len(state) == len(choices):
res.append(list(state))
return
@@ -17,28 +17,28 @@ def backtrack(
for i, choice in enumerate(choices):
# 枝刈り：要素の重複選択を許可しない
if not selected[i]:
# 試行：選択を行い、状態を更新
# 試行: 選択を行い、状態を更新
selected[i] = True
state.append(choice)
# 次の選択ラウンドに進む
# 次の選択へ進む
backtrack(state, choices, selected, res)
# 撤回：選択を取り消し、前の状態に復元
# バックトラック：選択を取り消し、前の状態に戻す
selected[i] = False
state.pop()
def permutations_i(nums: list[int]) -> list[list[int]]:
"""順列 I"""
"""全順列 I"""
res = []
backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)
return res
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
nums = [1, 2, 3]
res = permutations_i(nums)
print(f"入力配列 nums = {nums}")
print(f"すべての順列 res = {res}")
print(f"すべての順列 res = {res}")

20
ja/codes/python/chapter_backtracking/permutations_ii.py
View File

@@ -8,39 +8,39 @@ Author: krahets (krahets@163.com)
def backtrack(
state: list[int], choices: list[int], selected: list[bool], res: list[list[int]]
):
"""バックトラッキングアルゴリズム：順列 II"""
# 状態の長さが要素数と等しいとき、解を記録
"""バックトラッキング：順列 II"""
# 状態の長さが要素数に等しければ、解を記録
if len(state) == len(choices):
res.append(list(state))
return
# すべての選択肢を走査
duplicated = set[int]()
for i, choice in enumerate(choices):
# 枝刈り：要素の重複選択を許可せず、等しい要素の重複選択も許可しない
# 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない
if not selected[i] and choice not in duplicated:
# 試行：選択を行い、状態を更新
duplicated.add(choice) # 選択された要素値を記録
# 試行: 選択を行い、状態を更新
duplicated.add(choice) # 選択済みの要素値を記録
selected[i] = True
state.append(choice)
# 次の選択ラウンドに進む
# 次の選択へ進む
backtrack(state, choices, selected, res)
# 撤回：選択を取り消し、前の状態に復元
# バックトラック：選択を取り消し、前の状態に戻す
selected[i] = False
state.pop()
def permutations_ii(nums: list[int]) -> list[list[int]]:
"""順列 II"""
"""全順列 II"""
res = []
backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)
return res
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
nums = [1, 2, 2]
res = permutations_ii(nums)
print(f"入力配列 nums = {nums}")
print(f"すべての順列 res = {res}")
print(f"すべての順列 res = {res}")

10
ja/codes/python/chapter_backtracking/preorder_traversal_i_compact.py
View File

@@ -12,7 +12,7 @@ from modules import TreeNode, print_tree, list_to_tree
def pre_order(root: TreeNode):
"""前順走査：例一"""
"""前順走査：例題 1"""
if root is None:
return
if root.val == 7:
@@ -22,15 +22,15 @@ def pre_order(root: TreeNode):
pre_order(root.right)
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
root = list_to_tree([1, 7, 3, 4, 5, 6, 7])
print("\n二分木を初期化")
print_tree(root)
# 前順走査
# 先行順走査
res = list[TreeNode]()
pre_order(root)
print("\n値が 7 のすべてのノードを出力")
print([node.val for node in res])
print("\n値が 7 のノードをすべて出力")
print([node.val for node in res])

14
ja/codes/python/chapter_backtracking/preorder_traversal_ii_compact.py
View File

@@ -12,31 +12,31 @@ from modules import TreeNode, print_tree, list_to_tree
def pre_order(root: TreeNode):
"""前順走査：例二"""
"""前順走査：例題 2"""
if root is None:
return
# 試行
# 試す
path.append(root)
if root.val == 7:
# 解を記録
res.append(list(path))
pre_order(root.left)
pre_order(root.right)
# 撤回
# バックトラック
path.pop()
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
root = list_to_tree([1, 7, 3, 4, 5, 6, 7])
print("\n二分木を初期化")
print_tree(root)
# 前順走査
# 先行順走査
path = list[TreeNode]()
res = list[list[TreeNode]]()
pre_order(root)
print("\nルートからノード 7 へのすべてのパスを出力")
print("\n根ノードからノード 7 までの経路をすべて出力")
for path in res:
print([node.val for node in path])
print([node.val for node in path])

14
ja/codes/python/chapter_backtracking/preorder_traversal_iii_compact.py
View File

@@ -12,32 +12,32 @@ from modules import TreeNode, print_tree, list_to_tree
def pre_order(root: TreeNode):
"""前順走査：例三"""
"""前順走査：例題 3"""
# 枝刈り
if root is None or root.val == 3:
return
# 試行
# 試す
path.append(root)
if root.val == 7:
# 解を記録
res.append(list(path))
pre_order(root.left)
pre_order(root.right)
# 撤回
# バックトラック
path.pop()
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
root = list_to_tree([1, 7, 3, 4, 5, 6, 7])
print("\n二分木を初期化")
print_tree(root)
# 前順走査
# 先行順走査
path = list[TreeNode]()
res = list[list[TreeNode]]()
pre_order(root)
print("\nルートからノード 7 へのすべてのパスを出力、値が 3 のノードは含まない")
print("\n根ノードからノード 7 までの経路をすべて出力し、経路には値が 3 のノードを含めない")
for path in res:
print([node.val for node in path])
print([node.val for node in path])

24
ja/codes/python/chapter_backtracking/preorder_traversal_iii_template.py
View File

@@ -22,7 +22,7 @@ def record_solution(state: list[TreeNode], res: list[list[TreeNode]]):
def is_valid(state: list[TreeNode], choice: TreeNode) -> bool:
"""現在の状態下で選択が合法かどうかを判定"""
"""現在の状態で、この選択が有効かどうかを判定"""
return choice is not None and choice.val != 3
@@ -32,40 +32,40 @@ def make_choice(state: list[TreeNode], choice: TreeNode):
def undo_choice(state: list[TreeNode], choice: TreeNode):
"""状態を復元"""
"""状態を元に戻す"""
state.pop()
def backtrack(
state: list[TreeNode], choices: list[TreeNode], res: list[list[TreeNode]]
):
"""バックトラッキングアルゴリズム：例三"""
# 解かどうかをチェック
"""バックトラッキング：例題 3"""
# 解かどうかを確認
if is_solution(state):
# 解を記録
record_solution(state, res)
# すべての選択肢を走査
for choice in choices:
# 枝刈り：選択が合法かどうかをチェック
# 枝刈り：選択が妥当かを確認する
if is_valid(state, choice):
# 試行：選択を行い、状態を更新
# 試行: 選択を行い、状態を更新
make_choice(state, choice)
# 次の選択ラウンドに進む
# 次の選択へ進む
backtrack(state, [choice.left, choice.right], res)
# 撤回：選択を取り消し、前の状態に復元
# バックトラック：選択を取り消し、前の状態に戻す
undo_choice(state, choice)
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
root = list_to_tree([1, 7, 3, 4, 5, 6, 7])
print("\n二分木を初期化")
print_tree(root)
# バックトラッキングアルゴリズム
# バックトラッキング法
res = []
backtrack(state=[], choices=[root], res=res)
print("\nルートからノード 7 へのすべてのパスを出力、パスに値が 3 のノードを含まないことを要求")
print("\n根ノードからノード 7 までの経路をすべて出力し、経路には値が 3 のノードを含まないことを条件とする")
for path in res:
print([node.val for node in path])
print([node.val for node in path])

26
ja/codes/python/chapter_backtracking/subset_sum_i.py
View File

@@ -8,41 +8,41 @@ Author: krahets (krahets@163.com)
def backtrack(
state: list[int], target: int, choices: list[int], start: int, res: list[list[int]]
):
"""バックトラッキングアルゴリズム：部分集合の和 I"""
# 部分集合の和が target と等しいとき、解を記録
"""バックトラッキング：部分和 I"""
# 部分集合の和が target に等しければ、解を記録
if target == 0:
res.append(list(state))
return
# すべての選択肢を走査
# 枝刈り二：start から走査を開始して重複する部分集合の生成を避ける
# 枝刈り 2: start から走査し、重複する部分集合の生成を避ける
for i in range(start, len(choices)):
# 枝刈り一：部分集合の和が target を超える場合、直ちにループを終了
# これは配列がソートされており、後の要素がより大きいため、部分集合の和は必ず target を超えるため
# 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する
# 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため
if target - choices[i] < 0:
break
# 試行：選択を行い、target、start を更新
# 試す：選択を行い、target と start を更新
state.append(choices[i])
# 次の選択ラウンドに進む
# 次の選択へ進む
backtrack(state, target - choices[i], choices, i, res)
# 撤回：選択を取り消し、前の状態に復元
# バックトラック：選択を取り消し、前の状態に戻す
state.pop()
def subset_sum_i(nums: list[int], target: int) -> list[list[int]]:
"""部分集合の和 I を解く"""
"""部分和 I を解く"""
state = [] # 状態（部分集合）
nums.sort() # nums をソート
start = 0 # 走査の開始点
res = [] # 結果リスト（部分集合リスト）
start = 0 # 開始点を走査
res = [] # 結果リスト（部分集合のリスト）
backtrack(state, target, nums, start, res)
return res
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
nums = [3, 4, 5]
target = 9
res = subset_sum_i(nums, target)
print(f"入力配列 nums = {nums}, target = {target}")
print(f"{target} と等しいすべての部分集合 res = {res}")
print(f"和が {target} に等しいすべての部分集合 res = {res}")

24
ja/codes/python/chapter_backtracking/subset_sum_i_naive.py
View File

@@ -12,39 +12,39 @@ def backtrack(
choices: list[int],
res: list[list[int]],
):
"""バックトラッキングアルゴリズム：部分集合の和 I"""
# 部分集合の和が target と等しいとき、解を記録
"""バックトラッキング：部分和 I"""
# 部分集合の和が target に等しければ、解を記録
if total == target:
res.append(list(state))
return
# すべての選択肢を走査
for i in range(len(choices)):
# 枝刈り：部分集合の和が target を超える場合、その選択をスキップ
# 枝刈り：部分和が target を超える場合はその選択をスキップする
if total + choices[i] > target:
continue
# 試行：選択を行い、要素と total を更新
# 試行：選択を行い、要素と total を更新する
state.append(choices[i])
# 次の選択ラウンドに進む
# 次の選択へ進む
backtrack(state, target, total + choices[i], choices, res)
# 撤回：選択を取り消し、前の状態に復元
# バックトラック：選択を取り消し、前の状態に戻す
state.pop()
def subset_sum_i_naive(nums: list[int], target: int) -> list[list[int]]:
"""部分集合の和 I を解く（重複する部分集合を含む）"""
"""部分和 I を解く（重複部分集合を含む）"""
state = [] # 状態（部分集合）
total = 0 # 部分集合の和
res = [] # 結果リスト（部分集合リスト）
total = 0 # 部分和
res = [] # 結果リスト（部分集合のリスト）
backtrack(state, target, total, nums, res)
return res
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
nums = [3, 4, 5]
target = 9
res = subset_sum_i_naive(nums, target)
print(f"入力配列 nums = {nums}, target = {target}")
print(f"{target} と等しいすべての部分集合 res = {res}")
print(f"この方法の結果には重複する集合が含まれる")
print(f"和が {target} に等しいすべての部分集合 res = {res}")
print(f"注意: この方法の出力結果には重複する集合が含まれます")

30
ja/codes/python/chapter_backtracking/subset_sum_ii.py
View File

@@ -8,45 +8,45 @@ Author: krahets (krahets@163.com)
def backtrack(
state: list[int], target: int, choices: list[int], start: int, res: list[list[int]]
):
"""バックトラッキングアルゴリズム：部分集合の和 II"""
# 部分集合の和が target と等しいとき、解を記録
"""バックトラッキング：部分和 II"""
# 部分集合の和が target に等しければ、解を記録
if target == 0:
res.append(list(state))
return
# すべての選択肢を走査
# 枝刈り二：start から走査を開始して重複する部分集合の生成を避ける
# 枝刈り三：start から走査を開始して同じ要素の重複選択を避ける
# 枝刈り 2: start から走査し、重複する部分集合の生成を避ける
# 枝刈り 3: start から走査し、同じ要素の重複選択を避ける
for i in range(start, len(choices)):
# 枝刈り一：部分集合の和が target を超える場合、直ちにループを終了
# これは配列がソートされており、後の要素がより大きいため、部分集合の和は必ず target を超えるため
# 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する
# 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため
if target - choices[i] < 0:
break
# 枝刈り四：要素が左の要素と等しい場合、検索分岐が重複していることを示すため、スキップ
# 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする
if i > start and choices[i] == choices[i - 1]:
continue
# 試行：選択を行い、target、start を更新
# 試す：選択を行い、target と start を更新
state.append(choices[i])
# 次の選択ラウンドに進む
# 次の選択へ進む
backtrack(state, target - choices[i], choices, i + 1, res)
# 撤回：選択を取り消し、前の状態に復元
# バックトラック：選択を取り消し、前の状態に戻す
state.pop()
def subset_sum_ii(nums: list[int], target: int) -> list[list[int]]:
"""部分集合の和 II を解く"""
"""部分和 II を解く"""
state = [] # 状態（部分集合）
nums.sort() # nums をソート
start = 0 # 走査の開始点
res = [] # 結果リスト（部分集合リスト）
start = 0 # 開始点を走査
res = [] # 結果リスト（部分集合のリスト）
backtrack(state, target, nums, start, res)
return res
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
nums = [4, 4, 5]
target = 9
res = subset_sum_ii(nums, target)
print(f"入力配列 nums = {nums}, target = {target}")
print(f"{target} と等しいすべての部分集合 res = {res}")
print(f"和が {target} に等しいすべての部分集合 res = {res}")

34
ja/codes/python/chapter_computational_complexity/iteration.py
View File

@@ -6,44 +6,44 @@ Author: krahets (krahets@163.com)
def for_loop(n: int) -> int:
"""forループ"""
"""for ループ"""
res = 0
# 1, 2, ..., n-1, n の合計をループ
# 1, 2, ..., n-1, n を順に加算する
for i in range(1, n + 1):
res += i
return res
def while_loop(n: int) -> int:
"""whileループ"""
"""while ループ"""
res = 0
i = 1 # 条件変数を初期化
# 1, 2, ..., n-1, n の合計をループ
i = 1 # 条件変数を初期化する
# 1, 2, ..., n-1, n を順に加算する
while i <= n:
res += i
i += 1 # 条件変数を更新
i += 1 # 条件変数を更新する
return res
def while_loop_ii(n: int) -> int:
"""whileループ（2つの更新）"""
"""while ループ（2回更新）"""
res = 0
i = 1 # 条件変数を初期化
# 1, 4, 10, ... の合計をループ
i = 1 # 条件変数を初期化する
# 1, 4, 10, ... を順に加算する
while i <= n:
res += i
# 条件変数を更新
# 条件変数を更新する
i += 1
i *= 2
return res
def nested_for_loop(n: int) -> str:
"""二重forループ"""
"""二重 for ループ"""
res = ""
# i = 1, 2, ..., n-1, n をループ
# i = 1, 2, ..., n-1, n とループする
for i in range(1, n + 1):
# j = 1, 2, ..., n-1, n をループ
# j = 1, 2, ..., n-1, n とループする
for j in range(1, n + 1):
res += f"({i}, {j}), "
return res
@@ -53,13 +53,13 @@ def nested_for_loop(n: int) -> str:
if __name__ == "__main__":
n = 5
res = for_loop(n)
print(f"\nforループの合計結果 res = {res}")
print(f"\nfor ループの合計結果 res = {res}")
res = while_loop(n)
print(f"\nwhileループの合計結果 res = {res}")
print(f"\nwhile ループの合計結果 res = {res}")
res = while_loop_ii(n)
print(f"\nwhileループ（2つの更新）の合計結果 res = {res}")
print(f"\nwhile ループ（2 回更新）の合計結果 res = {res}")
res = nested_for_loop(n)
print(f"\n二重forループの走査結果 {res}")
print(f"\n二重 for ループの走査結果 {res}")

18
ja/codes/python/chapter_computational_complexity/recursion.py
View File

@@ -12,22 +12,22 @@ def recur(n: int) -> int:
return 1
# 再帰：再帰呼び出し
res = recur(n - 1)
# 復帰：結果を返す
# 帰りがけ：結果を返す
return n + res
def for_loop_recur(n: int) -> int:
"""反復で再帰をシミュレート"""
# 明示的なスタックを使用してシステムコールスタックをシミュレート
"""反復で再帰を模擬する"""
# 明示的なスタックを使ってシステムコールスタックを模擬する
stack = []
res = 0
# 再帰：再帰呼び出し
for i in range(n, 0, -1):
# 「スタックへのプッシュ」で「再帰」をシミュレート
# 「スタックへのプッシュ」で「再帰」を模擬する
stack.append(i)
# 復帰：結果を返す
# 帰りがけ：結果を返す
while stack:
# 「スタックからのポップ」で「復帰」をシミュレート
# 「スタックから取り出す操作」で「帰り」をシミュレート
res += stack.pop()
# res = 1+2+3+...+n
return res
@@ -47,7 +47,7 @@ def fib(n: int) -> int:
# 終了条件 f(1) = 0, f(2) = 1
if n == 1 or n == 2:
return n - 1
# 再帰呼び出し f(n) = f(n-1) + f(n-2)
# f(n) = f(n-1) + f(n-2) を再帰的に呼び出す
res = fib(n - 1) + fib(n - 2)
# 結果 f(n) を返す
return res
@@ -60,10 +60,10 @@ if __name__ == "__main__":
print(f"\n再帰関数の合計結果 res = {res}")
res = for_loop_recur(n)
print(f"\n反復で再帰をシミュレートする合計結果 res = {res}")
print(f"\n反復で再帰をシミュレートした合計結果 res = {res}")
res = tail_recur(n, 0)
print(f"\n末尾再帰関数の合計結果 res = {res}")
res = fib(n)
print(f"\nフィボナッチ数列の第 {n} 項は {res} です")
print(f"\nフィボナッチ数列の第 {n} 項は {res}")

36
ja/codes/python/chapter_computational_complexity/space_complexity.py
View File

@@ -13,36 +13,36 @@ from modules import ListNode, TreeNode, print_tree
def function() -> int:
"""関数"""
# 何らかの操作を実行
# 何らかの処理を行う
return 0
def constant(n: int):
"""定数複雑度"""
# 定数、変数、オブジェクトは O(1) のスペースを占有
"""定数階"""
# 定数、変数、オブジェクトは O(1) の空間を占める
a = 0
nums = [0] * 10000
node = ListNode(0)
# ループ内の変数は O(1) のスペースを占有
# ループ内の変数は O(1) の空間を占める
for _ in range(n):
c = 0
# ループ内の関数は O(1) のスペースを占有
# ループ内の関数は O(1) の空間を占める
for _ in range(n):
function()
def linear(n: int):
"""線形複雑度"""
# 長さ n のリストは O(n) のスペースを占有
"""線形階"""
# 長さ n のリストは O(n) の空間を使用
nums = [0] * n
# 長さ n のハッシュマップは O(n) のスペースを占有
# 長さ n のハッシュテーブルは O(n) の空間を使用
hmap = dict[int, str]()
for i in range(n):
hmap[i] = str(i)
def linear_recur(n: int):
"""線形複雑度（再帰実装）"""
"""線形時間（再帰実装）"""
print("再帰 n =", n)
if n == 1:
return
@@ -50,22 +50,22 @@ def linear_recur(n: int):
def quadratic(n: int):
"""平方複雑度"""
# 二次元リストは O(n^2) のスペースを占有
"""二乗階"""
# 二次元リストは O(n^2) の空間を使用
num_matrix = [[0] * n for _ in range(n)]
def quadratic_recur(n: int) -> int:
"""平方複雑度（再帰実装）"""
"""二次時間（再帰実装）"""
if n <= 0:
return 0
# 配列 nums の長さは n, n-1, ..., 2, 1
nums = [0] * n
print(f"再帰 n = {n} の中で配列の長さ = {len(nums)}")
return quadratic_recur(n - 1)
def build_tree(n: int) -> TreeNode | None:
"""指数複雑度（完全二分木の構築）"""
"""指数時間（完全二分木の構築）"""
if n == 0:
return None
root = TreeNode(0)
@@ -77,14 +77,14 @@ def build_tree(n: int) -> TreeNode | None:
"""Driver Code"""
if __name__ == "__main__":
n = 5
# 定数複雑度
# 定数階
constant(n)
# 線形複雑度
# 線形階
linear(n)
linear_recur(n)
# 平方複雑度
# 二乗階
quadratic(n)
quadratic_recur(n)
# 指数複雑度
# 指数オーダー
root = build_tree(n)
print_tree(root)

90
ja/codes/python/chapter_computational_complexity/time_complexity.py
View File

@@ -6,7 +6,7 @@ Author: krahets (krahets@163.com)
def constant(n: int) -> int:
"""定数複雑度"""
"""定数階"""
count = 0
size = 100000
for _ in range(size):
@@ -15,7 +15,7 @@ def constant(n: int) -> int:
def linear(n: int) -> int:
"""線形複雑度"""
"""線形階"""
count = 0
for _ in range(n):
count += 1
@@ -23,18 +23,18 @@ def linear(n: int) -> int:
def array_traversal(nums: list[int]) -> int:
"""線形複雑度（配列の走査）"""
"""線形時間（配列を走査）"""
count = 0
# ループ回数は配列の長さに比例する
# ループ回数は配列長に比例する
for num in nums:
count += 1
return count
def quadratic(n: int) -> int:
"""二次複雑度"""
"""二乗階"""
count = 0
# ループ回数はデータサイズnの二乗に比例する
# ループ回数はデータサイズ n の二乗に比例する
for i in range(n):
for j in range(n):
count += 1
@@ -42,26 +42,26 @@ def quadratic(n: int) -> int:
def bubble_sort(nums: list[int]) -> int:
"""二次複雑度（バブルソート）"""
"""二次時間（バブルソート）"""
count = 0 # カウンタ
# 外側のループ: 未ソート範囲は [0, i]
# 外側のループ：未ソート区間は [0, i]
for i in range(len(nums) - 1, 0, -1):
# 内側のループ: 未ソート範囲 [0, i] の最大要素を右端にスワップ
# 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換
for j in range(i):
if nums[j] > nums[j + 1]:
# nums[j] と nums[j + 1] をスワップ
# nums[j] と nums[j + 1] を交換
tmp: int = nums[j]
nums[j] = nums[j + 1]
nums[j + 1] = tmp
count += 3 # 要素のスワップは3つの個別操作を含む
count += 3 # 要素交換には 3 回の単位操作が含まれる
return count
def exponential(n: int) -> int:
"""指数複雑度（ループ実装）"""
"""指数時間（ループ実装）"""
count = 0
base = 1
# セルは毎回2つに分裂し、1, 2, 4, 8, ..., 2^(n-1) の数列を形成する
# 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する
for _ in range(n):
for _ in range(base):
count += 1
@@ -71,14 +71,14 @@ def exponential(n: int) -> int:
def exp_recur(n: int) -> int:
"""指数複雑度（再帰実装）"""
"""指数時間（再帰実装）"""
if n == 1:
return 1
return exp_recur(n - 1) + exp_recur(n - 1) + 1
def logarithmic(n: int) -> int:
"""対数複雑度（ループ実装）"""
"""対数時間（ループ実装）"""
count = 0
while n > 1:
n = n / 2
@@ -87,65 +87,67 @@ def logarithmic(n: int) -> int:
def log_recur(n: int) -> int:
"""対数複雑度（再帰実装）"""
"""対数時間（再帰実装）"""
if n <= 1:
return 0
return log_recur(n / 2) + 1
def linear_log_recur(n: int) -> int:
"""線形対数複雑度"""
"""線形対数時間"""
if n <= 1:
return 1
count: int = linear_log_recur(n // 2) + linear_log_recur(n // 2)
# 二つに分割すると、部分問題の規模は半分になる
count = linear_log_recur(n // 2) + linear_log_recur(n // 2)
# 現在の部分問題には n 個の操作が含まれる
for _ in range(n):
count += 1
return count
def factorial_recur(n: int) -> int:
"""階乗複雑度（再帰実装）"""
"""階乗時間（再帰実装）"""
if n == 0:
return 1
count = 0
# 1つからnに分岐
# 1個から n 個に分裂
for _ in range(n):
count += factorial_recur(n - 1)
return count
"""ドライバコード"""
"""Driver Code"""
if __name__ == "__main__":
# nを変更して、様々な複雑度での操作回数の変化傾向を体験できる
# n を変えて実行し、各計算量で操作回数がどう変化するかを確認できる
n = 8
print("入力データサイズ n =", n)
count: int = constant(n)
print("定数複雑度の操作回数 =", count)
count = constant(n)
print("定数時間の操作回数 =", count)
count: int = linear(n)
print("線形複雑度の操作回数 =", count)
count: int = array_traversal([0] * n)
print("線形複雑度（配列の走査）の操作回数 =", count)
count = linear(n)
print("線形時間の操作回数 =", count)
count = array_traversal([0] * n)
print("線形時間（配列走査）の操作回数 =", count)
count: int = quadratic(n)
print("二次複雑度の操作回数 =", count)
count = quadratic(n)
print("二乗時間の操作回数 =", count)
nums = [i for i in range(n, 0, -1)] # [n, n-1, ..., 2, 1]
count: int = bubble_sort(nums)
print("二次複雑度（バブルソート）の操作回数 =", count)
count = bubble_sort(nums)
print("二乗時間（バブルソート）の操作回数 =", count)
count: int = exponential(n)
print("指数複雑度（ループ実装）の操作回数 =", count)
count: int = exp_recur(n)
print("指数複雑度（再帰実装）の操作回数 =", count)
count = exponential(n)
print("指数時間（ループ実装）の操作回数 =", count)
count = exp_recur(n)
print("指数時間（再帰実装）の操作回数 =", count)
count: int = logarithmic(n)
print("対数複雑度（ループ実装）の操作回数 =", count)
count: int = log_recur(n)
print("対数複雑度（再帰実装）の操作回数 =", count)
count = logarithmic(n)
print("対数時間（ループ実装）の操作回数 =", count)
count = log_recur(n)
print("対数時間（再帰実装）の操作回数 =", count)
count: int = linear_log_recur(n)
print("線形対数複雑度（再帰実装）の操作回数 =", count)
count = linear_log_recur(n)
print("線形対数時間（再帰実装）の操作回数 =", count)
count: int = factorial_recur(n)
print("階乗複雑度（再帰実装）の操作回数 =", count)
count = factorial_recur(n)
print("階乗時間（再帰実装）の操作回数 =", count)

14
ja/codes/python/chapter_computational_complexity/worst_best_time_complexity.py
View File

@@ -8,8 +8,8 @@ import random
def random_numbers(n: int) -> list[int]:
"""要素 1, 2, ..., n を含む配列を生成、順序はシャッフル"""
# 配列 nums = 1, 2, 3, ..., n を生成
"""要素が 1, 2, ..., n で順序がシャッフルされた配列を生成する"""
# 配列 nums =: 1, 2, 3, ..., n を生成する
nums = [i for i in range(1, n + 1)]
# 配列要素をランダムにシャッフル
random.shuffle(nums)
@@ -17,10 +17,10 @@ def random_numbers(n: int) -> list[int]:
def find_one(nums: list[int]) -> int:
"""配列 nums で数値 1 のインデックスを検索"""
"""配列 nums 内で数値 1 のインデックスを探す"""
for i in range(len(nums)):
# 要素 1 が配列の最初にある場合、最良時間計算量 O(1) を達成
# 要素 1 が配列の最後にある場合、最悪時間計算量 O(n) を達成
# 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる
# 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる
if nums[i] == 1:
return i
return -1
@@ -32,5 +32,5 @@ if __name__ == "__main__":
n = 100
nums: list[int] = random_numbers(n)
index: int = find_one(nums)
print("\nシャッフル後の配列 [ 1, 2, ..., n ] =", nums)
print("数値 1 のインデックス =", index)
print("\n配列 [ 1, 2, ..., n ] をシャッフルすると =", nums)
print("数値 1 のインデックスは", index)

14
ja/codes/python/chapter_divide_and_conquer/binary_search_recur.py
View File

@@ -7,19 +7,19 @@ Author: krahets (krahets@163.com)
def dfs(nums: list[int], target: int, i: int, j: int) -> int:
"""二分探索：問題 f(i, j)"""
# 区間が空の場合、対象要素がないことを示すため、-1 を返す
# 区間が空なら対象要素は存在しないので -1 を返す
if i > j:
return -1
# 中点インデックス m を計算
m = (i + j) // 2
if nums[m] < target:
# 再帰部分問題 f(m+1, j)
# 部分問題 f(m+1, j) を再帰的に解く
return dfs(nums, target, m + 1, j)
elif nums[m] > target:
# 再帰部分問題 f(i, m-1)
# 部分問題 f(i, m-1) を再帰的に解く
return dfs(nums, target, i, m - 1)
else:
# 対象要素を発見したため、そのインデックスを返す
# 目標要素が見つかったらそのインデックスを返す
return m
@@ -30,11 +30,11 @@ def binary_search(nums: list[int], target: int) -> int:
return dfs(nums, target, 0, n - 1)
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
target = 6
nums = [1, 3, 6, 8, 12, 15, 23, 26, 31, 35]
# 二分探索（両端閉区間）
# 二分探索（両閉区間）
index = binary_search(nums, target)
print("対象要素 6 のインデックス =", index)
print("対象要素 6 のインデックス = ", index)

22
ja/codes/python/chapter_divide_and_conquer/build_tree.py
View File

@@ -18,31 +18,31 @@ def dfs(
l: int,
r: int,
) -> TreeNode | None:
"""二分木の構築：分割統治"""
# 部分木の区間が空のとき終了
"""二分木を構築：分割統治"""
# 部分木区間が空なら終了する
if r - l < 0:
return None
# ルートノードを初期化
# ルートノードを初期化する
root = TreeNode(preorder[i])
# m をクエリして左部分木と右部分木を分割
# m を求めて左右部分木を分割する
m = inorder_map[preorder[i]]
# 部分問題：左部分木を構築
# 部分問題：左部分木を構築する
root.left = dfs(preorder, inorder_map, i + 1, l, m - 1)
# 部分問題：右部分木を構築
# 部分問題：右部分木を構築する
root.right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r)
# ルートノードを返す
# 根ノードを返す
return root
def build_tree(preorder: list[int], inorder: list[int]) -> TreeNode | None:
"""二分木を構築"""
# ハッシュテーブルを初期化、中順走査の要素からインデックスへのマッピングを保存
# inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する
inorder_map = {val: i for i, val in enumerate(inorder)}
root = dfs(preorder, inorder_map, 0, 0, len(inorder) - 1)
return root
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
preorder = [3, 9, 2, 1, 7]
inorder = [9, 3, 1, 2, 7]
@@ -50,5 +50,5 @@ if __name__ == "__main__":
print(f"中順走査 = {inorder}")
root = build_tree(preorder, inorder)
print("構築された二分木は：")
print_tree(root)
print("構築した二分木:")
print_tree(root)

28
ja/codes/python/chapter_divide_and_conquer/hanota.py
View File

@@ -6,48 +6,48 @@ Author: krahets (krahets@163.com)
def move(src: list[int], tar: list[int]):
"""円盤を移動"""
# src の上から円盤を取り出す
"""円盤を 1 枚移動"""
# src の上から円盤を1枚取り出す
pan = src.pop()
# 円盤を tar の上に置く
tar.append(pan)
def dfs(i: int, src: list[int], buf: list[int], tar: list[int]):
"""ハノイの塔問題 f(i) を解く"""
# src に円盤が 1 つだけ残っている場合、それを tar に移動
"""ハノイの塔の問題 f(i) を解く"""
# src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す
if i == 1:
move(src, tar)
return
# 部分問題 f(i-1)：tar の助けを借りて src の上の i-1 個の円盤を buf に移動
# 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す
dfs(i - 1, src, tar, buf)
# 部分問題 f(1)：残りの 1 個の円盤を src から tar に移動
# 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す
move(src, tar)
# 部分問題 f(i-1)：src の助けを借りて buf の上の i-1 個の円盤を tar に移動
# 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す
dfs(i - 1, buf, src, tar)
def solve_hanota(A: list[int], B: list[int], C: list[int]):
"""ハノイの塔問題を解く"""
"""ハノイの塔を解く"""
n = len(A)
# B の助けを借りて A の上の n 個の円盤を C に移動
# A の上から n 枚の円盤を B を介して C へ移す
dfs(n, A, B, C)
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
# リストの末尾が柱の上部
# リスト末尾が柱の頂上
A = [5, 4, 3, 2, 1]
B = []
C = []
print("初期状態：")
print("初期状態:")
print(f"A = {A}")
print(f"B = {B}")
print(f"C = {C}")
solve_hanota(A, B, C)
print("円盤移動後：")
print("円盤の移動完了後:")
print(f"A = {A}")
print(f"B = {B}")
print(f"C = {C}")
print(f"C = {C}")

18
ja/codes/python/chapter_dynamic_programming/climbing_stairs_backtrack.py
View File

@@ -7,31 +7,31 @@ Author: krahets (krahets@163.com)
def backtrack(choices: list[int], state: int, n: int, res: list[int]) -> int:
"""バックトラッキング"""
# n 段目に登ったとき、解の数に 1 を加える
# 第 n 段に到達したら、方法数を 1 増やす
if state == n:
res[0] += 1
# すべての選択肢を走査
for choice in choices:
# 枝刈り：n 段を超えて登ることを許可しない
# 枝刈り: 第 n 段を超えないようにする
if state + choice > n:
continue
# 試行：選択を行い、状態を更新
# 試行: 選択を行い、状態を更新
backtrack(choices, state + choice, n, res)
# 撤回
# バックトラック
def climbing_stairs_backtrack(n: int) -> int:
"""階段登り：バックトラッキング"""
choices = [1, 2] # 1 段または 2 段登ることを選択可能
state = 0 # 0 段目から登り始める
res = [0] # res[0] を使用して解の数を記録
choices = [1, 2] # 1 段または 2 段上ることを選べる
state = 0 # 第 0 段から上り始める
res = [0] # res[0] を使って方法数を記録する
backtrack(choices, state, n, res)
return res[0]
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
n = 9
res = climbing_stairs_backtrack(n)
print(f"{n} 段登り、合計 {res} 通りの解がある")
print(f"{n} 段の階段を上る方法は全部で {res} 通りです")

12
ja/codes/python/chapter_dynamic_programming/climbing_stairs_constraint_dp.py
View File

@@ -6,24 +6,24 @@ Author: krahets (krahets@163.com)
def climbing_stairs_constraint_dp(n: int) -> int:
"""制約付き階段登り：動的プログラミング"""
"""制約付き階段登り：動的計画法"""
if n == 1 or n == 2:
return 1
# dp テーブルを初期化、部分問題の解を格納するために使用
# 部分問題の解を保存するために dp テーブルを初期化
dp = [[0] * 3 for _ in range(n + 1)]
# 初期状態：最小の部分問題の解を事前設定
# 初期状態：最小部分問題の解をあらかじめ設定
dp[1][1], dp[1][2] = 1, 0
dp[2][1], dp[2][2] = 0, 1
# 状態遷移：小さい部分問題から大きい部分問題を段階的に解く
# 状態遷移：小さい部分問題から大きい部分問題へ順に解く
for i in range(3, n + 1):
dp[i][1] = dp[i - 1][2]
dp[i][2] = dp[i - 2][1] + dp[i - 2][2]
return dp[n][1] + dp[n][2]
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
n = 9
res = climbing_stairs_constraint_dp(n)
print(f"{n} 段登り、合計 {res} 通りの解がある")
print(f"{n} 段の階段を上る方法は全部で {res} 通りです")

8
ja/codes/python/chapter_dynamic_programming/climbing_stairs_dfs.py
View File

@@ -6,8 +6,8 @@ Author: krahets (krahets@163.com)
def dfs(i: int) -> int:
"""探索"""
# 既知の dp[1] と dp[2] は、それらを返す
"""検索"""
# dp[1] と dp[2] は既知なので返す
if i == 1 or i == 2:
return i
# dp[i] = dp[i-1] + dp[i-2]
@@ -20,9 +20,9 @@ def climbing_stairs_dfs(n: int) -> int:
return dfs(n)
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
n = 9
res = climbing_stairs_dfs(n)
print(f"{n} 段登り、合計 {res} 通りの解がある")
print(f"{n} 段の階段を上る方法は全部で {res} 通りです")

16
ja/codes/python/chapter_dynamic_programming/climbing_stairs_dfs_mem.py
View File

@@ -6,30 +6,30 @@ Author: krahets (krahets@163.com)
def dfs(i: int, mem: list[int]) -> int:
"""記憶化探索"""
# 既知の dp[1] と dp[2] は、それらを返す
"""メモ化探索"""
# dp[1] と dp[2] は既知なので返す
if i == 1 or i == 2:
return i
# dp[i] の記録がある場合、それを返す
# dp[i] の記録があれば、それをそのまま返す
if mem[i] != -1:
return mem[i]
# dp[i] = dp[i-1] + dp[i-2]
count = dfs(i - 1, mem) + dfs(i - 2, mem)
# dp[i] を記録
# dp[i] を記録する
mem[i] = count
return count
def climbing_stairs_dfs_mem(n: int) -> int:
"""階段登り：記憶化探索"""
# mem[i] は i 段目に登る解の総数を記録、-1 は記録なしを意味する
"""階段登り：メモ化探索"""
# mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す
mem = [-1] * (n + 1)
return dfs(n, mem)
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
n = 9
res = climbing_stairs_dfs_mem(n)
print(f"{n} 段登り、合計 {res} 通りの解がある")
print(f"{n} 段の階段を上る方法は全部で {res} 通りです")

16
ja/codes/python/chapter_dynamic_programming/climbing_stairs_dp.py
View File

@@ -6,21 +6,21 @@ Author: krahets (krahets@163.com)
def climbing_stairs_dp(n: int) -> int:
"""階段登り：動的プログラミング"""
"""階段登り：動的計画法"""
if n == 1 or n == 2:
return n
# dp テーブルを初期化、部分問題の解を格納するため使用
# 部分問題の解を保存するために dp テーブルを初期化
dp = [0] * (n + 1)
# 初期状態：最小の部分問題の解を事前設定
# 初期状態：最小部分問題の解をあらかじめ設定
dp[1], dp[2] = 1, 2
# 状態遷移：小さい部分問題から大きい部分問題を段階的に解く
# 状態遷移：小さい部分問題から大きい部分問題へ順に解く
for i in range(3, n + 1):
dp[i] = dp[i - 1] + dp[i - 2]
return dp[n]
def climbing_stairs_dp_comp(n: int) -> int:
"""階段登り：空間最適化動的プログラミング"""
"""階段登り：空間最適化した動的計画法"""
if n == 1 or n == 2:
return n
a, b = 1, 2
@@ -29,12 +29,12 @@ def climbing_stairs_dp_comp(n: int) -> int:
return b
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
n = 9
res = climbing_stairs_dp(n)
print(f"{n} 段登り、合計 {res} 通りの解がある")
print(f"{n} 段の階段を上る方法は全部で {res} 通りです")
res = climbing_stairs_dp_comp(n)
print(f"{n} 段登り、合計 {res} 通りの解がある")
print(f"{n} 段の階段を上る方法は全部で {res} 通りです")

28
ja/codes/python/chapter_dynamic_programming/coin_change.py
View File

@@ -6,28 +6,28 @@ Author: krahets (krahets@163.com)
def coin_change_dp(coins: list[int], amt: int) -> int:
"""硬貨交換：動的プログラミング"""
"""コイン両替：動的計画法"""
n = len(coins)
MAX = amt + 1
# dp テーブルを初期化
dp = [[0] * (amt + 1) for _ in range(n + 1)]
# 状態遷移：最初の行と最初の列
# 状態遷移：先頭行と先頭列
for a in range(1, amt + 1):
dp[0][a] = MAX
# 状態遷移：残りの行と列
# 状態遷移: 残りの行と列
for i in range(1, n + 1):
for a in range(1, amt + 1):
if coins[i - 1] > a:
# 目標金額を超える場合、硬貨 i を選択しない
# 目標金額を超えるなら硬貨 i は選ばない
dp[i][a] = dp[i - 1][a]
else:
# 硬貨 i を選択しないのと選択するのとで小さい値
# 硬貨 i を選ばない場合と選ぶ場合の小さい方
dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)
return dp[n][amt] if dp[n][amt] != MAX else -1
def coin_change_dp_comp(coins: list[int], amt: int) -> int:
"""硬貨交換：空間最適化動的プログラミング"""
"""コイン交換：空間最適化後の動的計画法"""
n = len(coins)
MAX = amt + 1
# dp テーブルを初期化
@@ -35,26 +35,26 @@ def coin_change_dp_comp(coins: list[int], amt: int) -> int:
dp[0] = 0
# 状態遷移
for i in range(1, n + 1):
# 順序で走査
# 順方向に走査する
for a in range(1, amt + 1):
if coins[i - 1] > a:
# 目標金額を超える場合、硬貨 i を選択しない
# 目標金額を超えるなら硬貨 i は選ばない
dp[a] = dp[a]
else:
# 硬貨 i を選択しないのと選択するのとで小さい値
# 硬貨 i を選ばない場合と選ぶ場合の小さい方
dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)
return dp[amt] if dp[amt] != MAX else -1
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
coins = [1, 2, 5]
amt = 4
# 動的プログラミング
# 動的計画法
res = coin_change_dp(coins, amt)
print(f"目標金額に到達するのに必要な硬貨の最小数 = {res}")
print(f"目標金額を作るのに必要な最小硬貨枚数は {res}")
# 空間最適化動的プログラミング
# 空間最適化後の動的計画法
res = coin_change_dp_comp(coins, amt)
print(f"目標金額に到達するのに必要な硬貨の最小数 = {res}")
print(f"目標金額を作るのに必要な最小硬貨枚数は {res}")

26
ja/codes/python/chapter_dynamic_programming/coin_change_ii.py
View File

@@ -6,53 +6,53 @@ Author: krahets (krahets@163.com)
def coin_change_ii_dp(coins: list[int], amt: int) -> int:
"""硬貨交換 II：動的プログラミング"""
"""コイン両替 II：動的計画法"""
n = len(coins)
# dp テーブルを初期化
dp = [[0] * (amt + 1) for _ in range(n + 1)]
# 最初の列を初期化
# 先頭列を初期化する
for i in range(n + 1):
dp[i][0] = 1
# 状態遷移
for i in range(1, n + 1):
for a in range(1, amt + 1):
if coins[i - 1] > a:
# 目標金額を超える場合、硬貨 i を選択しない
# 目標金額を超えるなら硬貨 i は選ばない
dp[i][a] = dp[i - 1][a]
else:
# 硬貨 i を選択しないのと選択するのとの両方の選択肢の和
# コイン i を選ばない場合と選ぶ場合の和
dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]
return dp[n][amt]
def coin_change_ii_dp_comp(coins: list[int], amt: int) -> int:
"""硬貨交換 II：空間最適化動的プログラミング"""
"""コイン両替 II：空間最適化した動的計画法"""
n = len(coins)
# dp テーブルを初期化
dp = [0] * (amt + 1)
dp[0] = 1
# 状態遷移
for i in range(1, n + 1):
# 順序で走査
# 順方向に走査する
for a in range(1, amt + 1):
if coins[i - 1] > a:
# 目標金額を超える場合、硬貨 i を選択しない
# 目標金額を超えるなら硬貨 i は選ばない
dp[a] = dp[a]
else:
# 硬貨 i を選択しないのと選択するのとの両方の選択肢の和
# コイン i を選ばない場合と選ぶ場合の和
dp[a] = dp[a] + dp[a - coins[i - 1]]
return dp[amt]
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
coins = [1, 2, 5]
amt = 5
# 動的プログラミング
# 動的計画法
res = coin_change_ii_dp(coins, amt)
print(f"目標金額を構成する硬貨の組み合わせ数は {res}")
print(f"目標金額を作る硬貨の組み合わせ数は {res}")
# 空間最適化動的プログラミング
# 空間最適化後の動的計画法
res = coin_change_ii_dp_comp(coins, amt)
print(f"目標金額を構成する硬貨の組み合わせ数は {res}")
print(f"目標金額を作る硬貨の組み合わせ数は {res}")

74
ja/codes/python/chapter_dynamic_programming/edit_distance.py
View File

@@ -1,123 +1,123 @@
"""
File: edit_distance.py
File: edit_distancde.py
Created Time: 2023-07-04
Author: krahets (krahets@163.com)
"""
def edit_distance_dfs(s: str, t: str, i: int, j: int) -> int:
"""編集距離：ブルートフォース探索"""
# s と t の両方が空の場合、0 を返す
"""編集距離：総当たり探索"""
# s と t がともに空なら 0 を返す
if i == 0 and j == 0:
return 0
# s が空の場合、t の長さを返す
# s が空なら t の長さを返す
if i == 0:
return j
# t が空の場合、s の長さを返す
# t が空なら s の長さを返す
if j == 0:
return i
# 2 つの文字が等しい場合、これら 2 つの文字をスキップ
# 2 つの文字が等しければ、その 2 文字をそのままスキップする
if s[i - 1] == t[j - 1]:
return edit_distance_dfs(s, t, i - 1, j - 1)
# 最小編集数 = 3 つの操作（挿入、削除、置換）からの最小編集数 + 1
# 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1
insert = edit_distance_dfs(s, t, i, j - 1)
delete = edit_distance_dfs(s, t, i - 1, j)
replace = edit_distance_dfs(s, t, i - 1, j - 1)
# 最小編集数を返す
# 最小編集回数を返す
return min(insert, delete, replace) + 1
def edit_distance_dfs_mem(s: str, t: str, mem: list[list[int]], i: int, j: int) -> int:
"""編集距離：記憶化探索"""
# s と t の両方が空の場合、0 を返す
"""編集距離：メモ化探索"""
# s と t がともに空なら 0 を返す
if i == 0 and j == 0:
return 0
# s が空の場合、t の長さを返す
# s が空なら t の長さを返す
if i == 0:
return j
# t が空の場合、s の長さを返す
# t が空なら s の長さを返す
if j == 0:
return i
# 記録がある場合、それを返す
# 記録済みなら、それをそのまま返す
if mem[i][j] != -1:
return mem[i][j]
# 2 つの文字が等しい場合、これら 2 つの文字をスキップ
# 2 つの文字が等しければ、その 2 文字をそのままスキップする
if s[i - 1] == t[j - 1]:
return edit_distance_dfs_mem(s, t, mem, i - 1, j - 1)
# 最小編集数 = 3 つの操作（挿入、削除、置換）からの最小編集数 + 1
# 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1
insert = edit_distance_dfs_mem(s, t, mem, i, j - 1)
delete = edit_distance_dfs_mem(s, t, mem, i - 1, j)
replace = edit_distance_dfs_mem(s, t, mem, i - 1, j - 1)
# 最小編集数を記録して返す
# 最小編集回数を記録して返す
mem[i][j] = min(insert, delete, replace) + 1
return mem[i][j]
def edit_distance_dp(s: str, t: str) -> int:
"""編集距離：動的プログラミング"""
"""編集距離：動的計画法"""
n, m = len(s), len(t)
dp = [[0] * (m + 1) for _ in range(n + 1)]
# 状態遷移：最初の行と最初の列
# 状態遷移：先頭行と先頭列
for i in range(1, n + 1):
dp[i][0] = i
for j in range(1, m + 1):
dp[0][j] = j
# 状態遷移：残りの行と列
# 状態遷移: 残りの行と列
for i in range(1, n + 1):
for j in range(1, m + 1):
if s[i - 1] == t[j - 1]:
# 2 つの文字が等しい場合、これら 2 つの文字をスキップ
# 2 つの文字が等しければ、その 2 文字をそのままスキップする
dp[i][j] = dp[i - 1][j - 1]
else:
# 最小編集数 = 3 つの操作（挿入、削除、置換）からの最小編集数 + 1
# 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1
dp[i][j] = min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1
return dp[n][m]
def edit_distance_dp_comp(s: str, t: str) -> int:
"""編集距離：空間最適化動的プログラミング"""
"""編集距離：空間最適化した動的計画法"""
n, m = len(s), len(t)
dp = [0] * (m + 1)
# 状態遷移：最初の行
# 状態遷移：先頭行
for j in range(1, m + 1):
dp[j] = j
# 状態遷移：残りの行
for i in range(1, n + 1):
# 状態遷移：最初の列
leftup = dp[0] # dp[i-1, j-1] を一時的に保存
# 状態遷移：先頭列
leftup = dp[0] # dp[i-1, j-1] を一時保存する
dp[0] += 1
# 状態遷移：残りの列
for j in range(1, m + 1):
temp = dp[j]
if s[i - 1] == t[j - 1]:
# 2 つの文字が等しい場合、これら 2 つの文字をスキップ
# 2 つの文字が等しければ、その 2 文字をそのままスキップする
dp[j] = leftup
else:
# 最小編集数 = 3 つの操作（挿入、削除、置換）からの最小編集数 + 1
# 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1
dp[j] = min(dp[j - 1], dp[j], leftup) + 1
leftup = temp # 次の dp[i-1, j-1] のために更新
leftup = temp # 次の反復の dp[i-1, j-1] に更新する
return dp[m]
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
s = "bag"
t = "pack"
n, m = len(s), len(t)
# ブルートフォース探索
# 全探索
res = edit_distance_dfs(s, t, n, m)
print(f"{s} を {t} に変更するために必要な最小編集数は {res}")
print(f"{s} を {t} に変更するには最小で {res} 回の編集が必要です")
# 記憶化探索
# メモ化探索
mem = [[-1] * (m + 1) for _ in range(n + 1)]
res = edit_distance_dfs_mem(s, t, mem, n, m)
print(f"{s} を {t} に変更するために必要な最小編集数は {res}")
print(f"{s} を {t} に変更するには最小で {res} 回の編集が必要です")
# 動的プログラミング
# 動的計画法
res = edit_distance_dp(s, t)
print(f"{s} を {t} に変更するために必要な最小編集数は {res}")
print(f"{s} を {t} に変更するには最小で {res} 回の編集が必要です")
# 空間最適化動的プログラミング
# 空間最適化後の動的計画法
res = edit_distance_dp_comp(s, t)
print(f"{s} を {t} に変更するために必要な最小編集数は {res}")
print(f"{s} を {t} に変更するには最小で {res} 回の編集が必要です")

54
ja/codes/python/chapter_dynamic_programming/knapsack.py
View File

@@ -6,43 +6,43 @@ Author: krahets (krahets@163.com)
def knapsack_dfs(wgt: list[int], val: list[int], i: int, c: int) -> int:
"""0-1 ナップサック：ブルートフォース探索"""
# すべてのアイテムが選択されたかナップサックに残り容量がない場合、値 0 を返す
"""0-1 ナップサック：総当たり探索"""
# すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す
if i == 0 or c == 0:
return 0
# ナップサック容量を超える場合、ナップサックに入れないことしか選択できない
# ナップサック容量を超える場合は、入れない選択しかできない
if wgt[i - 1] > c:
return knapsack_dfs(wgt, val, i - 1, c)
# アイテム i を入れないのと入れるのとの最大値を計算
# 品物 i を入れない場合と入れる場合の最大価値を計算する
no = knapsack_dfs(wgt, val, i - 1, c)
yes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1]
# 2 つの選択肢のうち大きい値を返す
# 2つの案のうち価値が大きいほうを返す
return max(no, yes)
def knapsack_dfs_mem(
wgt: list[int], val: list[int], mem: list[list[int]], i: int, c: int
) -> int:
"""0-1 ナップサック：記憶化探索"""
# すべてのアイテムが選択されたかナップサックに残り容量がない場合、値 0 を返す
"""0-1 ナップサック：メモ化探索"""
# すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す
if i == 0 or c == 0:
return 0
# 記録がある場合、それを返す
# 既に記録があればそのまま返す
if mem[i][c] != -1:
return mem[i][c]
# ナップサック容量を超える場合、ナップサックに入れないことしか選択できない
# ナップサック容量を超える場合は、入れない選択しかできない
if wgt[i - 1] > c:
return knapsack_dfs_mem(wgt, val, mem, i - 1, c)
# アイテム i を入れないのと入れるのとの最大値を計算
# 品物 i を入れない場合と入れる場合の最大価値を計算する
no = knapsack_dfs_mem(wgt, val, mem, i - 1, c)
yes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1]
# 2 つの選択肢のうち大きい値を記録して返す
# 2 つの案のうち価値が大きい方を記録して返す
mem[i][c] = max(no, yes)
return mem[i][c]
def knapsack_dp(wgt: list[int], val: list[int], cap: int) -> int:
"""0-1 ナップサック：動的プログラミング"""
"""0-1 ナップサック：動的計画法"""
n = len(wgt)
# dp テーブルを初期化
dp = [[0] * (cap + 1) for _ in range(n + 1)]
@@ -50,52 +50,52 @@ def knapsack_dp(wgt: list[int], val: list[int], cap: int) -> int:
for i in range(1, n + 1):
for c in range(1, cap + 1):
if wgt[i - 1] > c:
# ナップサック容量を超える場合、アイテム i を選択しない
# ナップサック容量を超えるなら品物 i は選ばない
dp[i][c] = dp[i - 1][c]
else:
# アイテム i を選択しないのと選択するのとで大きい値
# 品物 i を選ばない場合と選ぶ場合の大きい方
dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1])
return dp[n][cap]
def knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -> int:
"""0-1 ナップサック：空間最適化動的プログラミング"""
"""0-1 ナップサック：空間最適化後の動的計画法"""
n = len(wgt)
# dp テーブルを初期化
dp = [0] * (cap + 1)
# 状態遷移
for i in range(1, n + 1):
# 逆順で走査
# 逆順に走査する
for c in range(cap, 0, -1):
if wgt[i - 1] > c:
# ナップサック容量を超える場合、アイテム i を選択しない
# ナップサック容量を超えるなら品物 i は選ばない
dp[c] = dp[c]
else:
# アイテム i を選択しないのと選択するのとで大きい値
# 品物 i を選ばない場合と選ぶ場合の大きい方
dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])
return dp[cap]
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
wgt = [10, 20, 30, 40, 50]
val = [50, 120, 150, 210, 240]
cap = 50
n = len(wgt)
# ブルートフォース探索
# 全探索
res = knapsack_dfs(wgt, val, n, cap)
print(f"ナップサック容量を超えないアイテムの最大値は {res}")
print(f"ナップサック容量を超えない最大価値は {res}")
# 記憶化探索
# メモ化探索
mem = [[-1] * (cap + 1) for _ in range(n + 1)]
res = knapsack_dfs_mem(wgt, val, mem, n, cap)
print(f"ナップサック容量を超えないアイテムの最大値は {res}")
print(f"ナップサック容量を超えない最大価値は {res}")
# 動的プログラミング
# 動的計画法
res = knapsack_dp(wgt, val, cap)
print(f"ナップサック容量を超えないアイテムの最大値は {res}")
print(f"ナップサック容量を超えない最大価値は {res}")
# 空間最適化動的プログラミング
# 空間最適化後の動的計画法
res = knapsack_dp_comp(wgt, val, cap)
print(f"ナップサック容量を超えないアイテムの最大値は {res}")
print(f"ナップサック容量を超えない最大価値は {res}")

18
ja/codes/python/chapter_dynamic_programming/min_cost_climbing_stairs_dp.py
View File

@@ -6,22 +6,22 @@ Author: krahets (krahets@163.com)
def min_cost_climbing_stairs_dp(cost: list[int]) -> int:
"""最小コスト階段登り：動的プログラミング"""
"""階段登りの最小コスト：動的計画法"""
n = len(cost) - 1
if n == 1 or n == 2:
return cost[n]
# dp テーブルを初期化、部分問題の解を格納するために使用
# 部分問題の解を保存するために dp テーブルを初期化
dp = [0] * (n + 1)
# 初期状態：最小の部分問題の解を事前設定
# 初期状態：最小部分問題の解をあらかじめ設定
dp[1], dp[2] = cost[1], cost[2]
# 状態遷移：小さい部分問題から大きい部分問題を段階的に解く
# 状態遷移：小さい部分問題から大きい部分問題へ順に解く
for i in range(3, n + 1):
dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]
return dp[n]
def min_cost_climbing_stairs_dp_comp(cost: list[int]) -> int:
"""最小コスト階段登り：空間最適化動的プログラミング"""
"""階段昇りの最小コスト：空間最適化後の動的計画法"""
n = len(cost) - 1
if n == 1 or n == 2:
return cost[n]
@@ -31,13 +31,13 @@ def min_cost_climbing_stairs_dp_comp(cost: list[int]) -> int:
return b
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
cost = [0, 1, 10, 1, 1, 1, 10, 1, 1, 10, 1]
print(f"階段コストリストの入力：{cost}")
print(f"入力された階段コストのリストは {cost}")
res = min_cost_climbing_stairs_dp(cost)
print(f"階段を登る最小コスト {res}")
print(f"階段を上り切る最小コストは {res}")
res = min_cost_climbing_stairs_dp_comp(cost)
print(f"階段を登る最小コスト {res}")
print(f"階段を上り切る最小コストは {res}")

54
ja/codes/python/chapter_dynamic_programming/min_path_sum.py
View File

@@ -8,54 +8,54 @@ from math import inf
def min_path_sum_dfs(grid: list[list[int]], i: int, j: int) -> int:
"""最小パス和：ブルートフォース探索"""
# 左上のセルの場合、探索を終了
"""最小経路和：全探索"""
# 左上のセルなら探索を終了する
if i == 0 and j == 0:
return grid[0][0]
# 行または列のインデックスが範囲外の場合、+∞ コストを返す
# 行または列のインデックスが範囲外なら、コスト +∞ を返す
if i < 0 or j < 0:
return inf
# 左上から (i-1, j) と (i, j-1) への最小パスコストを計算
# 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する
up = min_path_sum_dfs(grid, i - 1, j)
left = min_path_sum_dfs(grid, i, j - 1)
# 左上から (i, j) への最小パスコストを返す
# 左上隅から (i, j) までの最小経路コストを返す
return min(left, up) + grid[i][j]
def min_path_sum_dfs_mem(
grid: list[list[int]], mem: list[list[int]], i: int, j: int
) -> int:
"""最小パス和：記憶化探索"""
# 左上のセルの場合、探索を終了
"""最小経路和：メモ化探索"""
# 左上のセルなら探索を終了する
if i == 0 and j == 0:
return grid[0][0]
# 行または列のインデックスが範囲外の場合、+∞ コストを返す
# 行または列のインデックスが範囲外なら、コスト +∞ を返す
if i < 0 or j < 0:
return inf
# 記録がある場合、それを返す
# 既に記録があればそのまま返す
if mem[i][j] != -1:
return mem[i][j]
# 左と上のセルからの最小パスコスト
# 左と上のセルからの最小経路コスト
up = min_path_sum_dfs_mem(grid, mem, i - 1, j)
left = min_path_sum_dfs_mem(grid, mem, i, j - 1)
# 左上から (i, j) への最小パスコストを記録して返す
# 左上から (i, j) までの最小経路コストを記録して返す
mem[i][j] = min(left, up) + grid[i][j]
return mem[i][j]
def min_path_sum_dp(grid: list[list[int]]) -> int:
"""最小パス和：動的プログラミング"""
"""最小経路和：動的計画法"""
n, m = len(grid), len(grid[0])
# dp テーブルを初期化
dp = [[0] * m for _ in range(n)]
dp[0][0] = grid[0][0]
# 状態遷移：最初の行
# 状態遷移：先頭行
for j in range(1, m):
dp[0][j] = dp[0][j - 1] + grid[0][j]
# 状態遷移：最初の列
# 状態遷移：先頭列
for i in range(1, n):
dp[i][0] = dp[i - 1][0] + grid[i][0]
# 状態遷移：残りの行と列
# 状態遷移: 残りの行と列
for i in range(1, n):
for j in range(1, m):
dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]
@@ -63,17 +63,17 @@ def min_path_sum_dp(grid: list[list[int]]) -> int:
def min_path_sum_dp_comp(grid: list[list[int]]) -> int:
"""最小パス和：空間最適化動的プログラミング"""
"""最小経路和：空間最適化後の動的計画法"""
n, m = len(grid), len(grid[0])
# dp テーブルを初期化
dp = [0] * m
# 状態遷移：最初の行
# 状態遷移：先頭行
dp[0] = grid[0][0]
for j in range(1, m):
dp[j] = dp[j - 1] + grid[0][j]
# 状態遷移：残りの行
for i in range(1, n):
# 状態遷移：最初の列
# 状態遷移：先頭列
dp[0] = dp[0] + grid[i][0]
# 状態遷移：残りの列
for j in range(1, m):
@@ -81,24 +81,24 @@ def min_path_sum_dp_comp(grid: list[list[int]]) -> int:
return dp[m - 1]
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
grid = [[1, 3, 1, 5], [2, 2, 4, 2], [5, 3, 2, 1], [4, 3, 5, 2]]
n, m = len(grid), len(grid[0])
# ブルートフォース探索
# 全探索
res = min_path_sum_dfs(grid, n - 1, m - 1)
print(f"左上から右下角への最小パス和は {res}")
print(f"左上から右下までの最小経路和は {res}")
# 記憶化探索
# メモ化探索
mem = [[-1] * m for _ in range(n)]
res = min_path_sum_dfs_mem(grid, mem, n - 1, m - 1)
print(f"左上から右下角への最小パス和は {res}")
print(f"左上から右下までの最小経路和は {res}")
# 動的プログラミング
# 動的計画法
res = min_path_sum_dp(grid)
print(f"左上から右下角への最小パス和は {res}")
print(f"左上から右下までの最小経路和は {res}")
# 空間最適化動的プログラミング
# 空間最適化後の動的計画法
res = min_path_sum_dp_comp(grid)
print(f"左上から右下角への最小パス和は {res}")
print(f"左上から右下までの最小経路和は {res}")

24
ja/codes/python/chapter_dynamic_programming/unbounded_knapsack.py
View File

@@ -6,7 +6,7 @@ Author: krahets (krahets@163.com)
def unbounded_knapsack_dp(wgt: list[int], val: list[int], cap: int) -> int:
"""完全ナップサック：動的プログラミング"""
"""完全ナップサック問題：動的計画法"""
n = len(wgt)
# dp テーブルを初期化
dp = [[0] * (cap + 1) for _ in range(n + 1)]
@@ -14,42 +14,42 @@ def unbounded_knapsack_dp(wgt: list[int], val: list[int], cap: int) -> int:
for i in range(1, n + 1):
for c in range(1, cap + 1):
if wgt[i - 1] > c:
# ナップサック容量を超える場合、アイテム i を選択しない
# ナップサック容量を超えるなら品物 i は選ばない
dp[i][c] = dp[i - 1][c]
else:
# アイテム i を選択しないのと選択するのとで大きい値
# 品物 i を選ばない場合と選ぶ場合の大きい方
dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1])
return dp[n][cap]
def unbounded_knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -> int:
"""完全ナップサック：空間最適化動的プログラミング"""
"""完全ナップサック問題：空間最適化後の動的計画法"""
n = len(wgt)
# dp テーブルを初期化
dp = [0] * (cap + 1)
# 状態遷移
for i in range(1, n + 1):
# 順序で走査
# 順方向に走査する
for c in range(1, cap + 1):
if wgt[i - 1] > c:
# ナップサック容量を超える場合、アイテム i を選択しない
# ナップサック容量を超えるなら品物 i は選ばない
dp[c] = dp[c]
else:
# アイテム i を選択しないのと選択するのとで大きい値
# 品物 i を選ばない場合と選ぶ場合の大きい方
dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])
return dp[cap]
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
wgt = [1, 2, 3]
val = [5, 11, 15]
cap = 4
# 動的プログラミング
# 動的計画法
res = unbounded_knapsack_dp(wgt, val, cap)
print(f"ナップサック容量を超えないアイテムの最大値は {res}")
print(f"ナップサック容量を超えない最大価値は {res}")
# 空間最適化動的プログラミング
# 空間最適化後の動的計画法
res = unbounded_knapsack_dp_comp(wgt, val, cap)
print(f"ナップサック容量を超えないアイテムの最大値は {res}")
print(f"ナップサック容量を超えない最大価値は {res}")

32
ja/codes/python/chapter_graph/graph_adjacency_list.py
View File

@@ -16,7 +16,7 @@ class GraphAdjList:
def __init__(self, edges: list[list[Vertex]]):
"""コンストラクタ"""
# 隣接リスト、キー: 頂点、値: その頂点の隣接する全頂点
# 隣接リスト。key は頂点、value はその頂点に隣接する全頂点
self.adj_list = dict[Vertex, list[Vertex]]()
# すべての頂点と辺を追加
for edge in edges:
@@ -48,16 +48,16 @@ class GraphAdjList:
"""頂点を追加"""
if vet in self.adj_list:
return
# 隣接リストに新しい連結リストを追加
# 隣接リストに新しいリストを追加
self.adj_list[vet] = []
def remove_vertex(self, vet: Vertex):
"""頂点を削除"""
if vet not in self.adj_list:
raise ValueError()
# 隣接リストから頂点vetに対応する連結リストを削除
# 隣接リストから頂点 vet に対応するリストを削除
self.adj_list.pop(vet)
# 他の頂点の連結リストを走査し、vetを含むすべての辺を削除
# 他の頂点のリストを走査し、vet を含むすべての辺を削除
for vertex in self.adj_list:
if vet in self.adj_list[vertex]:
self.adj_list[vertex].remove(vet)
@@ -70,7 +70,7 @@ class GraphAdjList:
print(f"{vertex.val}: {tmp},")
"""ドライバコード"""
"""Driver Code"""
if __name__ == "__main__":
# 無向グラフを初期化
v = vals_to_vets([1, 3, 2, 5, 4])
@@ -86,26 +86,26 @@ if __name__ == "__main__":
print("\n初期化後、グラフは")
graph.print()
# 辺を追加
# 頂点1、2 つまり v[0], v[2]
# 辺を追加する
# 頂点 1, 2 は `v[0]`, `v[2]`
graph.add_edge(v[0], v[2])
print("\n辺1-2を追加後、グラフは")
print("\n辺 1-2 を追加した後、グラフは")
graph.print()
# 辺を削除
# 頂点1、3 つまり v[0], v[1]
# 辺を削除する
# 頂点 1, 3 はそれぞれ v[0], v[1]
graph.remove_edge(v[0], v[1])
print("\n辺1-3を削除後、グラフは")
print("\n辺 1-3 を削除した後、グラフは")
graph.print()
# 頂点を追加
v5 = Vertex(6)
graph.add_vertex(v5)
print("\n頂点6を追加後、グラフは")
print("\n頂点 6 を追加した後、グラフは")
graph.print()
# 頂点を削除
# 頂点3 つまり v[1]
# 頂点を削除する
# 頂点 3 は v[1]
graph.remove_vertex(v[1])
print("\n頂点3を削除後、グラフは")
graph.print()
print("\n頂点 3 を削除した後、グラフは")
graph.print()

56
ja/codes/python/chapter_graph/graph_adjacency_matrix.py
View File

@@ -16,15 +16,15 @@ class GraphAdjMat:
def __init__(self, vertices: list[int], edges: list[list[int]]):
"""コンストラクタ"""
# 頂点リスト、要素は「頂点値」を表し、インデックスは「頂点インデックス」を表す
# 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す
self.vertices: list[int] = []
# 隣接行列、行と列のインデックスは「頂点インデックス」に対応
# 隣接行列。行・列のインデックスは「頂点インデックス」に対応
self.adj_mat: list[list[int]] = []
# 頂点を追加
for val in vertices:
self.add_vertex(val)
# 辺を追加
# edges要素は頂点インデックスを表す
# 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する
for e in edges:
self.add_edge(e[0], e[1])
@@ -35,12 +35,12 @@ class GraphAdjMat:
def add_vertex(self, val: int):
"""頂点を追加"""
n = self.size()
# 頂点リストに新しい頂点値を追加
# 頂点リストに新しい頂点の値を追加
self.vertices.append(val)
# 隣接行列に行を追加
# 隣接行列に 1 行追加
new_row = [0] * n
self.adj_mat.append(new_row)
# 隣接行列に列を追加
# 隣接行列に 1 列追加
for row in self.adj_mat:
row.append(0)
@@ -48,28 +48,28 @@ class GraphAdjMat:
"""頂点を削除"""
if index >= self.size():
raise IndexError()
# 頂点リストから`index`の頂点を削除
# 頂点リストから index の頂点を削除する
self.vertices.pop(index)
# 隣接行列から`index`の行を削除
# 隣接行列で index 行を削除する
self.adj_mat.pop(index)
# 隣接行列から`index`の列を削除
# 隣接行列で index 列を削除する
for row in self.adj_mat:
row.pop(index)
def add_edge(self, i: int, j: int):
"""辺を追加"""
# パラメータi、jは頂点要素のインデックスに対応
# インデックスの範囲外と等価性を処理
# パラメータ i, j は vertices の要素インデックスに対応する
# 範囲外と同値の場合の処理
if i < 0 or j < 0 or i >= self.size() or j >= self.size() or i == j:
raise IndexError()
# 無向グラフでは、隣接行列は主対角線について対称、すなわち (i, j) == (j, i) を満たす
# 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす
self.adj_mat[i][j] = 1
self.adj_mat[j][i] = 1
def remove_edge(self, i: int, j: int):
"""辺を削除"""
# パラメータi、jは頂点要素のインデックスに対応
# インデックスの範囲外と等価性を処理
# パラメータ i, j は vertices の要素インデックスに対応する
# 範囲外と同値の場合の処理
if i < 0 or j < 0 or i >= self.size() or j >= self.size() or i == j:
raise IndexError()
self.adj_mat[i][j] = 0
@@ -82,35 +82,35 @@ class GraphAdjMat:
print_matrix(self.adj_mat)
"""ドライバコード"""
"""Driver Code"""
if __name__ == "__main__":
# 無向グラフを初期化
# edges要素は頂点インデックスを表す
# 無向グラフを初期化する
# 注意: edges の要素は頂点インデックスであり、vertices の要素インデックスに対応する
vertices = [1, 3, 2, 5, 4]
edges = [[0, 1], [0, 3], [1, 2], [2, 3], [2, 4], [3, 4]]
graph = GraphAdjMat(vertices, edges)
print("\n初期化後、グラフは")
graph.print()
# 辺を追加
# 頂点1、2のインデックスはそれぞれ0、2
# 辺を追加する
# 頂点 1, 2 のインデックスはそれぞれ 0, 2
graph.add_edge(0, 2)
print("\n辺1-2を追加後、グラフは")
print("\n辺 1-2 を追加した後、グラフは")
graph.print()
# 辺を削除
# 頂点1、3のインデックスはそれぞれ0、1
# 辺を削除する
# 頂点 1, 3 のインデックスはそれぞれ 0, 1
graph.remove_edge(0, 1)
print("\n辺1-3を削除後、グラフは")
print("\n辺 1-3 を削除した後、グラフは")
graph.print()
# 頂点を追加
graph.add_vertex(6)
print("\n頂点6を追加後、グラフは")
print("\n頂点 6 を追加した後、グラフは")
graph.print()
# 頂点を削除
# 頂点3のインデックスは1
# 頂点を削除する
# 頂点 3 のインデックスは 1
graph.remove_vertex(1)
print("\n頂点3を削除後、グラフは")
graph.print()
print("\n頂点 3 を削除した後、グラフは")
graph.print()

34
ja/codes/python/chapter_graph/graph_bfs.py
View File

@@ -14,29 +14,29 @@ from graph_adjacency_list import GraphAdjList
def graph_bfs(graph: GraphAdjList, start_vet: Vertex) -> list[Vertex]:
"""幅優先走査"""
# 隣接リストを使用してグラフを表現し、指定された頂点のすべての隣接頂点を取得
# 頂点走査シーケンス
"""幅優先探索"""
# 指定した頂点の隣接頂点をすべて取得できるよう、隣接リストでグラフを表現する
# 頂点の走査順序
res = []
# ハッシュセット、訪問済み頂点を記録するために使用
# 訪問済み頂点を記録するためのハッシュ集合
visited = set[Vertex]([start_vet])
# BFSを実装するために使用されるキュー
# BFS の実装にキューを用いる
que = deque[Vertex]([start_vet])
# 頂点vetから開始し、すべての頂点が訪問されるまでループ
# 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す
while len(que) > 0:
vet = que.popleft() # キューの先頭の頂点をデキュー
res.append(vet) # 訪問済み頂点を記録
# その頂点のすべての隣接頂点を走査
vet = que.popleft() # 先頭の頂点をデキュー
res.append(vet) # 訪問した頂点を記録
# この頂点のすべての隣接頂点を走査
for adj_vet in graph.adj_list[vet]:
if adj_vet in visited:
continue # 既に訪問済みの頂点をスキップ
que.append(adj_vet) # 未訪問の頂点のみをエンキュー
visited.add(adj_vet) # 頂点を訪問済みとしてマーク
# 頂点走査シーケンスを返す
continue # 訪問済みの頂点をスキップ
que.append(adj_vet) # 未訪問の頂点のみをキューに追加
visited.add(adj_vet) # この頂点を訪問済みにする
# 頂点の走査順を返す
return res
"""ドライバコード"""
"""Driver Code"""
if __name__ == "__main__":
# 無向グラフを初期化
v = vals_to_vets([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
@@ -58,7 +58,7 @@ if __name__ == "__main__":
print("\n初期化後、グラフは")
graph.print()
# 幅優先走査
# 幅優先探索
res = graph_bfs(graph, v[0])
print("\n幅優先走査（BFS）の頂点シーケンスは")
print(vets_to_vals(res))
print("\n幅優先探索（BFS）の頂点順序は")
print(vets_to_vals(res))

26
ja/codes/python/chapter_graph/graph_dfs.py
View File

@@ -13,29 +13,29 @@ from graph_adjacency_list import GraphAdjList
def dfs(graph: GraphAdjList, visited: set[Vertex], res: list[Vertex], vet: Vertex):
"""深さ優先走査のヘルパー関数"""
res.append(vet) # 訪問済み頂点を記録
visited.add(vet) # 頂点を訪問済みとしてマーク
# その頂点のすべての隣接頂点を走査
"""深さ優先走査の補助関数"""
res.append(vet) # 訪問した頂点を記録
visited.add(vet) # この頂点を訪問済みにする
# この頂点のすべての隣接頂点を走査
for adjVet in graph.adj_list[vet]:
if adjVet in visited:
continue # 既に訪問済みの頂点をスキップ
continue # 訪問済みの頂点をスキップ
# 隣接頂点を再帰的に訪問
dfs(graph, visited, res, adjVet)
def graph_dfs(graph: GraphAdjList, start_vet: Vertex) -> list[Vertex]:
"""深さ優先走査"""
# 隣接リストを使用してグラフを表現し、指定された頂点のすべての隣接頂点を取得
# 頂点走査シーケンス
"""深さ優先探索"""
# 指定した頂点の隣接頂点をすべて取得できるよう、隣接リストでグラフを表現する
# 頂点の走査順序
res = []
# ハッシュセット、訪問済み頂点を記録するために使用
# 訪問済み頂点を記録するためのハッシュ集合
visited = set[Vertex]()
dfs(graph, visited, res, start_vet)
return res
"""ドライバコード"""
"""Driver Code"""
if __name__ == "__main__":
# 無向グラフを初期化
v = vals_to_vets([0, 1, 2, 3, 4, 5, 6])
@@ -51,7 +51,7 @@ if __name__ == "__main__":
print("\n初期化後、グラフは")
graph.print()
# 深さ優先走査
# 深さ優先探索
res = graph_dfs(graph, v[0])
print("\n深さ優先走査（DFS）の頂点シーケンスは")
print(vets_to_vals(res))
print("\n深さ優先探索（DFS）の頂点順序は")
print(vets_to_vals(res))

30
ja/codes/python/chapter_greedy/coin_change_greedy.py
View File

@@ -6,43 +6,43 @@ Author: krahets (krahets@163.com)
def coin_change_greedy(coins: list[int], amt: int) -> int:
"""硬貨交換：貪欲法"""
# coins リストがソートされていると仮定
"""コイン交換：貪欲法"""
# coins リストはソート済みと仮定する
i = len(coins) - 1
count = 0
# 残り金額がなくなるまで貪欲選択をループ
# 残額がなくなるまで貪欲選択を繰り返す
while amt > 0:
# 残り金額に最も近く、それより小さい硬貨を見つける
# 残額以下で最も近い硬貨を見つける
while i > 0 and coins[i] > amt:
i -= 1
# coins[i] を選択
# coins[i] を選択する
amt -= coins[i]
count += 1
# 実行可能な解が見つからない場合、-1 を返す
# 実行可能な解が見つからなければ -1 を返す
return count if amt == 0 else -1
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
# 貪欲法：大域最適解の発見を保証できる
# 貪欲法：大域最適解を保証できる
coins = [1, 5, 10, 20, 50, 100]
amt = 186
res = coin_change_greedy(coins, amt)
print(f"\ncoins = {coins}, amt = {amt}")
print(f"{amt} を構成するのに必要な硬貨の最小数は {res}")
print(f"{amt} を作るのに必要な最小の硬貨枚数は {res}")
# 貪欲法：大域最適解の発見を保証できない
# 貪欲法：大域最適解を保証できない
coins = [1, 20, 50]
amt = 60
res = coin_change_greedy(coins, amt)
print(f"\ncoins = {coins}, amt = {amt}")
print(f"{amt} を構成するのに必要な硬貨の最小数は {res}")
print(f"実際には必要な最小数は 3、つまり 20 + 20 + 20")
print(f"{amt} を作るのに必要な最小の硬貨枚数は {res}")
print(f"実際に必要な最小枚数は 3 ，つまり 20 + 20 + 20")
# 貪欲法：大域最適解の発見を保証できない
# 貪欲法：大域最適解を保証できない
coins = [1, 49, 50]
amt = 98
res = coin_change_greedy(coins, amt)
print(f"\ncoins = {coins}, amt = {amt}")
print(f"{amt} を構成するのに必要な硬貨の最小数は {res}")
print(f"実際には必要な最小数は 2、つまり 49 + 49")
print(f"{amt} を作るのに必要な最小の硬貨枚数は {res}")
print(f"実際に必要な最小枚数は 2 ，つまり 49 + 49")

24
ja/codes/python/chapter_greedy/fractional_knapsack.py
View File

@@ -6,41 +6,41 @@ Author: krahets (krahets@163.com)
class Item:
"""アイテム"""
"""品物"""
def __init__(self, w: int, v: int):
self.w = w # アイテムの重量
self.v = v # アイテムの価値
self.w = w # 品物の重さ
self.v = v # 品物の価値
def fractional_knapsack(wgt: list[int], val: list[int], cap: int) -> int:
"""分数ナップサック：貪欲法"""
# アイテムリストを作成、2 つの属性を含む：重量、価値
# 重さと価値の 2 属性を持つ品物リストを作成
items = [Item(w, v) for w, v in zip(wgt, val)]
# 単位価値 item.v / item.w で高い順にソート
# 単位価値 item.v / item.w の高い順にソートする
items.sort(key=lambda item: item.v / item.w, reverse=True)
# 貪欲選択をループ
# 貪欲選択を繰り返す
res = 0
for item in items:
if item.w <= cap:
# 残り容量が十分な場合、アイテム全体をナップサックに入れる
# 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる
res += item.v
cap -= item.w
else:
# 残り容量が不十分な場合、アイテムの一部をナップサックに入れる
# 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる
res += (item.v / item.w) * cap
# 残り容量がなくなったため、ループを中断
# 残り容量がないため、ループを抜ける
break
return res
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
wgt = [10, 20, 30, 40, 50]
val = [50, 120, 150, 210, 240]
cap = 50
n = len(wgt)
# 貪欲アルゴリズム
# 貪欲法
res = fractional_knapsack(wgt, val, cap)
print(f"ナップサック容量を超えないアイテムの最大値は {res}")
print(f"ナップサック容量を超えない最大価値は {res}")

16
ja/codes/python/chapter_greedy/max_capacity.py
View File

@@ -7,16 +7,16 @@ Author: krahets (krahets@163.com)
def max_capacity(ht: list[int]) -> int:
"""最大容量：貪欲法"""
# i、j を初期化、配列の両端で分割させる
# i, j を初期化し、それぞれ配列の両端に置く
i, j = 0, len(ht) - 1
# 初期最大容量は 0
# 初期の最大容量は 0
res = 0
# 2 つの板が出会うまで貪欲選択をループ
# 2 枚の板が出会うまで貪欲選択を繰り返す
while i < j:
# 最大容量を更新
# 最大容量を更新する
cap = min(ht[i], ht[j]) * (j - i)
res = max(res, cap)
# 短い板を内側に移動
# 短い方を内側へ動かす
if ht[i] < ht[j]:
i += 1
else:
@@ -24,10 +24,10 @@ def max_capacity(ht: list[int]) -> int:
return res
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
ht = [3, 8, 5, 2, 7, 7, 3, 4]
# 貪欲アルゴリズム
# 貪欲法
res = max_capacity(ht)
print(f"最大容量は {res}")
print(f"最大容量は {res}")

18
ja/codes/python/chapter_greedy/max_product_cutting.py
View File

@@ -8,26 +8,26 @@ import math
def max_product_cutting(n: int) -> int:
"""切断の最大積：貪欲法"""
# n <= 3 の場合、1 を切り出す必要がある
"""最大切断積：貪欲法"""
# n <= 3 のときは、必ず 1 を切り出す
if n <= 3:
return 1 * (n - 1)
# 貪欲的に 3 を切り出す、a は 3 の個数、b は余り
# 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする
a, b = n // 3, n % 3
if b == 1:
# 余りが 1 の場合、1 * 3 のペアを 2 * 2 に変換
# 余りが 1 のときは、1 * 3 を 2 * 2 に変える
return int(math.pow(3, a - 1)) * 2 * 2
if b == 2:
# 余りが 2 の場合、何もしない
# 余りが 2 のときは、そのままにする
return int(math.pow(3, a)) * 2
# 余りが 0 の場合、何もしない
# 余りが 0 のときは、そのままにする
return int(math.pow(3, a))
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
n = 58
# 貪欲アルゴリズム
# 貪欲法
res = max_product_cutting(n)
print(f"切断の最大積は {res}")
print(f"最大分割積は {res}")

48
ja/codes/python/chapter_hashing/array_hash_map.py
View File

@@ -6,7 +6,7 @@ Author: msk397 (machangxinq@gmail.com)
class Pair:
"""キー値ペア"""
"""キーと値の組"""
def __init__(self, key: int, val: str):
self.key = key
@@ -14,11 +14,11 @@ class Pair:
class ArrayHashMap:
"""配列実装に基づくハッシュテーブル"""
"""配列ベースのハッシュテーブル"""
def __init__(self):
"""コンストラクタ"""
# 100個のバケットを含む配列を初期化
# 100 個のバケットを含む配列を初期化
self.buckets: list[Pair | None] = [None] * 100
def hash_func(self, key: int) -> int:
@@ -26,8 +26,8 @@ class ArrayHashMap:
index = key % 100
return index
def get(self, key: int) -> str:
"""照会操作"""
def get(self, key: int) -> str | None:
"""検索操作"""
index: int = self.hash_func(key)
pair: Pair = self.buckets[index]
if pair is None:
@@ -35,7 +35,7 @@ class ArrayHashMap:
return pair.val
def put(self, key: int, val: str):
"""追加操作"""
"""追加と更新の操作"""
pair = Pair(key, val)
index: int = self.hash_func(key)
self.buckets[index] = pair
@@ -43,11 +43,11 @@ class ArrayHashMap:
def remove(self, key: int):
"""削除操作"""
index: int = self.hash_func(key)
# None に設定し、削除を表現
# None に設定し、削除を表す
self.buckets[index] = None
def entry_set(self) -> list[Pair]:
"""すべてのキー値ペアを取得"""
"""すべてのキーと値のペアを取得"""
result: list[Pair] = []
for pair in self.buckets:
if pair is not None:
@@ -83,35 +83,35 @@ if __name__ == "__main__":
hmap = ArrayHashMap()
# 追加操作
# キー値ペア (key, value) をハッシュテーブルに追加
hmap.put(12836, "Ha")
hmap.put(15937, "Luo")
hmap.put(16750, "Suan")
hmap.put(13276, "Fa")
hmap.put(10583, "Ya")
print("\n追加後、ハッシュテーブルは\nKey -> Value")
# ハッシュテーブルにキーと値の組 (key, value) を追加する
hmap.put(12836, "シャオハー")
hmap.put(15937, "シャオルオ")
hmap.put(16750, "シャオスワン")
hmap.put(13276, "シャオファー")
hmap.put(10583, "シャオヤー")
print("\n追加完了後、ハッシュテーブルは\nKey -> Value")
hmap.print()
# 照会操作
# ハッシュテーブルにキーを入力し、値を取得
# 検索操作
# ハッシュテーブルにキー key を入力し、値 value を取得する
name = hmap.get(15937)
print("\n学生ID 15937 を入力、名前 " + name + " が見つかりました")
print("\n学籍番号 15937 を入力すると、氏名は " + name)
# 削除操作
# ハッシュテーブルからキー値ペア (key, value) を削除
# ハッシュテーブルからキーと値の組 (key, value) を削除する
hmap.remove(10583)
print("\n10583 を削除後、ハッシュテーブルは\nKey -> Value")
print("\n10583 を削除した後、ハッシュテーブルは\nKey -> Value")
hmap.print()
# ハッシュテーブルを走査
print("\nキー値ペアを走査 Key->Value")
print("\nキーと値のペア Key->Value を走査")
for pair in hmap.entry_set():
print(pair.key, "->", pair.val)
print("\nキーを個別に走査 Key")
print("\nキー Key を個別に走査")
for key in hmap.key_set():
print(key)
print("\n値を個別に走査 Value")
print("\n値 Value を個別に走査")
for val in hmap.value_set():
print(val)
print(val)

6
ja/codes/python/chapter_hashing/built_in_hash.py
View File

@@ -24,14 +24,14 @@ if __name__ == "__main__":
hash_dec = hash(dec)
print(f"小数 {dec} のハッシュ値は {hash_dec}")
str = "Hello algorithm"
str = "Hello アルゴリズム"
hash_str = hash(str)
print(f"文字列 {str} のハッシュ値は {hash_str}")
tup = (12836, "Ha")
tup = (12836, "シャオハー")
hash_tup = hash(tup)
print(f"タプル {tup} のハッシュ値は {hash(hash_tup)}")
obj = ListNode(0)
hash_obj = hash(obj)
print(f"ノードオブジェクト {obj} のハッシュ値は {hash_obj}")
print(f"ノードオブジェクト {obj} のハッシュ値は {hash_obj}")

32
ja/codes/python/chapter_hashing/hash_map.py
View File

@@ -16,35 +16,35 @@ if __name__ == "__main__":
hmap = dict[int, str]()
# 追加操作
# キー値ペア (key, value) をハッシュテーブルに追加
hmap[12836] = "Ha"
hmap[15937] = "Luo"
hmap[16750] = "Suan"
hmap[13276] = "Fa"
hmap[10583] = "Ya"
print("\n追加後、ハッシュテーブルは\nKey -> Value")
# ハッシュテーブルにキーと値の組 (key, value) を追加する
hmap[12836] = "シャオハー"
hmap[15937] = "シャオルオ"
hmap[16750] = "シャオスワン"
hmap[13276] = "シャオファー"
hmap[10583] = "シャオヤー"
print("\n追加完了後、ハッシュテーブルは\nKey -> Value")
print_dict(hmap)
# 照会操作
# ハッシュテーブルにキーを入力し、値を取得
# 検索操作
# ハッシュテーブルにキー key を入力し、値 value を取得する
name: str = hmap[15937]
print("\n学生ID 15937 を入力、名前 " + name + " が見つかりました")
print("\n学籍番号 15937 を入力すると、氏名は " + name)
# 削除操作
# ハッシュテーブルからキー値ペア (key, value) を削除
# ハッシュテーブルからキーと値の組 (key, value) を削除する
hmap.pop(10583)
print("\n10583 を削除後、ハッシュテーブルは\nKey -> Value")
print("\n10583 を削除した後、ハッシュテーブルは\nKey -> Value")
print_dict(hmap)
# ハッシュテーブルを走査
print("\nキー値ペアを走査 Key->Value")
print("\nキーと値のペア Key->Value を走査")
for key, value in hmap.items():
print(key, "->", value)
print("\nキーを個別に走査 Key")
print("\nキー Key を個別に走査")
for key in hmap.keys():
print(key)
print("\n値を個別に走査 Value")
print("\n値 Value を個別に走査")
for val in hmap.values():
print(val)
print(val)

56
ja/codes/python/chapter_hashing/hash_map_chaining.py
View File

@@ -12,14 +12,14 @@ from chapter_hashing.array_hash_map import Pair
class HashMapChaining:
"""チェーンアドレス法ハッシュテーブル"""
"""チェイン法ハッシュテーブル"""
def __init__(self):
"""コンストラクタ"""
self.size = 0 # キー値ペアの数
self.capacity = 4 # ハッシュテーブルの容量
self.load_thres = 2.0 / 3.0 # 拡張をトリガーする負荷率の閾値
self.extend_ratio = 2 # 拡張の倍数
self.size = 0 # キーと値のペア数
self.capacity = 4 # ハッシュテーブル容量
self.load_thres = 2.0 / 3.0 # リサイズを発動する負荷率のしきい値
self.extend_ratio = 2 # 拡張倍率
self.buckets = [[] for _ in range(self.capacity)] # バケット配列
def hash_func(self, key: int) -> int:
@@ -31,29 +31,29 @@ class HashMapChaining:
return self.size / self.capacity
def get(self, key: int) -> str | None:
"""照会操作"""
"""検索操作"""
index = self.hash_func(key)
bucket = self.buckets[index]
# バケットを走査し、キーが見つかれば対応する val を返す
# バケットを走査し、key が見つかれば対応する val を返す
for pair in bucket:
if pair.key == key:
return pair.val
# キーが見つからない場合、None を返す
# key が見つからない場合は None を返す
return None
def put(self, key: int, val: str):
"""追加操作"""
# 負荷率が閾値を超えた場合、拡張を実行
# 負荷率がしきい値を超えたら、リサイズを実行
if self.load_factor() > self.load_thres:
self.extend()
index = self.hash_func(key)
bucket = self.buckets[index]
# バケットを走査し、指定されたキーに遭遇した場合、対応する val を更新して返す
# バケットを走査し、指定した key が見つかれば対応する val を更新して返す
for pair in bucket:
if pair.key == key:
pair.val = val
return
# キーが見つからない場合、キー値ペアを末尾に追加
# その key が存在しなければ、キーと値のペアを末尾に追加
pair = Pair(key, val)
bucket.append(pair)
self.size += 1
@@ -62,7 +62,7 @@ class HashMapChaining:
"""削除操作"""
index = self.hash_func(key)
bucket = self.buckets[index]
# バケットを走査し、その中からキー値ペアを削除
# バケットを走査してキーと値のペアを削除
for pair in bucket:
if pair.key == key:
bucket.remove(pair)
@@ -71,13 +71,13 @@ class HashMapChaining:
def extend(self):
"""ハッシュテーブルを拡張"""
# 元のハッシュテーブルを一時的に保存
# 元のハッシュテーブルを一時保存
buckets = self.buckets
# 拡張された新しいハッシュテーブルを初期化
# リサイズ後の新しいハッシュテーブルを初期化
self.capacity *= self.extend_ratio
self.buckets = [[] for _ in range(self.capacity)]
self.size = 0
# 元のハッシュテーブルから新しいハッシュテーブルにキー値ペアを移動
# キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す
for bucket in buckets:
for pair in bucket:
self.put(pair.key, pair.val)
@@ -97,22 +97,22 @@ if __name__ == "__main__":
hashmap = HashMapChaining()
# 追加操作
# キー値ペア (key, value) をハッシュテーブルに追加
hashmap.put(12836, "Ha")
hashmap.put(15937, "Luo")
hashmap.put(16750, "Suan")
hashmap.put(13276, "Fa")
hashmap.put(10583, "Ya")
print("\n追加後、ハッシュテーブルは\n[Key1 -> Value1, Key2 -> Value2, ...]")
# ハッシュテーブルにキーと値の組 (key, value) を追加する
hashmap.put(12836, "シャオハー")
hashmap.put(15937, "シャオルオ")
hashmap.put(16750, "シャオスワン")
hashmap.put(13276, "シャオファー")
hashmap.put(10583, "シャオヤー")
print("\n追加完了後、ハッシュテーブルは\n[Key1 -> Value1, Key2 -> Value2, ...]")
hashmap.print()
# 照会操作
# ハッシュテーブルにキーを入力し、値を取得
# 検索操作
# ハッシュテーブルにキー key を入力し、値 value を取得する
name = hashmap.get(13276)
print("\n学生ID 13276 を入力、名前 " + name + " が見つかりました")
print("\n学籍番号 13276 を入力すると、氏名は " + name)
# 削除操作
# ハッシュテーブルからキー値ペア (key, value) を削除
# ハッシュテーブルからキーと値の組 (key, value) を削除する
hashmap.remove(12836)
print("\n12836 を削除後、ハッシュテーブルは\n[Key1 -> Value1, Key2 -> Value2, ...]")
hashmap.print()
print("\n12836 を削除した後、ハッシュテーブルは\n[Key1 -> Value1, Key2 -> Value2, ...]")
hashmap.print()

80
ja/codes/python/chapter_hashing/hash_map_open_addressing.py
View File

@@ -16,12 +16,12 @@ class HashMapOpenAddressing:
def __init__(self):
"""コンストラクタ"""
self.size = 0 # キー値ペアの数
self.capacity = 4 # ハッシュテーブルの容量
self.load_thres = 2.0 / 3.0 # 拡張をトリガーする負荷率の閾値
self.extend_ratio = 2 # 拡張の倍数
self.size = 0 # キーと値のペア数
self.capacity = 4 # ハッシュテーブル容量
self.load_thres = 2.0 / 3.0 # リサイズを発動する負荷率のしきい値
self.extend_ratio = 2 # 拡張倍率
self.buckets: list[Pair | None] = [None] * self.capacity # バケット配列
self.TOMBSTONE = Pair(-1, "-1") # 削除マーク
self.TOMBSTONE = Pair(-1, "-1") # 削除済みマーク
def hash_func(self, key: int) -> int:
"""ハッシュ関数"""
@@ -32,70 +32,70 @@ class HashMapOpenAddressing:
return self.size / self.capacity
def find_bucket(self, key: int) -> int:
"""key に対応するバケットインデックスを検索"""
"""key に対応するバケットインデックスを探す"""
index = self.hash_func(key)
first_tombstone = -1
# 線形探査、空のバケットに遭遇したらブレーク
# 線形プロービングを行い、空バケットに達したら終了
while self.buckets[index] is not None:
# キーに遭遇した場合、対応するバケットインデックスを返す
# key が見つかったら、対応するバケットのインデックスを返す
if self.buckets[index].key == key:
# 削除マークが以前に遭遇していた場合、キー値ペアをそのインデックスに移動
# 以前に削除マークが見つかっていれば、そのインデックスへキーと値のペアを移動
if first_tombstone != -1:
self.buckets[first_tombstone] = self.buckets[index]
self.buckets[index] = self.TOMBSTONE
return first_tombstone # 移動されたバケットインデックスを返す
return index # バケットインデックスを返す
# 最初に遭遇した削除マークを記録
return first_tombstone # 移動後のバケットインデックスを返す
return index # バケットのインデックスを返す
# 最初に見つかった削除マークを記録
if first_tombstone == -1 and self.buckets[index] is self.TOMBSTONE:
first_tombstone = index
# バケットインデックスを計算、末尾を超えた場合は先頭に戻る
# バケットのインデックスを計算し、末尾を越えたら先頭に戻る
index = (index + 1) % self.capacity
# キーが存在しない場合、挿入ポイントのインデックスを返す
# key が存在しない場合は追加位置のインデックスを返す
return index if first_tombstone == -1 else first_tombstone
def get(self, key: int) -> str:
"""照会操作"""
# key に対応するバケットインデックスを検索
"""検索操作"""
# key に対応するバケットインデックスを探す
index = self.find_bucket(key)
# キー値ペアが見つかれば、対応する val を返す
# キーと値の組が見つかったら、対応する val を返す
if self.buckets[index] not in [None, self.TOMBSTONE]:
return self.buckets[index].val
# キー値ペアが存在しない場合、None を返す
# キーと値のペアが存在しない場合は `None` を返す
return None
def put(self, key: int, val: str):
"""追加操作"""
# 負荷率が閾値を超えた場合、拡張を実行
# 負荷率がしきい値を超えたら、リサイズを実行
if self.load_factor() > self.load_thres:
self.extend()
# key に対応するバケットインデックスを検索
# key に対応するバケットインデックスを探す
index = self.find_bucket(key)
# キー値ペアが見つかれば、val を上書きして返す
# キーと値の組が見つかったら、val を上書きして返す
if self.buckets[index] not in [None, self.TOMBSTONE]:
self.buckets[index].val = val
return
# キー値ペアが存在しない場合、キー値ペアを追加
# キーと値の組が存在しない場合は、その組を追加する
self.buckets[index] = Pair(key, val)
self.size += 1
def remove(self, key: int):
"""削除操作"""
# key に対応するバケットインデックスを検索
# key に対応するバケットインデックスを探す
index = self.find_bucket(key)
# キー値ペアが見つかれば、削除マークで覆う
# キーと値の組が見つかったら、削除マーカーで上書きする
if self.buckets[index] not in [None, self.TOMBSTONE]:
self.buckets[index] = self.TOMBSTONE
self.size -= 1
def extend(self):
"""ハッシュテーブルを拡張"""
# 元のハッシュテーブルを一時的に保存
# 元のハッシュテーブルを一時保存
buckets_tmp = self.buckets
# 拡張された新しいハッシュテーブルを初期化
# リサイズ後の新しいハッシュテーブルを初期化
self.capacity *= self.extend_ratio
self.buckets = [None] * self.capacity
self.size = 0
# 元のハッシュテーブルから新しいハッシュテーブルにキー値ペアを移動
# キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す
for pair in buckets_tmp:
if pair not in [None, self.TOMBSTONE]:
self.put(pair.key, pair.val)
@@ -117,22 +117,22 @@ if __name__ == "__main__":
hashmap = HashMapOpenAddressing()
# 追加操作
# キー値ペア (key, val) をハッシュテーブルに追加
hashmap.put(12836, "Ha")
hashmap.put(15937, "Luo")
hashmap.put(16750, "Suan")
hashmap.put(13276, "Fa")
hashmap.put(10583, "Ya")
print("\n追加後、ハッシュテーブルは\nKey -> Value")
# ハッシュテーブルにキーと値の組 (key, val) を追加する
hashmap.put(12836, "シャオハー")
hashmap.put(15937, "シャオルオ")
hashmap.put(16750, "シャオスワン")
hashmap.put(13276, "シャオファー")
hashmap.put(10583, "シャオヤー")
print("\n追加完了後、ハッシュテーブルは\nKey -> Value")
hashmap.print()
# 照会操作
# ハッシュテーブルにキーを入力し、値 val を取得
# 検索操作
# ハッシュテーブルにキー key を入力し、値 val を得る
name = hashmap.get(13276)
print("\n学生ID 13276 を入力、名前 " + name + " が見つかりました")
print("\n学籍番号 13276 を入力すると、氏名は " + name)
# 削除操作
# ハッシュテーブルからキー値ペア (key, val) を削除
# ハッシュテーブルからキーと値の組 (key, val) を削除する
hashmap.remove(16750)
print("\n16750 を削除後、ハッシュテーブルは\nKey -> Value")
hashmap.print()
print("\n16750 を削除した後、ハッシュテーブルは\nKey -> Value")
hashmap.print()

16
ja/codes/python/chapter_hashing/simple_hash.py
View File

@@ -6,7 +6,7 @@ Author: krahets (krahets@163.com)
def add_hash(key: str) -> int:
"""加法ハッシュ"""
"""加算ハッシュ"""
hash = 0
modulus = 1000000007
for c in key:
@@ -15,7 +15,7 @@ def add_hash(key: str) -> int:
def mul_hash(key: str) -> int:
"""乗法ハッシュ"""
"""乗算ハッシュ"""
hash = 0
modulus = 1000000007
for c in key:
@@ -24,7 +24,7 @@ def mul_hash(key: str) -> int:
def xor_hash(key: str) -> int:
"""XORハッシュ"""
"""XOR ハッシュ"""
hash = 0
modulus = 1000000007
for c in key:
@@ -43,16 +43,16 @@ def rot_hash(key: str) -> int:
"""Driver Code"""
if __name__ == "__main__":
key = "Hello algorithm"
key = "Hello アルゴリズム"
hash = add_hash(key)
print(f"加法ハッシュ値は {hash}")
print(f"加算ハッシュ値は {hash}")
hash = mul_hash(key)
print(f"乗法ハッシュ値は {hash}")
print(f"乗算ハッシュ値は {hash}")
hash = xor_hash(key)
print(f"XORハッシュ値は {hash}")
print(f"XOR ハッシュ値は {hash}")
hash = rot_hash(key)
print(f"回転ハッシュ値は {hash}")
print(f"回転ハッシュ値は {hash}")

38
ja/codes/python/chapter_heap/heap.py
View File

@@ -14,41 +14,41 @@ import heapq
def test_push(heap: list, val: int, flag: int = 1):
heapq.heappush(heap, flag * val) # ヒープに要素をプッシュ
print(f"\n要素 {val} をヒープにプッシュ後")
heapq.heappush(heap, flag * val) # 要素をヒープに追加
print(f"\n要素 {val} をヒープに追加した後")
print_heap([flag * val for val in heap])
def test_pop(heap: list, flag: int = 1):
val = flag * heapq.heappop(heap) # ヒープの先頭要素をポップ
print(f"\nヒープの先頭要素 {val} がヒープから出た後")
val = flag * heapq.heappop(heap) # ヒープ頂点の要素を取り出す
print(f"\nヒープ先頭要素 {val} を取り出した後")
print_heap([flag * val for val in heap])
"""ドライバコード"""
"""Driver Code"""
if __name__ == "__main__":
# 最小ヒープを初期化
min_heap, flag = [], 1
# 最大ヒープを初期化
max_heap, flag = [], -1
print("\n以下のテストケースは最大ヒープ用です")
# PythonのheapqモジュールはデフォルトでMinHeapを実装
# ヒープに入れる前に「要素を反転」することを考慮し、比較演算子を逆転させて最大ヒープを実装
# この例では、flag = 1は最小ヒープに対応し、flag = -1は最大ヒープに対応
print("\n以下のテストケースは最大ヒープ")
# Python の heapq モジュールはデフォルトで最小ヒープを実装している
# 要素を負にしてからヒープに入れると大小関係を反転でき、最大ヒープを実現できる
# この例では、flag = 1 が最小ヒープ、flag = -1 が最大ヒープに対応する
# ヒープに要素をプッシュ
# 要素をヒープに追加
test_push(max_heap, 1, flag)
test_push(max_heap, 3, flag)
test_push(max_heap, 2, flag)
test_push(max_heap, 5, flag)
test_push(max_heap, 4, flag)
# ヒープの先頭要素にアクセス
# ヒープ頂点の要素を取得
peek: int = flag * max_heap[0]
print(f"\nヒープの先頭要素は {peek}")
print(f"\nヒープ先頭要素は {peek}")
# ヒープの先頭要素をポップ
# ヒープ頂点の要素を取り出す
test_pop(max_heap, flag)
test_pop(max_heap, flag)
test_pop(max_heap, flag)
@@ -57,15 +57,15 @@ if __name__ == "__main__":
# ヒープのサイズを取得
size: int = len(max_heap)
print(f"\nヒープの要素数は {size}")
print(f"\nヒープ要素数は {size}")
# ヒープが空かどうかを判定
is_empty: bool = not max_heap
print(f"\nヒープは空ですか {is_empty}")
print(f"\nヒープが空かどうかは {is_empty}")
# リストを入力してヒープを構築
# 時間複雑度はO(n)、O(nlogn)ではない
# リストを入力してヒープを構築する
# 時間計算量は O(n) であり、O(nlogn) ではない
min_heap = [1, 3, 2, 5, 4]
heapq.heapify(min_heap)
print("\nリストを入力して最小ヒープを構築")
print_heap(min_heap)
print("\nリストを入力して最小ヒープを構築した後")
print_heap(min_heap)

68
ja/codes/python/chapter_heap/my_heap.py
View File

@@ -15,24 +15,24 @@ class MaxHeap:
"""最大ヒープ"""
def __init__(self, nums: list[int]):
"""コンストラクタ、入力リストに基づいてヒープを構築"""
# すべてのリスト要素をヒープに追加
"""コンストラクタ。入力リストに基づいてヒープを構築する"""
# リスト要素をそのままヒープに追加
self.max_heap = nums
# 葉以外のすべてのノードをヒープ化
# 葉ノード以外のすべてのノードをヒープ化
for i in range(self.parent(self.size() - 1), -1, -1):
self.sift_down(i)
def left(self, i: int) -> int:
"""左の子ノードのインデックスを取得"""
"""左子ノードのインデックスを取得"""
return 2 * i + 1
def right(self, i: int) -> int:
"""右の子ノードのインデックスを取得"""
"""右子ノードのインデックスを取得"""
return 2 * i + 2
def parent(self, i: int) -> int:
"""親ノードのインデックスを取得"""
return (i - 1) // 2 # 整数除算で切り下げ
return (i - 1) // 2 # 切り捨て除算
def swap(self, i: int, j: int):
"""要素を交換"""
@@ -47,91 +47,91 @@ class MaxHeap:
return self.size() == 0
def peek(self) -> int:
"""ヒープの先頭要素にアクセス"""
"""ヒープ先頭要素にアクセス"""
return self.max_heap[0]
def push(self, val: int):
"""ヒープに要素をプッシュ"""
"""要素をヒープに追加"""
# ノードを追加
self.max_heap.append(val)
# 下から上へヒープ化
self.sift_up(self.size() - 1)
def sift_up(self, i: int):
"""ノードiから開始して、下から上へヒープ化"""
"""ノード i から始めて、下から上へヒープ化"""
while True:
# ノードiの親ノードを取得
# ノード i の親ノードを取得
p = self.parent(i)
# 「ルートノードを越える」または「ノードが修復不要」の場合、ヒープ化を終了
# 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了
if p < 0 or self.max_heap[i] <= self.max_heap[p]:
break
# 2つのノードを交換
# 2 つのノードを交換
self.swap(i, p)
# 上向きのループヒープ化
# ループで下から上へヒープ化
i = p
def pop(self) -> int:
"""要素をヒープから出す"""
# 空の処理
"""要素をヒープから取り出す"""
# 空判定の処理
if self.is_empty():
raise IndexError("Heap is empty")
# ルートノードと最右端の葉ノードを交換（最初の要素と最後の要素を交換）
raise IndexError("ヒープが空です")
# 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）
self.swap(0, self.size() - 1)
# ノードを削除
val = self.max_heap.pop()
# 上から下へヒープ化
self.sift_down(0)
# ヒープの先頭要素を返す
# ヒープ先頭要素を返す
return val
def sift_down(self, i: int):
"""ノードiから開始して、上から下へヒープ化"""
"""ノード i から始めて、上から下へヒープ化"""
while True:
# i、l、rの中で最大のノードを決定し、maとする
# ノード i, l, r のうち値が最大のノードを ma とする
l, r, ma = self.left(i), self.right(i), i
if l < self.size() and self.max_heap[l] > self.max_heap[ma]:
ma = l
if r < self.size() and self.max_heap[r] > self.max_heap[ma]:
ma = r
# ノードiが最大またはインデックスl、rが範囲外の場合、さらなるヒープ化は不要、ブレーク
# ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける
if ma == i:
break
# 2つのノードを交換
# 2 つのノードを交換
self.swap(i, ma)
# 下向きのループヒープ化
# ループで上から下へヒープ化
i = ma
def print(self):
"""ヒープを出力（二分木）"""
"""ヒープ（二分木）を出力"""
print_heap(self.max_heap)
"""ドライバコード"""
"""Driver Code"""
if __name__ == "__main__":
# 最大ヒープを初期化
max_heap = MaxHeap([9, 8, 6, 6, 7, 5, 2, 1, 4, 3, 6, 2])
print("\nリストを入力してヒープを構築")
print("\nリストを入力してヒープを構築した後")
max_heap.print()
# ヒープの先頭要素にアクセス
# ヒープ頂点の要素を取得
peek = max_heap.peek()
print(f"\nヒープの先頭要素は {peek}")
print(f"\nヒープ先頭要素は {peek}")
# ヒープに要素をプッシュ
# 要素をヒープに追加
val = 7
max_heap.push(val)
print(f"\n要素 {val} をヒープにプッシュ後")
print(f"\n要素 {val} をヒープに追加した後")
max_heap.print()
# ヒープの先頭要素をポップ
# ヒープ頂点の要素を取り出す
peek = max_heap.pop()
print(f"\nヒープの先頭要素 {peek} がヒープから出た後")
print(f"\nヒープ先頭要素 {peek} を取り出した後")
max_heap.print()
# ヒープのサイズを取得
size = max_heap.size()
print(f"\nヒープの要素数は {size}")
print(f"\nヒープ要素数は {size}")
# ヒープが空かどうかを判定
is_empty = max_heap.is_empty()
print(f"\nヒープは空ですか {is_empty}")
print(f"\nヒープが空かどうかは {is_empty}")

12
ja/codes/python/chapter_heap/top_k.py
View File

@@ -14,26 +14,26 @@ import heapq
def top_k_heap(nums: list[int], k: int) -> list[int]:
"""ヒープを使用して配列内の最大k個の要素を見つける"""
"""ヒープに基づいて配列中の最大の k 個の要素を探す"""
# 最小ヒープを初期化
heap = []
# 配列の最初のk個の要素をヒープに入力
# 配列の先頭 k 個の要素をヒープに追加
for i in range(k):
heapq.heappush(heap, nums[i])
# k+1番目の要素から、ヒープの長さをkに保つ
# k+1 番目の要素から開始し、ヒープ長を k に保つ
for i in range(k, len(nums)):
# 現在の要素がヒープの先頭要素より大きい場合、ヒープの先頭要素を削除し、現在の要素をヒープに入力
# 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する
if nums[i] > heap[0]:
heapq.heappop(heap)
heapq.heappush(heap, nums[i])
return heap
"""ドライバコード"""
"""Driver Code"""
if __name__ == "__main__":
nums = [1, 7, 6, 3, 2]
k = 3
res = top_k_heap(nums, k)
print(f"最大の {k} 個の要素は")
print_heap(res)
print_heap(res)

40
ja/codes/python/chapter_searching/binary_search.py
View File

@@ -6,47 +6,47 @@ Author: timi (xisunyy@163.com)
def binary_search(nums: list[int], target: int) -> int:
"""二分探索（両端閉区間）"""
# 両端閉区間 [0, n-1] を初期化、すなわち i, j はそれぞれ配列の最初の要素と最後の要素を指す
"""二分探索（両閉区間）"""
# 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す
i, j = 0, len(nums) - 1
# 検索区間が空になるまでループ（i > j のとき空）
# ループし、探索区間が空になったら終了する（i > j で空）
while i <= j:
# 理論的には、Pythonの数値は無限に大きくなることができる（メモリサイズに依存）ため、大きな数のオーバーフローを考慮する必要はない
m = i + (j - i) // 2 # 中点インデックス m を計算
# 理論上、Python の数値は無限に大きくできるため（メモリ容量に依存）、大きな数のオーバーフローを考慮する必要はない
m = (i + j) // 2 # 中点インデックス m を計算
if nums[m] < target:
i = m + 1 # この場合、target は区間 [m+1, j] にあることを示す
i = m + 1 # この場合、target は区間 [m+1, j] にある
elif nums[m] > target:
j = m - 1 # この場合、target は区間 [i, m-1] にあることを示す
j = m - 1 # この場合、target は区間 [i, m-1] にある
else:
return m # ターゲット要素が見つかったため、そのインデックスを返す
return -1 # ターゲット要素が見つからなかったため、-1 を返す
return m # 目標要素が見つかったらそのインデックスを返す
return -1 # 目標要素が見つからなければ -1 を返す
def binary_search_lcro(nums: list[int], target: int) -> int:
"""二分探索（左閉右開区間）"""
# 左閉右開区間 [0, n) を初期化、すなわち i, j はそれぞれ配列の最初の要素と最後の要素+1を指す
# 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す
i, j = 0, len(nums)
# 検索区間が空になるまでループ（i = j のとき空）
# ループし、探索区間が空になったら終了する（i = j で空）
while i < j:
m = i + (j - i) // 2 # 中点インデックス m を計算
m = (i + j) // 2 # 中点インデックス m を計算
if nums[m] < target:
i = m + 1 # この場合、target は区間 [m+1, j) にあることを示す
i = m + 1 # この場合、target は区間 [m+1, j) にある
elif nums[m] > target:
j = m # この場合、target は区間 [i, m) にあることを示す
j = m # この場合、target は区間 [i, m) にある
else:
return m # ターゲット要素が見つかったため、そのインデックスを返す
return -1 # ターゲット要素が見つからなかったため、-1 を返す
return m # 目標要素が見つかったらそのインデックスを返す
return -1 # 目標要素が見つからなければ -1 を返す
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
target = 6
nums = [1, 3, 6, 8, 12, 15, 23, 26, 31, 35]
# 二分探索（両端閉区間）
# 二分探索（両閉区間）
index = binary_search(nums, target)
print("ターゲット要素 6 のインデックス =", index)
print("対象要素 6 のインデックス = ", index)
# 二分探索（左閉右開区間）
index = binary_search_lcro(nums, target)
print("ターゲット要素 6 のインデックス =", index)
print("対象要素 6 のインデックス = ", index)

28
ja/codes/python/chapter_searching/binary_search_edge.py
View File

@@ -12,38 +12,38 @@ from binary_search_insertion import binary_search_insertion
def binary_search_left_edge(nums: list[int], target: int) -> int:
"""最左端のターゲットの二分探索"""
# ターゲットの挿入位置を見つけることと同等
"""最も左の target を二分探索"""
# target の挿入位置を探すのと等価
i = binary_search_insertion(nums, target)
# ターゲットが見つからなかった場合、-1 を返す
# target が見つからなければ、-1 を返す
if i == len(nums) or nums[i] != target:
return -1
# ターゲットが見つかった場合、インデックス i を返す
# target が見つかったら、インデックス i を返す
return i
def binary_search_right_edge(nums: list[int], target: int) -> int:
"""最右端のターゲットの二分探索"""
# 最左端のターゲット + 1 を見つけることに変換
"""最も右の target を二分探索"""
# 最左の target + 1 を探す問題に変換する
i = binary_search_insertion(nums, target + 1)
# j は最右端のターゲットを指し、i はターゲットより大きい最初の要素を指す
# j は最も右の target を指し、i は target より大きい最初の要素を指す
j = i - 1
# ターゲットが見つからなかった場合、-1 を返す
# target が見つからなければ、-1 を返す
if j == -1 or nums[j] != target:
return -1
# ターゲットが見つかった場合、インデックス j を返す
# target が見つかったら、インデックス j を返す
return j
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
# 重複要素のある配列
# 重複要素を含む配列
nums = [1, 3, 6, 6, 6, 6, 6, 10, 12, 15]
print(f"\n配列 nums = {nums}")
# 左端と右端の境界の二分探索
# 二分探索で左端と右端を探す
for target in [6, 7]:
index = binary_search_left_edge(nums, target)
print(f"最左端の要素 {target} のインデックスは {index}")
print(f"左端の要素 {target} のインデックスは {index}")
index = binary_search_right_edge(nums, target)
print(f"最右端の要素 {target} のインデックスは {index}")
print(f"右端の要素 {target} のインデックスは {index}")

38
ja/codes/python/chapter_searching/binary_search_insertion.py
View File

@@ -6,49 +6,49 @@ Author: krahets (krahets@163.com)
def binary_search_insertion_simple(nums: list[int], target: int) -> int:
"""挿入位置の二分探索（重複要素なし）"""
i, j = 0, len(nums) - 1 # 両端閉区間 [0, n-1] を初期化
"""二分探索で挿入位置を探す（重複要素なし）"""
i, j = 0, len(nums) - 1 # 両閉区間 [0, n-1] を初期化
while i <= j:
m = i + (j - i) // 2 # 中点インデックス m を計算
m = (i + j) // 2 # 中点インデックス m を計算
if nums[m] < target:
i = m + 1 # ターゲットは区間 [m+1, j] にある
i = m + 1 # target は区間 [m+1, j] にある
elif nums[m] > target:
j = m - 1 # ターゲットは区間 [i, m-1] にある
j = m - 1 # target は区間 [i, m-1] にある
else:
return m # ターゲットが見つかった場合、挿入位置 m を返す
# ターゲットが見つからなかった場合、挿入位置 i を返す
return m # target が見つかったら、挿入位置 m を返す
# target が見つからなければ、挿入位置 i を返す
return i
def binary_search_insertion(nums: list[int], target: int) -> int:
"""挿入位置の二分探索（重複要素あり）"""
i, j = 0, len(nums) - 1 # 両端閉区間 [0, n-1] を初期化
"""二分探索で挿入位置を探す（重複要素あり）"""
i, j = 0, len(nums) - 1 # 両閉区間 [0, n-1] を初期化
while i <= j:
m = i + (j - i) // 2 # 中点インデックス m を計算
m = (i + j) // 2 # 中点インデックス m を計算
if nums[m] < target:
i = m + 1 # ターゲットは区間 [m+1, j] にある
i = m + 1 # target は区間 [m+1, j] にある
elif nums[m] > target:
j = m - 1 # ターゲットは区間 [i, m-1] にある
j = m - 1 # target は区間 [i, m-1] にある
else:
j = m - 1 # ターゲット未満の最初の要素は区間 [i, m-1] にある
j = m - 1 # target より小さい最初の要素は区間 [i, m-1] にある
# 挿入位置 i を返す
return i
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
# 重複要素のない配列
nums = [1, 3, 6, 8, 12, 15, 23, 26, 31, 35]
print(f"\n配列 nums = {nums}")
# 挿入位置の二分探索
# 二分探索で挿入位置を探す
for target in [6, 9]:
index = binary_search_insertion_simple(nums, target)
print(f"要素 {target} の挿入位置インデックスは {index}")
print(f"要素 {target} の挿入位置のインデックスは {index}")
# 重複要素のある配列
# 重複要素を含む配列
nums = [1, 3, 6, 6, 6, 6, 6, 10, 12, 15]
print(f"\n配列 nums = {nums}")
# 挿入位置の二分探索
# 二分探索で挿入位置を探す
for target in [2, 6, 20]:
index = binary_search_insertion(nums, target)
print(f"要素 {target} の挿入位置インデックスは {index}")
print(f"要素 {target} の挿入位置のインデックスは {index}")

18
ja/codes/python/chapter_searching/hashing_search.py
View File

@@ -13,8 +13,8 @@ from modules import ListNode, list_to_linked_list
def hashing_search_array(hmap: dict[int, int], target: int) -> int:
"""ハッシュ探索（配列）"""
# ハッシュテーブルのキー：ターゲット要素、値：インデックス
# ハッシュテーブルがこのキーを含まない場合、-1 を返す
# ハッシュテーブルの key: 目標要素、value: インデックス
# ハッシュテーブルにこの key がなければ -1 を返す
return hmap.get(target, -1)
@@ -22,12 +22,12 @@ def hashing_search_linkedlist(
hmap: dict[int, ListNode], target: int
) -> ListNode | None:
"""ハッシュ探索（連結リスト）"""
# ハッシュテーブルのキー：ターゲット要素、値：ノードオブジェクト
# ハッシュテーブルがこのキーを含まない場合、None を返す
# ハッシュテーブルの key: 対象要素、value: ノードオブジェクト
# ハッシュテーブルにこの key がなければ None を返す
return hmap.get(target, None)
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
target = 3
@@ -36,16 +36,16 @@ if __name__ == "__main__":
# ハッシュテーブルを初期化
map0 = dict[int, int]()
for i in range(len(nums)):
map0[nums[i]] = i # キー：要素、値：インデックス
map0[nums[i]] = i # key: 要素、value: インデックス
index: int = hashing_search_array(map0, target)
print("ターゲット要素 3 のインデックス =", index)
print("対象要素 3 のインデックス =", index)
# ハッシュ探索（連結リスト）
head: ListNode = list_to_linked_list(nums)
# ハッシュテーブルを初期化
map1 = dict[int, ListNode]()
while head:
map1[head.val] = head # キー：ノード値、値：ノード
map1[head.val] = head # key: ノード値、value: ノード
head = head.next
node: ListNode = hashing_search_linkedlist(map1, target)
print("ターゲットノード値 3 に対応するノードオブジェクトは", node)
print("対象ノード値 3 に対応するノードオブジェクトは", node)

20
ja/codes/python/chapter_searching/linear_search.py
View File

@@ -15,31 +15,31 @@ def linear_search_array(nums: list[int], target: int) -> int:
"""線形探索（配列）"""
# 配列を走査
for i in range(len(nums)):
if nums[i] == target: # ターゲット要素が見つかったため、そのインデックスを返す
if nums[i] == target: # 目標要素が見つかったらそのインデックスを返す
return i
return -1 # ターゲット要素が見つからなかったため、-1 を返す
return -1 # 目標要素が見つからなければ -1 を返す
def linear_search_linkedlist(head: ListNode, target: int) -> ListNode | None:
"""線形探索（連結リスト）"""
# リストを走査
# 連結リストを走査
while head:
if head.val == target: # ターゲットノードが見つかったため、それを返す
if head.val == target: # 対象ノードが見つかったら、それを返す
return head
head = head.next
return None # ターゲットノードが見つからなかったため、None を返す
return None # 対象ノードが見つからない場合は None を返す
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
target = 3
# 配列での線形探索を実行
# 配列で線形探索を行う
nums = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8]
index: int = linear_search_array(nums, target)
print("ターゲット要素 3 のインデックス =", index)
print("対象要素 3 のインデックス =", index)
# 連結リストでの線形探索を実行
# 連結リストで線形探索を行う
head: ListNode = list_to_linked_list(nums)
node: ListNode | None = linear_search_linkedlist(head, target)
print("ターゲットノード値 3 に対応するノードオブジェクトは", node)
print("対象ノード値 3 に対応するノードオブジェクトは", node)

24
ja/codes/python/chapter_searching/two_sum.py
View File

@@ -6,8 +6,8 @@ Author: krahets (krahets@163.com)
def two_sum_brute_force(nums: list[int], target: int) -> list[int]:
"""方法一：ブルートフォース列挙"""
# 二重ループ、時間計算量は O(n^2)
"""方法 1：総当たり列挙"""
# 2重ループのため、時間計算量は O(n^2)
for i in range(len(nums) - 1):
for j in range(i + 1, len(nums)):
if nums[i] + nums[j] == target:
@@ -16,10 +16,10 @@ def two_sum_brute_force(nums: list[int], target: int) -> list[int]:
def two_sum_hash_table(nums: list[int], target: int) -> list[int]:
"""方法二：補助ハッシュテーブル"""
# 補助ハッシュテーブル、空間計算量は O(n)
"""方法 2：補助ハッシュテーブル"""
# 補助ハッシュテーブルを使用し、空間計算量は O(n)
dic = {}
# 単一ループ、時間計算量は O(n)
# 単一ループで、時間計算量は O(n)
for i in range(len(nums)):
if target - nums[i] in dic:
return [dic[target - nums[i]], i]
@@ -27,16 +27,16 @@ def two_sum_hash_table(nums: list[int], target: int) -> list[int]:
return []
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
# ======= テストケース =======
# ======= Test Case =======
nums = [2, 7, 11, 15]
target = 13
# ====== ドライバーコード ======
# 方法一
# ====== Driver Code ======
# 方法 1
res: list[int] = two_sum_brute_force(nums, target)
print("方法一の結果 =", res)
# 方法二
print("方法1 res =", res)
# 方法 2
res: list[int] = two_sum_hash_table(nums, target)
print("方法二の結果 =", res)
print("方法2 res =", res)

22
ja/codes/python/chapter_sorting/bubble_sort.py
View File

@@ -8,9 +8,9 @@ Author: timi (xisunyy@163.com)
def bubble_sort(nums: list[int]):
"""バブルソート"""
n = len(nums)
# 外側のループ：未ソート範囲は [0, i]
# 外側のループ：未ソート区間は [0, i]
for i in range(n - 1, 0, -1):
# 内側のループ：未ソート範囲 [0, i] の最大要素を範囲の右端に移動
# 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換
for j in range(i):
if nums[j] > nums[j + 1]:
# nums[j] と nums[j + 1] を交換
@@ -18,27 +18,27 @@ def bubble_sort(nums: list[int]):
def bubble_sort_with_flag(nums: list[int]):
"""バブルソート（フラグによる最適化）"""
"""バブルソート（フラグ最適化）"""
n = len(nums)
# 外側のループ：未ソート範囲は [0, i]
# 外側のループ：未ソート区間は [0, i]
for i in range(n - 1, 0, -1):
flag = False # フラグを初期化
# 内側のループ：未ソート範囲 [0, i] の最大要素を範囲の右端に移動
flag = False # フラグを初期化する
# 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換
for j in range(i):
if nums[j] > nums[j + 1]:
# nums[j] と nums[j + 1] を交換
nums[j], nums[j + 1] = nums[j + 1], nums[j]
flag = True # 要素を交換したことを記録
flag = True # 交換する要素を記録
if not flag:
break # この回の「バブリング」で要素が交換されなかった場合、終了
break # このバブル処理で要素交換が一度もなければそのまま終了
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
nums = [4, 1, 3, 1, 5, 2]
bubble_sort(nums)
print("バブルソート完了 nums =", nums)
print("バブルソート完了後 nums =", nums)
nums1 = [4, 1, 3, 1, 5, 2]
bubble_sort_with_flag(nums1)
print("バブルソート完了 nums =", nums1)
print("バブルソート完了後 nums =", nums1)

16
ja/codes/python/chapter_sorting/bucket_sort.py
View File

@@ -7,20 +7,20 @@ Author: krahets (krahets@163.com)
def bucket_sort(nums: list[float]):
"""バケットソート"""
# k = n/2 個のバケットを初期化、各バケットに平均2個の要素を配置することを期待
# k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする
k = len(nums) // 2
buckets = [[] for _ in range(k)]
# 1. 配列要素を各バケットに分散
# 1. 配列要素を各バケットに振り分ける
for num in nums:
# 入力データ範囲は [0, 1)、num * k を使用してインデックス範囲 [0, k-1] にマッピング
# 入力データの範囲は [0, 1) であり、num * k を用いてインデックス範囲 [0, k-1] に写像する
i = int(num * k)
# num をバケット i に追加
buckets[i].append(num)
# 2. 各バケットをソート
# 2. 各バケットをソートする
for bucket in buckets:
# 組み込みソート関数を使用、他のソートアルゴリズムに置き換えることも可能
# 組み込みのソート関数を使う。他のソートアルゴリズムに置き換えてもよい
bucket.sort()
# 3. バケットを走査して結果をマージ
# 3. バケットを走査して結果を結合
i = 0
for bucket in buckets:
for num in bucket:
@@ -29,7 +29,7 @@ def bucket_sort(nums: list[float]):
if __name__ == "__main__":
# 入力データが浮動小数点数、範囲 [0, 1) であると仮定
# 入力データは範囲 [0, 1) の浮動小数点数とする
nums = [0.49, 0.96, 0.82, 0.09, 0.57, 0.43, 0.91, 0.75, 0.15, 0.37]
bucket_sort(nums)
print("バケットソート完了 nums =", nums)
print("バケットソート完了後 nums =", nums)

34
ja/codes/python/chapter_sorting/counting_sort.py
View File

@@ -7,17 +7,15 @@ Author: krahets (krahets@163.com)
def counting_sort_naive(nums: list[int]):
"""計数ソート"""
# シンプルな実装、オブジェクトのソートには使用できない
# 1. 配列内の最大要素 m を統計
m = 0
for num in nums:
m = max(m, num)
# 2. 各数字の出現回数を統計
# 簡易版。オブジェクトのソートには使えない
# 1. 配列の最大要素 m を求める
m = max(nums)
# 2. 各数値の出現回数を数える
# counter[num] は num の出現回数を表す
counter = [0] * (m + 1)
for num in nums:
counter[num] += 1
# 3. counter を走査し、各要素を元の配列 nums に埋め戻し
# 3. counter を走査し、各要素を元の配列 nums に書き戻す
i = 0
for num in range(m + 1):
for _ in range(counter[num]):
@@ -27,38 +25,38 @@ def counting_sort_naive(nums: list[int]):
def counting_sort(nums: list[int]):
"""計数ソート"""
# 完全な実装、オブジェクトのソートが可能で、安定ソート
# 1. 配列内の最大要素 m を統計
# 完全版。オブジェクトをソートでき、かつ安定ソートである
# 1. 配列の最大要素 m を求める
m = max(nums)
# 2. 各数字の出現回数を統計
# 2. 各数値の出現回数を数える
# counter[num] は num の出現回数を表す
counter = [0] * (m + 1)
for num in nums:
counter[num] += 1
# 3. counter の前置和を計算し、「出現回数」を「末尾インデックス」に変換
# counter[num]-1 は res において num が最後に出現するインデックス
# 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する
# つまり counter[num]-1 は、num が res に最後に現れるインデックス
for i in range(m):
counter[i + 1] += counter[i]
# 4. nums を逆順に走査し、各要素を結果配列 res に配置
# 4. nums を逆順に走査し、各要素を結果配列 res に格納する
# 結果を記録するための配列 res を初期化
n = len(nums)
res = [0] * n
for i in range(n - 1, -1, -1):
num = nums[i]
res[counter[num] - 1] = num # num を対応するインデックスに配置
counter[num] -= 1 # 前置和を1減らし、num を配置する次のインデックスを取得
# 結果配列 res を使用して元の配列 nums を上書き
counter[num] -= 1 # 累積和を 1 減らして、次に num を配置するインデックスを得る
# 結果配列 res で元の配列 nums を上書きする
for i in range(n):
nums[i] = res[i]
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
nums = [1, 0, 1, 2, 0, 4, 0, 2, 2, 4]
counting_sort_naive(nums)
print(f"計数ソート（オブジェクトソート不可）完了 nums = {nums}")
print(f"計数ソート（オブジェクトはソート不可）完了後 nums = {nums}")
nums1 = [1, 0, 1, 2, 0, 4, 0, 2, 2, 4]
counting_sort(nums1)
print(f"計数ソート完了 nums1 = {nums1}")
print(f"計数ソート完了後 nums1 = {nums1}")

22
ja/codes/python/chapter_sorting/heap_sort.py
View File

@@ -6,9 +6,9 @@ Author: krahets (krahets@163.com)
def sift_down(nums: list[int], n: int, i: int):
"""ヒープの長さが n、ノード i から上から下へヒープ化を開始"""
"""ヒープの長さは n。ノード i から下方向にヒープ化"""
while True:
# i、l、r の中で最大のノードを判定し、ma とする
# ノード i, l, r のうち値が最大のノードを ma とする
l = 2 * i + 1
r = 2 * i + 2
ma = i
@@ -16,30 +16,30 @@ def sift_down(nums: list[int], n: int, i: int):
ma = l
if r < n and nums[r] > nums[ma]:
ma = r
# ノード i が最大または l、r のインデックスが範囲外の場合、さらなるヒープ化は不要、ループを抜ける
# ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける
if ma == i:
break
# 2つのノードを交換
# 2 つのノードを交換
nums[i], nums[ma] = nums[ma], nums[i]
# 下向きにヒープ化をループ
# ループで上から下へヒープ化
i = ma
def heap_sort(nums: list[int]):
"""ヒープソート"""
# ヒープ構築操作：葉ノード以外のすべてのノードをヒープ化
# ヒープ構築：葉ノード以外のすべてのノードをヒープ化する
for i in range(len(nums) // 2 - 1, -1, -1):
sift_down(nums, len(nums), i)
# ヒープから最大要素を抽出し、n-1 回繰り返す
# ヒープから最大要素を取り出し、n-1 回繰り返す
for i in range(len(nums) - 1, 0, -1):
# ルートノードと最も右の葉ノードを交換（最初の要素と最後の要素を交換）
# 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）
nums[0], nums[i] = nums[i], nums[0]
# ルートノードから上から下へヒープ化を開始
# 根ノードを起点に、上から下へヒープ化
sift_down(nums, i, 0)
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
nums = [4, 1, 3, 1, 5, 2]
heap_sort(nums)
print("ヒープソート完了 nums =", nums)
print("ヒープソート完了後 nums =", nums)

12
ja/codes/python/chapter_sorting/insertion_sort.py
View File

@@ -7,19 +7,19 @@ Author: timi (xisunyy@163.com)
def insertion_sort(nums: list[int]):
"""挿入ソート"""
# 外側のループ：ソート済み範囲は [0, i-1]
# 外側ループ：整列済み区間は [0, i-1]
for i in range(1, len(nums)):
base = nums[i]
j = i - 1
# 内側のループ：base をソート済み範囲 [0, i-1] の正しい位置に挿入
# 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する
while j >= 0 and nums[j] > base:
nums[j + 1] = nums[j] # nums[j] を右に1つ移動
nums[j + 1] = nums[j] # nums[j] を 1 つ右へ移動する
j -= 1
nums[j + 1] = base # base を正しい位置に代入
nums[j + 1] = base # base を正しい位置に配置する
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
nums = [4, 1, 3, 1, 5, 2]
insertion_sort(nums)
print("挿入ソート完了 nums =", nums)
print("挿入ソート完了後 nums =", nums)

30
ja/codes/python/chapter_sorting/merge_sort.py
View File

@@ -6,13 +6,13 @@ Author: timi (xisunyy@163.com), krahets (krahets@163.com)
def merge(nums: list[int], left: int, mid: int, right: int):
"""左サブ配列と右サブ配列をマージ"""
# 左サブ配列区間は [left, mid]、右サブ配列区間は [mid+1, right]
# 一時配列 tmp を作成してマージ結果を格納
"""左部分配列と右部分配列をマージ"""
# 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]
# マージ結果を格納する一時配列 tmp を作成
tmp = [0] * (right - left + 1)
# 左右サブ配列の開始インデックスを初期化
# 左右の部分配列の開始インデックスを初期化する
i, j, k = left, mid + 1, 0
# 両方のサブ配列に要素が残っている間、より小さい要素を一時配列にコピー
# 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする
while i <= mid and j <= right:
if nums[i] <= nums[j]:
tmp[k] = nums[i]
@@ -21,7 +21,7 @@ def merge(nums: list[int], left: int, mid: int, right: int):
tmp[k] = nums[j]
j += 1
k += 1
# 残った左右サブ配列の要素を一時配列にコピー
# 左右の部分配列の残り要素を一時配列にコピーする
while i <= mid:
tmp[k] = nums[i]
i += 1
@@ -30,7 +30,7 @@ def merge(nums: list[int], left: int, mid: int, right: int):
tmp[k] = nums[j]
j += 1
k += 1
# 一時配列 tmp の要素を元の配列 nums の対応する区間にコピーバック
# 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする
for k in range(0, len(tmp)):
nums[left + k] = tmp[k]
@@ -39,17 +39,17 @@ def merge_sort(nums: list[int], left: int, right: int):
"""マージソート"""
# 終了条件
if left >= right:
return # サブ配列の長さが1のときに再帰を終了
# 分割段階
mid = left + (right - left) // 2 # 中点を計算
merge_sort(nums, left, mid) # 左サブ配列を再帰的に処理
merge_sort(nums, mid + 1, right) # 右サブ配列を再帰的に処理
# マージ段階
return # 部分配列の長さが 1 になったら再帰を終了
# 分割フェーズ
mid = (left + right) // 2 # 中点を計算
merge_sort(nums, left, mid) # 左部分配列を再帰処理
merge_sort(nums, mid + 1, right) # 右部分配列を再帰処理
# マージフェーズ
merge(nums, left, mid, right)
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
nums = [7, 3, 2, 6, 0, 1, 5, 4]
merge_sort(nums, 0, len(nums) - 1)
print("マージソート完了 nums =", nums)
print("マージソート完了後 nums =", nums)

90
ja/codes/python/chapter_sorting/quick_sort.py
View File

@@ -9,28 +9,28 @@ class QuickSort:
"""クイックソートクラス"""
def partition(self, nums: list[int], left: int, right: int) -> int:
"""分割"""
# nums[left] をピボットとして使用
"""番兵分割"""
# nums[left] を基準値とする
i, j = left, right
while i < j:
while i < j and nums[j] >= nums[left]:
j -= 1 # 右から左へピボットより小さい最初の要素を探す
j -= 1 # 右から左へ基準値未満の最初の要素を探す
while i < j and nums[i] <= nums[left]:
i += 1 # 左から右へピボットより大きい最初の要素を探す
# 要素を交換
i += 1 # 左から右へ基準値より大きい最初の要素を探す
# 要素の交換
nums[i], nums[j] = nums[j], nums[i]
# ピボットを2つのサブ配列の境界に交換
# 基準値を 2 つの部分配列の境界へ交換する
nums[i], nums[left] = nums[left], nums[i]
return i # ピボットのインデックスを返す
return i # 基準値のインデックスを返す
def quick_sort(self, nums: list[int], left: int, right: int):
"""クイックソート"""
# サブ配列の長さが1のときに再帰を終了
# 部分配列の長さが 1 なら再帰を終了する
if left >= right:
return
# 分割
# 番兵分割
pivot = self.partition(nums, left, right)
# 左サブ配列と右サブ配列を再帰的に処理
# 左右の部分配列を再帰処理
self.quick_sort(nums, left, pivot - 1)
self.quick_sort(nums, pivot + 1, right)
@@ -39,7 +39,7 @@ class QuickSortMedian:
"""クイックソートクラス（中央値ピボット最適化）"""
def median_three(self, nums: list[int], left: int, mid: int, right: int) -> int:
"""3つの候補要素の中央値を選択"""
"""3つの候補要素の中央値を選ぶ"""
l, m, r = nums[left], nums[mid], nums[right]
if (l <= m <= r) or (r <= m <= l):
return mid # m は l と r の間
@@ -48,82 +48,82 @@ class QuickSortMedian:
return right
def partition(self, nums: list[int], left: int, right: int) -> int:
"""分割（三点中央値）"""
# nums[left] をピボットとして使用
"""番兵による分割処理（3 点中央値）"""
# nums[left] を基準値とする
med = self.median_three(nums, left, (left + right) // 2, right)
# 中央値を配列の最左端に交換
# 中央値を配列の最左端に交換する
nums[left], nums[med] = nums[med], nums[left]
# nums[left] をピボットとして使用
# nums[left] を基準値とする
i, j = left, right
while i < j:
while i < j and nums[j] >= nums[left]:
j -= 1 # 右から左へピボットより小さい最初の要素を探す
j -= 1 # 右から左へ基準値未満の最初の要素を探す
while i < j and nums[i] <= nums[left]:
i += 1 # 左から右へピボットより大きい最初の要素を探す
# 要素を交換
i += 1 # 左から右へ基準値より大きい最初の要素を探す
# 要素の交換
nums[i], nums[j] = nums[j], nums[i]
# ピボットを2つのサブ配列の境界に交換
# 基準値を 2 つの部分配列の境界へ交換する
nums[i], nums[left] = nums[left], nums[i]
return i # ピボットのインデックスを返す
return i # 基準値のインデックスを返す
def quick_sort(self, nums: list[int], left: int, right: int):
"""クイックソート"""
# サブ配列の長さが1のときに再帰を終了
# 部分配列の長さが 1 なら再帰を終了する
if left >= right:
return
# 分割
# 番兵分割
pivot = self.partition(nums, left, right)
# 左サブ配列と右サブ配列を再帰的に処理
# 左右の部分配列を再帰処理
self.quick_sort(nums, left, pivot - 1)
self.quick_sort(nums, pivot + 1, right)
class QuickSortTailCall:
"""クイックソートクラス（末尾再帰最適化）"""
"""クイックソートクラス（再帰深度最適化）"""
def partition(self, nums: list[int], left: int, right: int) -> int:
"""分割"""
# nums[left] をピボットとして使用
"""番兵分割"""
# nums[left] を基準値とする
i, j = left, right
while i < j:
while i < j and nums[j] >= nums[left]:
j -= 1 # 右から左へピボットより小さい最初の要素を探す
j -= 1 # 右から左へ基準値未満の最初の要素を探す
while i < j and nums[i] <= nums[left]:
i += 1 # 左から右へピボットより大きい最初の要素を探す
# 要素を交換
i += 1 # 左から右へ基準値より大きい最初の要素を探す
# 要素の交換
nums[i], nums[j] = nums[j], nums[i]
# ピボットを2つのサブ配列の境界に交換
# 基準値を 2 つの部分配列の境界へ交換する
nums[i], nums[left] = nums[left], nums[i]
return i # ピボットのインデックスを返す
return i # 基準値のインデックスを返す
def quick_sort(self, nums: list[int], left: int, right: int):
"""クイックソート（末尾再帰最適化）"""
# サブ配列の長さが1のときに終了
"""クイックソート（再帰深度最適化）"""
# 部分配列の長さが 1 なら終了
while left < right:
# 分割操作
# 番兵による分割処理
pivot = self.partition(nums, left, right)
# 2つのサブ配列のうち短い方に対してクイックソートを実行
# 2 つの部分配列のうち短いほうにクイックソートを適用する
if pivot - left < right - pivot:
self.quick_sort(nums, left, pivot - 1) # 左サブ配列を再帰的にソート
left = pivot + 1 # 残りの未ソート区間は [pivot + 1, right]
self.quick_sort(nums, left, pivot - 1) # 左部分配列を再帰的にソート
left = pivot + 1 # 未ソート区間の残りは [pivot + 1, right]
else:
self.quick_sort(nums, pivot + 1, right) # 右サブ配列を再帰的にソート
right = pivot - 1 # 残りの未ソート区間は [left, pivot - 1]
self.quick_sort(nums, pivot + 1, right) # 右部分配列を再帰的にソート
right = pivot - 1 # 未ソート区間の残りは [left, pivot - 1]
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
# クイックソート
nums = [2, 4, 1, 0, 3, 5]
QuickSort().quick_sort(nums, 0, len(nums) - 1)
print("クイックソート完了 nums =", nums)
print("クイックソート完了後 nums =", nums)
# クイックソート（中央値ピボット最適化）
# クイックソート（中央値の基準値で最適化）
nums1 = [2, 4, 1, 0, 3, 5]
QuickSortMedian().quick_sort(nums1, 0, len(nums1) - 1)
print("クイックソート（中央値ピボット最適化）完了 nums =", nums1)
print("クイックソート（中央値ピボット最適化）完了後 nums =", nums1)
# クイックソート（末尾再帰最適化）
# クイックソート（再帰深度最適化）
nums2 = [2, 4, 1, 0, 3, 5]
QuickSortTailCall().quick_sort(nums2, 0, len(nums2) - 1)
print("クイックソート（末尾再帰最適化）完了 nums =", nums2)
print("クイックソート（再帰深度最適化）完了後 nums =", nums2)

38
ja/codes/python/chapter_sorting/radix_sort.py
View File

@@ -6,51 +6,51 @@ Author: krahets (krahets@163.com)
def digit(num: int, exp: int) -> int:
"""要素 num の k 番目の桁を取得、exp = 10^(k-1)"""
# k の代わりに exp を渡すことで、ここでコストの高い累乗計算を避けることができる
"""要素 num の下から k 桁目を取得（exp = 10^(k-1)）"""
# ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す
return (num // exp) % 10
def counting_sort_digit(nums: list[int], exp: int):
"""計数ソート（nums の k 番目の桁に基づく）"""
# 10進数の桁の範囲は 0~9、したがって長さ10のバケット配列が必要
"""計数ソート（nums の k 桁目でソート）"""
# 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要
counter = [0] * 10
n = len(nums)
# 数字 0~9 の出現回数を統計
# 0~9 の各数字の出現回数を集計する
for i in range(n):
d = digit(nums[i], exp) # nums[i] の k 番目の桁を取得、d とする
counter[d] += 1 # 数字 d の出現回数を統計
# 前置和を計算し、「出現回数」を「配列インデックス」に変換
d = digit(nums[i], exp) # nums[i] の第 k 位を取得し、d とする
counter[d] += 1 # 数字 d の出現回数を数える
# 累積和を求め、「出現回数」を「配列インデックス」に変換する
for i in range(1, 10):
counter[i] += counter[i - 1]
# 逆順に走査し、バケット統計に基づいて各要素を res に配置
# 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する
res = [0] * n
for i in range(n - 1, -1, -1):
d = digit(nums[i], exp)
j = counter[d] - 1 # 配列内の d のインデックス j を取得
res[j] = nums[i] # 現在の要素をインデックス j に配置
counter[d] -= 1 # d の数を1減らす
# 結果を使用して元の配列 nums を上書き
j = counter[d] - 1 # d の配列内インデックス j を取得する
res[j] = nums[i] # 現在の要素をインデックス j に格納する
counter[d] -= 1 # d の個数を 1 減らす
# 結果で元の配列 nums を上書きする
for i in range(n):
nums[i] = res[i]
def radix_sort(nums: list[int]):
"""基数ソート"""
# 配列の最大要素を取得し、最大桁数を判定するために使用
# 最大桁数の判定用に配列の最大要素を取得
m = max(nums)
# 最下位桁から最上位桁まで走査
# 下位桁から上位桁の順に走査する
exp = 1
while exp <= m:
# 配列要素の k 番目の桁に対して計数ソートを実行
# 配列要素の k 桁目に対して計数ソートを行う
# k = 1 -> exp = 1
# k = 2 -> exp = 10
# つまり、exp = 10^(k-1)
# つまり exp = 10^(k-1)
counting_sort_digit(nums, exp)
exp *= 10
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
# 基数ソート
nums = [
@@ -66,4 +66,4 @@ if __name__ == "__main__":
63832996,
]
radix_sort(nums)
print("基数ソート完了 nums =", nums)
print("基数ソート完了後 nums =", nums)

10
ja/codes/python/chapter_sorting/selection_sort.py
View File

@@ -8,19 +8,19 @@ Author: krahets (krahets@163.com)
def selection_sort(nums: list[int]):
"""選択ソート"""
n = len(nums)
# 外側のループ：未ソート範囲は [i, n-1]
# 外側ループ：未整列区間は [i, n-1]
for i in range(n - 1):
# 内側のループ：未ソート範囲内で最小要素を見つける
# 内側のループ：未ソート区間の最小要素を見つける
k = i
for j in range(i + 1, n):
if nums[j] < nums[k]:
k = j # 最小要素のインデックスを記録
# 最小要素を未ソート範囲の先頭要素と交換
# その最小要素を未整列区間の先頭要素と交換する
nums[i], nums[k] = nums[k], nums[i]
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
nums = [4, 1, 3, 1, 5, 2]
selection_sort(nums)
print("選択ソート完了 nums =", nums)
print("選択ソート完了後 nums =", nums)

74
ja/codes/python/chapter_stack_and_queue/array_deque.py
View File

@@ -6,7 +6,7 @@ Author: krahets (krahets@163.com)
class ArrayDeque:
"""循環配列ベースの双端キュークラス"""
"""循環配列ベースの両端キュー"""
def __init__(self, capacity: int):
"""コンストラクタ"""
@@ -15,78 +15,78 @@ class ArrayDeque:
self._size: int = 0
def capacity(self) -> int:
"""双端キューの容量を取得"""
"""両端キューの容量を取得"""
return len(self._nums)
def size(self) -> int:
"""双端キューの長さを取得"""
"""両端キューの長さを取得"""
return self._size
def is_empty(self) -> bool:
"""双端キューが空かどうかを判定"""
"""両端キューが空かどうかを判定"""
return self._size == 0
def index(self, i: int) -> int:
"""循環配列のインデックスを計算"""
# モジュロ演算によって循環配列を実装
# i が配列の末尾を超えた場合、先頭に戻る
# i が配列の先頭を超えた場合、末尾に戻る
# 剰余演算により配列の先頭と末尾をつなげる
# i が配列の末尾を越えたら先頭に戻る
# i が配列の先頭を越えて前に出たら末尾に戻る
return (i + self.capacity()) % self.capacity()
def push_first(self, num: int):
"""前端エンキュー"""
"""キュー先頭にエンキュー"""
if self._size == self.capacity():
print("双端キューが満杯です")
print("両端キューがいっぱいです")
return
# フロントポインタを左に1つ移動
# モジュロ演算によってフロントが配列の先頭を超えて末尾に戻ることを実装
# 先頭ポインタを左に 1 つ移動する
# 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする
self._front = self.index(self._front - 1)
# num を前端に追加
# num をキュー先頭に追加
self._nums[self._front] = num
self._size += 1
def push_last(self, num: int):
"""後端エンキュー"""
"""キュー末尾にエンキュー"""
if self._size == self.capacity():
print("双端キューが満杯です")
print("両端キューがいっぱいです")
return
# リアポインタを計算、リアインデックス + 1 を指す
# キュー末尾ポインタを計算し、末尾インデックス + 1 を指す
rear = self.index(self._front + self._size)
# num を後端に追加
# num をキュー末尾に追加
self._nums[rear] = num
self._size += 1
def pop_first(self) -> int:
"""前端デキュー"""
"""キュー先頭からデキュー"""
num = self.peek_first()
# フロントポインタを1つ後ろに移動
# 先頭ポインタを 1 つ後ろへ進める
self._front = self.index(self._front + 1)
self._size -= 1
return num
def pop_last(self) -> int:
"""後端デキュー"""
"""キュー末尾からデキュー"""
num = self.peek_last()
self._size -= 1
return num
def peek_first(self) -> int:
"""前端要素にアクセス"""
"""キュー先頭の要素にアクセス"""
if self.is_empty():
raise IndexError("Double-ended queue is empty")
raise IndexError("両端キューが空です")
return self._nums[self._front]
def peek_last(self) -> int:
"""後端要素にアクセス"""
"""キュー末尾の要素にアクセス"""
if self.is_empty():
raise IndexError("Double-ended queue is empty")
# 後端要素のインデックスを計算
raise IndexError("両端キューが空です")
# 末尾要素のインデックスを計算
last = self.index(self._front + self._size - 1)
return self._nums[last]
def to_array(self) -> list[int]:
"""出力用の配列を返す"""
# 有効な長さ範囲内の要素のみを変換
# 有効長の範囲内のリスト要素のみを変換
res = []
for i in range(self._size):
res.append(self._nums[self.index(self._front + i)])
@@ -95,35 +95,35 @@ class ArrayDeque:
"""Driver Code"""
if __name__ == "__main__":
# 双端キューを初期化
# 両端キューを初期化
deque = ArrayDeque(10)
deque.push_last(3)
deque.push_last(2)
deque.push_last(5)
print("双端キュー deque =", deque.to_array())
print("両端キュー deque =", deque.to_array())
# 要素にアクセス
peek_first: int = deque.peek_first()
print("前端要素 peek_first =", peek_first)
print("先頭要素 peek_first =", peek_first)
peek_last: int = deque.peek_last()
print("後端要素 peek_last =", peek_last)
print("末尾要素 peek_last =", peek_last)
# 要素をエンキュー
deque.push_last(4)
print("要素 4 を後端エンキュー、deque =", deque.to_array())
print("要素 4 を末尾に追加した後 deque =", deque.to_array())
deque.push_first(1)
print("要素 1 を前端エンキュー、deque =", deque.to_array())
print("要素 1 を先頭に追加した後 deque =", deque.to_array())
# 要素をデキュー
pop_last: int = deque.pop_last()
print("後端でデキューされた要素 =", pop_last, "、後端デキュー後の deque =", deque.to_array())
print("末尾から取り出した要素 =", pop_last, "、末尾から取り出した後 deque =", deque.to_array())
pop_first: int = deque.pop_first()
print("前端でデキューされた要素 =", pop_first, "、前端デキュー後の deque =", deque.to_array())
print("先頭から取り出した要素 =", pop_first, "、先頭から取り出した後 deque =", deque.to_array())
# 双端キューの長さを取得
# 両端キューの長さを取得
size: int = deque.size()
print("双端キューの長さ size =", size)
print("両端キューの長さ size =", size)
# 双端キューが空かどうかを判定
# 両端キューが空かどうかを判定
is_empty: bool = deque.is_empty()
print("双端キューが空かどうか =", is_empty)
print("両端キューが空かどうか =", is_empty)

32
ja/codes/python/chapter_stack_and_queue/array_queue.py
View File

@@ -6,12 +6,12 @@ Author: Peng Chen (pengchzn@gmail.com)
class ArrayQueue:
"""循環配列ベースのキュークラス"""
"""循環配列ベースのキュー"""
def __init__(self, size: int):
"""コンストラクタ"""
self._nums: list[int] = [0] * size # キュー要素を格納する配列
self._front: int = 0 # フロントポインタ、フロント要素を指す
self._front: int = 0 # 先頭ポインタ。先頭要素を指す
self._size: int = 0 # キューの長さ
def capacity(self) -> int:
@@ -29,30 +29,30 @@ class ArrayQueue:
def push(self, num: int):
"""エンキュー"""
if self._size == self.capacity():
raise IndexError("Queue is full")
# リアポインタを計算、リアインデックス + 1 を指す
# モジュロ演算を使用してリアポインタを配列の末尾から先頭に戻す
raise IndexError("キューがいっぱいです")
# 末尾ポインタを計算し、末尾インデックス + 1 を指す
# 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする
rear: int = (self._front + self._size) % self.capacity()
# num をリアに追加
# num をキュー末尾に追加
self._nums[rear] = num
self._size += 1
def pop(self) -> int:
"""デキュー"""
num: int = self.peek()
# フロントポインタを1つ後ろに移動、末尾を超えた場合は配列の先頭に戻る
# 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す
self._front = (self._front + 1) % self.capacity()
self._size -= 1
return num
def peek(self) -> int:
"""フロント要素にアクセス"""
"""キュー先頭の要素にアクセス"""
if self.is_empty():
raise IndexError("Queue is empty")
raise IndexError("キューが空です")
return self._nums[self._front]
def to_list(self) -> list[int]:
"""出力用の配列を返す"""
"""表示用のリストを返す"""
res = [0] * self.size()
j: int = self._front
for i in range(self.size()):
@@ -74,14 +74,14 @@ if __name__ == "__main__":
queue.push(4)
print("キュー queue =", queue.to_list())
# フロント要素にアクセス
# キュー先頭の要素にアクセス
peek: int = queue.peek()
print("フロント要素 peek =", peek)
print("先頭要素 peek =", peek)
# 要素をデキュー
pop: int = queue.pop()
print("デキューされた要素 pop =", pop)
print("デキュー後のキュー =", queue.to_list())
print("取り出した要素 pop =", pop)
print("取り出した後 queue =", queue.to_list())
# キューの長さを取得
size: int = queue.size()
@@ -91,8 +91,8 @@ if __name__ == "__main__":
is_empty: bool = queue.is_empty()
print("キューが空かどうか =", is_empty)
# 循環配列のテスト
# 循環配列をテストする
for i in range(10):
queue.push(i)
queue.pop()
print("第", i, "回目のエンキュー + デキューで、queue =", queue.to_list())
print("第", i, "回目の追加 + 取り出し後 queue = ", queue.to_list())

18
ja/codes/python/chapter_stack_and_queue/array_stack.py
View File

@@ -6,7 +6,7 @@ Author: Peng Chen (pengchzn@gmail.com)
class ArrayStack:
"""配列ベースのスタッククラス"""
"""配列ベースのスタック"""
def __init__(self):
"""コンストラクタ"""
@@ -27,17 +27,17 @@ class ArrayStack:
def pop(self) -> int:
"""ポップ"""
if self.is_empty():
raise IndexError("Stack is empty")
raise IndexError("スタックが空です")
return self._stack.pop()
def peek(self) -> int:
"""スタックトップ要素にアクセス"""
"""スタックトップの要素にアクセス"""
if self.is_empty():
raise IndexError("Stack is empty")
raise IndexError("スタックが空です")
return self._stack[-1]
def to_list(self) -> list[int]:
"""出力用の配列を返す"""
"""表示用のリストを返す"""
return self._stack
@@ -54,14 +54,14 @@ if __name__ == "__main__":
stack.push(4)
print("スタック stack =", stack.to_list())
# スタックトップ要素にアクセス
# スタックトップの要素にアクセス
peek: int = stack.peek()
print("スタックトップ要素 peek =", peek)
# 要素をポップ
pop: int = stack.pop()
print("ポップされた要素 pop =", pop)
print("ポップ後のスタック =", stack.to_list())
print("ポップした要素 pop =", pop)
print("ポップ後 stack =", stack.to_list())
# スタックの長さを取得
size: int = stack.size()
@@ -69,4 +69,4 @@ if __name__ == "__main__":
# 空かどうかを判定
is_empty: bool = stack.is_empty()
print("スタックが空かどうか =", is_empty)
print("スタックが空かどうか =", is_empty)

36
ja/codes/python/chapter_stack_and_queue/deque.py
View File

@@ -8,35 +8,35 @@ from collections import deque
"""Driver Code"""
if __name__ == "__main__":
# 双端キューを初期化
# 両端キューを初期化
deq: deque[int] = deque()
# 要素をエンキュー
deq.append(2) # 後端に追加
deq.append(2) # 末尾に追加する
deq.append(5)
deq.append(4)
deq.appendleft(3) # 前端に追加
deq.appendleft(3) # 先頭に追加する
deq.appendleft(1)
print("双端キュー deque =", deq)
print("両端キュー deque =", deq)
# 要素にアクセス
front: int = deq[0] # 前端要素
print("前端要素 front =", front)
rear: int = deq[-1] # 後端要素
print("後端要素 rear =", rear)
front: int = deq[0] # 先頭要素
print("先頭要素 front =", front)
rear: int = deq[-1] # 末尾要素
print("末尾要素 rear =", rear)
# 要素をデキュー
pop_front: int = deq.popleft() # 前端要素のデキュー
print("前端でデキューされた要素 pop_front =", pop_front)
print("前端デキュー後のデック =", deq)
pop_rear: int = deq.pop() # 後端要素のデキュー
print("後端でデキューされた要素 pop_rear =", pop_rear)
print("後端デキュー後のデック =", deq)
pop_front: int = deq.popleft() # 先頭要素を取り出す
print("先頭から取り出した要素 pop_front =", pop_front)
print("先頭から取り出した後 deque =", deq)
pop_rear: int = deq.pop() # 末尾要素を取り出す
print("末尾から取り出した要素 pop_rear =", pop_rear)
print("末尾から取り出した後 deque =", deq)
# 双端キューの長さを取得
# 両端キューの長さを取得
size: int = len(deq)
print("双端キューの長さ size =", size)
print("両端キューの長さ size =", size)
# 双端キューが空かどうかを判定
# 両端キューが空かどうかを判定
is_empty: bool = len(deq) == 0
print("双端キューが空かどうか =", is_empty)
print("両端キューが空かどうか =", is_empty)

84
ja/codes/python/chapter_stack_and_queue/linkedlist_deque.py
View File

@@ -16,93 +16,93 @@ class ListNode:
class LinkedListDeque:
"""双方向連結リストベースの双端キュークラス"""
"""双方向連結リストベースの両端キュー"""
def __init__(self):
"""コンストラクタ"""
self._front: ListNode | None = None # ヘッドノード front
self._rear: ListNode | None = None # テールノード rear
self._size: int = 0 # 双端キューの長さ
self._front: ListNode | None = None # 先頭ノード front
self._rear: ListNode | None = None # 末尾ノード rear
self._size: int = 0 # 両端キューの長さ
def size(self) -> int:
"""双端キューの長さを取得"""
"""両端キューの長さを取得"""
return self._size
def is_empty(self) -> bool:
"""双端キューが空かどうかを判定"""
"""両端キューが空かどうかを判定"""
return self._size == 0
def push(self, num: int, is_front: bool):
"""エンキュー操作"""
node = ListNode(num)
# リストが空の場合、front と rear の両方を node に向ける
# 連結リストが空なら、front と rear の両方を node に向ける
if self.is_empty():
self._front = self._rear = node
# 前端エンキュー操作
# 先頭へのエンキュー操作
elif is_front:
# ノードをリストの先頭に追加
# node を連結リストの先頭に追加
self._front.prev = node
node.next = self._front
self._front = node # ヘッドノードを更新
# 後端エンキュー操作
self._front = node # 先頭ノードを更新する
# 末尾へのエンキュー操作
else:
# ノードをリストの末尾に追加
# node を連結リストの末尾に追加
self._rear.next = node
node.prev = self._rear
self._rear = node # テールノードを更新
self._rear = node # 末尾ノードを更新する
self._size += 1 # キューの長さを更新
def push_first(self, num: int):
"""前端エンキュー"""
"""キュー先頭にエンキュー"""
self.push(num, True)
def push_last(self, num: int):
"""後端エンキュー"""
"""キュー末尾にエンキュー"""
self.push(num, False)
def pop(self, is_front: bool) -> int:
"""デキュー操作"""
if self.is_empty():
raise IndexError("Double-ended queue is empty")
# 前端デキュー操作
raise IndexError("両端キューが空です")
# キュー先頭からの取り出し
if is_front:
val: int = self._front.val # ヘッドノードの値を一時的に保存
# ヘッドノードを削除
val: int = self._front.val # 先頭ノードの値を一時保存
# 先頭ノードを削除
fnext: ListNode | None = self._front.next
if fnext is not None:
fnext.prev = None
self._front.next = None
self._front = fnext # ヘッドノードを更新
# 後端デキュー操作
self._front = fnext # 先頭ノードを更新する
# キュー末尾からの取り出し
else:
val: int = self._rear.val # テールノードの値を一時的に保存
# テールノードを削除
val: int = self._rear.val # 末尾ノードの値を一時保存
# 末尾ノードを削除
rprev: ListNode | None = self._rear.prev
if rprev is not None:
rprev.next = None
self._rear.prev = None
self._rear = rprev # テールノードを更新
self._rear = rprev # 末尾ノードを更新する
self._size -= 1 # キューの長さを更新
return val
def pop_first(self) -> int:
"""前端デキュー"""
"""キュー先頭からデキュー"""
return self.pop(True)
def pop_last(self) -> int:
"""後端デキュー"""
"""キュー末尾からデキュー"""
return self.pop(False)
def peek_first(self) -> int:
"""前端要素にアクセス"""
"""キュー先頭の要素にアクセス"""
if self.is_empty():
raise IndexError("Double-ended queue is empty")
raise IndexError("両端キューが空です")
return self._front.val
def peek_last(self) -> int:
"""後端要素にアクセス"""
"""キュー末尾の要素にアクセス"""
if self.is_empty():
raise IndexError("Double-ended queue is empty")
raise IndexError("両端キューが空です")
return self._rear.val
def to_array(self) -> list[int]:
@@ -117,35 +117,35 @@ class LinkedListDeque:
"""Driver Code"""
if __name__ == "__main__":
# 双端キューを初期化
# 両端キューを初期化
deque = LinkedListDeque()
deque.push_last(3)
deque.push_last(2)
deque.push_last(5)
print("双端キュー deque =", deque.to_array())
print("両端キュー deque =", deque.to_array())
# 要素にアクセス
peek_first: int = deque.peek_first()
print("前端要素 peek_first =", peek_first)
print("先頭要素 peek_first =", peek_first)
peek_last: int = deque.peek_last()
print("後端要素 peek_last =", peek_last)
print("末尾要素 peek_last =", peek_last)
# 要素をエンキュー
deque.push_last(4)
print("要素 4 を後端エンキュー、deque =", deque.to_array())
print("要素 4 を末尾に追加した後 deque =", deque.to_array())
deque.push_first(1)
print("要素 1 を前端エンキュー、deque =", deque.to_array())
print("要素 1 を先頭に追加した後 deque =", deque.to_array())
# 要素をデキュー
pop_last: int = deque.pop_last()
print("後端でデキューされた要素 =", pop_last, "、後端デキュー後の deque =", deque.to_array())
print("末尾から取り出した要素 =", pop_last, "、末尾から取り出した後 deque =", deque.to_array())
pop_first: int = deque.pop_first()
print("前端でデキューされた要素 =", pop_first, "、前端デキュー後の deque =", deque.to_array())
print("先頭から取り出した要素 =", pop_first, "、先頭から取り出した後 deque =", deque.to_array())
# 双端キューの長さを取得
# 両端キューの長さを取得
size: int = deque.size()
print("双端キューの長さ size =", size)
print("両端キューの長さ size =", size)
# 双端キューが空かどうかを判定
# 両端キューが空かどうかを判定
is_empty: bool = deque.is_empty()
print("双端キューが空かどうか =", is_empty)
print("両端キューが空かどうか =", is_empty)

30
ja/codes/python/chapter_stack_and_queue/linkedlist_queue.py
View File

@@ -12,12 +12,12 @@ from modules import ListNode
class LinkedListQueue:
"""連結リストベースのキュークラス"""
"""連結リストベースのキュー"""
def __init__(self):
"""コンストラクタ"""
self._front: ListNode | None = None # ヘッドノード front
self._rear: ListNode | None = None # テールノード rear
self._front: ListNode | None = None # 先頭ノード front
self._rear: ListNode | None = None # 末尾ノード rear
self._size: int = 0
def size(self) -> int:
@@ -30,13 +30,13 @@ class LinkedListQueue:
def push(self, num: int):
"""エンキュー"""
# テールノードの後ろに num を追加
# 末尾ノードの後ろに num を追加
node = ListNode(num)
# キューが空の場合、ヘッドとテールノードの両方をそのノードに向ける
# キューが空なら、先頭・末尾ノードをともにそのノードに設定
if self._front is None:
self._front = node
self._rear = node
# キューが空でない場合、そのノードをテールノードの後ろに追加
# キューが空でなければ、そのノードを末尾ノードの後ろに追加
else:
self._rear.next = node
self._rear = node
@@ -45,19 +45,19 @@ class LinkedListQueue:
def pop(self) -> int:
"""デキュー"""
num = self.peek()
# ヘッドノードを削除
# 先頭ノードを削除
self._front = self._front.next
self._size -= 1
return num
def peek(self) -> int:
"""フロント要素にアクセス"""
"""キュー先頭の要素にアクセス"""
if self.is_empty():
raise IndexError("Queue is empty")
raise IndexError("キューが空です")
return self._front.val
def to_list(self) -> list[int]:
"""出力用のリストに変換"""
"""表示用にリストへ変換"""
queue = []
temp = self._front
while temp:
@@ -79,14 +79,14 @@ if __name__ == "__main__":
queue.push(4)
print("キュー queue =", queue.to_list())
# フロント要素にアクセス
# キュー先頭の要素にアクセス
peek: int = queue.peek()
print("フロント要素 front =", peek)
print("先頭要素 front =", peek)
# 要素をデキュー
pop_front: int = queue.pop()
print("デキューされた要素 pop =", pop_front)
print("デキュー後のキュー =", queue.to_list())
print("取り出した要素 pop =", pop_front)
print("取り出した後 queue =", queue.to_list())
# キューの長さを取得
size: int = queue.size()
@@ -94,4 +94,4 @@ if __name__ == "__main__":
# キューが空かどうかを判定
is_empty: bool = queue.is_empty()
print("キューが空かどうか =", is_empty)
print("キューが空かどうか =", is_empty)

16
ja/codes/python/chapter_stack_and_queue/linkedlist_stack.py
View File

@@ -12,7 +12,7 @@ from modules import ListNode
class LinkedListStack:
"""連結リストベースのスタッククラス"""
"""連結リストベースのスタック"""
def __init__(self):
"""コンストラクタ"""
@@ -42,13 +42,13 @@ class LinkedListStack:
return num
def peek(self) -> int:
"""スタックトップ要素にアクセス"""
"""スタックトップの要素にアクセス"""
if self.is_empty():
raise IndexError("Stack is empty")
raise IndexError("スタックが空です")
return self._peek.val
def to_list(self) -> list[int]:
"""出力用のリストに変換"""
"""表示用にリストへ変換"""
arr = []
node = self._peek
while node:
@@ -71,14 +71,14 @@ if __name__ == "__main__":
stack.push(4)
print("スタック stack =", stack.to_list())
# スタックトップ要素にアクセス
# スタックトップの要素にアクセス
peek: int = stack.peek()
print("スタックトップ要素 peek =", peek)
# 要素をポップ
pop: int = stack.pop()
print("ポップされた要素 pop =", pop)
print("ポップ後のスタック =", stack.to_list())
print("ポップした要素 pop =", pop)
print("ポップ後 stack =", stack.to_list())
# スタックの長さを取得
size: int = stack.size()
@@ -86,4 +86,4 @@ if __name__ == "__main__":
# 空かどうかを判定
is_empty: bool = stack.is_empty()
print("スタックが空かどうか =", is_empty)
print("スタックが空かどうか =", is_empty)

16
ja/codes/python/chapter_stack_and_queue/queue.py
View File

@@ -8,9 +8,9 @@ from collections import deque
"""Driver Code"""
if __name__ == "__main__":
# キューを初期化
# Pythonでは、一般的にdequeクラスをキューとして考えます
# queue.Queue()は純粋なキュークラスですが、あまりユーザーフレンドリーではありません
# キューを初期化する
# Python では通常、両端キュー deque をキューとして使う
# queue.Queue() は正統なキュークラスだが、あまり使いやすくない
que: deque[int] = deque()
# 要素をエンキュー
@@ -21,14 +21,14 @@ if __name__ == "__main__":
que.append(4)
print("キュー que =", que)
# フロント要素にアクセス
# キュー先頭の要素にアクセス
front: int = que[0]
print("フロント要素 front =", front)
print("先頭要素 front =", front)
# 要素をデキュー
pop: int = que.popleft()
print("デキューされた要素 pop =", pop)
print("デキュー後のキュー =", que)
print("取り出した要素 pop =", pop)
print("取り出し後 que =", que)
# キューの長さを取得
size: int = len(que)
@@ -36,4 +36,4 @@ if __name__ == "__main__":
# キューが空かどうかを判定
is_empty: bool = len(que) == 0
print("キューが空かどうか =", is_empty)
print("キューが空かどうか =", is_empty)

12
ja/codes/python/chapter_stack_and_queue/stack.py
View File

@@ -6,8 +6,8 @@ Author: Peng Chen (pengchzn@gmail.com)
"""Driver Code"""
if __name__ == "__main__":
# スタックを初期化
# Pythonには組み込みのスタッククラスはありませんが、リストをスタックとして使用できます
# スタックを初期化する
# Python には組み込みのスタッククラスがないため、list をスタックとして使える
stack: list[int] = []
# 要素をプッシュ
@@ -18,14 +18,14 @@ if __name__ == "__main__":
stack.append(4)
print("スタック stack =", stack)
# スタックトップ要素にアクセス
# スタックトップの要素にアクセス
peek: int = stack[-1]
print("スタックトップ要素 peek =", peek)
# 要素をポップ
pop: int = stack.pop()
print("ポップされた要素 pop =", pop)
print("ポップ後のスタック =", stack)
print("ポップした要素 pop =", pop)
print("ポップ後 stack =", stack)
# スタックの長さを取得
size: int = len(stack)
@@ -33,4 +33,4 @@ if __name__ == "__main__":
# 空かどうかを判定
is_empty: bool = len(stack) == 0
print("スタックが空かどうか =", is_empty)
print("スタックが空かどうか =", is_empty)

44
ja/codes/python/chapter_tree/array_binary_tree.py
View File

@@ -12,49 +12,49 @@ from modules import TreeNode, list_to_tree, print_tree
class ArrayBinaryTree:
"""配列ベースの二分木クラス"""
"""配列表現による二分木クラス"""
def __init__(self, arr: list[int | None]):
"""コンストラクタ"""
self._tree = list(arr)
def size(self):
"""リストの容量"""
"""リスト容量"""
return len(self._tree)
def val(self, i: int) -> int | None:
"""インデックスiのノードの値を取得"""
# インデックスが範囲外の場合、Noneを返し、空席を表す
"""インデックス i のノードの値を取得"""
# インデックスが範囲外なら、空きを表す None を返す
if i < 0 or i >= self.size():
return None
return self._tree[i]
def left(self, i: int) -> int | None:
"""インデックスiのノードの左の子のインデックスを取得"""
"""インデックス i のノードの左子ノードのインデックスを取得"""
return 2 * i + 1
def right(self, i: int) -> int | None:
"""インデックスiのノードの右の子のインデックスを取得"""
"""インデックス i のノードの右子ノードのインデックスを取得"""
return 2 * i + 2
def parent(self, i: int) -> int | None:
"""インデックスiのノードの親のインデックスを取得"""
"""インデックス i のノードの親ノードのインデックスを取得"""
return (i - 1) // 2
def level_order(self) -> list[int]:
"""レベル順走査"""
self.res = []
# 配列を走査
# 配列を直接走査する
for i in range(self.size()):
if self.val(i) is not None:
self.res.append(self.val(i))
return self.res
def dfs(self, i: int, order: str):
"""深さ優先走査"""
"""深さ優先探索"""
if self.val(i) is None:
return
# 前順走査
# 先行順走査
if order == "pre":
self.res.append(self.val(i))
self.dfs(self.left(i), order)
@@ -67,7 +67,7 @@ class ArrayBinaryTree:
self.res.append(self.val(i))
def pre_order(self) -> list[int]:
"""前順走査"""
"""先行順走査"""
self.res = []
self.dfs(0, order="pre")
return self.res
@@ -85,35 +85,35 @@ class ArrayBinaryTree:
return self.res
"""ドライバコード"""
"""Driver Code"""
if __name__ == "__main__":
# 二分木を初期化
# 特定の関数を使用して配列を二分木に変換
# ここでは、配列から直接二分木を生成する関数を利用する
arr = [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]
root = list_to_tree(arr)
print("\n二分木を初期化\n")
print("二分木の配列表現:")
print("二分木の配列表現：")
print(arr)
print("二分木の連結リスト表現:")
print("二分木の連結リスト表現：")
print_tree(root)
# 配列ベースの二分木クラス
# 配列表現による二分木クラス
abt = ArrayBinaryTree(arr)
# ノードにアクセス
i = 1
l, r, p = abt.left(i), abt.right(i), abt.parent(i)
print(f"\n現在のノードのインデックスは {i}、値は {abt.val(i)}")
print(f"その左の子ノードのインデックスは {l}、値は {abt.val(l)}")
print(f"その右の子ノードのインデックスは {r}、値は {abt.val(r)}")
print(f"その左子ノードのインデックスは {l}、値は {abt.val(l)}")
print(f"その右子ノードのインデックスは {r}、値は {abt.val(r)}")
print(f"その親ノードのインデックスは {p}、値は {abt.val(p)}")
# 木を走査
res = abt.level_order()
print("\nレベル順走査:", res)
print("\nレベル順走査：", res)
res = abt.pre_order()
print("前順走査:", res)
print("先行順走査：", res)
res = abt.in_order()
print("中順走査:", res)
print("中間順走査：", res)
res = abt.post_order()
print("後順走査:", res)
print("後行順走査：", res)

102
ja/codes/python/chapter_tree/avl_tree.py
View File

@@ -12,67 +12,67 @@ from modules import TreeNode, print_tree
class AVLTree:
"""AVL木"""
"""AVL 木"""
def __init__(self):
"""コンストラクタ"""
self._root = None
def get_root(self) -> TreeNode | None:
"""二分木のルートノードを取得"""
"""二分木の根ノードを取得"""
return self._root
def height(self, node: TreeNode | None) -> int:
"""ノードの高さを取得"""
# 空ノードの高さは-1、葉ノードの高さは0
# 空ノードの高さは -1、葉ノードの高さは 0
if node is not None:
return node.height
return -1
def update_height(self, node: TreeNode | None):
"""ノードの高さを更新"""
# ノードの高さ = 最も高い部分木の高さ + 1
"""ノードの高さを更新する"""
# ノードの高さは最も高い部分木の高さ + 1 に等しい
node.height = max([self.height(node.left), self.height(node.right)]) + 1
def balance_factor(self, node: TreeNode | None) -> int:
"""バランス因子を取得"""
# 空ノードのバランス因子は0
"""平衡係数を取得"""
# 空ノードの平衡係数は 0
if node is None:
return 0
# ノードのバランス因子 = 左部分木の高さ - 右部分木の高さ
# ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ
return self.height(node.left) - self.height(node.right)
def right_rotate(self, node: TreeNode | None) -> TreeNode | None:
"""右回転操作"""
"""右回転"""
child = node.left
grand_child = child.right
# childを中心にnodeを右に回転
# child を支点として node を右回転させる
child.right = node
node.left = grand_child
# ノードの高さを更新
# ノードの高さを更新する
self.update_height(node)
self.update_height(child)
# 回転後の部分木のルートを返す
# 回転後の部分木の根ノードを返す
return child
def left_rotate(self, node: TreeNode | None) -> TreeNode | None:
"""左回転操作"""
"""左回転"""
child = node.right
grand_child = child.left
# childを中心にnodeを左に回転
# child を支点として node を左回転させる
child.left = node
node.right = grand_child
# ノードの高さを更新
# ノードの高さを更新する
self.update_height(node)
self.update_height(child)
# 回転後の部分木のルートを返す
# 回転後の部分木の根ノードを返す
return child
def rotate(self, node: TreeNode | None) -> TreeNode | None:
"""回転操作を実行して部分木のバランスを復元"""
# nodeのバランス因子を取得
"""回転操作を行い、この部分木の平衡を回復する"""
# ノード node の平衡係数を取得
balance_factor = self.balance_factor(node)
# 左偏り木
# 左に偏った木
if balance_factor > 1:
if self.balance_factor(node.left) >= 0:
# 右回転
@@ -81,7 +81,7 @@ class AVLTree:
# 左回転してから右回転
node.left = self.left_rotate(node.left)
return self.right_rotate(node)
# 右偏り木
# 右に偏った木
elif balance_factor < -1:
if self.balance_factor(node.right) <= 0:
# 左回転
@@ -90,7 +90,7 @@ class AVLTree:
# 右回転してから左回転
node.right = self.right_rotate(node.right)
return self.left_rotate(node)
# バランスの取れた木、回転不要、戻る
# 平衡木なので回転不要、そのまま返す
return node
def insert(self, val):
@@ -98,20 +98,20 @@ class AVLTree:
self._root = self.insert_helper(self._root, val)
def insert_helper(self, node: TreeNode | None, val: int) -> TreeNode:
"""再帰的にノードを挿入（ヘルパーメソッド）"""
"""ノードを再帰的に挿入する（補助メソッド）"""
if node is None:
return TreeNode(val)
# 1. 挿入位置を見つけてノードを挿入
# 1. 挿入位置を探索してノードを挿入
if val < node.val:
node.left = self.insert_helper(node.left, val)
elif val > node.val:
node.right = self.insert_helper(node.right, val)
else:
# 重複ノードは挿入しない、戻る
# 重複ノードは挿入せず、そのまま返す
return node
# ノードの高さを更新
# ノードの高さを更新する
self.update_height(node)
# 2. 回転操作を実行して部分木のバランスを復元
# 2. 回転操作を行い、部分木の平衡を回復する
return self.rotate(node)
def remove(self, val: int):
@@ -119,10 +119,10 @@ class AVLTree:
self._root = self.remove_helper(self._root, val)
def remove_helper(self, node: TreeNode | None, val: int) -> TreeNode | None:
"""再帰的にノードを削除（ヘルパーメソッド）"""
"""ノードを再帰的に削除する（補助メソッド）"""
if node is None:
return None
# 1. ノードを見つけて削除
# 1. ノードを探索して削除
if val < node.val:
node.left = self.remove_helper(node.left, val)
elif val > node.val:
@@ -130,71 +130,71 @@ class AVLTree:
else:
if node.left is None or node.right is None:
child = node.left or node.right
# 子ノード数 = 0、ノードを削除して戻る
# 子ノード数 = 0 の場合、node をそのまま削除して返す
if child is None:
return None
# 子ノード数 = 1、ノードを削除
# 子ノード数 = 1 の場合、node をそのまま削除する
else:
node = child
else:
# 子ノード数 = 2、中順走査の次のノードを削除し、それで現在のノードを置き換え
# 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える
temp = node.right
while temp.left is not None:
temp = temp.left
node.right = self.remove_helper(node.right, temp.val)
node.val = temp.val
# ノードの高さを更新
# ノードの高さを更新する
self.update_height(node)
# 2. 回転操作を実行して部分木のバランスを復元
# 2. 回転操作を行い、部分木の平衡を回復する
return self.rotate(node)
def search(self, val: int) -> TreeNode | None:
"""ノードを探索"""
cur = self._root
# ループで探索、葉ノードを通過した後にブレーク
# ループで探索し、葉ノードを越えたら抜ける
while cur is not None:
# ターゲットノードはcurの右部分木にある
# 目標ノードは cur の右部分木にある
if cur.val < val:
cur = cur.right
# ターゲットノードはcurの左部分木にある
# 目標ノードは cur の左部分木にある
elif cur.val > val:
cur = cur.left
# ターゲットノードを発見、ループをブレーク
# 目標ノードが見つかったらループを抜ける
else:
break
# ターゲットノードを返す
# 目標ノードを返す
return cur
"""ドライバコード"""
"""Driver Code"""
if __name__ == "__main__":
def test_insert(tree: AVLTree, val: int):
tree.insert(val)
print("\nノード {} を挿入後、AVL木は".format(val))
print("\nノード {} を挿入した後、AVL 木は".format(val))
print_tree(tree.get_root())
def test_remove(tree: AVLTree, val: int):
tree.remove(val)
print("\nノード {} を削除後、AVL木は".format(val))
print("\nノード {} を削除した後、AVL 木は".format(val))
print_tree(tree.get_root())
# 空のAVL木を初期化
# 空の AVL 木を初期化する
avl_tree = AVLTree()
# ノードを挿入
# AVL木がノード挿入後にバランスを維持する様子に注目
# ノードを挿入する
# ノード挿入後に AVL 木がどのように平衡を保つかに注目
for val in [1, 2, 3, 4, 5, 8, 7, 9, 10, 6]:
test_insert(avl_tree, val)
# 重複ノードを挿入
# 重複ノードを挿入する
test_insert(avl_tree, 7)
# ノードを削除
# AVL木がノード削除後にバランスを維持する様子に注目
test_remove(avl_tree, 8) # 次数0のノードを削除
test_remove(avl_tree, 5) # 次数1のノードを削除
test_remove(avl_tree, 4) # 次数2のノードを削除
# ノードを削除する
# ノード削除後に AVL 木がどのように平衡を保つかに注目
test_remove(avl_tree, 8) # 次数 0 のノードを削除する
test_remove(avl_tree, 5) # 次数 1 のノードを削除する
test_remove(avl_tree, 4) # 次数 2 のノードを削除する
result_node = avl_tree.search(7)
print("\n発見されたノードオブジェクト: {}、ノードの値 = {}".format(result_node, result_node.val))
print("\n見つかったノードオブジェクトは {}、ノードの値 = {}".format(result_node, result_node.val))

66
ja/codes/python/chapter_tree/binary_search_tree.py
View File

@@ -16,46 +16,46 @@ class BinarySearchTree:
def __init__(self):
"""コンストラクタ"""
# 空の木を初期化
# 空の木を初期化する
self._root = None
def get_root(self) -> TreeNode | None:
"""二分木のルートノードを取得"""
"""二分木の根ノードを取得"""
return self._root
def search(self, num: int) -> TreeNode | None:
"""ノードを探索"""
cur = self._root
# ループで探索、葉ノードを通過した後にブレーク
# ループで探索し、葉ノードを越えたら抜ける
while cur is not None:
# ターゲットノードはcurの右部分木にある
# 目標ノードは cur の右部分木にある
if cur.val < num:
cur = cur.right
# ターゲットノードはcurの左部分木にある
# 目標ノードは cur の左部分木にある
elif cur.val > num:
cur = cur.left
# ターゲットノードを発見、ループをブレーク
# 目標ノードが見つかったらループを抜ける
else:
break
return cur
def insert(self, num: int):
"""ノードを挿入"""
# 木が空の場合、ルートノードを初期化
# 木が空なら、根ノードを初期化する
if self._root is None:
self._root = TreeNode(num)
return
# ループで探索、葉ノードを通過した後にブレーク
# ループで探索し、葉ノードを越えたら抜ける
cur, pre = self._root, None
while cur is not None:
# 重複ノードを発見したため、戻る
# 重複ノードが見つかったら、直ちに返す
if cur.val == num:
return
pre = cur
# 挿入位置はcurの右部分木にある
# 挿入位置は cur の右部分木にある
if cur.val < num:
cur = cur.right
# 挿入位置はcurの左部分木にある
# 挿入位置は cur の左部分木にある
else:
cur = cur.left
# ノードを挿入
@@ -67,80 +67,80 @@ class BinarySearchTree:
def remove(self, num: int):
"""ノードを削除"""
# 木が空の場合、戻る
# 木が空なら、そのまま早期リターンする
if self._root is None:
return
# ループで探索、葉ノードを通過した後にブレーク
# ループで探索し、葉ノードを越えたら抜ける
cur, pre = self._root, None
while cur is not None:
# 削除するノードを発見、ループをブレーク
# 削除対象のノードが見つかったら、ループを抜ける
if cur.val == num:
break
pre = cur
# 削除するノードはcurの右部分木にある
# 削除対象ノードは cur の右部分木にある
if cur.val < num:
cur = cur.right
# 削除するノードはcurの左部分木にある
# 削除対象ノードは cur の左部分木にある
else:
cur = cur.left
# 削除するノードが存在しない場合、戻る
# 削除対象ノードがなければそのまま返す
if cur is None:
return
# 子ノード数 = 0 または 1
# 子ノード数 = 0 or 1
if cur.left is None or cur.right is None:
# 子ノード数 = 0/1の場合、child = null/その子ノード
# 子ノード数が 0 / 1 のとき、child = null / その子ノード
child = cur.left or cur.right
# ノードcurを削除
# ノード cur を削除する
if cur != self._root:
if pre.left == cur:
pre.left = child
else:
pre.right = child
else:
# 削除されるノードがルートの場合、ルートを再割り当て
# 削除ノードが根ノードなら、根ノードを再設定
self._root = child
# 子ノード数 = 2
else:
# curの中順走査の次のノードを取得
# 中順走査における cur の次ノードを取得
tmp: TreeNode = cur.right
while tmp.left is not None:
tmp = tmp.left
# 再帰的にノードtmpを削除
# ノード tmp を再帰的に削除
self.remove(tmp.val)
# curをtmpで置き換え
# tmp で cur を上書きする
cur.val = tmp.val
"""ドライバコード"""
"""Driver Code"""
if __name__ == "__main__":
# 二分探索木を初期化
bst = BinarySearchTree()
nums = [8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15]
# 注意：異なる挿入順序により、様々な木構造が生成される可能性がある。この特定のシーケンスは完全二分木を作成する
# 注意：挿入順序が異なると異なる二分木が生成される。このシーケンスからは完全二分木を生成できる
for num in nums:
bst.insert(num)
print("\n初期化された二分木は\n")
print("\n初期化した二分木は\n")
print_tree(bst.get_root())
# ノードを探索
node = bst.search(7)
print("\n発見されたノードオブジェクト: {}, ノードの値 = {}".format(node, node.val))
print("\n見つかったノードオブジェクトは: {}、ノードの値 = {}".format(node, node.val))
# ノードを挿入
bst.insert(16)
print("\nノード16を挿入後の二分木は\n")
print("\nノード 16 を挿入した後、二分木は\n")
print_tree(bst.get_root())
# ノードを削除
bst.remove(1)
print("\nノード1を削除後の二分木は\n")
print("\nノード 1 を削除した後、二分木は\n")
print_tree(bst.get_root())
bst.remove(2)
print("\nノード2を削除後の二分木は\n")
print("\nノード 2 を削除した後、二分木は\n")
print_tree(bst.get_root())
bst.remove(4)
print("\nノード4を削除後の二分木は\n")
print_tree(bst.get_root())
print("\nノード 4 を削除した後、二分木は\n")
print_tree(bst.get_root())

16
ja/codes/python/chapter_tree/binary_tree.py
View File

@@ -11,16 +11,16 @@ sys.path.append(str(Path(__file__).parent.parent))
from modules import TreeNode, print_tree
"""ドライバコード"""
"""Driver Code"""
if __name__ == "__main__":
# 二分木を初期化
# ノードを初期化
# 二分木を初期化する
# ノードを初期化する
n1 = TreeNode(val=1)
n2 = TreeNode(val=2)
n3 = TreeNode(val=3)
n4 = TreeNode(val=4)
n5 = TreeNode(val=5)
# ノードの参照（ポインタ）を構築
# ノード間の参照（ポインタ）を構築する
n1.left = n2
n1.right = n3
n2.left = n4
@@ -30,12 +30,12 @@ if __name__ == "__main__":
# ノードの挿入と削除
P = TreeNode(0)
# ノードPを n1 -> n2 の間に挿入
# n1 -> n2 の間にノード P を挿入
n1.left = P
P.left = n2
print("\nノードPを挿入後\n")
print("\nノード P を挿入した後\n")
print_tree(n1)
# ノードを削除
n1.left = n2
print("\nノードPを削除後\n")
print_tree(n1)
print("\nノード P を削除した後\n")
print_tree(n1)

18
ja/codes/python/chapter_tree/binary_tree_bfs.py
View File

@@ -14,29 +14,29 @@ from collections import deque
def level_order(root: TreeNode | None) -> list[int]:
"""レベル順走査"""
# キューを初期化し、ルートノードを追加
# キューを初期化し、ルートノードを追加する
queue: deque[TreeNode] = deque()
queue.append(root)
# 走査シーケンスを格納するリストを初期化
# 走査順序を保存するためのリストを初期化する
res = []
while queue:
node: TreeNode = queue.popleft() # キューからデキュー
res.append(node.val) # ノードの値を保存
node: TreeNode = queue.popleft() # デキュー
res.append(node.val) # ノードの値を保存する
if node.left is not None:
queue.append(node.left) # 左の子ノードをエンキュー
queue.append(node.left) # 左子ノードをキューに追加
if node.right is not None:
queue.append(node.right) # 右の子ノードをエンキュー
queue.append(node.right) # 右子ノードをキューに追加
return res
"""ドライバコード"""
"""Driver Code"""
if __name__ == "__main__":
# 二分木を初期化
# 特定の関数を使用して配列を二分木に変換
# ここでは、配列から直接二分木を生成する関数を利用する
root: TreeNode = list_to_tree(arr=[1, 2, 3, 4, 5, 6, 7])
print("\n二分木を初期化\n")
print_tree(root)
# レベル順走査
res: list[int] = level_order(root)
print("\nレベル順走査のノードシーケンスを出力 = ", res)
print("\nレベル順走査のノード出力シーケンス = ", res)

20
ja/codes/python/chapter_tree/binary_tree_dfs.py
View File

@@ -12,10 +12,10 @@ from modules import TreeNode, list_to_tree, print_tree
def pre_order(root: TreeNode | None):
"""前順走査"""
"""先行順走査"""
if root is None:
return
# 訪問順序: ルートノード -> 左部分木 -> 右部分木
# 訪問順序：根ノード -> 左部分木 -> 右部分木
res.append(root.val)
pre_order(root=root.left)
pre_order(root=root.right)
@@ -25,7 +25,7 @@ def in_order(root: TreeNode | None):
"""中順走査"""
if root is None:
return
# 訪問順序: 左部分木 -> ルートノード -> 右部分木
# 訪問優先順: 左部分木 -> 根ノード -> 右部分木
in_order(root=root.left)
res.append(root.val)
in_order(root=root.right)
@@ -35,31 +35,31 @@ def post_order(root: TreeNode | None):
"""後順走査"""
if root is None:
return
# 訪問順序: 左部分木 -> 右部分木 -> ルートノード
# 訪問優先順: 左部分木 -> 右部分木 -> 根ノード
post_order(root=root.left)
post_order(root=root.right)
res.append(root.val)
"""ドライバコード"""
"""Driver Code"""
if __name__ == "__main__":
# 二分木を初期化
# 特定の関数を使用して配列を二分木に変換
# ここでは、配列から直接二分木を生成する関数を利用する
root = list_to_tree(arr=[1, 2, 3, 4, 5, 6, 7])
print("\n二分木を初期化\n")
print_tree(root)
# 前順走査
# 先行順走査
res = []
pre_order(root)
print("\n前順走査のノードシーケンスを出力 = ", res)
print("\n先行順走査のノード出力シーケンス = ", res)
# 中順走査
res.clear()
in_order(root)
print("\n中順走査のノードシーケンスを出力 = ", res)
print("\n中間順走査のノード出力シーケンス = ", res)
# 後順走査
res.clear()
post_order(root)
print("\n後順走査のノードシーケンスを出力 = ", res)
print("\n後行順走査のノード出力シーケンス = ", res)

6
ja/codes/python/modules/__init__.py
View File

@@ -1,8 +1,8 @@
# PEP 585に従う - 標準コレクションでの型ヒント
# Follow the PEP 585 - Type Hinting Generics In Standard Collections
# https://peps.python.org/pep-0585/
from __future__ import annotations
# 共通ライブラリをここでインポートして、`from module import *`でコードを簡潔にする
# Import common libs here to simplify the code by `from module import *`
from .list_node import (
ListNode,
list_to_linked_list,
@@ -16,4 +16,4 @@ from .print_util import (
print_tree,
print_dict,
print_heap,
)
)

8
ja/codes/python/modules/list_node.py
View File

@@ -6,15 +6,15 @@ Author: krahets (krahets@163.com)
class ListNode:
"""連結リストのノードクラス"""
"""連結リストノードクラス"""
def __init__(self, val: int):
self.val: int = val # ノードの値
self.val: int = val # ノード値
self.next: ListNode | None = None # 後続ノードへの参照
def list_to_linked_list(arr: list[int]) -> ListNode | None:
"""リストを連結リストにデシリアライズ"""
"""リストを連結リストにデシリアライズする"""
dum = head = ListNode(0)
for a in arr:
node = ListNode(a)
@@ -29,4 +29,4 @@ def linked_list_to_list(head: ListNode | None) -> list[int]:
while head:
arr.append(head.val)
head = head.next
return arr
return arr

16
ja/codes/python/modules/print_util.py
View File

@@ -9,7 +9,7 @@ from .list_node import ListNode, linked_list_to_list
def print_matrix(mat: list[list[int]]):
"""行列を出力"""
"""行列を出力する"""
s = []
for arr in mat:
s.append(" " + str(arr))
@@ -39,10 +39,10 @@ def print_tree(
root: TreeNode | None, prev: Trunk | None = None, is_right: bool = False
):
"""
二分木を出力
この木プリンタはTECHIE DELIGHTから借用
https://www.techiedelight.com/c-program-print-binary-tree/
"""
二分木を出力
This tree printer is borrowed from TECHIE DELIGHT
https://www.techiedelight.com/c-program-print-binary-tree/
"""
if root is None:
return
@@ -75,7 +75,7 @@ def print_dict(hmap: dict):
def print_heap(heap: list[int]):
"""ヒープを出力"""
print("ヒープの配列表現:", heap)
print("ヒープの木表現:")
print("ヒープの配列表現：", heap)
print("ヒープの木構造表示：")
root: TreeNode | None = list_to_tree(heap)
print_tree(root)
print_tree(root)

44
ja/codes/python/modules/tree_node.py
View File

@@ -8,51 +8,51 @@ from collections import deque
class TreeNode:
"""二分木のノードクラス"""
"""二分木ノードクラス"""
def __init__(self, val: int = 0):
self.val: int = val # ノードの値
self.val: int = val # ノード値
self.height: int = 0 # ノードの高さ
self.left: TreeNode | None = None # 左の子ノードへの参照
self.right: TreeNode | None = None # 右の子ノードへの参照
self.left: TreeNode | None = None # 左子ノードへの参照
self.right: TreeNode | None = None # 右子ノードへの参照
# シリアライゼーションのエンコーディングルールについては、以下を参照:
# シリアライズの符号化規則は以下を参照:
# https://www.hello-algo.com/chapter_tree/array_representation_of_tree/
# 二分木の配列表現:
# [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]
# 二分木の連結リスト表現:
# /——— 15
# /——— 7
# /——— 3
# | \——— 6
# | \——— 12
# /——— 15
# /——— 7
# /——— 3
# | \——— 6
# | \——— 12
# ——— 1
# \——— 2
# | /——— 9
# \——— 4
# \——— 8
# \——— 2
# | /——— 9
# \——— 4
# \——— 8
def list_to_tree_dfs(arr: list[int], i: int) -> TreeNode | None:
"""リストを二分木にデシリアライズ: 再帰的"""
# インデックスが配列の境界外、または対応する要素がNoneの場合、Noneを返す
"""リストを二分木にデシリアライズする: 再帰"""
# 添字が配列長を超えるか、対応する要素が None なら、None を返す
if i < 0 or i >= len(arr) or arr[i] is None:
return None
# 現在のノードを構築
# 現在のノードを構築する
root = TreeNode(arr[i])
# 左右の部分木を再帰的に構築
# 左右の部分木を再帰的に構築する
root.left = list_to_tree_dfs(arr, 2 * i + 1)
root.right = list_to_tree_dfs(arr, 2 * i + 2)
return root
def list_to_tree(arr: list[int]) -> TreeNode | None:
"""リストを二分木にデシリアライズ"""
"""リストを二分木にデシリアライズする"""
return list_to_tree_dfs(arr, 0)
def tree_to_list_dfs(root: TreeNode, i: int, res: list[int]) -> list[int]:
"""二分木をリストにシリアライズ: 再帰的"""
"""二分木をリストにシリアライズする: 再帰"""
if root is None:
return
if i >= len(res):
@@ -63,7 +63,7 @@ def tree_to_list_dfs(root: TreeNode, i: int, res: list[int]) -> list[int]:
def tree_to_list(root: TreeNode | None) -> list[int]:
"""二分木をリストにシリアライズ"""
"""二分木をリストにシリアライズする"""
res = []
tree_to_list_dfs(root, 0, res)
return res
return res

6
ja/codes/python/modules/vertex.py
View File

@@ -11,10 +11,10 @@ class Vertex:
def vals_to_vets(vals: list[int]) -> list["Vertex"]:
"""値のリストvalsを入力し、頂点のリストvetsを返す"""
"""値リスト vals を入力し、頂点リスト vets を返す"""
return [Vertex(val) for val in vals]
def vets_to_vals(vets: list["Vertex"]) -> list[int]:
"""頂点のリストvetsを入力し、値のリストvalsを返す"""
return [vet.val for vet in vets]
"""頂点リスト vets を入力し、値リスト vals を返す"""
return [vet.val for vet in vets]

16
ja/codes/python/test_all.py
View File

@@ -6,11 +6,11 @@ env = os.environ.copy()
env["PYTHONIOENCODING"] = "utf-8"
if __name__ == "__main__":
# ソースコードファイルを検索
src_paths = sorted(glob.glob("ja/codes/python/chapter_*/*.py"))
# find source code files
src_paths = sorted(glob.glob("chapter_*/*.py"))
errors = []
# python コードを実行
# run python code
for src_path in src_paths:
process = subprocess.Popen(
["python", src_path],
@@ -20,14 +20,14 @@ if __name__ == "__main__":
env=env,
encoding='utf-8'
)
# プロセスの完了を待ち、出力とエラーメッセージを取得
# Wait for the process to complete, and get the output and error messages
stdout, stderr = process.communicate()
# 終了ステータスをチェック
# Check the exit status
exit_status = process.returncode
if exit_status != 0:
errors.append(stderr)
print(f"{len(src_paths)} ファイルをテストしました")
print(f"{len(errors)} ファイルで例外が見つかりました")
print(f"Tested {len(src_paths)} files")
print(f"Found exception in {len(errors)} files")
if len(errors) > 0:
raise RuntimeError("\n\n".join(errors))
raise RuntimeError("\n\n".join(errors))