init

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))

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])

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")
+            

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:]))

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")

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")

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))

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])

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)

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))

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:])))

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)

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)

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)

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))

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))

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))

3D.cpp

@@ -0,0 +1,50 @@
+#include <iostream>
+
+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;
+}

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])

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))

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)

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")

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")

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))

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))))

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))

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}")

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)

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)

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))

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)

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)

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)

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)

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))

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)

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)

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")

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)

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))

9A.py

@@ -0,0 +1 @@
+print(int(input())*int(input()))

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])

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))

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())

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)

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)

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)

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)

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)