fix

Author: hidehic0

code/main.py

@@ -1,23 +1,17 @@
 # 多次元配列作成
-from typing import List, Any
+from typing import Any
 
 
-def create_array1(n: int, default: Any = 0) -> List[Any]:
-    """
-    1次元配列を初期化する関数
-    """
+def create_array1(n: int, default=0) -> list[Any]:
+    """1次元配列を初期化する関数"""
     return [default] * n
 
 
-def create_array2(a: int, b: int, default: Any = 0) -> List[List[Any]]:
-    """
-    2次元配列を初期化する関数
-    """
+def create_array2(a: int, b: int, default=0) -> list[list[Any]]:
+    """2次元配列を初期化する関数"""
     return [[default] * b for _ in [0] * a]
 
 
-def create_array3(a: int, b: int, c: int, default: Any = 0) -> List[List[List[Any]]]:
-    """
-    3次元配列を初期化する関数
-    """
+def create_array3(a: int, b: int, c: int, default=0) -> list[list[list[Any]]]:
+    """3次元配列を初期化する関数"""
     return [[[default] * c for _ in [0] * b] for _ in [0] * a]

libs/array_create.py

@@ -1,11 +1,14 @@
-from typing import Callable
+from typing.abc import Callable
 
 
 def binary_search(
-    fn: Callable[[int], bool], right: int = 0, left: int = -1, return_left: bool = True
+    fn: Callable[[int], bool],
+    right: int = 0,
+    left: int = -1,
+    return_left: bool = True,
 ) -> int:
-    """
-    二分探索の抽象的なライブラリ
+    """二分探索の抽象的なライブラリ
+
     評価関数の結果に応じて、二分探索する
     最終的にはleftを出力します
 

libs/binary_search.py

@@ -1,37 +1,27 @@
-from typing import List, Tuple
+def compress_1d(points: list[int] | tuple[int]) -> list[int]:
+    """一次元座標圧縮
 
-
-def compress_1d(points: List[int] | Tuple[int]) -> List[int]:
-    """
-    一次元座標圧縮します
     計算量は、O(N log N)です
 
     lとrは、まとめて入れる事で、座圧できます
     """
-    res = []
     d = {num: ind for ind, num in enumerate(sorted(set(points)))}
 
-    for a in points:
-        res.append(d[a])
+    return [d[a] for a in points]
 
-    return res
 
+def compress_2d(points) -> list[tuple[int, int]]:
+    """二次元座標圧縮
 
-def compress_2d(points):
-    """
-    2次元座標圧縮を行う関数
     入力: points - [(x1, y1), (x2, y2), ...] の形式の座標リスト
     出力: 圧縮後の座標リストと、元の座標から圧縮後の座標へのマッピング
     """
     # x座標とy座標を分離
-    x_coords = sorted(set(x for x, y in points))  # 重複を削除してソート
-    y_coords = sorted(set(y for x, y in points))
+    x_coords = sorted({x for x, y in points})  # 重複を削除してソート
+    y_coords = sorted({y for x, y in points})
 
     # 座標から圧縮後の値へのマッピング辞書を作成
     x_map = {val: idx for idx, val in enumerate(x_coords)}
     y_map = {val: idx for idx, val in enumerate(y_coords)}
 
-    # 圧縮後の座標リストを作成
-    compressed = [(x_map[x], y_map[y]) for x, y in points]
-
-    return compressed
+    return [(x_map[x], y_map[y]) for x, y in points]

libs/coordinate_compression.py

