complete 1580.py 10942.py

zeta_python/completed/10942.py

@@ -0,0 +1,44 @@
+import sys
+
+input = sys.stdin.readline
+
+
+class Palindrome:
+    def __init__(self, N: int, arr: list[int]):
+        self.N = N
+        self.arr = arr
+        self.P = [[0 for _ in range(N)] for _ in range(N)]
+
+        for i in range(self.N):
+            s = i
+            e = i
+            while 0 <= s and e < self.N:
+                if self.arr[s] == self.arr[e]:
+                    self.P[s][e] = 1
+                else:
+                    break
+                s -= 1
+                e += 1
+
+        for i in range(self.N - 1):
+            s = i
+            e = i + 1
+            while 0 <= s and e < self.N:
+                if self.arr[s] == self.arr[e]:
+                    self.P[s][e] = 1
+                else:
+                    break
+                s -= 1
+                e += 1
+
+    def is_partial_valid(self, s: int, e: int) -> int:
+        return self.P[s][e]
+
+
+if __name__ == "__main__":
+    N = int(input())
+    arr = list(map(int, input().split()))
+    solver = Palindrome(N, arr)
+    M = int(input())
+    for s, e in [tuple(map(lambda x: int(x) - 1, input().split())) for _ in range(M)]:
+        print(solver.is_partial_valid(s, e))

zeta_python/completed/1580.py

@@ -0,0 +1,87 @@
+from collections import deque
+
+MOVEABLE = [
+    (1, 0),
+    (-1, 0),
+    (0, 1),
+    (0, -1),
+    (0, 0),
+    (1, 1),
+    (-1, -1),
+    (1, -1),
+    (-1, 1),
+]
+
+
+class Board:
+    def __init__(self, N, M, arr):
+        self.size = (N, M)
+        self.__arr = arr
+
+    def check_wall(self, i, j):
+        return (
+            not (0 <= i < self.size[0] and 0 <= j < self.size[1])
+            or self.__arr[self.size[1] * i + j]
+        )
+
+
+class AgentSwitching:
+    def __init__(self, N, M, raw):
+        self.agents_init = [(-1, -1), (-1, -1)]
+        arr = []
+        for i, s in enumerate(raw):
+            for j, c in enumerate(s):
+                if c == "X":
+                    arr.append(1)
+                elif c == "A":
+                    self.agents_init[0] = (i, j)
+                    arr.append(0)
+                elif c == "B":
+                    self.agents_init[1] = (i, j)
+                    arr.append(0)
+                else:
+                    arr.append(0)
+        self.board = Board(N, M, arr)
+
+    def solve(self):
+        vis = [
+            [[[0 for _ in range(M)] for _ in range(N)] for _ in range(M)]
+            for _ in range(N)
+        ]
+        D = deque([(self.agents_init[0], self.agents_init[1], 0)])
+        while D:
+            (ai, aj), (bi, bj), turn = D.popleft()
+
+            if vis[ai][aj][bi][bj]:
+                continue
+            if (ai, aj) == self.agents_init[1] and (bi, bj) == self.agents_init[0]:
+
+                return turn
+            a_possible = [
+                (ai + mi, aj + mj)
+                for mi, mj in MOVEABLE
+                if not self.board.check_wall(ai + mi, aj + mj)
+            ]
+            b_possible = [
+                (bi + mi, bj + mj)
+                for mi, mj in MOVEABLE
+                if not self.board.check_wall(bi + mi, bj + mj)
+            ]
+            for new_a in a_possible:
+                for new_b in b_possible:
+                    if new_a == new_b:
+                        continue
+                    if new_a == (bi, bj) and new_b == (ai, aj):
+                        continue
+
+                    D.append((new_a, new_b, turn + 1))
+            vis[ai][aj][bi][bj] = 1
+
+        return -1
+
+
+if __name__ == "__main__":
+    N, M = map(int, input().split())
+    raw_consume = [input().rstrip() for _ in range(N)]
+    solver = AgentSwitching(N, M, raw_consume)
+    print(solver.solve())