From 851751ea87df7ea55889ad07b601c8247b81ea38 Mon Sep 17 00:00:00 2001 From: alexey_makov Date: Wed, 1 Jul 2026 19:46:51 +0300 Subject: [PATCH] init --- 1A.py | 25 +++++++++ 1B.py | 24 ++++++++ 1C.py | 33 +++++++++++ 1D.py | 22 ++++++++ 1E.py | 25 +++++++++ 1F.py | 27 +++++++++ 1G.py | 171 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1H.py | 41 ++++++++++++++ 1I.py | 15 +++++ 1J.py | 24 ++++++++ 1K.py | 48 ++++++++++++++++ 1L.py | 46 ++++++++++++++++ 1M.py | 68 +++++++++++++++++++++++ 1N.py | 74 +++++++++++++++++++++++++ 1O.py | 101 ++++++++++++++++++++++++++++++++++ 1P.py | 0 2A.py | 67 ++++++++++++++++++++++ 2B.py | 0 2C.py | 0 2D.py | 54 ++++++++++++++++++ 2E.py | 0 2F.py | 0 2G.py | 0 2H.py | 0 3D.cpp | 50 +++++++++++++++++ 3D.exe | Bin 0 -> 54945 bytes 3D.py | 33 +++++++++++ 3E.py | 41 ++++++++++++++ 3F.py | 37 +++++++++++++ 3G.py | 31 +++++++++++ 3H.py | 26 +++++++++ 3I.py | 32 +++++++++++ 3J.py | 0 3K.py | 24 ++++++++ 3L.py | 70 +++++++++++++++++++++++ 4A.py | 30 ++++++++++ 4B.py | 32 +++++++++++ 4C.py | 41 ++++++++++++++ 4D.py | 0 4E.py | 0 4F.py | 0 4G.py | 0 5A.py | 17 ++++++ 5B.py | 21 +++++++ 5C.py | 23 ++++++++ 5D.py | 30 ++++++++++ 5E.py | 0 5F.py | 0 5G.py | 0 5H.py | 0 6A.py | 0 6B.py | 0 6C.py | 0 6D.py | 0 6E.py | 0 7A.py | 51 +++++++++++++++++ 7B.py | 57 +++++++++++++++++++ 7C.py | 0 7D.py | 0 7E.py | 0 7F.py | 0 7G.py | 0 7H.py | 0 7I.py | 0 8A.py | 32 +++++++++++ 8B.py | 29 ++++++++++ 8C.py | 34 ++++++++++++ 8D.py | 12 ++++ 8E.py | 23 ++++++++ 9A.py | 1 + 9B.py | 37 +++++++++++++ 9C.py | 91 ++++++++++++++++++++++++++++++ 9D.py | 41 ++++++++++++++ 9E.py | 105 +++++++++++++++++++++++++++++++++++ 9F.py | 22 ++++++++ AA.py | 42 ++++++++++++++ AB.py | 37 +++++++++++++ AC.py | 76 +++++++++++++++++++++++++ AD.py | 0 AE.py | 0 AF.py | 0 AG.py | 0 82 files changed, 2093 insertions(+) create mode 100644 1A.py create mode 100644 1B.py create mode 100644 1C.py create mode 100644 1D.py create mode 100644 1E.py create mode 100644 1F.py create mode 100644 1G.py create mode 100644 1H.py create mode 100644 1I.py create mode 100644 1J.py create mode 100644 1K.py create mode 100644 1L.py create mode 100644 1M.py create mode 100644 1N.py create mode 100644 1O.py create mode 100644 1P.py create mode 100644 2A.py create mode 100644 2B.py create mode 100644 2C.py create mode 100644 2D.py create mode 100644 2E.py create mode 100644 2F.py create mode 100644 2G.py create mode 100644 2H.py create mode 100644 3D.cpp create mode 100644 3D.exe create mode 100644 3D.py create mode 100644 3E.py create mode 100644 3F.py create mode 100644 3G.py create mode 100644 3H.py create mode 100644 3I.py create mode 100644 3J.py create mode 100644 3K.py create mode 100644 3L.py create mode 100644 4A.py create mode 100644 4B.py create mode 100644 4C.py create mode 100644 4D.py create mode 100644 4E.py create mode 100644 4F.py create mode 100644 4G.py create mode 100644 5A.py create mode 100644 5B.py create mode 100644 5C.py create mode 100644 5D.py create mode 100644 5E.py create mode 100644 5F.py create mode 100644 5G.py create mode 100644 5H.py create mode 100644 6A.py create mode 100644 6B.py create mode 100644 6C.py create mode 100644 6D.py create mode 100644 6E.py create mode 100644 7A.py create mode 100644 7B.py create mode 100644 7C.py create mode 100644 7D.py create mode 100644 7E.py create mode 100644 7F.py create mode 100644 7G.py create mode 100644 7H.py create mode 100644 7I.py create mode 100644 8A.py create mode 100644 8B.py create mode 100644 8C.py create mode 100644 8D.py create mode 100644 8E.py create mode 100644 9A.py create mode 100644 9B.py create mode 100644 9C.py create mode 100644 9D.py create mode 100644 9E.py create mode 100644 9F.py create mode 100644 AA.py create mode 100644 AB.py create mode 100644 AC.py create mode 100644 AD.py create mode 100644 AE.py create mode 100644 AF.py create mode 100644 AG.py diff --git a/1A.py b/1A.py new file mode 100644 index 0000000..0692fc6 --- /dev/null +++ b/1A.py @@ -0,0 +1,25 @@ +V, E = map(int, input().split()) +adj = [[] for i in range(V + 1)] +for i in range(E): + u, v = map(int, input().split()) + adj[u].append(v) + adj[v].append(u) +visited = [False] * (V + 1) +ans = [] +for i in range(1, V + 1): + if not visited[i]: + comp = [] + stack = [i] + visited[i] = True + while stack: + u = stack.pop() + comp.append(u) + for v in adj[u]: + if not visited[v]: + visited[v] = True + stack.append(v) + ans.append(comp) +print(len(ans)) +for comp in ans: + print(len(comp)) + print(*(comp)) \ No newline at end of file diff --git a/1B.py b/1B.py new file mode 100644 index 0000000..420aabc --- /dev/null +++ b/1B.py @@ -0,0 +1,24 @@ +V, E = map(int, input().split()) +adj = [[] for i in range(V + 1)] +for i in range(E): + u, v = map(int, input().split()) + adj[u].append(v) + adj[v].append(u) +visited = [False] * (V + 1) +ans = [] +for i in range(1, V + 1): + if not visited[i]: + comp = [] + stack = [i] + visited[i] = True + while stack: + u = stack.pop() + comp.append(u) + for v in adj[u]: + if not visited[v]: + visited[v] = True + stack.append(v) + ans.append(comp) +print(len(ans) - 1) +for i in range(len(ans) - 1): + print(ans[i][0], ans[i+1][0]) \ No newline at end of file diff --git a/1C.py b/1C.py new file mode 100644 index 0000000..b01d6be --- /dev/null +++ b/1C.py @@ -0,0 +1,33 @@ +N, M = map(int, input().split()) +adj = [[] for i in range(N+1)] +for i in range(M): + u, v = map(int, input().split()) + adj[u].append(v) +color = [0]*(N+1) # 0-нет цвета, 1 - обработка, 2 - отмечена и мы закончили +parent = [0]*(N+1) +for i in range(1, N+1): + if color[i] == 0: + stack = [i] + while stack: + u = stack.pop() + if color[u] == 0: + color[u] = 1 + stack.append(u) + for v in adj[u]: + if color[v] == 0: + stack.append(v) + parent[v] = u + elif color[v] == 1 : + cycle = [v] + curr = u + while curr != v: + cycle.append(curr) + curr = parent[curr] + print(len(cycle)) + print(*(cycle[::-1])) + exit() + elif color[u] == 1: + color[u] = 2 + +print("-1") + \ No newline at end of file diff --git a/1D.py b/1D.py new file mode 100644 index 0000000..ebeaa6f --- /dev/null +++ b/1D.py @@ -0,0 +1,22 @@ +n, m = map(int, input().split()) +adj = [[] for i in range(n + 1)] +for i in range(m): + u, v = map(int, input().split()) + adj[u].append(v) + adj[v].append(u) +color = [0] * (n + 1) +for i in range(1, n + 1): + if color[i] == 0: + color[i] = 1 + stack = [i] + while stack: + u = stack.pop() + c = color[u] + for v in adj[u]: + if color[v] == 0: + color[v] = 3 - c + stack.append(v) + elif color[v] == c: + print("-1") + exit() +print(*(color[1:])) diff --git a/1E.py b/1E.py new file mode 100644 index 0000000..3071931 --- /dev/null +++ b/1E.py @@ -0,0 +1,25 @@ +n, m = map(int, input().split()) +adj = [[] for _ in range(n + 1)] +in_degree = [0] * (n + 1) +for _ in range(m): + u, v = map(int, input().split()) + adj[u].append(v) + in_degree[v] += 1 +q = [] +for i in range(1, n + 1): + if in_degree[i] == 0: + q.append(i) +head = 0 +topsort = [] +while head < len(q): + u = q[head] + head += 1 + topsort.append(u) + for v in adj[u]: + in_degree[v] -= 1 + if in_degree[v] == 0: + q.append(v) +if len(topsort) == n: + print(*topsort) +else: + print("-1") \ No newline at end of file diff --git a/1F.py b/1F.py new file mode 100644 index 0000000..78a0518 --- /dev/null +++ b/1F.py @@ -0,0 +1,27 @@ +n = int(input()) +edges = [input().strip() for _ in range(n - 1)] +R_in = [0] * n +R_out = [0] * n +B_in = [0] * n +B_out = [0] * n +for i in range(n - 1): + row = edges[i] + for j_idx, color in enumerate(row): + j = i + 1 + j_idx + if color == 'R': + R_out[i] += 1 + R_in[j] += 1 + else: + B_out[i] += 1 + B_in[j] += 1 +t_mixed_x2 = 0 +s_in_out = 0 +for v in range(n): + road_R = R_in[v] + R_out[v] + road_B = B_in[v] + B_out[v] + t_mixed_x2 += road_R * road_B + s_in_out += R_in[v] * B_out[v] + B_in[v] * R_out[v] +if t_mixed_x2 // 2 == s_in_out: + print("YES") +else: + print("NO") \ No newline at end of file diff --git a/1G.py b/1G.py new file mode 100644 index 0000000..697bb6a --- /dev/null +++ b/1G.py @@ -0,0 +1,171 @@ +import sys + +# Читаем весь ввод разом +data = sys.stdin.read().split() +if not data: + sys.exit(0) + +n = int(data[0]) +m = int(data[1]) + +g = [[] for _ in range(n + 1)] +idx = 2 +for _ in range(m): + u = int(data[idx]) + v = int(data[idx + 1]) + g[u].append(v) + g[v].append(u) + idx += 2 + +# Структуры для DFS-дерева +tree_adj = [[] for _ in range(n + 1)] +sz = [1] * (n + 1) +parent = [0] * (n + 1) +visited = [False] * (n + 1) + +# Строим DFS-дерево итеративно, чтобы не словить RecursionError +stack = [1] +visited[1] = True +order = [] +edge_idx = [0] * (n + 1) + +while stack: + u = stack[-1] + found = False + while edge_idx[u] < len(g[u]): + v = g[u][edge_idx[u]] + edge_idx[u] += 1 + if not visited[v]: + visited[v] = True + parent[v] = u + tree_adj[u].append(v) + stack.append(v) + found = True + break + if not found: + order.append(u) + stack.pop() + +# Считаем размеры поддеревьев (снизу вверх) +for u in order: + if parent[u] != 0: + sz[parent[u]] += sz[u] + +# Поиск единственного верного пути сверху вниз +u = 1 +dp = 1 +path = [] +target_found = -1 + +while u != 0: + path.append(u) + rem = n - len(path) + if rem == 0: + break + + children = tree_adj[u] + + # Проверяем, можем ли мы остановиться прямо сейчас + if rem % 2 == 0 and rem > 0: + target = rem // 2 + temp_dp = dp + mask = (1 << (target + 1)) - 1 + temp_dp &= mask + + # Мысленно добавляем всех детей текущей вершины в рюкзак + for c in children: + temp_dp = (temp_dp | (temp_dp << sz[c])) & mask + + if temp_dp & (1 << target): + target_found = target + break + + if not children: + break + + # Если мы не можем остановиться, мы обязаны шагнуть в самое тяжелое поддерево, + # чтобы "раздробить" его на части. + heavy_child = max(children, key=lambda x: sz[x]) + + # Все остальные дети навсегда "отваливаются" от пути, добавляем их в рюкзак + mask_dp = (1 << ((n + 2) // 2)) - 1 + dp &= mask_dp + for c in children: + if c != heavy_child: + dp = (dp | (dp << sz[c])) & mask_dp + + u = heavy_child + +if target_found != -1: + # Мы нашли путь! Теперь соберем все отвалившиеся поддеревья, из которых мы набрали target + items = [] + for i in range(len(path) - 1): + curr_node = path[i] + next_node = path[i+1] + for c in tree_adj[curr_node]: + if c != next_node: + items.append((c, sz[c])) + + last_node = path[-1] + for c in tree_adj[last_node]: + items.append((c, sz[c])) + + # Честный алгоритм рюкзака с восстановлением ответа (только для собранных компонент) + track = [-1] * (target_found + 1) + dp_track = 1 + + for i, (c, w) in enumerate(items): + nxt = (dp_track << w) & ((1 << (target_found + 1)) - 1) + diff = nxt & ~dp_track + if diff: + # Быстрый битовый трюк для итерации только по новым битам + bit = (diff & -diff) + while diff > 0: + pos = bit.bit_length() - 1 + if pos <= target_found and track[pos] == -1: + track[pos] = i + diff ^= bit + bit = (diff & -diff) + dp_track |= nxt + if dp_track & (1 << target_found): + break + + used_items = set() + curr_w = target_found + while curr_w > 0: + idx = track[curr_w] + used_items.add(idx) + curr_w -= items[idx][1] + + a_ans = [] + b_ans = [] + + # Раскидываем полные поддеревья по комнатам А и Б + for i, (c, w) in enumerate(items): + comp_nodes = [] + q = [c] + h = 0 + while h < len(q): + curr_node = q[h] + h += 1 + comp_nodes.append(curr_node) + for child in tree_adj[curr_node]: + q.append(child) + + if i in used_items: + a_ans.extend(comp_nodes) + else: + b_ans.extend(comp_nodes) + + # Вывод + print(len(path), len(a_ans)) + print(*path) + print(*a_ans) + print(*b_ans) +else: + # Железобетонный фолбек (теоретически недостижим на валидных данных) + half = (n - 1) // 2 + print(1, half) + print(1) + print(*range(2, 2 + half)) + print(*range(2 + half, n + 1)) \ No newline at end of file diff --git a/1H.py b/1H.py new file mode 100644 index 0000000..48c21bb --- /dev/null +++ b/1H.py @@ -0,0 +1,41 @@ +n, m, s, t = map(int, input().split()) + +graph = [[] for _ in range(n + 1)] +in_degree = [0] * (n + 1) + +for _ in range(m): + u, v, weight = map(int, input().split()) + graph[u].append((v, weight)) + in_degree[v] += 1 + +queue = [] +for i in range(1, n + 1): + if in_degree[i] == 0: + queue.append(i) + +order = [] +head = 0 + +while head < len(queue): + current = queue[head] + head += 1 + order.append(current) + + for neighbor, weight in graph[current]: + in_degree[neighbor] -= 1 + if in_degree[neighbor] == 0: + queue.append(neighbor) + +dist = [10**18] * (n + 1) +dist[s] = 0 + +for node in order: + if dist[node] != 10**18: + for neighbor, weight in graph[node]: + if dist[node] + weight < dist[neighbor]: + dist[neighbor] = dist[node] + weight + +if dist[t] == 10**18: + print("Unreachable") +else: + print(dist[t]) \ No newline at end of file diff --git a/1I.py b/1I.py new file mode 100644 index 0000000..3b1c534 --- /dev/null +++ b/1I.py @@ -0,0 +1,15 @@ +n, m = map(int, input().split()) +e = [] +for _ in range(m): + u, v = map(int, input().split()) + e.append((u, v)) +p = list(map(int, input().split())) +d = [0] * (n + 1) +for i in range(n): + d[p[i]] = i +ans = "YES" +for u, v in e: + if d[u] > d[v]: + ans = "NO" + break +print(ans) \ No newline at end of file diff --git a/1J.py b/1J.py new file mode 100644 index 0000000..1bb48ed --- /dev/null +++ b/1J.py @@ -0,0 +1,24 @@ +import heapq + +n = int(input()) +adj = [[] for _ in range(n + 1)] +in_deg = [0] * (n + 1) +for i in range(1, n + 1): + data = list(map(int, input().split())) + if data[0] > 0: + for parent in data[1:]: + adj[parent].append(i) + in_deg[i] += 1 +queue = [] +for i in range(1, n + 1): + if in_deg[i] == 0: + heapq.heappush(queue, i) +ans = [] +while queue: + cur = heapq.heappop(queue) + ans.append(cur) + for nb in adj[cur]: + in_deg[nb] -= 1 + if in_deg[nb] == 0: + heapq.heappush(queue, nb) +print(*(ans)) \ No newline at end of file diff --git a/1K.py b/1K.py new file mode 100644 index 0000000..31f7d6c --- /dev/null +++ b/1K.py @@ -0,0 +1,48 @@ +import sys +input = sys.stdin.readline +line = input().split() +if not line: + sys.exit() +n, m = map(int, line) +g = [[] for _ in range(n + 1)] +gr = [[] for _ in range(n + 1)] +for _ in range(m): + u, v = map(int, input().split()) + g[u].append(v) + gr[v].append(u) +used = [0] * (n + 1) +order = [] +head = [0] * (n + 1) +for i in range(1, n + 1): + if not used[i]: + stack = [i] + used[i] = 1 + while stack: + v = stack[-1] + if head[v] < len(g[v]): + to = g[v][head[v]] + head[v] += 1 + if not used[to]: + used[to] = 1 + stack.append(to) + else: + stack.pop() + order.append(v) +used = [0] * (n + 1) +comp = [0] * (n + 1) +c = 1 +for i in reversed(order): + if not used[i]: + stack = [i] + used[i] = 1 + comp[i] = c + while stack: + v = stack.pop() + for to in gr[v]: + if not used[to]: + used[to] = 1 + comp[to] = c + stack.append(to) + c += 1 +print(c - 1) +print(" ".join(map(str, comp[1:]))) \ No newline at end of file diff --git a/1L.py b/1L.py new file mode 100644 index 0000000..3c6fdd5 --- /dev/null +++ b/1L.py @@ -0,0 +1,46 @@ +import sys +input = sys.stdin.readline +line = input().split() +if not line: + sys.exit() +n, m = map(int, line) +g = [[] for _ in range(n + 1)] +gr = [[] for _ in range(n + 1)] +for _ in range(m): + u, v = map(int, input().split()) + g[u].append(v) + gr[v].append(u) +used = [0] * (n + 1) +order = [] +head = [0] * (n + 1) +for i in range(1, n + 1): + if not used[i]: + stack = [i] + used[i] = 1 + while stack: + v = stack[-1] + if head[v] < len(g[v]): + to = g[v][head[v]] + head[v] += 1 + if not used[to]: + used[to] = 1 + stack.append(to) + else: + stack.pop() + order.append(v) +used = [0] * (n + 1) +ans = 0 +for i in reversed(order): + if not used[i]: + stack = [i] + used[i] = 1 + size = 0 + while stack: + v = stack.pop() + size += 1 + for to in gr[v]: + if not used[to]: + used[to] = 1 + stack.append(to) + ans += min(size, 2) +print(ans) \ No newline at end of file diff --git a/1M.py b/1M.py new file mode 100644 index 0000000..7238cb3 --- /dev/null +++ b/1M.py @@ -0,0 +1,68 @@ +import sys + +data = sys.stdin.read().split() +if not data: + exit() +n = int(data[0]) +m = int(data[1]) +k = int(data[2]) +a = [0] * (n + 1) +max_val = 0 +for i in range(1, n + 1): + a[i] = int(data[2 + i]) + if a[i] > max_val: + max_val = a[i] +adj = [[] for _ in range(n + 1)] +idx = 3 + n +for _ in range(m): + u = int(data[idx]) + v = int(data[idx+1]) + adj[u].append(v) + idx += 2 +l = 1 +r = max_val +ans = -1 +while l <= r: + mid = (l + r) // 2 + in_degree = [0] * (n + 1) + valid_count = 0 + for u in range(1, n + 1): + if a[u] <= mid: + valid_count += 1 + for v in adj[u]: + if a[v] <= mid: + in_degree[v] += 1 + q = [] + dp = [0] * (n + 1) + possible = False + for i in range(1, n + 1): + if a[i] <= mid: + dp[i] = 1 + if dp[i] >= k: + possible = True + if in_degree[i] == 0: + q.append(i) + head = 0 + visited_count = 0 + while head < len(q) and not possible: + u = q[head] + head += 1 + visited_count += 1 + for v in adj[u]: + if a[v] <= mid: + if dp[u] + 1 > dp[v]: + dp[v] = dp[u] + 1 + if dp[v] >= k: + possible = True + break + in_degree[v] -= 1 + if in_degree[v] == 0: + q.append(v) + if visited_count < valid_count: + possible = True + if possible: + ans = mid + r = mid - 1 + else: + l = mid + 1 +print(ans) \ No newline at end of file diff --git a/1N.py b/1N.py new file mode 100644 index 0000000..a68d9b7 --- /dev/null +++ b/1N.py @@ -0,0 +1,74 @@ +import sys + +data = sys.stdin.read().split() +if not data: + exit() +n = int(data[0]) +m = int(data[1]) +adj_all = [[] for _ in range(n + 1)] +adj2 = [[] for _ in range(n + 1)] +rev_adj2 = [[] for _ in range(n + 1)] +edges2 = [] +idx = 2 +for _ in range(m): + u = int(data[idx]) + v = int(data[idx+1]) + t = int(data[idx+2]) + idx += 3 + adj_all[u].append(v) + if t == 2: + adj2[u].append(v) + rev_adj2[v].append(u) + edges2.append((u, v)) +reachable = [False] * (n + 1) +reachable[1] = True +q = [1] +head = 0 +while head < len(q): + u = q[head] + head += 1 + for v in adj_all[u]: + if not reachable[v]: + reachable[v] = True + q.append(v) +visited = [False] * (n + 1) +order = [] +edge_idx = [0] * (n + 1) +stack = [] +for i in range(1, n + 1): + if not visited[i]: + visited[i] = True + stack.append(i) + while stack: + u = stack[-1] + if edge_idx[u] < len(adj2[u]): + v = adj2[u][edge_idx[u]] + edge_idx[u] += 1 + if not visited[v]: + visited[v] = True + stack.append(v) + else: + order.append(u) + stack.pop() +scc_id = [0] * (n + 1) +current_scc = 0 +for i in range(n - 1, -1, -1): + start_node = order[i] + if scc_id[start_node] == 0: + current_scc += 1 + q_scc = [start_node] + scc_id[start_node] = current_scc + head_scc = 0 + while head_scc < len(q_scc): + u = q_scc[head_scc] + head_scc += 1 + for v in rev_adj2[u]: + if scc_id[v] == 0: + scc_id[v] = current_scc + q_scc.append(v) +ans = "No" +for u, v in edges2: + if reachable[u] and scc_id[u] != scc_id[v]: + ans = "Yes" + break +print(ans) \ No newline at end of file diff --git a/1O.py b/1O.py new file mode 100644 index 0000000..d3afa4a --- /dev/null +++ b/1O.py @@ -0,0 +1,101 @@ +import sys +from collections import deque + +reader = (int(token) for line in sys.stdin for token in line.split()) +n = next(reader) +m = next(reader) +A = next(reader) +B = next(reader) +w = [] +e = [] +for i in range(n): + x = next(reader) + y = next(reader) + if x == 0: + w.append((y, i)) + elif x == A: + e.append((y, i)) +max_e = 2 * m +head = [-1] * n +rhead = [-1] * n +to = [0] * max_e +nxt = [0] * max_e +rto = [0] * max_e +rnxt = [0] * max_e +ec = 0 +rec = 0 +for _ in range(m): + u = next(reader) - 1 + v = next(reader) - 1 + k = next(reader) + to[ec] = v + nxt[ec] = head[u] + head[u] = ec + ec += 1 + rto[rec] = u + rnxt[rec] = rhead[v] + rhead[v] = rec + rec += 1 + if k == 2: + to[ec] = u + nxt[ec] = head[v] + head[v] = ec + ec += 1 + rto[rec] = v + rnxt[rec] = rhead[u] + rhead[u] = rec + rec += 1 +vis = [False] * n +q = deque([i for y, i in w]) +for i in q: + vis[i] = True +while q: + v = q.popleft() + idx = head[v] + while idx != -1: + t = to[idx] + if not vis[t]: + vis[t] = True + q.append(t) + idx = nxt[idx] +valid_e = [(y, i) for y, i in e if vis[i]] +valid_e.sort() +mx = [-1] * n +q = deque() +for i in range(len(valid_e) - 1, -1, -1): + _, node = valid_e[i] + if mx[node] == -1: + mx[node] = i + q.append(node) + while q: + v = q.popleft() + idx = rhead[v] + while idx != -1: + t = rto[idx] + if mx[t] == -1: + mx[t] = i + q.append(t) + idx = rnxt[idx] +mn = [-1] * n +for i in range(len(valid_e)): + _, node = valid_e[i] + if mn[node] == -1: + mn[node] = i + q.append(node) + while q: + v = q.popleft() + idx = rhead[v] + while idx != -1: + t = rto[idx] + if mn[t] == -1: + mn[t] = i + q.append(t) + idx = rnxt[idx] +w.sort(reverse=True) +ans = [] +for y, i in w: + if mx[i] != -1 and mn[i] != -1: + ans.append(str(mx[i] - mn[i] + 1)) + else: + ans.append("0") +print('\n'.join(ans)) \ No newline at end of file diff --git a/1P.py b/1P.py new file mode 100644 index 0000000..e69de29 diff --git a/2A.py b/2A.py new file mode 100644 index 0000000..fb5cf4e --- /dev/null +++ b/2A.py @@ -0,0 +1,67 @@ +import sys + + +data = sys.stdin.read().split() +ptr = 0 + + +while ptr < len(data): + n = int(data[ptr]) + ptr += 1 + m = int(data[ptr]) + ptr += 1 + N = 2 * n + g = [[] for _ in range(N)] + gr = [[] for _ in range(N)] + for _ in range(m): + i1 = int(data[ptr]); ptr += 1 + e1 = int(data[ptr]); ptr += 1 + i2 = int(data[ptr]); ptr += 1 + e2 = int(data[ptr]); ptr += 1 + u_neg = 2 * i1 + (1 - e1) + v_neg = 2 * i2 + (1 - e2) + u_pos = 2 * i1 + e1 + v_pos = 2 * i2 + e2 + g[u_neg].append(v_pos) + gr[v_pos].append(u_neg) + g[v_neg].append(u_pos) + gr[u_pos].append(v_neg) + visited = [False] * N + order = [] + for i in range(N): + if not visited[i]: + stack = [(i, 0)] + visited[i] = True + while stack: + cur, edge_idx = stack[-1] + if edge_idx < len(g[cur]): + next_node = g[cur][edge_idx] + stack[-1] = (cur, edge_idx + 1) + if not visited[next_node]: + visited[next_node] = True + stack.append((next_node, 0)) + else: + order.append(cur) + stack.pop() + comp = [-1] * N + c_id = 0 + for i in range(N - 1, -1, -1): + start_node = order[i] + if comp[start_node] == -1: + c_id += 1 + stack = [start_node] + comp[start_node] = c_id + while stack: + cur = stack.pop() + for neighbor in gr[cur]: + if comp[neighbor] == -1: + comp[neighbor] = c_id + stack.append(neighbor) + + res = [] + for i in range(n): + if comp[2 * i + 1] > comp[2 * i]: + res.append("1") + else: + res.append("0") + print("".join(res)) \ No newline at end of file diff --git a/2B.py b/2B.py new file mode 100644 index 0000000..e69de29 diff --git a/2C.py b/2C.py new file mode 100644 index 0000000..e69de29 diff --git a/2D.py b/2D.py new file mode 100644 index 0000000..5ca1298 --- /dev/null +++ b/2D.py @@ -0,0 +1,54 @@ +import sys + +data = sys.stdin.read().split() +if not data: + sys.exit() +n = int(data[0]) +m = int(data[1]) +adj = [[] for _ in range(n + 1)] +idx = 2 +for i in range(1, m + 1): + u = int(data[idx]) + v = int(data[idx+1]) + idx += 2 + adj[u].append((v, i)) + adj[v].append((u, i)) +tin = [-1] * (n + 1) +fup = [-1] * (n + 1) +ans = [] +timer = 0 +ptr = [0] * (n + 1) +stack = [] +for i in range(1, n + 1): + if tin[i] == -1: + tin[i] = fup[i] = timer + timer += 1 + stack.append((i, -1)) + while stack: + v, p_e = stack[-1] + if ptr[v] < len(adj[v]): + to, e_idx = adj[v][ptr[v]] + ptr[v] += 1 + + if e_idx == p_e: + continue + + if tin[to] != -1: + if tin[to] < fup[v]: + fup[v] = tin[to] + else: + tin[to] = fup[to] = timer + timer += 1 + stack.append((to, e_idx)) + else: + stack.pop() + if stack: + p_v, _ = stack[-1] + if fup[v] < fup[p_v]: + fup[p_v] = fup[v] + if fup[v] > tin[p_v]: + ans.append(p_e) +ans.sort() +print(len(ans)) +if ans: + print(*(ans)) \ No newline at end of file diff --git a/2E.py b/2E.py new file mode 100644 index 0000000..e69de29 diff --git a/2F.py b/2F.py new file mode 100644 index 0000000..e69de29 diff --git a/2G.py b/2G.py new file mode 100644 index 0000000..e69de29 diff --git a/2H.py b/2H.py new file mode 100644 index 0000000..e69de29 diff --git a/3D.cpp b/3D.cpp new file mode 100644 index 0000000..b12d393 --- /dev/null +++ b/3D.cpp @@ -0,0 +1,50 @@ +#include + +using namespace std; + +long long x[20005]; +long long y[20005]; +long long D[20005]; +bool visited[20005]; + +int main() { + int n; + cin >> n; + for (int i = 1; i <= n; i++) { + cin >> x[i] >> y[i]; + } + int s, t; + cin >> s >> t; + long long INF = 1000000000000000000LL; + for (int i = 1; i <= n; i++) { + D[i] = INF; + visited[i] = false; + } + D[s] = 0; + for (int i = 1; i <= n; i++) { + int u = -1; + long long min_d = INF; + for (int j = 1; j <= n; j++) { + if (visited[j] == false && D[j] < min_d) { + min_d = D[j]; + u = j; + } + } + if (u == -1 || u == t || D[u] == INF) { + break; + } + visited[u] = true; + for (int v = 1; v <= n; v++) { + if (visited[v] == false) { + long long dx = x[u] - x[v]; + long long dy = y[u] - y[v]; + long long cost = D[u] + dx * dx + dy * dy; + if (cost < D[v]) { + D[v] = cost; + } + } + } + } + cout << D[t] << "\n"; + return 0; +} \ No newline at end of file diff --git a/3D.exe b/3D.exe new file mode 100644 index 0000000000000000000000000000000000000000..a5ac168c20149f4d60f3939000b3aa9ca3658ce1 GIT binary patch literal 54945 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 D3d=#4 literal 0 HcmV?d00001 diff --git a/3D.py b/3D.py new file mode 100644 index 0000000..25a363b --- /dev/null +++ b/3D.py @@ -0,0 +1,33 @@ +data = open(0).read().split() +if not data: + exit() +n = int(data[0]) +x = [0] * n +y = [0] * n +idx = 1 +for i in range(n): + x[i] = int(data[idx]) + y[i] = int(data[idx+1]) + idx += 2 +s = int(data[idx]) - 1 +t = int(data[idx+1]) - 1 +INF = 10**18 +D = [INF] * n +D[s] = 0 +unvisited = list(range(n)) +get_D = D.__getitem__ +while unvisited: + u = min(unvisited, key=get_D) + if u == t or D[u] == INF: + break + unvisited.remove(u) + du = D[u] + xu = x[u] + yu = y[u] + for v in unvisited: + dx = xu - x[v] + dy = yu - y[v] + cost = du + dx * dx + dy * dy + if cost < D[v]: + D[v] = cost +print(D[t]) \ No newline at end of file diff --git a/3E.py b/3E.py new file mode 100644 index 0000000..5887f60 --- /dev/null +++ b/3E.py @@ -0,0 +1,41 @@ +import sys + + +data = sys.stdin.read().split() +if not data: + exit() +n = int(data[0]) +m = int(data[1]) +INF = 10**15 +dist = [] +for i in range(n + 1): + row = [INF] * (n + 1) + row[i] = 0 + dist.append(row) +idx = 2 +for _ in range(m): + u = int(data[idx]) + v = int(data[idx+1]) + w = int(data[idx+2]) + idx += 3 + if w < dist[u][v]: + dist[u][v] = w +for k in range(1, n + 1): + for i in range(1, n + 1): + if dist[i][k] != INF: + for j in range(1, n + 1): + if dist[k][j] != INF: + new_dist = dist[i][k] + dist[k][j] + if new_dist < dist[i][j]: + dist[i][j] = new_dist +out = [] +for i in range(1, n + 1): + row_out = [] + for j in range(1, n + 1): + if dist[i][j] == INF: + row_out.append("30000") + else: + row_out.append(str(dist[i][j])) + out.append(" ".join(row_out)) + +print("\n".join(out)) \ No newline at end of file diff --git a/3F.py b/3F.py new file mode 100644 index 0000000..529d339 --- /dev/null +++ b/3F.py @@ -0,0 +1,37 @@ +import sys +data = sys.stdin.read().split() +if not data: + exit() +n = int(data[0]) +m = int(data[1]) +U = [0] * m +V = [0] * m +W = [0] * m +idx = 2 +for i in range(m): + U[i] = int(data[idx]) + V[i] = int(data[idx+1]) + W[i] = int(data[idx+2]) + idx += 3 +INF = 10**15 +D = [INF] * (n + 1) +D[1] = 0 +for _ in range(n - 1): + any_relaxed = False + for i in range(m): + u = U[i] + if D[u] != INF: + v = V[i] + cost = D[u] + W[i] + if cost < D[v]: + D[v] = cost + any_relaxed = True + if not any_relaxed: + break +ans = [] +for i in range(1, n + 1): + if D[i] == INF: + ans.append(30000) + else: + ans.append(D[i]) +print(*ans) \ No newline at end of file diff --git a/3G.py b/3G.py new file mode 100644 index 0000000..af7b152 --- /dev/null +++ b/3G.py @@ -0,0 +1,31 @@ +import sys +import heapq +data = sys.stdin.read().split() +if data: + n = int(data[0]) + m = int(data[1]) + graph = [[] for _ in range(n + 1)] + idx = 2 + for _ in range(m): + u = int(data[idx]) + v = int(data[idx+1]) + w = int(data[idx+2]) + graph[u].append((v, w)) + graph[v].append((u, w)) + idx += 3 + inf = 10**18 + dist = [inf] * (n + 1) + dist[1] = 0 + pq = [(0, 1)] + while len(pq) > 0: + d, u = heapq.heappop(pq) + if d > dist[u]: + continue + for v, w in graph[u]: + if dist[u] + w < dist[v]: + dist[v] = dist[u] + w + heapq.heappush(pq, (dist[v], v)) + ans = [] + for i in range(1, n + 1): + ans.append(str(dist[i])) + sys.stdout.write(" ".join(ans) + "\n") \ No newline at end of file diff --git a/3H.py b/3H.py new file mode 100644 index 0000000..8f6fb20 --- /dev/null +++ b/3H.py @@ -0,0 +1,26 @@ +import sys + +input_data = sys.stdin.read().split() +N = int(input_data[0]) +edges = [] +idx = 1 +for i in range(N): + for j in range(N): + w = int(input_data[idx]) + idx += 1 + if w != 100000: + edges.append((i, j, w)) +d = [0] * N +for _ in range(N - 1): + for u, v, w in edges: + if d[u] + w < d[v]: + d[v] = d[u] + w +flag = False +for u, v, w in edges: + if d[u] + w < d[v]: + flag = True + break +if flag: + print("YES") +else: + print("NO") diff --git a/3I.py b/3I.py new file mode 100644 index 0000000..cead3ac --- /dev/null +++ b/3I.py @@ -0,0 +1,32 @@ +import sys + +input_data = sys.stdin.read().split() +N = int(input_data[0]) +M = int(input_data[1]) +K = int(input_data[2]) +S = int(input_data[3]) - 1 +edges = [] +ptr = 4 +for _ in range(M): + u = int(input_data[ptr]) - 1 + v = int(input_data[ptr+1]) - 1 + w = int(input_data[ptr+2]) + edges.append((u, v, w)) + ptr += 3 +INF = 10**15 +dp = [INF] * N +dp[S] = 0 +for _ in range(K): + next_dp = [INF] * N + for u, v, w in edges: + if dp[u] != INF: + if dp[u] + w < next_dp[v]: + next_dp[v] = dp[u] + w + dp = next_dp +res = [] +for val in dp: + if val == INF: + res.append("-1") + else: + res.append(str(val)) +print("\n".join(res)) \ No newline at end of file diff --git a/3J.py b/3J.py new file mode 100644 index 0000000..e69de29 diff --git a/3K.py b/3K.py new file mode 100644 index 0000000..b40eb52 --- /dev/null +++ b/3K.py @@ -0,0 +1,24 @@ +import sys + +data = list(map(int, sys.stdin.read().split())) + +n = data[0] +init_ = data[1 : 1 + n * n] +queue_to_del = [x - 1 for x in data[1 + n * n :]] +ans = [] +active = [False] * n +for step in range(n - 1, -1, -1): + k = queue_to_del[step] + active[k] = True + cur_sum = 0 + k_row = k * n + for i in range(n): + i_row = i * n + dik = init_[i_row + k] + for j in range(n): + if dik + init_[k_row + j] < init_[i_row + j]: + init_[i_row + j] = dik + init_[k_row + j] + if active[i] and active[j]: + cur_sum += init_[i_row + j] + ans.append(cur_sum) +print(" ".join(map(str, reversed(ans)))) \ No newline at end of file diff --git a/3L.py b/3L.py new file mode 100644 index 0000000..d76a9c5 --- /dev/null +++ b/3L.py @@ -0,0 +1,70 @@ +import sys + +data = sys.stdin.read().split() +if not data: + exit() +n = int(data[0]) +m = int(data[1]) +ans = [] +for i in range(n): + ans.extend(list(data[2 + i])) +q = [0] * (n * m) +head = 0 +tail = 0 +for c in range(m): + if ans[c] == '.': + ans[c] = '^' + q[tail] = c + tail += 1 +for c in range(m): + pos = (n - 1) * m + c + if ans[pos] == '.': + ans[pos] = 'v' + q[tail] = pos + tail += 1 +for r in range(n): + pos = r * m + if ans[pos] == '.': + ans[pos] = '<' + q[tail] = pos + tail += 1 +for r in range(n): + pos = r * m + (m - 1) + if ans[pos] == '.': + ans[pos] = '>' + q[tail] = pos + tail += 1 +while head < tail: + pos = q[head] + head += 1 + r = pos // m + c = pos % m + if r > 0: + npos = pos - m + if ans[npos] == '.': + ans[npos] = 'v' + q[tail] = npos + tail += 1 + if r < n - 1: + npos = pos + m + if ans[npos] == '.': + ans[npos] = '^' + q[tail] = npos + tail += 1 + if c > 0: + npos = pos - 1 + if ans[npos] == '.': + ans[npos] = '>' + q[tail] = npos + tail += 1 + if c < m - 1: + npos = pos + 1 + if ans[npos] == '.': + ans[npos] = '<' + q[tail] = npos + tail += 1 + +out = [] +for r in range(n): + out.append("".join(ans[r * m : (r + 1) * m])) +print("\n".join(out)) \ No newline at end of file diff --git a/4A.py b/4A.py new file mode 100644 index 0000000..cd37709 --- /dev/null +++ b/4A.py @@ -0,0 +1,30 @@ +import sys +import math + +data = sys.stdin.read().split() +n = int(data[0]) +xs = [] +ys = [] +idx = 1 +for _ in range(n): + xs.append(int(data[idx])) + ys.append(int(data[idx+1])) + idx += 2 +min_e = [float('inf')] * n +used = [False] * n +min_e[0] = 0.0 +ans = 0.0 +for _ in range(n): + v = -1 + for i in range(n): + if not used[i] and (v == -1 or min_e[i] < min_e[v]): + v = i + used[v] = True + ans += math.sqrt(min_e[v]) + vx, vy = xs[v], ys[v] + for u in range(n): + if not used[u]: + dist_sq = (xs[u] - vx)**2 + (ys[u] - vy)**2 + if dist_sq < min_e[u]: + min_e[u] = dist_sq +print(f"{ans:.10f}") \ No newline at end of file diff --git a/4B.py b/4B.py new file mode 100644 index 0000000..2524cf0 --- /dev/null +++ b/4B.py @@ -0,0 +1,32 @@ +import sys + +data = sys.stdin.read().split() +n = int(data[0]) +m = int(data[1]) +edges = [] +idx = 2 +for _ in range(m): + edges.append((int(data[idx+2]), int(data[idx]), int(data[idx+1]))) + idx += 3 +edges.sort() +p = list(range(n + 1)) +def find(i): + r = i + while r != p[r]: + r = p[r] + c = i + while c != r: + p[c], c = r, p[c] + return r +ans = 0 +cnt = 0 +for w, u, v in edges: + ru = find(u) + rv = find(v) + if ru != rv: + p[ru] = rv + ans += w + cnt += 1 + if cnt == n - 1: + break +print(ans) \ No newline at end of file diff --git a/4C.py b/4C.py new file mode 100644 index 0000000..28a8b9e --- /dev/null +++ b/4C.py @@ -0,0 +1,41 @@ +import sys + +data = sys.stdin.read().split() +n, m = int(data[0]), int(data[1]) +edges = [] +idx = 2 +for i in range(m): + edges.append([int(data[idx+2]), int(data[idx]), int(data[idx+1]), i]) + idx += 3 +edges.sort() +def find(i, p): + if p[i] == i: return i + p[i] = find(p[i], p) + return p[i] +p = list(range(n + 1)) +s1 = 0 +mst_edges = [] +for j in range(m): + w, u, v, eid = edges[j] + ru, rv = find(u, p), find(v, p) + if ru != rv: + p[ru] = rv + s1 += w + mst_edges.append(j) +s2 = float('inf') +for i in mst_edges: + p = list(range(n + 1)) + w_tot = 0 + cnt = 0 + for j in range(m): + if j == i: + continue + w, u, v, eid = edges[j] + ru, rv = find(u, p), find(v, p) + if ru != rv: + p[ru] = rv + w_tot += w + cnt += 1 + if cnt == n - 1 and w_tot < s2: + s2 = w_tot +print(s1, s2) diff --git a/4D.py b/4D.py new file mode 100644 index 0000000..e69de29 diff --git a/4E.py b/4E.py new file mode 100644 index 0000000..e69de29 diff --git a/4F.py b/4F.py new file mode 100644 index 0000000..e69de29 diff --git a/4G.py b/4G.py new file mode 100644 index 0000000..e69de29 diff --git a/5A.py b/5A.py new file mode 100644 index 0000000..a70a277 --- /dev/null +++ b/5A.py @@ -0,0 +1,17 @@ +import sys + +s = sys.stdin.read().strip() +n = len(s) + +z = [0] * n +z[0] = n +l, r = 0, 0 +for i in range(1, n): + if i <= r: + z[i] = min(r - i + 1, z[i - l]) + while i + z[i] < n and s[z[i]] == s[i + z[i]]: + z[i] += 1 + if i + z[i] - 1 > r: + l = i + r = i + z[i] - 1 +print(*(z)) \ No newline at end of file diff --git a/5B.py b/5B.py new file mode 100644 index 0000000..0da40e0 --- /dev/null +++ b/5B.py @@ -0,0 +1,21 @@ +import sys + +data = sys.stdin.read().split() +s, t = data[0], data[1] +m = len(t) +st = t + "#" + s +n = len(st) +z = [0] * n +l, r = 0, 0 +ans = [] +for i in range(1, n): + if i <= r: + z[i] = min(r - i + 1, z[i - l]) + while i + z[i] < n and st[z[i]] == st[i + z[i]]: + z[i] += 1 + if i + z[i] - 1 > r: + l = i + r = i + z[i] - 1 + if z[i] == m: + ans.append(i - m - 1) +print(*ans) \ No newline at end of file diff --git a/5C.py b/5C.py new file mode 100644 index 0000000..8e053d5 --- /dev/null +++ b/5C.py @@ -0,0 +1,23 @@ +import sys + +data = sys.stdin.read().split() +a, b = data[0], data[1] +n = len(a) +st = a + "#" + b + b +total_len = len(st) +z = [0] * total_len +l, r = 0, 0 +ans = -1 +for i in range(1, total_len): + if i <= r: + z[i] = min(r - i + 1, z[i - l]) + while i + z[i] < total_len and st[z[i]] == st[i + z[i]]: + z[i] += 1 + if i + z[i] - 1 > r: + l = i + r = i + z[i] - 1 + if n + 1 <= i < 2 * n + 1: + if z[i] == n: + ans = i - (n + 1) + break +print(ans) \ No newline at end of file diff --git a/5D.py b/5D.py new file mode 100644 index 0000000..e6cd0d0 --- /dev/null +++ b/5D.py @@ -0,0 +1,30 @@ +import sys + +line = sys.stdin.buffer.readline().split() +n, m = int(line[0]), int(line[1]) +g = sys.stdin.buffer.readline().strip() +pi = [0] * n +for i in range(1, n): + j = pi[i-1] + while j > 0 and g[i] != g[j]: + j = pi[j-1] + if g[i] == g[j]: j += 1 + pi[i] = j +ans = 0 +idx = 0 +j = 0 +while True: + chunk = sys.stdin.buffer.read(131072) + if not chunk: + break + chunk = chunk.replace(b'\n', b'').replace(b'\r', b'') + for c in chunk: + while j > 0 and c != g[j]: + j = pi[j-1] + if c == g[j]: + j += 1 + if j == n: + ans += (idx - n + 1) + j = pi[n-1] + idx += 1 +print(ans) \ No newline at end of file diff --git a/5E.py b/5E.py new file mode 100644 index 0000000..e69de29 diff --git a/5F.py b/5F.py new file mode 100644 index 0000000..e69de29 diff --git a/5G.py b/5G.py new file mode 100644 index 0000000..e69de29 diff --git a/5H.py b/5H.py new file mode 100644 index 0000000..e69de29 diff --git a/6A.py b/6A.py new file mode 100644 index 0000000..e69de29 diff --git a/6B.py b/6B.py new file mode 100644 index 0000000..e69de29 diff --git a/6C.py b/6C.py new file mode 100644 index 0000000..e69de29 diff --git a/6D.py b/6D.py new file mode 100644 index 0000000..e69de29 diff --git a/6E.py b/6E.py new file mode 100644 index 0000000..e69de29 diff --git a/7A.py b/7A.py new file mode 100644 index 0000000..b214c1f --- /dev/null +++ b/7A.py @@ -0,0 +1,51 @@ +import sys + +data = sys.stdin.read().split() +n, m = int(data[0]), int(data[1]) +parents = [0] * n +idx = 2 +for i in range(1, n): + parents[i] = int(data[idx]) + idx += 1 +a1, a2 = int(data[idx]), int(data[idx+1]) +x, y, z = int(data[idx+2]), int(data[idx+3]), int(data[idx+4]) +adj = [[] for _ in range(n)] +for i in range(1, n): + adj[parents[i]].append(i) +depth = [0] * n +q = [0] +for u in q: + for v in adj[u]: + depth[v] = depth[u] + 1 + q.append(v) +up = [[0] * 18 for _ in range(n)] +for i in range(1, n): + up[i][0] = parents[i] +for k in range(1, 18): + for i in range(n): + up[i][k] = up[up[i][k-1]][k-1] +a = [0] * (2 * m + 1) +a[1], a[2] = a1, a2 +for i in range(3, 2 * m + 1): + a[i] = (x * a[i-2] + y * a[i-1] + z) % n +ans = 0 +v = 0 +for i in range(1, m + 1): + u = (a[2*i-1] + v) % n + vq = a[2*i] + if depth[u] < depth[vq]: + u, vq = vq, u + diff = depth[u] - depth[vq] + for k in range(18): + if (diff >> k) & 1: + u = up[u][k] + if u == vq: + v = u + else: + for k in range(17, -1, -1): + if up[u][k] != up[vq][k]: + u = up[u][k] + vq = up[vq][k] + v = up[u][0] + ans += v +print(ans) \ No newline at end of file diff --git a/7B.py b/7B.py new file mode 100644 index 0000000..af73273 --- /dev/null +++ b/7B.py @@ -0,0 +1,57 @@ +import sys + +def f_lca(u, v_node): + if d[u] < d[v_node]: + u, v_node = v_node, u + diff = d[u] - d[v_node] + for k in range(18): + if (diff >> k) & 1: + u = up[u][k] + if u == v_node: + return u + for k in range(17, -1, -1): + if up[u][k] != up[v_node][k]: + u = up[u][k] + v_node = up[v_node][k] + return up[u][0] + + +data = sys.stdin.read().split() +n = int(data[0]) +v = [0] + [int(x) for x in data[1 : n + 1]] +g = [[] for _ in range(n + 1)] +idx = n + 1 +for _ in range(n - 1): + u, p_node = int(data[idx]), int(data[idx + 1]) + g[u].append(p_node) + g[p_node].append(u) + idx += 2 +m = int(data[idx]) +idx += 1 +d = [0] * (n + 1) +p = [0] * (n + 1) +par = [0] * (n + 1) +d[1] = 1 +p[1] = v[1] +q = [1] +for u in q: + for nv in g[u]: + if nv != par[u]: + par[nv] = u + d[nv] = d[u] + 1 + p[nv] = p[u] + v[nv] + q.append(nv) +up = [[0] * 18 for _ in range(n + 1)] +for i in range(1, n + 1): + up[i][0] = par[i] +for k in range(1, 18): + for i in range(1, n + 1): + up[i][k] = up[up[i][k - 1]][k - 1] +out = [] +for _ in range(m): + x, y = int(data[idx]), int(data[idx + 1]) + idx += 2 + lca = f_lca(x, y) + ans = p[x] + p[y] - p[lca] - p[up[lca][0]] + out.append(str(ans)) +print("\n".join(out)) \ No newline at end of file diff --git a/7C.py b/7C.py new file mode 100644 index 0000000..e69de29 diff --git a/7D.py b/7D.py new file mode 100644 index 0000000..e69de29 diff --git a/7E.py b/7E.py new file mode 100644 index 0000000..e69de29 diff --git a/7F.py b/7F.py new file mode 100644 index 0000000..e69de29 diff --git a/7G.py b/7G.py new file mode 100644 index 0000000..e69de29 diff --git a/7H.py b/7H.py new file mode 100644 index 0000000..e69de29 diff --git a/7I.py b/7I.py new file mode 100644 index 0000000..e69de29 diff --git a/8A.py b/8A.py new file mode 100644 index 0000000..3531749 --- /dev/null +++ b/8A.py @@ -0,0 +1,32 @@ +import sys + +data = sys.stdin.read().split() +a = int(data[0]) +b = int(data[1]) +c = int(data[2]) + +x0, x1 = 1, 0 +y0, y1 = 0, 1 +temp_a, temp_b = a, b + +while temp_b != 0: + q = temp_a // temp_b + temp_a, temp_b = temp_b, temp_a % temp_b + x0, x1 = x1, x0 - q * x1 + y0, y1 = y1, y0 - q * y1 + +g = temp_a +x = x0 +y = y0 + +if c % g != 0: + print("Impossible") +else: + x *= c // g + y *= c // g + step = b // g + x = x % step + if x < 0: + x += step + y = (c - a * x) // b + print(x, y) \ No newline at end of file diff --git a/8B.py b/8B.py new file mode 100644 index 0000000..ef6e32d --- /dev/null +++ b/8B.py @@ -0,0 +1,29 @@ +import sys +from array import array + +data = sys.stdin.read().split() +p = int(data[0]) +if p == 2: + print(1) + sys.exit(0) +half = p // 2 + 1 +inv = array('i', [0] * half) +inv[1] = 1 +current_sum = 0 +count = 0 +for i in range(1, p): + if i == 1: + val = 1 + elif i < half: + inv[i] = (p - (p // i) * inv[p % i]) % p + val = inv[i] + else: + val = (p - (p // i) * inv[p % i]) % p + current_sum = (current_sum + val) % p + count += 1 + if count == 100: + print(current_sum) + current_sum = 0 + count = 0 +if count > 0: + print(current_sum) \ No newline at end of file diff --git a/8C.py b/8C.py new file mode 100644 index 0000000..5f2f4e6 --- /dev/null +++ b/8C.py @@ -0,0 +1,34 @@ +import sys + +def check(n): + if n < 2: + return False + if n in (2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37): + return True + if n % 2 == 0: + return False + d = n - 1 + r = 0 + while d % 2 == 0: + d //= 2 + r += 1 + bases = (2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37) + for a in bases: + x = pow(a, d, n) + if x == 1 or x == n - 1: + continue + for _ in range(r - 1): + x = pow(x, 2, n) + if x == n - 1: + break + else: + return False + return True +data = sys.stdin.read().split() +num_tests = int(data[0]) +for i in range(1, num_tests + 1): + val = int(data[i]) + if check(val): + print("YES") + else: + print("NO") \ No newline at end of file diff --git a/8D.py b/8D.py new file mode 100644 index 0000000..4d3d7c3 --- /dev/null +++ b/8D.py @@ -0,0 +1,12 @@ +import sys +import math + +data = sys.stdin.read().split() +x1 = int(data[0]) +y1 = int(data[1]) +x2 = int(data[2]) +y2 = int(data[3]) +dx = abs(x2 - x1) +dy = abs(y2 - y1) +ans = math.gcd(dx, dy) + 1 +print(ans) \ No newline at end of file diff --git a/8E.py b/8E.py new file mode 100644 index 0000000..e684777 --- /dev/null +++ b/8E.py @@ -0,0 +1,23 @@ +import sys + +data = sys.stdin.read().split() +n = int(data[0]) +factors = [] +d = 2 +while d * d <= n: + if n % d == 0: + count = 0 + while n % d == 0: + count += 1 + n //= d + factors.append((d, count)) + d += 1 +if n > 1: + factors.append((n, 1)) +ans_parts = [] +for p, e in factors: + if e > 1: + ans_parts.append(f"{p}^{e}") + else: + ans_parts.append(f"{p}") +print("*".join(ans_parts)) \ No newline at end of file diff --git a/9A.py b/9A.py new file mode 100644 index 0000000..595db68 --- /dev/null +++ b/9A.py @@ -0,0 +1 @@ +print(int(input())*int(input())) \ No newline at end of file diff --git a/9B.py b/9B.py new file mode 100644 index 0000000..a88c9a9 --- /dev/null +++ b/9B.py @@ -0,0 +1,37 @@ +import sys + +data = sys.stdin.read().split() +if data: + target_N = int(data[0]) + target_H = int(data[1]) + MOD = 786433 + if target_H > 30: + print(0) + sys.exit(0) + min_n = [0] * 35 + min_n[0] = 0 + min_n[1] = 1 + for h in range(2, 35): + min_n[h] = min_n[h-1] + min_n[h-2] + 1 + dp = [[0] * (target_N + 1) for _ in range(target_H + 2)] + dp[0][0] = 1 + if target_N >= 1: + dp[1][1] = 1 + for h_idx in range(2, target_H + 2): + h_real = h_idx - 1 + if min_n[h_real + 1] > target_N: + break + for n in range(min_n[h_real + 1], target_N + 1): + ways = 0 + min_k = min_n[h_idx - 2] + max_k = n - 1 - min_n[h_idx - 2] + if min_k > max_k: + continue + for k in range(min_k, max_k + 1): + r = n - 1 - k + w1 = dp[h_idx-1][k] * dp[h_idx-1][r] + w2 = dp[h_idx-1][k] * dp[h_idx-2][r] + w3 = dp[h_idx-2][k] * dp[h_idx-1][r] + ways += w1 + w2 + w3 + dp[h_idx][n] = ways % MOD + print(dp[target_H + 1][target_N]) \ No newline at end of file diff --git a/9C.py b/9C.py new file mode 100644 index 0000000..dfc1ba2 --- /dev/null +++ b/9C.py @@ -0,0 +1,91 @@ +import sys + +input_data = sys.stdin.read().split() +if not input_data: + sys.exit() + +MOD = 998244353 +G = 3 + +def ntt(a, invert): + n = len(a) + j = 0 + for i in range(1, n): + bit = n >> 1 + while j & bit: + j ^= bit + bit >>= 1 + j ^= bit + if i < j: + a[i], a[j] = a[j], a[i] + step = 2 + while step <= n: + half = step >> 1 + wlen = pow(G, (MOD - 1) // step, MOD) + if invert: + wlen = pow(wlen, MOD - 2, MOD) + w = [1] * half + curr = 1 + for i in range(half): + w[i] = curr + curr = (curr * wlen) % MOD + for i in range(0, n, step): + for j in range(half): + u = a[i + j] + v = (a[i + j + half] * w[j]) % MOD + a[i + j] = (u + v) % MOD + a[i + j + half] = (u - v + MOD) % MOD + step <<= 1 + if invert: + n_inv = pow(n, MOD - 2, MOD) + for i in range(n): + a[i] = (a[i] * n_inv) % MOD + +def multiply(a, b): + if not a or not b: + return [] + sz = len(a) + len(b) - 1 + n = 1 + while n < sz: + n <<= 1 + a = a + [0] * (n - len(a)) + b = b + [0] * (n - len(b)) + ntt(a, False) + ntt(b, False) + for i in range(n): + a[i] = (a[i] * b[i]) % MOD + ntt(a, True) + return a[:sz] +t = int(input_data[0]) +ptr = 1 +for _ in range(t): + if ptr >= len(input_data): + break + n = int(input_data[ptr]) + s = input_data[ptr+1] + ptr += 2 + A = [0] * n + B = [0] * n + for i in range(n): + if s[i] == 'V': + A[i] = 1 + elif s[i] == 'K': + B[n - 1 - i] = 1 + C = multiply(A, B) + bad = [False] * (n + 1) + for k in range(len(C)): + if C[k] > 0: + dist = abs(n - 1 - k) + if dist <= n: + bad[dist] = True + ans = [] + for p in range(1, n + 1): + valid = True + for m in range(p, n + 1, p): + if bad[m]: + valid = False + break + if valid: + ans.append(p) + print(len(ans)) + print(*(ans)) \ No newline at end of file diff --git a/9D.py b/9D.py new file mode 100644 index 0000000..3250a4e --- /dev/null +++ b/9D.py @@ -0,0 +1,41 @@ +import sys + +input_data = sys.stdin.read().split() +s_len = int(input_data[0]) +t_len = int(input_data[1]) +k = int(input_data[2]) +S = input_data[3] +T = input_data[4] + +mask_S = {} +for char in "ACGT": + valid = [0] * s_len + + last = -1000000 + for i in range(s_len): + if S[i] == char: + last = i + if i - last <= k: + valid[i] = 1 + + last = 1000000 + for i in range(s_len - 1, -1, -1): + if S[i] == char: + last = i + if last - i <= k: + valid[i] = 1 + + b = bytearray((s_len + 7) // 8) + for i in range(s_len): + if valid[i]: + b[i // 8] |= (1 << (i % 8)) + + mask_S[char] = int.from_bytes(b, byteorder='little') + +ans_mask = (1 << (s_len - t_len + 1)) - 1 +ans_mask &= mask_S[T[0]] + +for j in range(1, t_len): + ans_mask = (ans_mask << 1) & mask_S[T[j]] + +print(ans_mask.bit_count()) \ No newline at end of file diff --git a/9E.py b/9E.py new file mode 100644 index 0000000..dcd263d --- /dev/null +++ b/9E.py @@ -0,0 +1,105 @@ +import sys + +input_data = sys.stdin.read().split() + +n = int(input_data[0]) +k = int(input_data[1]) + +idx = 2 +a = [int(x) for x in input_data[idx : idx + n]] +idx += n + +b = [int(x) for x in input_data[idx : idx + k]] +idx += k + +q = int(input_data[idx]) +idx += 1 + +queries = [int(x) for x in input_data[idx : idx + q]] + +MOD = 998244353 +G = 3 + +def ntt(a, invert): + n = len(a) + j = 0 + for i in range(1, n): + bit = n >> 1 + while j & bit: + j ^= bit + bit >>= 1 + j ^= bit + if i < j: + a[i], a[j] = a[j], a[i] + step = 2 + while step <= n: + half = step >> 1 + wlen = pow(G, (MOD - 1) // step, MOD) + if invert: + wlen = pow(wlen, MOD - 2, MOD) + w = [1] * half + curr = 1 + for i in range(half): + w[i] = curr + curr = (curr * wlen) % MOD + for i in range(0, n, step): + for j in range(half): + u = a[i + j] + v = (a[i + j + half] * w[j]) % MOD + a[i + j] = (u + v) % MOD + a[i + j + half] = (u - v + MOD) % MOD + step <<= 1 + if invert: + n_inv = pow(n, MOD - 2, MOD) + for i in range(n): + a[i] = (a[i] * n_inv) % MOD + +def multiply(a, b): + sz = len(a) + len(b) - 1 + n = 1 + while n < sz: + n <<= 1 + a_pad = a + [0] * (n - len(a)) + b_pad = b + [0] * (n - len(b)) + ntt(a_pad, False) + ntt(b_pad, False) + for i in range(n): + a_pad[i] = (a_pad[i] * b_pad[i]) % MOD + ntt(a_pad, True) + return a_pad[:sz] + +max_a = 300005 +counts = [0] * max_a +for x in a: + if x < max_a: + counts[x] += 1 + +final_ans = [0] * len(queries) + +for H in b: + polynoms = [] + for x in range(1, min(H, max_a)): + if counts[x] > 0: + polynoms.append([1, counts[x]]) + + if not polynoms: + P = [1] + else: + while len(polynoms) > 1: + next_level = [] + for i in range(0, len(polynoms), 2): + if i + 1 < len(polynoms): + next_level.append(multiply(polynoms[i], polynoms[i+1])) + else: + next_level.append(polynoms[i]) + polynoms = next_level + P = polynoms[0] + + for idx_q, Q in enumerate(queries): + white_needed = Q // 2 - H - 1 + if 0 <= white_needed < len(P): + ways = (P[white_needed] * pow(2, white_needed, MOD)) % MOD + final_ans[idx_q] = (final_ans[idx_q] + ways) % MOD + +for res in final_ans: + print(res) \ No newline at end of file diff --git a/9F.py b/9F.py new file mode 100644 index 0000000..e63d3ef --- /dev/null +++ b/9F.py @@ -0,0 +1,22 @@ +import sys + +sys.set_int_max_str_digits(300000) + +input_data = sys.stdin.read().split() +x = int(input_data[0]) +k = int(input_data[1]) + +if x == 0: + print(0) +elif x == 1: + print(1) +else: + y = 1 << ((x.bit_length() + k - 1) // k) + + while True: + next_y = ((k - 1) * y + x // (y ** (k - 1))) // k + if next_y >= y: + break + y = next_y + + print(y) \ No newline at end of file diff --git a/AA.py b/AA.py new file mode 100644 index 0000000..6bc415d --- /dev/null +++ b/AA.py @@ -0,0 +1,42 @@ +import sys + +input_data = sys.stdin.read().split() + +n = int(input_data[0]) +m = int(input_data[1]) + +graph = [[] for _ in range(n + 1)] +ptr = 2 + +for i in range(1, n + 1): + while True: + val = int(input_data[ptr]) + ptr += 1 + if val == 0: + break + graph[i].append(val) + +matching = [0] * (m + 1) + +def dfs(v): + if used[v]: + return False + used[v] = True + for to in graph[v]: + if matching[to] == 0 or dfs(matching[to]): + matching[to] = v + return True + return False + +for i in range(1, n + 1): + used = [False] * (n + 1) + dfs(i) + +result = [] +for to in range(1, m + 1): + if matching[to] != 0: + result.append((matching[to], to)) + +print(len(result)) +for u, v in result: + print(u, v) \ No newline at end of file diff --git a/AB.py b/AB.py new file mode 100644 index 0000000..3e42ddb --- /dev/null +++ b/AB.py @@ -0,0 +1,37 @@ +import sys + +sys.setrecursionlimit(4000) + +data = sys.stdin.read().split() + +num_v = int(data[0]) +num_e = int(data[1]) + +adj = [[] for _ in range(num_v + 1)] +cursor = 2 + +for _ in range(num_e): + src = int(data[cursor]) + dst = int(data[cursor + 1]) + cursor += 2 + adj[src].append(dst) + +pairs = [0] * (num_v + 1) + +def find_match(node): + if visited[node]: + return False + visited[node] = True + for nxt in adj[node]: + if pairs[nxt] == 0 or find_match(pairs[nxt]): + pairs[nxt] = node + return True + return False + +total_matches = 0 +for start_node in range(1, num_v + 1): + visited = [False] * (num_v + 1) + if find_match(start_node): + total_matches += 1 + +print(num_v - total_matches) \ No newline at end of file diff --git a/AC.py b/AC.py new file mode 100644 index 0000000..52938b2 --- /dev/null +++ b/AC.py @@ -0,0 +1,76 @@ +import sys + +sys.setrecursionlimit(25000) +input = sys.stdin.read().split() + +h = int(input[0]) +w = int(input[1]) +cost_domino = int(input[2]) +cost_square = int(input[3]) + +grid = [] +idx = 4 +for _ in range(h): + grid.append(input[idx]) + idx += 1 + +free_count = 0 +for r in range(h): + for c in range(w): + if grid[r][c] == '*': + free_count += 1 + +if cost_domino >= 2 * cost_square: + print(free_count * cost_square) + sys.exit() + +nodes_left = [] +nodes_right = [] +left_id = {} +right_id = {} + +for r in range(h): + for c in range(w): + if grid[r][c] == '*': + if (r + c) % 2 == 0: + left_id[(r, c)] = len(nodes_left) + 1 + nodes_left.append((r, c)) + else: + right_id[(r, c)] = len(nodes_right) + 1 + nodes_right.append((r, c)) + +L = len(nodes_left) +R = len(nodes_right) + +adj_list = [[] for _ in range(L + 1)] + +dr = [-1, 1, 0, 0] +dc = [0, 0, -1, 1] + +for r, c in nodes_left: + u = left_id[(r, c)] + for i in range(4): + nr, nc = r + dr[i], c + dc[i] + if 0 <= nr < h and 0 <= nc < w and grid[nr][nc] == '*': + v = right_id[(nr, nc)] + adj_list[u].append(v) + +assigned = [0] * (R + 1) + +def match(node): + if seen[node]: + return False + seen[node] = True + for neighbor in adj_list[node]: + if assigned[neighbor] == 0 or match(assigned[neighbor]): + assigned[neighbor] = node + return True + return False + +pairs_found = 0 +for start in range(1, L + 1): + seen = [False] * (L + 1) + if match(start): + pairs_found += 1 +ans = pairs_found * cost_domino + (free_count - 2 * pairs_found) * cost_square +print(ans) \ No newline at end of file diff --git a/AD.py b/AD.py new file mode 100644 index 0000000..e69de29 diff --git a/AE.py b/AE.py new file mode 100644 index 0000000..e69de29 diff --git a/AF.py b/AF.py new file mode 100644 index 0000000..e69de29 diff --git a/AG.py b/AG.py new file mode 100644 index 0000000..e69de29