@@ -1,22 +1,18 @@
-from typing import List, Tuple
-
-
-def coordinates_to_id(H: int, W: int) -> Tuple[List[List[int]], List[Tuple[int]]]:
-    """
-    座標にID変換します
+def coordinates_to_id(h: int, w: int) -> tuple[list[list[int]], list[tuple[int, int]]]:
+    """座標を一次元のindexに変換する関数
 
     返り値は、
     最初のが、座標からid
     二つめのが、idから座標
     です
     """
-    ItC = [[-1] * W for _ in [0] * H]
-    CtI = [(-1, -1) for _ in [0] * (H * W)]
+    ItC = [[-1] * w for _ in [0] * h]
+    CtI = [(-1, -1) for _ in [0] * (h * w)]
 
     i = 0
 
-    for x in range(H):
-        for y in range(W):
+    for x in range(h):
+        for y in range(w):
             ItC[x][y] = i
             CtI[i] = (x, y)
             i += 1

libs/coordinates_to_id.py

@@ -1,12 +1,13 @@
 import heapq
-from typing import List, Tuple
 
 
 def dijkstra(
-    graph: List[List[Tuple[int]]], startpoint: int = 0, output_prev: bool = False
-) -> List[int] | Tuple[List[int], List[int]]:
-    """
-    ダイクストラ法です
+    graph: list[list[tuple[int]]],
+    startpoint: int = 0,
+    output_prev: bool = False,
+) -> list[int] | tuple[list[int], list[int]]:
+    """ダイクストラ法のライブラリ
+
     GraphW構造体を使う場合は、allメソッドで、そんまま入れてください
     定数倍速いのかは分かりません(いつも使っているフォーマット)
     経路復元したい場合は、output_prevをTrueにすればprevも返ってくるので、それを使用して復元してください
@@ -16,6 +17,7 @@ def dijkstra(
     prev = [-1] * len(graph)
     if not 0 <= startpoint < len(graph):
         raise IndexError("あのー0-indexedですか?")
+
     used[startpoint] = 0
     PQ = [(0, startpoint)]
 
@@ -38,5 +40,5 @@ def dijkstra(
 
     if not output_prev:
         return used
-    else:
-        return used, prev
+
+    return used, prev

libs/dijkstra.py

@@ -1,41 +1,29 @@
-from typing import Tuple
-
-
 def euclid_dis(x1: int, y1: int, x2: int, y2: int) -> int:
-    """
-    ユークリッド距離を計算します
+    """ユークリッド距離を計算する関数
 
     注意:
     この関数はsqrtを取りません(主に少数誤差用)
     sqrtを取りたい場合は、自分で計算してください
     """
-
     return ((x1 - x2) ** 2) + ((y1 - y2) ** 2)
 
 
 def manhattan_dis(x1: int, y1: int, x2: int, y2: int) -> int:
-    """
-    マンハッタン距離を計算します
-    """
-
+    """マンハッタン距離を計算する関数"""
     return abs(x1 - x2) + abs(y1 - y2)
 
 
-def manhattan_45turn(x: int, y: int) -> Tuple[int]:
-    """
-    座標を45度回転します
+def manhattan_45turn(x: int, y: int) -> tuple[int]:
+    """マンハッタン距離用の座標を45度回転する関数
+
     回転すると、マンハッタン距離が、チェビシェフ距離になるので、距離の最大値などが簡単に求められます
     """
-
     res_x = x - y
     res_y = x + y
 
     return res_x, res_y
 
 
 def chebyshev_dis(x1: int, y1: int, x2: int, y2: int) -> int:
-    """
-    チェビシェフ距離を計算します
-    """
-
+    """チェビシェフ距離を計算する関数"""
     return max(abs(x1 - x2), abs(y1 - y2))

libs/dis_lib.py

@@ -1,10 +1,9 @@
 # DPのテンプレート
-from typing import List
 
 
-def partial_sum_dp(lis: List[int], X: int) -> List[bool]:
-    """
-    部分和dpのテンプレート
+def partial_sum_dp(lis: list[int], X: int) -> list[bool]:
+    """部分和dpのテンプレート
+
     lisは品物です
     dp配列の長さは、Xにします
     計算量は、O(X*len(L))みたいな感じ
@@ -28,8 +27,8 @@ def partial_sum_dp(lis: List[int], X: int) -> List[bool]:
 
 
 def knapsack_dp(lis: list[list[int]], W: int) -> int:
-    """
-    ナップサック問題を一次元DPで解く
+    """ナップサックdpのテンプレート
+
     lis: 品物のリスト [[重さ, 価値], ...]
     W: ナップサックの容量
     戻り値: 最大価値
@@ -41,16 +40,17 @@ def knapsack_dp(lis: list[list[int]], W: int) -> int:
 
     for w, v in lis:
         if w < 0 or v < 0:
-            raise ValueError("Weight and value must be non-negative")
+            msg = "Weight and value must be non-negative"
+            raise ValueError(msg)
         for k in reversed(range(W - w + 1)):
             dp[k + w] = max(dp[k + w], dp[k] + v)
 
     return dp[W]
 
 
-def article_breakdown(lis: List[List[int]]) -> List[List[int]]:
-    """
-    個数制限付きナップサックの品物を分解します
+def article_breakdown(lis: list[list[int]]) -> list[list[int]]:
+    """個数制限付きナップサック問題用の品物を分解する関数
+
     個数の値が、各品物の一番右にあれば正常に動作します
     """
     res = []

libs/dp.py

@@ -1,10 +1,11 @@
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any
 
 
 class DualSegmentTree:
-    def __init__(self, op: Callable[[Any, Any], Any], e: Any, n: int) -> None:
-        """
-        区間作用/一点取得のセグメント木
+    def __init__(self, op: Callable[[Any, Any], Any], e, n: int) -> None:
+        """区間作用/一点取得のセグメント木
+
         opは区間作用用の関数
         eは初期値
         vは長さ
@@ -16,9 +17,7 @@ def __init__(self, op: Callable[[Any, Any], Any], e: Any, n: int) -> None:
         self.data = [e] * (self.n * 2)
 
     def apply(self, l, r, x) -> None:
-        """
-        区間[l,r)にxを適用
-        """
+        """区間[l,r)にxを適用"""
         assert 0 <= l <= r <= self.n
         l += self.n
         r += self.n
@@ -35,9 +34,7 @@ def apply(self, l, r, x) -> None:
             r >>= 1
 
     def get(self, p: int) -> Any:
-        """
-        pの値を取得する
-        """
+        """pの値を取得する"""
         assert 0 <= p < self.n
 
         res = self._e

libs/dual_segtree.py

@@ -1,9 +1,7 @@
-from typing import List, Tuple
-
-
 class EulerTour:
-    def __init__(self, edges: List[Tuple[int, int, int]], root: int = 0) -> None:
-        """
+    def __init__(self, edges: list[tuple[int, int, int]], root: int = 0) -> None:
+        """オイラーツアーのライブラリ
+
         edges[i] = (u, v, w)
         なお閉路がない、連結という前提 エラー処理をしていない
 
@@ -14,15 +12,14 @@ def __init__(self, edges: List[Tuple[int, int, int]], root: int = 0) -> None:
         Warning:
         ac-library-pythonを__init__内で使用しているので注意
         定数倍が遅い事に注意 あとメモリも注意 結構リストを使用している
-        """
-        # assert len(edges) >= 1
 
+        """
         from atcoder.segtree import SegTree
 
         self.edges = edges
         self._n = max([max(u, v) for u, v, w in edges]) + 1
         self.root = root
-        self.graph: List[List[Tuple[int, int, int]]] = [[] for _ in [0] * self._n]
+        self.graph: list[list[tuple[int, int, int]]] = [[] for _ in [0] * self._n]
 
         for i, (u, v, w) in enumerate(edges):
             self.graph[u].append((v, w, i))
@@ -37,12 +34,10 @@ def __init__(self, edges: List[Tuple[int, int, int]], root: int = 0) -> None:
             [(d, i) for i, d in enumerate(self.depth)],
         )
 
-        return
-
     def _build(self) -> None:
-        self.euler_tour: List[Tuple[int, int]] = [(0, -1)]
-        self.edge_cost: List[int] = [0]
-        self.depth: List[int] = [0]
+        self.euler_tour: list[tuple[int, int]] = [(0, -1)]
+        self.edge_cost: list[int] = [0]
+        self.depth: list[int] = [0]
 
         def dfs(cur: int, p: int = -1, d: int = 0) -> None:
             for nxt, w, i in self.graph[cur]:
@@ -78,8 +73,6 @@ def dfs(cur: int, p: int = -1, d: int = 0) -> None:
             self.last_arrival[u] = i
 
     def lca(self, a: int, b: int) -> int:
-        # assert 0 <= a < self._n and 0 <= b < self._n
-
         l, r = (
             min(self.first_arrival[a], self.first_arrival[b]),
             max(self.last_arrival[a], self.last_arrival[b]),
@@ -92,10 +85,7 @@ def path_query_from_root(self, u: int) -> int:
         return self.segtree_edgecost.prod(0, self.first_arrival[u] + 1)
 
     def path_query(self, a: int, b: int) -> int:
-        """
-        aからbへの最短経路
-        """
-        # assert 0 <= a < self._n and 0 <= b < self._n
+        """aからbへの最短経路"""
         try:
             l = self.lca(a, b)
         except IndexError:
@@ -108,6 +98,5 @@ def path_query(self, a: int, b: int) -> int:
         )
 
     def change_edge_cost(self, i: int, w: int) -> None:
-        # assert 0 <= i < len(self.edges)
         self.segtree_edgecost.set(self.edge_plus[i], w)
         self.segtree_edgecost.set(self.edge_minus[i], -w)