├── 5.2 Вычисление НОК и НОД ├── C │ ├── solution.py │ └── problem.md ├── A │ ├── solution.py │ └── problem.md └── B │ ├── solution.py │ └── problem.md ├── 10.5 Задача поиска кратчайшего пути в графе ├── B │ └── solution.py └── A │ └── problem.md ├── README.md ├── 3.1 Полный перебор и оптимизация перебора ├── A │ └── solution.py ├── B │ ├── solution.py │ └── problem.md └── C │ ├── solution.py │ └── problem.md ├── 4.2 Задача «Сумма двух чисел» ├── C │ ├── solution.py │ └── problem.md ├── A │ ├── solution.py │ └── problem.md ├── D │ ├── solution.py │ └── problem.md └── B │ ├── solution.py │ └── problem.md ├── 3.3 Динамическое программирование ├── A │ ├── solution.py │ └── problem.md └── B │ ├── solution.py │ └── problem.md ├── 4.3 Задача «Максимальное произведение» ├── B │ ├── solution.py │ └── problem.md ├── A │ ├── solution.py │ └── problem.md ├── C │ ├── solution.py │ └── problem.md └── D │ ├── solution.py │ └── problem.md ├── 6.5 Задача «Количество призов» └── A │ ├── solution.py │ └── problem.md ├── 6.3 Задача «Рекламная компания» ├── A │ ├── solution.py │ └── problem.md └── B │ ├── solution.py │ └── problem.md ├── 5.1 Задачи о числах Фибоначчи ├── A │ ├── solution.py │ └── problem.md ├── B │ ├── solution.py │ └── problem.md ├── D │ ├── solution.py │ └── problem.md ├── C │ ├── solution.py │ └── problem.md └── E │ ├── solution.py │ └── problem.md ├── 6.4 Задача «Сбор подписей» ├── B │ ├── solution.py │ └── problem.md ├── A │ ├── solution.py │ └── problem.md └── C │ ├── solution.py │ └── problem.md ├── 6.1 Задача «Размен» ├── B │ ├── solution.py │ └── problem.md └── A │ ├── solution.py │ └── problem.md ├── 6.2 Задача «Специи» ├── B │ ├── solution.py │ └── problem.md └── A │ ├── solution.py │ └── problem.md ├── 3.4 Рекурсивные алгоритмы ├── B │ ├── solution.py │ └── problem.md └── A │ ├── solution.py │ └── problem.md ├── 9.3 Словарь └── A │ ├── solution.py │ └── problem.md ├── 8.2 Задача «Размен 2» └── A │ ├── solution.py │ ├── solution_1.py │ └── problem.md ├── 9.2 Множество ├── A │ ├── solution.py │ └── problem.md └── B │ ├── solution.py │ └── problem.md ├── 3.2 Жадные алгоритмы └── A │ ├── solution.py │ └── problem.md ├── 3.5 Алгоритмы «Разделяй и властвуй» ├── A │ ├── solution.py │ └── problem.md ├── B │ ├── solution.py │ └── problem.md └── C │ ├── solution.py │ └── problem.md ├── 9.6 Дек └── A │ ├── solution.py │ └── problem.md ├── 7.2 Поиск доминирующего элемента ├── A │ ├── solution.py │ └── problem.md └── B │ ├── solution.py │ └── problem.md ├── 6.6 Задача «Максимальный оклад» ├── C │ ├── solution.py │ └── problem.md ├── B │ ├── solution.py │ └── problem.md └── A │ ├── solution.py │ └── problem.md ├── 7.1 Двоичный поиск ├── A │ ├── solution.py │ └── problem.md ├── B │ ├── solution.py │ └── problem.md ├── D │ ├── solution.py │ └── problem.md └── C │ ├── problem.md │ └── solution.py ├── 3.6 Рандомизированные алгоритмы ├── A │ ├── solution.py │ └── problem.md └── B │ ├── solution.py │ └── problem.md ├── 8.5 Задача LCS ├── A │ ├── solution.py │ └── problem.md └── B │ ├── solution.py │ └── problem.md ├── 8.3 Задача «Простой калькулятор» └── A │ ├── solution.py │ ├── solution_1.py │ └── problem.md ├── 7.3 Модификация быстрой сортировки ├── A │ ├── solution.py │ └── problem.md └── B │ ├── solution.py │ └── problem.md ├── 9.4 Стек ├── A │ ├── solution.py │ └── problem.md ├── B │ ├── solution.py │ └── problem.md └── C │ ├── solution.py │ └── problem.md ├── 8.6 Задача о рюкзаке └── A │ ├── solution.py │ └── problem.md ├── 8.7 Задача «Сувениры» └── A │ ├── solution.py │ └── problem.md ├── 10.2 Представление графа в памяти компьютера ├── A │ └── solution.py └── B │ ├── solution.py │ └── problem.md ├── 8.4 Задача «Расстояние редактирования» └── A │ ├── solution.py │ └── problem.md ├── 7.4 Подсчёт инверсий ├── A │ ├── solution.py │ └── problem.md ├── B │ ├── solution.py │ └── problem.md ├── C │ ├── solution.py │ └── problem.md └── D │ └── problem.md ├── 10.4 Алгоритм нахождения компонент связности в графе └── A │ ├── solution.py │ └── problem.md ├── 10.3 Обходы графа ├── B │ ├── solution.py │ └── problem.md ├── A │ ├── solution.py │ └── problem.md ├── C │ ├── solution.py │ └── problem.md └── D │ └── problem.md ├── 8.8 Задача «Расставить скобки» ├── B │ ├── problem.md │ └── solution.py ├── C │ ├── problem.md │ └── solution.py └── A │ ├── problem.md │ └── solution.py ├── 9.1 Односвязный список ├── B │ ├── solution.py │ └── problem.md └── A │ ├── solution.py │ └── problem.md └── 7.5 Задача «Пара ближайших точек» └── A ├── solution.py └── problem.md /5.2 Вычисление НОК и НОД/C/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | -------------------------------------------------------------------------------- /10.5 Задача поиска кратчайшего пути в графе/B/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # algorithms 2 | Решение задач из хэндбука Основы алгоритмов от Яндекса 3 | -------------------------------------------------------------------------------- /3.1 Полный перебор и оптимизация перебора/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | import math 4 | xx = int(input()) 5 | print(math.factorial(xx)) 6 | -------------------------------------------------------------------------------- /3.1 Полный перебор и оптимизация перебора/B/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | import math 4 | n = int(input()) 5 | k = int(input()) 6 | 7 | print(math.comb(n,k)) 8 | -------------------------------------------------------------------------------- /4.2 Задача «Сумма двух чисел»/C/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | n = int(input()) 4 | a = input() 5 | b = input() 6 | print(''.join([a[i] + b[i] for i in range(len(a))])) 7 | -------------------------------------------------------------------------------- /3.3 Динамическое программирование/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | n, m = map(int, input().split()) 4 | 5 | if n % 2 == 0 and m % 2 == 0: 6 | print('Loose') 7 | else: 8 | print('Win') 9 | -------------------------------------------------------------------------------- /3.1 Полный перебор и оптимизация перебора/C/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | import math 4 | 5 | xx, yy = map(int, input().split()) 6 | 7 | print(int(math.factorial(xx + yy - 1) / (math.factorial(yy) * (math.factorial(xx - 1))))) 8 | -------------------------------------------------------------------------------- /4.3 Задача «Максимальное произведение»/B/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | n = int(input()) 4 | 5 | if 1 + ((n - 2) * 2) > (1.5 * n): 6 | print('Yes') 7 | print(n, end=' ') 8 | print(*range(1, n)) 9 | else: 10 | print('No') 11 | -------------------------------------------------------------------------------- /6.5 Задача «Количество призов»/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | n = int(input()) 4 | 5 | res = 0 6 | for i in range(int(max(1, n ** 0.5 - 2)), n): 7 | x = (i * (i +1)) / 2 8 | if x > n: 9 | break 10 | res = i 11 | print(res) 12 | -------------------------------------------------------------------------------- /4.2 Задача «Сумма двух чисел»/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | def sum_of_digits(first_digit, second_digit): 4 | return first_digit + second_digit 5 | 6 | if __name__ == '__main__': 7 | a, b = map(int, input().split()) 8 | print(sum_of_digits(a, b)) 9 | -------------------------------------------------------------------------------- /3.3 Динамическое программирование/B/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | n, m = map(int, input().split()) 4 | n, m = max(n, m), min(n, m) 5 | rocks = dict() 6 | rocks[(0,0)] = 'Loose' 7 | 8 | if n == m or (((n - m) % 3) == 0): 9 | print('Loose') 10 | else: 11 | print('Win') 12 | -------------------------------------------------------------------------------- /4.3 Задача «Максимальное произведение»/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | def MaxPairwiseProductBySorting(a): 4 | a.sort() 5 | return a[-1]*a[-2] 6 | 7 | n = int(input()) 8 | m = list(map(int, input().split())) 9 | 10 | print(MaxPairwiseProductBySorting(m)) 11 | -------------------------------------------------------------------------------- /6.3 Задача «Рекламная компания»/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | n = int(input()) 4 | p = sorted(list(map(int, input().split()))) 5 | c = sorted(list(map(int, input().split()))) 6 | result = 0 7 | 8 | for i in range(n): 9 | result += p[i] * c[i] 10 | print(result) 11 | -------------------------------------------------------------------------------- /5.1 Задачи о числах Фибоначчи/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | def fib(a): 4 | if n <= 1: 5 | return n 6 | f_0, f_1 = 0, 1 7 | for i in range(2, a+1): 8 | f_0, f_1 = f_1, f_0 + f_1 9 | return f_1 10 | 11 | n = int(input()) 12 | print(fib(n)) 13 | -------------------------------------------------------------------------------- /5.1 Задачи о числах Фибоначчи/B/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | def fib(a): 4 | if a <= 1: 5 | return a 6 | f_0, f_1 = 0, 1 7 | for i in range(1, a): 8 | f_0, f_1 = f_1, (f_0 + f_1) % 10 9 | return f_1 10 | 11 | 12 | n = int(input()) 13 | print(fib(n)) 14 | -------------------------------------------------------------------------------- /5.2 Вычисление НОК и НОД/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | def GCD(a, b): 4 | while a > 0 and b > 0: 5 | if a >= b: 6 | a = a % b 7 | else: 8 | b = b % a 9 | return max(a,b) 10 | 11 | 12 | n, m = map(int, input().split()) 13 | print(GCD(n, m)) 14 | -------------------------------------------------------------------------------- /5.2 Вычисление НОК и НОД/B/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | def GCD(a, b): 4 | while a > 0 and b > 0: 5 | if a >= b: 6 | a = a % b 7 | else: 8 | b = b % a 9 | return max(a,b) 10 | 11 | 12 | n, m = map(int, input().split()) 13 | print((n * m) // GCD(n, m)) 14 | -------------------------------------------------------------------------------- /4.3 Задача «Максимальное произведение»/C/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | def max_pair(arr): 4 | arr.sort() 5 | right = arr[-2] * arr[-1] * arr[-3] 6 | left = arr[0] * arr[1] * arr[-1] 7 | print(max(right, left)) 8 | 9 | n = int(input()) 10 | m = list(map(int, input().split())) 11 | max_pair(m) 12 | -------------------------------------------------------------------------------- /6.4 Задача «Сбор подписей»/B/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | n, el = map(int, input().split()) 4 | xi = sorted(list(map(int, input().split()))) 5 | 6 | count = 0 7 | r_point = None 8 | 9 | for x in xi: 10 | if r_point is None or x > r_point: 11 | count += 1 12 | r_point = x + el 13 | print(count) 14 | -------------------------------------------------------------------------------- /6.1 Задача «Размен»/B/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | n = int(input()) 4 | nominal = [1, 5, 10, 20, 50] 5 | 6 | numCoins = 0 7 | final = [] 8 | 9 | for i in nominal[::-1]: 10 | if n >= i: 11 | numCoins += n // i 12 | final += [i] * (n // i) 13 | n = n % i 14 | 15 | print(numCoins) 16 | print(*final) 17 | -------------------------------------------------------------------------------- /6.2 Задача «Специи»/B/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | 4 | n, s = map(int, input().split()) 5 | 6 | things = [int(input()) for _ in range(n)] 7 | things.sort(reverse=True) 8 | count = 0 9 | 10 | while things: 11 | if things[-1] <= s: 12 | s -= things.pop() 13 | count += 1 14 | else: 15 | things.pop() 16 | print(count) 17 | -------------------------------------------------------------------------------- /3.4 Рекурсивные алгоритмы/B/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | def big_t(m): 4 | k = m - round((2 * m + 1) ** 0.5) + 1 5 | 6 | if m == 1: 7 | return 1 8 | else: 9 | return 2 * big_t(k) + t(m - k) 10 | 11 | def t(T): 12 | if T == 1: 13 | return 1 14 | else: 15 | return 2 * t(T - 1) + 1 16 | 17 | n = int(input()) 18 | print(big_t(n)) 19 | -------------------------------------------------------------------------------- /4.3 Задача «Максимальное произведение»/D/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | def max_pair(arr): 4 | arr.sort() 5 | right = arr[-2] * arr[-1] * arr[-3] * arr[-4] 6 | left = arr[0] * arr[1] * arr[-1] * arr[-2] 7 | full_left = arr[0] * arr[1] * arr[2] * arr[3] 8 | print(max(right, left, full_left)) 9 | 10 | n = int(input()) 11 | m = list(map(int, input().split())) 12 | max_pair(m) 13 | -------------------------------------------------------------------------------- /9.3 Словарь/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | unknown_dict = dict() 4 | answer = [] 5 | 6 | q = int(input()) 7 | for _ in range(q): 8 | query = input().split() 9 | if query[0] == '1': 10 | unknown_dict[query[1]] = query[2] 11 | elif query[0] == '2': 12 | temp = unknown_dict.get(query[1], '-1') 13 | answer.append(temp) 14 | 15 | print('\n'.join(answer)) 16 | -------------------------------------------------------------------------------- /8.2 Задача «Размен 2»/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | def change(money): 4 | table = [10**3 for i in range(money+1)] 5 | table[0] = 0 6 | 7 | for m in range(1, money+1): 8 | for c in [1, 3, 4]: 9 | if c <= m: 10 | table[m] = min(table[m], 1 + table[m-c]) 11 | return table[money] 12 | 13 | 14 | m = int(input()) 15 | print(change(m)) 16 | 17 | -------------------------------------------------------------------------------- /6.4 Задача «Сбор подписей»/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | n = int(input()) 4 | lr = sorted([tuple(map(int, input().split())) for _ in range(n)], key = lambda x: x[1]) 5 | 6 | count = 0 7 | points = [] 8 | 9 | for point in lr: 10 | left, right = point 11 | if not points or left > points[-1]: 12 | points.append(right) 13 | count += 1 14 | print(count) 15 | print(*points) 16 | -------------------------------------------------------------------------------- /4.2 Задача «Сумма двух чисел»/D/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | n, m = map(int, input().split()) 4 | matrix_f = [list(map(int, input().split())) for k in range(n)] 5 | matrix_s = [list(map(int, input().split())) for k in range(n)] 6 | 7 | res = [[matrix_f[j][i] + matrix_s[j][i] for i in range(m)] for j in range(n)] 8 | 9 | for x in range(n): 10 | for y in range(m): 11 | print(res[x][y], end=' ') 12 | -------------------------------------------------------------------------------- /9.2 Множество/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | numbers = set() 4 | 5 | n = int(input()) 6 | answer = [] 7 | 8 | for _ in range(n): 9 | q, num = input().split() 10 | if q == '1': 11 | numbers.add(num) 12 | elif q == '2': 13 | if num in numbers: 14 | answer.append('1') 15 | else: 16 | answer.append('0') 17 | 18 | print('\n'.join(answer)) 19 | -------------------------------------------------------------------------------- /3.2 Жадные алгоритмы/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | line = [] 4 | res = [] 5 | 6 | for lin in range(int(input())): 7 | line.append(tuple(map(int, input().split()))) 8 | 9 | line_sorted = sorted(line, key = lambda x: x[::-1]) 10 | while line_sorted: 11 | left, right = line_sorted.pop(0) 12 | res.append((left, right)) 13 | for lin in line_sorted[::-1]: 14 | if lin[0] <= right: 15 | line_sorted.remove(lin) 16 | 17 | print(len(res)) 18 | -------------------------------------------------------------------------------- /3.5 Алгоритмы «Разделяй и властвуй»/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | def select_sort(seq): 4 | for i in range(len(seq) - 1): 5 | min_index = i 6 | for k in range(i + 1, len(seq)): 7 | if seq[k] < seq[min_index]: 8 | min_index = k 9 | seq[i], seq[min_index] = seq[min_index], seq[i] 10 | return seq 11 | 12 | n = int(input()) 13 | a = list(map(int, input().split())) 14 | 15 | print(*select_sort(a)) 16 | -------------------------------------------------------------------------------- /6.1 Задача «Размен»/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | final = [] 4 | cnt = 0 5 | n = int(input()) 6 | 7 | for ten in range((n // 10) + 1): 8 | 9 | for five in range(((n - (10 * ten)) // 5) + 1): 10 | one = n - 10 * ten - 5 * five 11 | steps = str(ten + five + one) 12 | final.append((steps + ' ' + '10 ' * ten + '5 ' * five + '1 ' * one).rstrip()) 13 | cnt += 1 14 | print(cnt) 15 | print(*final, sep='\n') 16 | -------------------------------------------------------------------------------- /3.4 Рекурсивные алгоритмы/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | def move(n, start, finish): 4 | if n == 1: 5 | print(start, finish) 6 | else: 7 | tmp = 6 - start - finish 8 | move(n - 1, start, tmp) 9 | print(start, finish) 10 | move(n - 1, tmp, finish) 11 | 12 | def t(T): 13 | if T == 1: 14 | return 1 15 | else: 16 | return 2 * t(T - 1) + 1 17 | 18 | n = int(input()) 19 | print(t(n)) 20 | 21 | move(n, 1, 3) 22 | -------------------------------------------------------------------------------- /6.2 Задача «Специи»/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | n, w = map(int, input().split()) 4 | 5 | spicy = [tuple(map(float, input().split())) for _ in range(n)] 6 | spicy.sort(key = lambda x: x[0] / x[1]) 7 | cost = 0 8 | 9 | while w > 0 and spicy: 10 | loop_spicy_c, loop_spicy_w = spicy.pop() 11 | loop_amount = min(loop_spicy_w, w) 12 | value = (loop_spicy_c / loop_spicy_w) * loop_amount 13 | w -= loop_amount 14 | cost += value 15 | print(cost) 16 | -------------------------------------------------------------------------------- /4.2 Задача «Сумма двух чисел»/B/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | def many(a_x, b_x, arr_a, arr_b): 4 | print(max(a_x, b_x)) 5 | ind = -1 6 | 7 | for i in arr_b[::-1]: 8 | arr_a[ind] += i 9 | ind -= 1 10 | print(*arr_a) 11 | 12 | n = int(input()) 13 | a = list(map(int, input().split())) 14 | m = int(input()) 15 | b = list(map(int, input().split())) 16 | if len(a) != len(b): 17 | a, b = max(a, b, key=len), min(a, b, key=len) 18 | many(n, m, a, b) 19 | -------------------------------------------------------------------------------- /9.6 Дек/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | # дек на двух стеках реализован в последней задаче подглавы СТЕК 3 | 4 | from collections import deque 5 | 6 | deq = deque() 7 | n = int(input()) 8 | answer = [] 9 | 10 | for _ in range(n): 11 | query = input().split() 12 | if query[0] == '1': 13 | deq.append(query[1]) 14 | elif query[0] == '2': 15 | deq.popleft() 16 | 17 | t = '-1' 18 | if len(deq): 19 | t = deq[0] 20 | answer.append(t) 21 | 22 | print('\n'.join(answer)) 23 | -------------------------------------------------------------------------------- /7.2 Поиск доминирующего элемента/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | n = int(input()) 4 | ax = list(map(int, input().split())) 5 | #ax.sort() 6 | 7 | def major(a): 8 | count = 0 9 | candidate = 0 10 | for person in a: 11 | if count == 0: 12 | candidate = person 13 | count += 1 14 | else: 15 | if person == candidate: 16 | count += 1 17 | else: 18 | count -= 1 19 | return (1 if count else 0) 20 | print(major(ax)) 21 | -------------------------------------------------------------------------------- /6.3 Задача «Рекламная компания»/B/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | # Решение до банального простое, гораздо больше времени ушло на понимание условия задачи. Пример задачи с подвохом. 3 | 4 | n, k, w = map(int, input().split()) 5 | order = sorted([list(map(int, input().split())) for _ in range(k)], key = lambda x: -x[0]) 6 | 7 | result = 0 8 | 9 | place = n * w 10 | for i in order: 11 | if place: 12 | c, p = i 13 | amount = min(p, place) 14 | result += c * amount 15 | place -= amount 16 | print(result) 17 | -------------------------------------------------------------------------------- /8.2 Задача «Размен 2»/A/solution_1.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | import sys 4 | sys. setrecursionlimit(1500) 5 | 6 | table = dict() 7 | 8 | def change(money): 9 | if money not in table: 10 | if money == 0: 11 | table[money] = 0 12 | else: 13 | result = 10 ** 3 14 | for c in [1, 3, 4]: 15 | if c <= money: 16 | result = min(result, 1 + change(money - c)) 17 | table[money] = result 18 | return table[money] 19 | m = int(input()) 20 | print(change(m)) 21 | -------------------------------------------------------------------------------- /6.6 Задача «Максимальный оклад»/C/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | r, c = map(int, input().split()) 4 | 5 | kings = 0 6 | if r * c < 2: 7 | kings = 0 8 | elif r == 1 or c == 1: 9 | temp = max(r, c) 10 | if temp % 3 != 0: 11 | kings += temp - (temp // 3 + 1) 12 | else: 13 | kings += temp - (temp // 3) 14 | else: 15 | r_full = r - (r // 3 + [0, 1][r % 3 != 0]) 16 | r_empty = r - r_full 17 | fill_row = c - (c // 3 + [0, 1][c % 3 != 0]) 18 | kings = r_full * c + r_empty * fill_row 19 | print(kings) 20 | -------------------------------------------------------------------------------- /6.6 Задача «Максимальный оклад»/B/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | # Да, в этой главе 2 задачи с плохими тестами. В очередной раз пришлось искать алгоритм для тестов, а не условий задачи. Времени ушло примерно полдня 3 | 4 | n, k = map(int, input().split()) 5 | a = list(map(int, input().split())) 6 | my_robot = a[k-1] 7 | a.sort() 8 | weak = len(a[:a.index(my_robot)]) 9 | strong = len(a[a.index(my_robot) + 1:]) 10 | 11 | result = 0 12 | while weak: 13 | if strong % 2: 14 | weak -= 1 15 | weak //= 2 16 | strong //= 2 17 | result += 1 18 | print(result) 19 | -------------------------------------------------------------------------------- /7.1 Двоичный поиск/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | def bin_search(n, arr, q): 4 | min_index = 0 5 | max_index = n - 1 6 | while max_index >= min_index: 7 | middle_ind = (min_index + max_index) // 2 8 | if arr[middle_ind] == q: 9 | return middle_ind 10 | elif arr[middle_ind] < q: 11 | min_index = middle_ind + 1 12 | else: 13 | max_index = middle_ind - 1 14 | return -1 15 | 16 | n = int(input()) 17 | k = list(map(int, input().split())) 18 | q = int(input()) 19 | 20 | print(bin_search(n, k, q)) 21 | -------------------------------------------------------------------------------- /6.4 Задача «Сбор подписей»/C/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | n, el = map(int, input().split()) 4 | xi = sorted(list(map(int, input().split()))) 5 | 6 | if len(set(xi)) <= el: 7 | print(0) 8 | else: 9 | sub_point = [(xi[p+1] - xi[p], p+1) for p in range(len(xi)-1)] 10 | sub_point.sort(key = lambda x: -x[0]) 11 | ind_to_list = sorted(sub_point[:el-1], key = lambda y: -y[1]) 12 | result = 0 13 | for ind in ind_to_list: 14 | cnt, i = ind 15 | result += xi[i:][-1] - xi[i:][0] 16 | del xi[i:] 17 | result += xi[-1] - xi[0] 18 | print(result) 19 | -------------------------------------------------------------------------------- /5.1 Задачи о числах Фибоначчи/D/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | def pisano(modulo): 4 | cache = [0, 1] 5 | cur, _next, period = 0, 1, 0 6 | while True: 7 | cur, _next = _next, (cur + _next) % modulo 8 | cache.append(_next) 9 | period += 1 10 | if cur == 0 and _next == 1: 11 | return cache, period 12 | 13 | 14 | def fib(a, b): 15 | if a <= 1: 16 | return a 17 | 18 | table, b_pisano = pisano(b) 19 | res = table[a % b_pisano] 20 | return (res if res > 0 else 10) - 1 21 | 22 | n = int(input()) 23 | print(fib(n+2, 10)) 24 | -------------------------------------------------------------------------------- /3.6 Рандомизированные алгоритмы/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | # Это не разбиение Ломуто, но в тестах ошибка и в итоге нужен такой алгоритм для этих тестов 3 | 4 | n = int(input()) 5 | m = list(map(int, input().split())) 6 | 7 | def lomuto(arr): 8 | 9 | left_list = [] 10 | right_list = [] 11 | pivot = arr[0] 12 | 13 | for i in arr: 14 | if i <= pivot: 15 | left_list.append(i) 16 | else: 17 | right_list.append(i) 18 | left_list[0], left_list[-1] = left_list[-1], left_list[0] 19 | 20 | return left_list + right_list 21 | 22 | print(*lomuto(m)) 23 | -------------------------------------------------------------------------------- /3.6 Рандомизированные алгоритмы/A/problem.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
21 | -------------------------------------------------------------------------------- /8.5 Задача LCS/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.3 2 | 3 | n = int(input()) 4 | first_data = list(map(int, input().split())) 5 | m = int(input()) 6 | second_data = list(map(int, input().split())) 7 | 8 | table = [[0] * (m + 1) for _ in range(n + 1)] 9 | #print(*table, sep = '\n') 10 | 11 | for row in range(1, n + 1): 12 | for col in range(1, m + 1): 13 | # table[row][col] = table[row - 1][col] 14 | table[row][col] = max(table[row - 1][col], table[row][col - 1]) 15 | if first_data[row - 1] == second_data[col - 1]: 16 | table[row][col] = max(table[row][col], table[row - 1][col - 1] + 1) 17 | 18 | print(table[row][col]) 19 | -------------------------------------------------------------------------------- /8.3 Задача «Простой калькулятор»/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | n = int(input()) 4 | 5 | dp = [0] * (n + 1) 6 | prev = [0] * (n + 1) 7 | 8 | for i in range(2, n + 1): 9 | dp[i] = dp[i - 1] + 1 10 | prev[i] = i - 1 11 | 12 | if i % 2 == 0 and (dp[i // 2] + 1 < dp[i]): 13 | dp[i] = dp[i // 2] + 1 14 | prev[i] = i // 2 15 | 16 | if i % 3 == 0 and (dp[i // 3] + 1 < dp[i]): 17 | dp[i] = dp[i // 3] + 1 18 | prev[i] = i // 3 19 | 20 | answer = [] 21 | ans_ind = n 22 | while ans_ind > 0: 23 | answer.append(ans_ind) 24 | ans_ind = prev[ans_ind] 25 | answer.reverse() 26 | 27 | print(dp[n]) 28 | print(*answer) 29 | -------------------------------------------------------------------------------- /7.3 Модификация быстрой сортировки/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | n = int(input()) 4 | a = list(map(int, input().split())) 5 | 6 | def randomqs(len_a, arr): 7 | import random 8 | 9 | if len_a <= 1: 10 | return arr 11 | random_element = random.choice(arr) 12 | arr_small = [num for num in arr if num < random_element] 13 | arr_equal = [num for num in arr if num == random_element] 14 | arr_big = [num for num in arr if num > random_element] 15 | sort_arr_small = randomqs(len(arr_small), arr_small) 16 | sort_arr_big = randomqs(len(arr_big), arr_big) 17 | final = sort_arr_small + arr_equal + sort_arr_big 18 | return final 19 | 20 | print(*randomqs(n, a)) 21 | -------------------------------------------------------------------------------- /5.1 Задачи о числах Фибоначчи/C/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | def pisano(modulo): 4 | cache = [0, 1] 5 | cur, _next, period = 0, 1, 0 6 | while True: 7 | cur, _next = _next, (cur + _next) % modulo 8 | cache.append(_next) 9 | period += 1 10 | if cur == 0 and _next == 1: 11 | return cache, period 12 | 13 | def fib(a, b): 14 | if a <= 1: 15 | return a 16 | 17 | table, b_pisano = pisano(b) 18 | return table[a % b_pisano] 19 | # f_0, f_1 = 0, 1 20 | # for i in range(1, (a % b_pisano)): 21 | # f_0, f_1 = f_1, (f_0 + f_1) % m 22 | # # print(f_1) 23 | # return f_1 24 | 25 | n, m = map(int, input().split()) 26 | print(fib(n, m)) 27 | -------------------------------------------------------------------------------- /8.3 Задача «Простой калькулятор»/A/solution_1.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.3 2 | 3 | n = int(input()) 4 | dp = [0] * (n + 1) 5 | 6 | for num in range(2, n + 1): 7 | dp[num] = 1 + dp[num - 1] 8 | if not (num % 2): 9 | dp[num] = min(dp[num], dp[num // 2] + 1) 10 | if not (num % 3): 11 | dp[num] = min(dp[num], dp[num // 3] + 1) 12 | #print(*dp) 13 | 14 | operations = list() 15 | num = n 16 | while num > 1: 17 | operations.append(num) 18 | if dp[num] == dp[num - 1] + 1: 19 | num -= 1 20 | elif not (num % 2) and dp[num] == dp[num // 2] + 1: 21 | num //= 2 22 | elif not (num % 3) and dp[num] == dp[num // 3] + 1: 23 | num //= 3 24 | operations.append(num) 25 | 26 | operations.reverse() 27 | print(dp[n]) 28 | print(*operations) 29 | -------------------------------------------------------------------------------- /5.1 Задачи о числах Фибоначчи/E/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | def pisano(modulo): 4 | cache = [0, 1] 5 | cur, _next, period = 0, 1, 0 6 | cur_100, _next100 = 0, 1 7 | while True: 8 | cur, _next = _next, (cur + _next) % modulo 9 | cur_100, _next100 = _next100, (cur_100 + _next100) % 100 10 | cache.append(_next100) 11 | period += 1 12 | if cur == 0 and _next == 1: 13 | return cache, period 14 | 15 | 16 | def fib(a, b): 17 | if a <= 1: 18 | return (a if a == 0 else a - 1) 19 | 20 | table, b_pisano = pisano(b) 21 | res = table[a % b_pisano] 22 | return (res if res > 0 else 10) - 1 23 | 24 | m, n = map(int, input().split()) 25 | print((fib(n+2, 10) - fib(m+1, 10)) % 10) 26 | -------------------------------------------------------------------------------- /7.2 Поиск доминирующего элемента/B/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | n = int(input()) 4 | ax = list(map(int, input().split())) 5 | 6 | def maxi_el(num, arr): 7 | if num < 4: 8 | ret_dic = {} 9 | for elem in arr: 10 | ret_dic[elem] = ret_dic.get(elem, 0) + 1 11 | return ret_dic 12 | 13 | mid = num // 4 14 | left_arr = arr[:num // 4] 15 | right_arr = arr[num // 4:] 16 | rec_left = maxi_el(len(left_arr), left_arr) 17 | rec_right = maxi_el(len(right_arr), right_arr) 18 | final_dict = dict() 19 | for key in (set(rec_left) | set(rec_right)): 20 | 21 | if arr.count(key) > num // 4: 22 | final_dict[key] = 1 23 | 24 | 25 | return final_dict 26 | 27 | print((1 if len(maxi_el(n, ax)) == 3 else 0)) 28 | -------------------------------------------------------------------------------- /9.4 Стек/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | 4 | class Stack: 5 | def __init__(self): 6 | self.array = [] 7 | 8 | def push(self, item): 9 | self.array.append(item) 10 | 11 | def pop(self): 12 | return self.array.pop() 13 | 14 | def size(self): 15 | return True if self.array else False 16 | 17 | def back(self): 18 | if self.size(): 19 | return self.array[-1] 20 | else: 21 | return -1 22 | 23 | arr = Stack() 24 | n = int(input()) 25 | answer = [] 26 | 27 | for _ in range(n): 28 | query = input().split() 29 | if query[0] == '1': 30 | arr.push(query[1]) 31 | elif query[0] == '2': 32 | arr.pop() 33 | 34 | answer.append(str(arr.back())) 35 | 36 | print('\n'.join(answer)) 37 | -------------------------------------------------------------------------------- /9.4 Стек/B/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | 4 | class Stack: 5 | def __init__(self): 6 | self.array = [] 7 | 8 | def push(self, item): 9 | self.array.append(item) 10 | 11 | def pop(self): 12 | return self.array.pop() 13 | 14 | def size(self): 15 | return True if self.array else False 16 | 17 | def back(self): 18 | if self.size(): 19 | return self.array[-1] 20 | else: 21 | return False 22 | 23 | arr = Stack() 24 | n = int(input()) 25 | queries = list(map(int, input().split())) 26 | answer = [0] * n 27 | 28 | for i in range(n): 29 | while arr.size() and queries[i] > arr.back()[0]: 30 | elem, num = arr.pop() 31 | answer[i] += answer[num] + 1 32 | 33 | arr.push((queries[i], i)) 34 | 35 | print(*answer) 36 | -------------------------------------------------------------------------------- /6.6 Задача «Максимальный оклад»/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | # Очередное задание с ошибочными тестами, когда тесты поправят, решение перестанет проходить. Затратил день на поиск алгоритма под тесты :-) 3 | 4 | n = int(input()) 5 | a = list(map(int, input().split())) 6 | a.sort(reverse=True) 7 | def better(first, second): 8 | num_1 = str(first) 9 | num_2 = str(second) 10 | l_num_1 = len(num_1) 11 | l_num_2 = len(num_2) 12 | min_len = min(l_num_1, l_num_2) 13 | if l_num_1 == l_num_2: 14 | return num_1 > num_2 15 | else: 16 | return num_1[:min_len] >= num_2[:min_len] 17 | 18 | result = '' 19 | while a: 20 | max_num = 0 21 | for num in a: 22 | if better(num, max_num): 23 | max_num = num 24 | result += str(max_num) 25 | a.remove(max_num) 26 | 27 | print(result) 28 | -------------------------------------------------------------------------------- /7.1 Двоичный поиск/B/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | def many_bin_search(n, arr, m, arr_to_search): 4 | result = [] 5 | for i in (arr_to_search): 6 | min_index = 0 7 | max_index = n - 1 8 | ans = -1 9 | while max_index >= min_index: 10 | middle_ind = (min_index + max_index) // 2 11 | if arr[middle_ind] == i: 12 | ans = middle_ind 13 | break 14 | elif arr[middle_ind] > i: 15 | max_index = middle_ind - 1 16 | else: 17 | min_index = middle_ind + 1 18 | result.append(ans) 19 | return result 20 | 21 | n = int(input()) 22 | k = list(map(int, input().split())) 23 | m = int(input()) 24 | q = list(map(int, input().split())) 25 | 26 | for x in many_bin_search(n, k, m, q): 27 | print(x) 28 | -------------------------------------------------------------------------------- /8.6 Задача о рюкзаке/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.3 2 | 3 | from sys import stdin 4 | 5 | w, n = map(int, stdin.readline().split()) 6 | gold = list(map(int, stdin.readline().split())) 7 | 8 | def knapsack(arr, weight, n): 9 | dp = [[False] * (n + 1) for _ in range(weight + 1)] 10 | # print(*dp, sep = '\n') 11 | dp[0][0] = True 12 | for i in range(1, n + 1): 13 | for w in range(weight + 1): 14 | if arr[i-1] > w: 15 | dp[w][i] = dp[w][i - 1] 16 | else: 17 | dp[w][i] = (dp[w][i - 1] or dp[w - arr[i - 1]][i - 1]) 18 | # print('ready dp') 19 | # print(*dp, sep = '\n') 20 | 21 | for w in range(weight, -1, -1): 22 | #for i in range(n, -1, -1): 23 | if dp[w][n] == True: 24 | return w 25 | return 0 26 | print(knapsack(gold, w, n)) 27 | 28 | -------------------------------------------------------------------------------- /7.1 Двоичный поиск/D/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | n, k = map(int, input().split()) 4 | x = sorted(set(map(int, input().split()))) 5 | 6 | def right_len(point, key, lenght): 7 | end = point[0] + lenght 8 | key -= 1 9 | for p in point: 10 | if end < p: 11 | key -= 1 12 | end = p + lenght 13 | if key < 0: 14 | return False 15 | return True 16 | 17 | def min_len(n, arr, k): 18 | if k >= len(arr): 19 | return 0 20 | minimum = 0 21 | maximum = arr[len(arr)-1] - arr[0] 22 | while minimum != maximum: 23 | mid = minimum + (maximum - minimum) // 2 24 | if mid == maximum or mid == minimum: 25 | return maximum 26 | if right_len(arr, k, mid): 27 | maximum = mid 28 | else: 29 | minimum = mid 30 | 31 | return maximum 32 | 33 | print(min_len(n, x, k)) 34 | -------------------------------------------------------------------------------- /8.7 Задача «Сувениры»/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.3 2 | 3 | from sys import stdin 4 | 5 | n = int(stdin.readline().rstrip()) 6 | gold = [0] + list(map(int, stdin.readline().split())) 7 | 8 | def pirate(arr, n): 9 | sum_arr = sum(arr) 10 | if (sum_arr % 3): 11 | return False 12 | V = sum_arr // 3 13 | dp = [[[False] * (V + 1) for _ in range(V + 1)] for _ in range(n + 1)] 14 | # print(*dp, sep = '\n') 15 | dp[0][0][0] = True 16 | 17 | for i in range(1, n + 1): 18 | for s1 in range(V + 1): 19 | for s2 in range(V + 1): 20 | dp[i][s1][s2] = dp[i - 1][s1][s2] 21 | if s1 >= arr[i]: 22 | dp[i][s1][s2] = dp[i][s1][s2] or dp[i - 1][s1 - arr[i]][s2] 23 | if s2 >= arr[i]: 24 | dp[i][s1][s2] = dp[i][s1][s2] or dp[i - 1][s1][s2 - arr[i]] 25 | return dp[n][V][V] 26 | 27 | print(1 if pirate(gold, n) == True else 0) 28 | -------------------------------------------------------------------------------- /4.2 Задача «Сумма двух чисел»/A/problem.md: -------------------------------------------------------------------------------- 1 | # A + B 2 | 3 | Задача-разминка: найдите сумму двух чисел. 4 | 5 | ## Формат ввода 6 | 7 | Целые числа a и b на одной строке (разделённые пробелом). 8 | 9 | Ограничения: 0≤a,b≤90. 10 | 11 | ## Формат вывода 12 | 13 | Сумма a и b. 14 | 15 | ## Пример 16 | 17 | Ввод 18 | 19 | 9 7 20 | 21 | 22 | Вывод 23 | 24 | 16 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
45 | -------------------------------------------------------------------------------- /8.5 Задача LCS/B/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.3 2 | # Рекурсивный алгоритм с мемо(р)изацией выглядел бы более читаемо, но упирался в 12 тесте в Time Limit 3 | 4 | from sys import stdin 5 | 6 | n = int(stdin.readline().rstrip()) 7 | first_data = list(map(int, stdin.readline().split())) 8 | m = int(stdin.readline().rstrip()) 9 | second_data = list(map(int, stdin.readline().split())) 10 | b = int(stdin.readline().rstrip()) 11 | third_data = list(map(int, stdin.readline().split())) 12 | 13 | dp = [[[0] * (b + 1) for _ in range(m + 1)] for _ in range(n + 1)] 14 | 15 | for row in range(1, n + 1): 16 | for seg in range(1, m + 1): 17 | for elem in range(1, b + 1): 18 | dp[row][seg][elem] = max(dp[row - 1][seg][elem], dp[row][seg - 1][elem], dp[row][seg][elem - 1]) 19 | if first_data[row - 1] == second_data[seg - 1] and second_data[seg - 1] == third_data[elem - 1]: 20 | dp[row][seg][elem] = max(dp[row][seg][elem], dp[row - 1][seg - 1][elem - 1] + 1) 21 | 22 | print(dp[row][seg][elem]) 23 | 24 | -------------------------------------------------------------------------------- /10.2 Представление графа в памяти компьютера/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.3 2 | 3 | from sys import stdin 4 | 5 | n, m = map(int, stdin.readline().split()) 6 | first_graph = [[0] * (n + 1) for _ in range(n + 1)] 7 | second_graph = [[0] * (n + 1) for _ in range(n + 1)] 8 | 9 | for _ in range(m): 10 | row = list(map(int, stdin.readline().split()[1:])) 11 | if len(row) > 1: 12 | for stop in range(1, len(row)): 13 | now_stop = row[stop] 14 | prev_stop = row[stop - 1] 15 | first_graph[now_stop][prev_stop] = 1 16 | first_graph[prev_stop][now_stop] = 1 17 | 18 | for bus_stop_from in range(len(row)): 19 | for bus_stop_to in range(len(row)): 20 | if bus_stop_from != bus_stop_to: 21 | second_graph[row[bus_stop_from]][row[bus_stop_to]] = 1 22 | 23 | for i in range(1, len(first_graph)): 24 | print(' '.join(str(first_graph[i][j]) for j in range(1, len(first_graph[i])))) 25 | for i in range(1, len(second_graph)): 26 | print(' '.join(str(second_graph[i][j]) for j in range(1, len(second_graph[i])))) 27 | 28 | -------------------------------------------------------------------------------- /7.3 Модификация быстрой сортировки/B/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | # Да, на питоне это оказалось реально сделать 3 | 4 | import sys 5 | 6 | sys.setrecursionlimit(10000) 7 | def partition(a, p_left, p_right): 8 | 9 | v = a[(p_left + p_right) // 2][0] 10 | i = p_left 11 | j = p_right 12 | while i <= j: 13 | while a[i][0] < v: 14 | i += 1 15 | while a[j][0] > v: 16 | j -= 1 17 | if i >= j: 18 | break 19 | 20 | a[i], a[j] = a[j], a[i] 21 | i += 1 22 | j -= 1 23 | return j 24 | 25 | def quicksort(a, left, right, k=1): 26 | pivot = (left + right) // 2 27 | #a[pivot][0] = n - k + 1 28 | a[pivot][0] = k 29 | if left < right: 30 | q = partition(a, left, right) 31 | quicksort(a, left, q, k + 1) 32 | quicksort(a, q+1, right, k) 33 | 34 | n = int(input()) 35 | #a = [[0, m] for m in range(1, n+1)] 36 | a = [[0, m] for m in range(n, 0, -1)] 37 | quicksort(a, 0, n-1) 38 | 39 | a.sort(key = lambda x: x[1]) 40 | b = [i[0] for i in a] 41 | print(*b) 42 | 43 | 44 | 45 | 46 | -------------------------------------------------------------------------------- /8.4 Задача «Расстояние редактирования»/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | word_one = input() 4 | word_two = input() 5 | word_one = 'x' + word_one # Чтобы не проставлять единички 6 | word_two = 'x' + word_two 7 | 8 | # table = [[0] * len(word_one) for _ in range(len(word_two))] 9 | table = [] 10 | for row in range(len(word_one)): 11 | temp_list = [] 12 | for col in range(len(word_two)): 13 | if row == 0: 14 | temp_list.append(col) 15 | elif col == 0: 16 | temp_list.append(row) 17 | else: 18 | temp_list.append(0) 19 | table.append(temp_list) 20 | 21 | for row in range(1, len(word_one)): 22 | for col in range(1, len(word_two)): 23 | match = table[row - 1][col - 1] 24 | mismatch = table[row - 1][col - 1] + 1 25 | insertion = table[row][col - 1] + 1 26 | deletion = table[row - 1][col] + 1 27 | if word_one[row] == word_two[col]: 28 | table[row][col] = min(match, insertion, deletion) 29 | else: 30 | table[row][col] = min(mismatch, insertion, deletion) 31 | 32 | print(table[row][col]) 33 | 34 | -------------------------------------------------------------------------------- /3.1 Полный перебор и оптимизация перебора/B/problem.md: -------------------------------------------------------------------------------- 1 | # Сочетания 2 | 3 | Выведите число сочетаний C(n,k). 4 | 5 | ## Формат ввода 6 | 7 | В первой строке находится два числа n (1≤n≤7), k (1≤k≤7). 8 | 9 | ## Формат вывода 10 | 11 | Выведите ответ на задачу. 12 | 13 | ### Пример 1 14 | 15 | Ввод 16 | 17 | 3 2 18 | 19 | 20 | Вывод 21 | 22 | 3 23 | 24 | 25 | ### Пример 2 26 | 27 | Ввод 28 | 29 | 7 5 30 | 31 | 32 | Вывод 33 | 34 | 21 35 | 36 | 37 | ### Пример 3 38 | 39 | Ввод 40 | 41 | 1 1 42 | 43 | 44 | Вывод 45 | 46 | 1 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
67 | 68 | -------------------------------------------------------------------------------- /7.4 Подсчёт инверсий/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | n = int(input()) 4 | list_a = list(map(int, input().split())) 5 | 6 | def Merge(left_half, right_half): 7 | sorted_list = [] 8 | inversions = 0 9 | #left.reverse() 10 | #right.reverse() 11 | while left_half and right_half: 12 | #left_elem = left.pop() 13 | #r_elem = right.pop() 14 | if left_half[0] <= right_half[0]: 15 | sorted_list.append(left_half.pop(0)) 16 | else: 17 | sorted_list.append(right_half.pop(0)) 18 | inversions += len(left_half) 19 | sorted_list += left_half if left_half else right_half 20 | return sorted_list, inversions 21 | 22 | 23 | 24 | def count_inversion(n, a): 25 | if n <= 1: 26 | return (a, 0) 27 | pivot = n // 2 28 | left_half = a[: pivot] 29 | right_half = a[pivot:] 30 | left_half, left_rec = count_inversion(pivot, left_half) 31 | right_half, right_rec = count_inversion(n-pivot, right_half) 32 | a, inversion = Merge(left_half, right_half) 33 | return (a, (left_rec + right_rec + inversion)) 34 | 35 | print(count_inversion(n, list_a)[1]) 36 | -------------------------------------------------------------------------------- /7.4 Подсчёт инверсий/B/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | n = int(input()) 4 | list_a = list(map(int, input().split())) 5 | 6 | def Merge(left_half, right_half): 7 | sorted_list = [] 8 | inversions = 0 9 | #left.reverse() 10 | #right.reverse() 11 | while left_half and right_half: 12 | #left_elem = left.pop() 13 | #r_elem = right.pop() 14 | if left_half[0] < right_half[0]: 15 | sorted_list.append(left_half.pop(0)) 16 | else: 17 | sorted_list.append(right_half.pop(0)) 18 | inversions += len(left_half) 19 | sorted_list += left_half if left_half else right_half 20 | return sorted_list, inversions 21 | 22 | 23 | 24 | def count_inversion(n, a): 25 | if n <= 1: 26 | return (a, 0) 27 | pivot = n // 2 28 | left_half = a[: pivot] 29 | right_half = a[pivot:] 30 | left_half, left_rec = count_inversion(pivot, left_half) 31 | right_half, right_rec = count_inversion(n-pivot, right_half) 32 | a, inversion = Merge(left_half, right_half) 33 | return (a, (left_rec + right_rec + inversion)) 34 | 35 | print(count_inversion(n, list_a)[1]) 36 | -------------------------------------------------------------------------------- /7.4 Подсчёт инверсий/C/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | n = int(input()) 4 | list_a = list(map(int, input().split())) 5 | 6 | def Merge(left_half, right_half): 7 | sorted_list = [] 8 | inversions = 0 9 | #left.reverse() 10 | #right.reverse() 11 | while left_half and right_half: 12 | #left_elem = left.pop() 13 | #r_elem = right.pop() 14 | if left_half[0] < right_half[0]: 15 | sorted_list.append(left_half.pop(0)) 16 | else: 17 | sorted_list.append(right_half.pop(0)) 18 | inversions += len(left_half) 19 | sorted_list += left_half if left_half else right_half 20 | return sorted_list, inversions 21 | 22 | 23 | 24 | def count_inversion(n, a): 25 | if n <= 1: 26 | return (a, 0) 27 | pivot = n // 2 28 | left_half = a[: pivot] 29 | right_half = a[pivot:] 30 | left_half, left_rec = count_inversion(pivot, left_half) 31 | right_half, right_rec = count_inversion(n-pivot, right_half) 32 | a, inversion = Merge(left_half, right_half) 33 | return (a, (left_rec + right_rec + inversion)) 34 | 35 | print(count_inversion(n, list_a)[1]) 36 | -------------------------------------------------------------------------------- /3.1 Полный перебор и оптимизация перебора/C/problem.md: -------------------------------------------------------------------------------- 1 | # Сочетания с повторениями 2 | 3 | Выведите число сочетаний с повторением С‾(n,k). 4 | 5 | ## Формат ввода 6 | 7 | В первой строке находятся два числа n (1≤n≤4), k (1≤k≤4). 8 | 9 | ## Формат вывода 10 | 11 | Выведите ответ на задачу. 12 | 13 | ### Пример 1 14 | 15 | Ввод 16 | 17 | 1 1 18 | 19 | 20 | Вывод 21 | 22 | 1 23 | 24 | 25 | ### Пример 2 26 | 27 | Ввод 28 | 29 | 4 3 30 | 31 | 32 | Вывод 33 | 34 | 20 35 | 36 | 37 | ### Пример 3 38 | 39 | Ввод 40 | 41 | 2 2 42 | 43 | 44 | Вывод 45 | 46 | 3 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
67 | -------------------------------------------------------------------------------- /5.2 Вычисление НОК и НОД/A/problem.md: -------------------------------------------------------------------------------- 1 | # Наибольший общий делитель 2 | 3 | Для двух чисел a и b найдите их наибольший общий делитель. 4 | 5 | ## Формат ввода 6 | 7 | Целые числа a и b (разделённые пробелом). 8 | 9 | Ограничения: 1≤a,b≤2⋅109. 10 | 11 | ## Формат вывода 12 | 13 | Наибольший общий делитель чисел a и b. 14 | 15 | ### Пример 1 16 | 17 | Ввод 18 | 19 | 18 35 20 | 21 | 22 | Вывод 23 | 24 | 1 25 | 26 | 27 | ### Пример 2 28 | 29 | Ввод 30 | 31 | 28851538 1183019 32 | 33 | 34 | Вывод 35 | 36 | 17657 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
57 | -------------------------------------------------------------------------------- /5.2 Вычисление НОК и НОД/B/problem.md: -------------------------------------------------------------------------------- 1 | # Наименьшее общее кратное 2 | 3 | Для двух чисел a и b найдите их наименьшее общее кратное. 4 | 5 | ## Формат ввода 6 | 7 | Целые числа a и b (разделённые пробелом). 8 | 9 | Ограничения: 1≤a,b≤2⋅109. 10 | 11 | ## Формат вывода 12 | 13 | Наименьшее общее кратное чисел a и b. 14 | 15 | ### Пример 1 16 | 17 | Ввод 18 | 19 | 6 8 20 | 21 | 22 | Вывод 23 | 24 | 24 25 | 26 | 27 | ### Пример 2 28 | 29 | Ввод 30 | 31 | 761457 614573 32 | 33 | 34 | Вывод 35 | 36 | 467970912861 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
57 | -------------------------------------------------------------------------------- /3.5 Алгоритмы «Разделяй и властвуй»/B/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | # В условии сказано "Задано n отсортированных по неубыванию последовательностей..." но это не так. После таких случаев, начинаешь везде перестраховываться :-) 3 | 4 | def merge(list_1, list_2): 5 | sorted_list = [] 6 | left_ind = 0 7 | right_ind = 0 8 | 9 | while left_ind <= len(list_1)-1 and right_ind <= len(list_2)-1 and list_1 and list_2: 10 | if list_1[left_ind] <= list_2[right_ind]: 11 | sorted_list.append(list_1[left_ind]) 12 | left_ind += 1 13 | elif list_2[right_ind] <= list_1[left_ind]: 14 | sorted_list.append(list_2[right_ind]) 15 | right_ind += 1 16 | 17 | if left_ind-1 == len(list_1) - 1 or not list_1: 18 | sorted_list.extend(list_2[right_ind:]) 19 | elif right_ind-1 == len(list_2) - 1 or not list_2: 20 | sorted_list.extend(list_1[left_ind:]) 21 | return sorted_list 22 | 23 | n = int(input()) 24 | res = [] 25 | 26 | for _ in range(n): 27 | t = input() 28 | input_list = list(map(int, input().split())) 29 | input_list.sort() 30 | res = merge(res, input_list) 31 | 32 | 33 | print(*res) 34 | -------------------------------------------------------------------------------- /3.6 Рандомизированные алгоритмы/B/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | from random import choice 4 | 5 | def lomuto(arr, low, high): 6 | random_n = choice(range(low, high+1)) 7 | arr[random_n], arr[high] = arr[high], arr[random_n] 8 | pivot = arr[high] 9 | i = low - 1 10 | for j in range(low, high): 11 | if arr[j] <= pivot: 12 | i += 1 13 | arr[i], arr[j] = arr[j], arr[i] 14 | arr[i+1], arr[high] = arr[high], arr[i+1] 15 | return i+1 16 | 17 | def quick_sort(arr, low, high): 18 | if low < high: 19 | piv = lomuto(arr, low, high) 20 | quick_sort(arr, low, piv - 1) 21 | quick_sort(arr, piv + 1, high) 22 | 23 | n = int(input()) 24 | m = list(map(int, input().split())) 25 | quick_sort(m, 0, n-1) 26 | print(*m) 27 | 28 | ''' 29 | QuickSort(c): 30 | if |c| = 1: // только один элемент 31 | return c 32 | m = c[1] // возьмем первый элемент c 33 | // определим элементы c_small меньше m 34 | // определим элементы c_large больше m 35 | QuickSort(c_small) 36 | QuickSort(c_large) 37 | // объединим c_small, m и c_large в сортированный список c_sorted 38 | return c_sorted 39 | ''' 40 | -------------------------------------------------------------------------------- /9.2 Множество/B/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | # Как решить применяя множества без словарей, придумать не получилось 3 | 4 | from sys import stdin 5 | 6 | n = int(stdin.readline().rstrip()) 7 | 8 | answer = 0 9 | prepared_input = [0] * n 10 | 11 | for i in range(n): 12 | text = stdin.readline().rstrip() 13 | temp = [0] * (len(text) + 1) 14 | for j in range(len(text)): 15 | temp[j] = text[:j] + text[j + 1:] 16 | temp[len(text)] = text 17 | prepared_input[i] = temp 18 | 19 | 20 | for seg in range(len(prepared_input[0])): 21 | suffixs_set = set() 22 | suffixs = dict() 23 | words = set() 24 | words_dict = dict() 25 | 26 | for suff in prepared_input: 27 | suffix = suff[seg] 28 | word = suff[-1] 29 | if suffix in suffixs_set: 30 | repeats = 0 31 | if word in words: 32 | repeats = words_dict.get(word) 33 | answer += (suffixs[suffix] - repeats) 34 | else: 35 | suffixs_set.add(suffix) 36 | 37 | suffixs[suffix] = suffixs.get(suffix, 0) + 1 38 | words.add(word) 39 | words_dict[word] = words_dict.get(word, 0) + 1 40 | 41 | print(answer) 42 | -------------------------------------------------------------------------------- /5.1 Задачи о числах Фибоначчи/A/problem.md: -------------------------------------------------------------------------------- 1 | # Числа Фибоначчи 2 | 3 | Дано целое число n, необходимо вычислить n\-е число Фибоначчи. 4 | 5 | Напомним, что F0\=0, F1\=1 и Fn\=Fn-1+Fn-2 при n≥2. 6 | 7 | ## Формат ввода 8 | 9 | Целое число n. 10 | 11 | Ограничения: 0≤n≤45. 12 | 13 | ## Формат вывода 14 | 15 | Выведите Fn. 16 | 17 | ### Пример 1 18 | 19 | Ввод 20 | 21 | 3 22 | 23 | 24 | Вывод 25 | 26 | 2 27 | 28 | 29 | ### Пример 2 30 | 31 | Ввод 32 | 33 | 10 34 | 35 | 36 | Вывод 37 | 38 | 55 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
59 | -------------------------------------------------------------------------------- /10.4 Алгоритм нахождения компонент связности в графе/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.3 2 | # Задачка-отдых 3 | 4 | from sys import stdin 5 | 6 | n, m = map(int, stdin.readline().split()) 7 | graph = [[] for _ in range(n + 1)] 8 | for _ in range(m): 9 | u, v = map(int, stdin.readline().split()) 10 | graph[u].append(v) 11 | graph[v].append(u) 12 | 13 | component = [] 14 | 15 | used = set() 16 | for begin in range(1, n + 1): 17 | if begin not in used: 18 | now_chain = [] 19 | stack = [] 20 | stack.append(begin) 21 | used.add(begin) 22 | now_chain.append(begin) 23 | while stack: 24 | start_point = stack.pop() 25 | for his_friend in graph[start_point]: 26 | if his_friend not in used: 27 | used.add(his_friend) 28 | now_chain.append(his_friend) 29 | stack.append(his_friend) 30 | component.append(now_chain) 31 | if len(component) > 1: 32 | answer = [] 33 | for island in range(1, len(component)): 34 | answer.append(f'{component[island - 1][-1]} {component[island][-1]}') 35 | print(len(answer)) 36 | print('\n'.join(answer)) 37 | else: 38 | print(0) 39 | 40 | -------------------------------------------------------------------------------- /5.1 Задачи о числах Фибоначчи/E/problem.md: -------------------------------------------------------------------------------- 1 | # Последняя цифра частичной суммы чисел Фибоначчи 2 | 3 | Даны числа m и n, необходимо найти последнюю цифру суммы Fm+Fm+1+…+Fn​. 4 | 5 | ## Формат ввода 6 | 7 | Целые числа m и n. 8 | 9 | Ограничения: 0≤m≤n≤1014. 10 | 11 | ## Формат вывода 12 | 13 | Последняя цифра суммы Fm+Fm+1+…+Fn​​. 14 | 15 | ### Пример 1 16 | 17 | Ввод 18 | 19 | 3 7 20 | 21 | 22 | Вывод 23 | 24 | 1 25 | 26 | 27 | ### Пример 2 28 | 29 | Ввод 30 | 31 | 10 10 32 | 33 | 34 | Вывод 35 | 36 | 5 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
57 | -------------------------------------------------------------------------------- /3.5 Алгоритмы «Разделяй и властвуй»/C/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | def merge(list_1, list_2): 4 | sorted_list = [] 5 | left_ind = 0 6 | right_ind = 0 7 | 8 | while left_ind <= len(list_1)-1 and right_ind <= len(list_2)-1 and list_1 and list_2: 9 | if list_1[left_ind] <= list_2[right_ind]: 10 | sorted_list.append(list_1[left_ind]) 11 | left_ind += 1 12 | elif list_2[right_ind] <= list_1[left_ind]: 13 | sorted_list.append(list_2[right_ind]) 14 | right_ind += 1 15 | 16 | if left_ind-1 == len(list_1) - 1 or not list_1: 17 | sorted_list.extend(list_2[right_ind:]) 18 | elif right_ind-1 == len(list_2) - 1 or not list_2: 19 | sorted_list.extend(list_1[left_ind:]) 20 | return sorted_list 21 | 22 | def merge_sort(list_full): 23 | if len(list_full) == 1: 24 | return list_full 25 | lenght = len(list_full) // 2 26 | first_half = list_full[:lenght] 27 | second_half = list_full[lenght:] 28 | sorted_first_half = merge_sort(first_half) 29 | sorted_second_half = merge_sort(second_half) 30 | sort_list = merge(sorted_first_half, sorted_second_half) 31 | return sort_list 32 | 33 | n = int(input()) 34 | res = list(map(int, input().split())) 35 | 36 | print(*merge_sort(res)) 37 | -------------------------------------------------------------------------------- /10.3 Обходы графа/B/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.3 2 | 3 | x, y = map(int, input().split()) 4 | minimum = min(x, y) 5 | maximum = max(x, y) + 40 #нужен небольшой запас, есть тесты которые проверяют, что оптимальнее получить значение больше и сделать вычитание 6 | 7 | from collections import deque # можно было бы использовать очередь в виде кольцевого буфера, но и этого хватило 8 | queue = deque() 9 | used = [0] * (maximum + 1) 10 | queue.append(x) 11 | destination = [maximum] * (maximum + 1) 12 | destination[x] = 0 13 | used[x] = 1 14 | isMinusUsed = False 15 | while queue: 16 | vertex = queue.popleft() 17 | for i in range(1, 10): # с - цифра, задание немного с хитринкой :-) 18 | plus = vertex + i 19 | minus = vertex - i 20 | mul = vertex * i 21 | options = [minus, plus, mul] # можно поиграться с оптимизацией, если описать случаи когда нужно совершать различные операции 22 | if not isMinusUsed: # обязательно нужно проверять и с 0, возможно так будет быстрее дойти 23 | isMinusUsed = True 24 | options.append(0) 25 | for var in options: 26 | if 0 <= var <= maximum and not used[var]: 27 | queue.append(var) 28 | used[var] = 1 29 | destination[var] = destination[vertex] + 1 30 | print(destination[y]) 31 | 32 | -------------------------------------------------------------------------------- /8.2 Задача «Размен 2»/A/problem.md: -------------------------------------------------------------------------------- 1 | # Оптимальный размен 2 | 3 | Задано одно целое число money. Требуется представить число money в виде суммы минимального количества монет номиналами 1, 3 и 4. 4 | 5 | ## Формат ввода 6 | 7 | Целое число money. 8 | 9 | Ограничения: $1 \\le money \\le 10^3$. 10 | 11 | ## Формат вывода 12 | 13 | Минимальное количество монет номиналами 1, 3, 4, чтобы получить число money. 14 | 15 | ### Пример 1 16 | 17 | Ввод 18 | 19 | 18 20 | 21 | 22 | Вывод 23 | 24 | 5 25 | 26 | 27 | ### Пример 2 28 | 29 | Ввод 30 | 31 | 20 32 | 33 | 34 | Вывод 35 | 36 | 5 37 | 38 | 39 | ### Пример 3 40 | 41 | Ввод 42 | 43 | 34 44 | 45 | 46 | Вывод 47 | 48 | 9 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
69 | -------------------------------------------------------------------------------- /5.1 Задачи о числах Фибоначчи/C/problem.md: -------------------------------------------------------------------------------- 1 | # Огромное число Фибоначчи 2 | 3 | Даны целые числа n и m, необходимо найти остаток от деления n\-го числа Фибоначчи на m. 4 | 5 | ## Формат ввода 6 | 7 | Целые числа n и m. 8 | 9 | Ограничения: 1≤n≤1014, 2≤m≤103. 10 | 11 | ## Формат вывода 12 | 13 | Fn mod m --- остаток от деления Fn​ на m. 14 | 15 | ### Пример 1 16 | 17 | Ввод 18 | 19 | 1 239 20 | 21 | 22 | Вывод 23 | 24 | 1 25 | 26 | 27 | ### Пример 2 28 | 29 | Ввод 30 | 31 | 115 1000 32 | 33 | 34 | Вывод 35 | 36 | 885 37 | 38 | 39 | ### Пример 3 40 | 41 | Ввод 42 | 43 | 2816213588 239 44 | 45 | 46 | Вывод 47 | 48 | 151 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 |
Ограничение времени3 секунды
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
70 | -------------------------------------------------------------------------------- /8.8 Задача «Расставить скобки»/B/problem.md: -------------------------------------------------------------------------------- 1 | # Вычисление арифметического выражения без скобок 2 | 3 | Ввод содержит только строку s длиной n. Строка состоит из чисел операндов (числа от 0 до 99) и операций +, -, \*. Посчитайте значения выражения. 4 | 5 | ## Формат ввода 6 | 7 | Ограничения: строка содержит максимум 20 символов. 8 | 9 | ## Формат вывода 10 | 11 | Выведите ответ на задачу. 12 | 13 | ### Пример 1 14 | 15 | Ввод 16 | 17 | 5-8+7*4-8+9 18 | 19 | 20 | Вывод 21 | 22 | 26 23 | 24 | 25 | ### Пример 2 26 | 27 | Ввод 28 | 29 | 23*17-18+37 30 | 31 | 32 | Вывод 33 | 34 | 410 35 | 36 | 37 | ### Пример 3 38 | 39 | Ввод 40 | 41 | 1+1+4+0-0*0+15 42 | 43 | 44 | Вывод 45 | 46 | 21 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
67 | -------------------------------------------------------------------------------- /8.8 Задача «Расставить скобки»/C/problem.md: -------------------------------------------------------------------------------- 1 | # Вычисление арифметического выражения со скобоками 2 | 3 | Ввод содержит только строку s длиной n. Строка состоит из чисел операндов (числа от 0 до 99), операций +, -, \* и скобок (). Посчитайте значения выражения. 4 | 5 | ## Формат ввода 6 | 7 | Ограничения: строка содержит максимум 20 символов. 8 | 9 | ## Формат вывода 10 | 11 | Выведите ответ на задачу. 12 | 13 | ### Пример 1 14 | 15 | Ввод 16 | 17 | (1+2)*4 18 | 19 | 20 | Вывод 21 | 22 | 12 23 | 24 | 25 | ### Пример 2 26 | 27 | Ввод 28 | 29 | (2+2)*2+0*1-10 30 | 31 | 32 | Вывод 33 | 34 | -2 35 | 36 | 37 | ### Пример 3 38 | 39 | Ввод 40 | 41 | ((2+2)*2) 42 | 43 | 44 | Вывод 45 | 46 | 8 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
67 | -------------------------------------------------------------------------------- /7.4 Подсчёт инверсий/C/problem.md: -------------------------------------------------------------------------------- 1 | # Подсчет транспозиций 2 | 3 | Дана перестановка p из n целых чисел. Необходимо вычислить, какое минимальное количество транспозиций требуется совершить, чтобы упорядочить элементы перестановки по возрастанию. 4 | 5 | Транспозиция -- это обмен соседних элементов перестановки p местами. 6 | 7 | ## Формат ввода 8 | 9 | Первая строка содержит целое число n, следующая --- последовательность целых чисел $p\_0, \\dotsc, p\_{n-1}$​. 10 | 11 | Ограничения: $1 \\le n \\le 30\\,000$, $1 \\le p\_i \\le n$ для всех $0 \\le i \\le n-1$. Все $p\_i$​ различны. 12 | 13 | ## Формат вывода 14 | 15 | Минимальное количество транспозиций. 16 | 17 | ## Пример 18 | 19 | Ввод 20 | 21 | 5 22 | 3 5 4 2 1 23 | 24 | 25 | Вывод 26 | 27 | 8 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
48 | -------------------------------------------------------------------------------- /3.6 Рандомизированные алгоритмы/B/problem.md: -------------------------------------------------------------------------------- 1 | # Быстрая сортировка 2 | 3 | Реализуйте QuickSort. 4 | 5 | ## Формат ввода 6 | 7 | В первой строке задано число n (1≤n≤100000). 8 | 9 | Во второй строке задано n чисел ai​ (1≤ai​≤109). 10 | 11 | ## Формат вывода 12 | 13 | Выведите отсортированный массив чисел. 14 | 15 | ### Пример 1 16 | 17 | Ввод 18 | 19 | 7 20 | 13 17 37 73 31 19 23 21 | 22 | 23 | Вывод 24 | 25 | 13 17 19 23 31 37 73 26 | 27 | 28 | ### Пример 2 29 | 30 | Ввод 31 | 32 | 4 33 | 18 20 3 17 34 | 35 | 36 | Вывод 37 | 38 | 3 17 18 20 39 | 40 | 41 | ### Пример 3 42 | 43 | Ввод 44 | 45 | 3 46 | 1 11 1 47 | 48 | 49 | Вывод 50 | 51 | 1 1 11 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
72 | -------------------------------------------------------------------------------- /3.5 Алгоритмы «Разделяй и властвуй»/C/problem.md: -------------------------------------------------------------------------------- 1 | # Сортировка слиянием 2 | 3 | Реализуйте сортировку слиянием. 4 | 5 | ## Формат ввода 6 | 7 | В первой строке задано число n (1≤n≤100000). 8 | 9 | Во второй строке задано n чисел ai​ (0≤ai≤109). 10 | 11 | ## Формат вывода 12 | 13 | Выведите отсортированный массив чисел. 14 | 15 | ### Пример 1 16 | 17 | Ввод 18 | 19 | 7 20 | 13 17 37 73 31 19 23 21 | 22 | 23 | Вывод 24 | 25 | 13 17 19 23 31 37 73 26 | 27 | 28 | ### Пример 2 29 | 30 | Ввод 31 | 32 | 4 33 | 18 20 3 17 34 | 35 | 36 | Вывод 37 | 38 | 3 17 18 20 39 | 40 | 41 | ### Пример 3 42 | 43 | Ввод 44 | 45 | 3 46 | 0 11 0 47 | 48 | 49 | Вывод 50 | 51 | 0 0 11 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
72 | -------------------------------------------------------------------------------- /3.5 Алгоритмы «Разделяй и властвуй»/A/problem.md: -------------------------------------------------------------------------------- 1 | # Сортировка выбором 2 | 3 | Реализуйте сортировку выбором. 4 | 5 | ## Формат ввода 6 | 7 | В первой строке задано число n (1≤n≤1000). 8 | 9 | Во второй строке задано n чисел ai​ (1≤ai​≤109). 10 | 11 | ## Формат вывода 12 | 13 | Выведите отсортированный массив чисел. 14 | 15 | ### Пример 1 16 | 17 | Ввод 18 | 19 | 7 20 | 13 17 37 73 31 19 23 21 | 22 | 23 | Вывод 24 | 25 | 13 17 19 23 31 37 73 26 | 27 | 28 | ### Пример 2 29 | 30 | Ввод 31 | 32 | 6 33 | 12 18 7 11 5 17 34 | 35 | 36 | Вывод 37 | 38 | 5 7 11 12 17 18 39 | 40 | 41 | ### Пример 3 42 | 43 | Ввод 44 | 45 | 3 46 | 1 2 3 47 | 48 | 49 | Вывод 50 | 51 | 1 2 3 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
73 | -------------------------------------------------------------------------------- /5.1 Задачи о числах Фибоначчи/D/problem.md: -------------------------------------------------------------------------------- 1 | # Последняя цифра суммы чисел Фибоначчи 2 | 3 | Дано число n, необходимо найти последнюю цифру суммы F0+F1+F2+…+F2​. 4 | 5 | ## Формат ввода 6 | 7 | Целое число n. 8 | 9 | Ограничения: 0≤n≤1014. 10 | 11 | ## Формат вывода 12 | 13 | Последняя цифра суммы F0+F1+F2+…+F2​. 14 | 15 | ### Пример 1 16 | 17 | Ввод 18 | 19 | 3 20 | 21 | 22 | Вывод 23 | 24 | 4 25 | 26 | 27 | ### Пример 2 28 | 29 | Ввод 30 | 31 | 100 32 | 33 | 34 | Вывод 35 | 36 | 5 37 | 38 | 39 | ## Примечание 40 | 41 | Исчерпывающий поиск будет слишком медленным для этой задачи, попробуйте придумать формулу для F0+F1+F2+…+F2​. 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
62 | -------------------------------------------------------------------------------- /10.2 Представление графа в памяти компьютера/B/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.3 2 | 3 | from sys import stdin 4 | 5 | n, m = map(int, stdin.readline().split()) 6 | room = [[-1] * (m + 2) for _ in range(n + 2)] 7 | """ 8 | -1 = клетка, по которой НЕЛЬЗЯ перемещаться (#) 9 | 0 = клетка, по которой МОЖНО перемещаться (.) 10 | 1 = клетка, по которой прошли 11 | """ 12 | for row in range(1, n + 1): 13 | line = stdin.readline().rstrip() 14 | for piece in range(1, m + 1): 15 | if line[piece - 1] == '.': 16 | room[row][piece] = 0 17 | #print(*room, sep = '\n') 18 | drow = [-1, 0, 1, 0] 19 | dcol = [0, 1, 0, -1] 20 | start_row, start_col = map(int, stdin.readline().split()) 21 | robot = [start_row, start_col] 22 | direction = 0 23 | amount_moves = int(stdin.readline().rstrip()) 24 | moves = stdin.readline().rstrip() 25 | answer = 1 26 | room[robot[0]][robot[1]] = 1 27 | for step in moves: 28 | if step == 'R': 29 | direction = (direction + 1) % 4 30 | elif step == 'L': 31 | direction = (direction - 1) % 4 32 | elif step == 'M': 33 | to_row = robot[0] + drow[direction] 34 | to_col = robot[1] + dcol[direction] 35 | if room[to_row][to_col] in (0, 1): 36 | if room[to_row][to_col] == 0: 37 | room[to_row][to_col] = 1 38 | answer += 1 39 | robot[0] += drow[direction] 40 | robot[1] += dcol[direction] 41 | print(answer) 42 | 43 | -------------------------------------------------------------------------------- /8.8 Задача «Расставить скобки»/B/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.3 2 | 3 | 4 | from sys import stdin 5 | from collections import deque 6 | # Мне не захотелось писать стек, взял готовую 7 | # двухстороннюю очередь из стандартной библиотеки, она тоже прекрасно подойдет 8 | # В тестах нет отрицательных чисел, этот код только для положительных чисел и 0. 9 | 10 | text = stdin.readline().rstrip() 11 | postfix_expression = [] 12 | queue = deque() 13 | 14 | storage = 0 15 | for sym in text: 16 | if sym.isdigit(): 17 | storage = storage * 10 + int(sym) 18 | else: 19 | postfix_expression.append(storage) 20 | if sym == '*' and queue and queue[0] == '*': 21 | while queue[0] != '*': 22 | postfix_expression.append(queue.popleft()) 23 | elif sym == '+' or sym == '-': 24 | while queue: 25 | postfix_expression.append(queue.popleft()) 26 | queue.appendleft(sym) 27 | storage = 0 28 | postfix_expression.append(storage) 29 | 30 | while queue: 31 | postfix_expression.append(queue.popleft()) 32 | 33 | for operand in postfix_expression: 34 | if isinstance(operand, int): 35 | queue.appendleft(operand) 36 | else: 37 | num_2 = queue.popleft() 38 | num_1 = queue.popleft() 39 | queue.appendleft(eval(f'{num_1}{operand}{num_2}')) 40 | 41 | answer = 0 42 | if queue: 43 | answer = queue.popleft() 44 | print(answer) 45 | -------------------------------------------------------------------------------- /7.2 Поиск доминирующего элемента/A/problem.md: -------------------------------------------------------------------------------- 1 | # Поиск доминирующего элемента 2 | 3 | Ваша задача --- проверить, содержит ли данная последовательность элемент, который встречается более половины раз. 4 | 5 | ## Формат ввода 6 | 7 | Первая строка содержит целое число n, следующая --- последовательность nnn целых неотрицательных чисел $a\_0, \\dotsc, a\_{n-1}$​. 8 | 9 | Ограничения: $1 \\le n \\le 10^5$; $0 \\le a\_i \\le 10^9$ для всех $0 \\le i \\lt n$. 10 | 11 | ## Формат вывода 12 | 13 | Выведите 1, если в последовательности содержится элемент, который встречается больше, чем _n/2_ раз, и 0 в противном случае. 14 | 15 | ### Пример 1 16 | 17 | Ввод 18 | 19 | 5 20 | 2 3 9 2 2 21 | 22 | 23 | Вывод 24 | 25 | 1 26 | 27 | 28 | ### Пример 2 29 | 30 | Ввод 31 | 32 | 4 33 | 1 2 3 1 34 | 35 | 36 | Вывод 37 | 38 | 0 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
59 | -------------------------------------------------------------------------------- /3.2 Жадные алгоритмы/A/problem.md: -------------------------------------------------------------------------------- 1 | # Бронирование переговорки 2 | 3 | Задано n интервалов. Требуется найти максимальное количество взаимно непересекающихся интервалов. 4 | 5 | Два интервала пересекаются, если они имеют хотя бы одну общую точку. 6 | 7 | ## Формат ввода 8 | 9 | В первой строке задано одно число n (1≤n≤100) — количество интервалов. 10 | 11 | В следующих n строках заданы интервалы li,ri​ (1≤li≤ri≤50). 12 | 13 | ## Формат вывода 14 | 15 | Выведите ответ на задачу. 16 | 17 | ### Пример 1 18 | 19 | Ввод 20 | 21 | 3 22 | 1 3 23 | 2 3 24 | 4 5 25 | 26 | 27 | Вывод 28 | 29 | 2 30 | 31 | 32 | ### Пример 2 33 | 34 | Ввод 35 | 36 | 5 37 | 1 2 38 | 2 3 39 | 4 5 40 | 4 5 41 | 5 6 42 | 43 | 44 | Вывод 45 | 46 | 2 47 | 48 | 49 | ### Пример 3 50 | 51 | Ввод 52 | 53 | 2 54 | 1 50 55 | 49 50 56 | 57 | 58 | Вывод 59 | 60 | 1 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
81 | -------------------------------------------------------------------------------- /6.4 Задача «Сбор подписей»/B/problem.md: -------------------------------------------------------------------------------- 1 | # Покрытие точек отрезками одинаковой длины 2 | 3 | Заданы n точек на прямой. 4 | 5 | Выведите наименьшее количество отрезков длины L, которые необходимы, чтобы покрыть все точки. 6 | 7 | ## Формат ввода 8 | 9 | В первой строке находится два числа n и L. Во второй строке заданы координаты n точек $x\_i$​. 10 | 11 | Ограничения: $1 \leq n \leq 10^5$, $1 \leq L \leq 10^9$, $\-10^9 \leq x\_i \leq 10^9$ для всех i от 0 до n−1. 12 | 13 | ## Формат вывода 14 | 15 | Наименьшее количество отрезков. 16 | 17 | ### Пример 1 18 | 19 | Ввод 20 | 21 | 5 4 22 | 1 1 3 4 5 23 | 24 | 25 | Вывод 26 | 27 | 1 28 | 29 | 30 | ### Пример 2 31 | 32 | Ввод 33 | 34 | 5 1 35 | 1 2 3 4 5 36 | 37 | 38 | Вывод 39 | 40 | 3 41 | 42 | 43 | ### Пример 3 44 | 45 | Ввод 46 | 47 | 6 2 48 | 1 2 3 4 5 6 49 | 50 | 51 | Вывод 52 | 53 | 2 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
74 | -------------------------------------------------------------------------------- /7.4 Подсчёт инверсий/A/problem.md: -------------------------------------------------------------------------------- 1 | # Количество инверсий 2 | 3 | Дан массив a из n целых чисел. Необходимо вычислить количество инверсий в этом массиве. Инверсия -- это такая пара индексов _i,j_, что $i \\lt j$ и $a\_i \\gt a\_j$​. 4 | 5 | ## Формат ввода 6 | 7 | Первая строка содержит целое число n, следующая --- последовательность целых чисел $a\_0, \\dotsc, a\_{n-1}$. 8 | 9 | Ограничения: $1 \\le n \\le 30\\,000$, $1 \\le a\_i \\le 10^9$ для всех $0 \\le i \\le n-1$. 10 | 11 | ## Формат вывода 12 | 13 | Количество инверсий в последовательности. 14 | 15 | ### Пример 1 16 | 17 | Ввод 18 | 19 | 5 20 | 2 3 9 2 9 21 | 22 | 23 | Вывод 24 | 25 | 2 26 | 27 | 28 | ### Пример 2 29 | 30 | Ввод 31 | 32 | 3 33 | 1 1 1 34 | 35 | 36 | Вывод 37 | 38 | 0 39 | 40 | 41 | ### Пример 3 42 | 43 | Ввод 44 | 45 | 10 46 | 1 2 1 2 1 2 3 1 3 1 47 | 48 | 49 | Вывод 50 | 51 | 12 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
72 | -------------------------------------------------------------------------------- /4.3 Задача «Максимальное произведение»/A/problem.md: -------------------------------------------------------------------------------- 1 | # Максимальное произведение 2 | 3 | Дана последовательность неотрицательных целых чисел a1,…,an​. Вычислите 4 | 5 | max⁡ ai⋅aj,1≤i≠j≤n. 6 | 7 | Обратите внимание, что i и j должны быть разными, хотя в каких-то случаях можно наблюдать, что ai\=aj​. 8 | 9 | ## Формат ввода 10 | 11 | Первая строка содержит целое число n. Следующая строка содержит n неотрицательных целых чисел a1,…,an​ (разделены пробелами). 12 | 13 | Ограничения: 2≤n≤2⋅105; 0≤a1,…,an≤2⋅105. 14 | 15 | ## Формат вывода 16 | 17 | Максимальное попарное произведение. 18 | 19 | ### Пример 1 20 | 21 | Ввод 22 | 23 | 3 24 | 1 2 3 25 | 26 | 27 | Вывод 28 | 29 | 6 30 | 31 | 32 | ### Пример 2 33 | 34 | Ввод 35 | 36 | 2 37 | 0 1 38 | 39 | 40 | Вывод 41 | 42 | 0 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
63 | -------------------------------------------------------------------------------- /7.4 Подсчёт инверсий/D/problem.md: -------------------------------------------------------------------------------- 1 | # Подсчет транспозиций (усложненная) 2 | 3 | Дана перестановка p из n целых чисел. Необходимо вычислить, какое минимальное количество транспозиций требуется совершить, чтобы упорядочить элементы перестановки _хорошо_. 4 | 5 | Будем говорить, что элементы перестановки упорядочены _хорошо_, если найдется такое число x от 1 до n, что перестановка имеет вид $x, x+1, \\ldots , n, 1, 2, \\ldots , x-1$. 6 | 7 | Транспозиция -- это обмен соседних элементов перестановки p местами. 8 | 9 | ## Формат ввода 10 | 11 | Первая строка содержит целое число n, следующая --- последовательность целых чисел $p\_0, \\dotsc, p\_{n-1}$​. 12 | 13 | Ограничения: $1 \\le n \\le 30\\,000$, $1 \\le p\_i \\le n$ для всех $0 \\le i \\le n-1$. Все $p\_i$​ различны. 14 | 15 | ## Формат вывода 16 | 17 | Минимальное количество транспозиций. 18 | 19 | ## Пример 20 | 21 | Ввод 22 | 23 | 5 24 | 3 5 4 2 1 25 | 26 | 27 | Вывод 28 | 29 | 2 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
50 | -------------------------------------------------------------------------------- /7.4 Подсчёт инверсий/B/problem.md: -------------------------------------------------------------------------------- 1 | # Количество полуинверсий 2 | 3 | Дан массив a из n целых чисел. Необходимо вычислить количество полуинверсий в этом массиве. Полуинверсия -- это такая пара индексов _i,j_, что $i \\lt j$ и $a\_i \\geq a\_j$​. 4 | 5 | ## Формат ввода 6 | 7 | Первая строка содержит целое число n, следующая --- последовательность целых чисел $a\_0, \\dotsc, a\_{n-1}$. 8 | 9 | Ограничения: $1 \\le n \\le 30\\,000$, $1 \\le a\_i \\le 10^9$ для всех $0 \\le i \\le n-1$. 10 | 11 | ## Формат вывода 12 | 13 | Количество полуинверсий в последовательности. 14 | 15 | ### Пример 1 16 | 17 | Ввод 18 | 19 | 5 20 | 2 3 9 2 9 21 | 22 | 23 | Вывод 24 | 25 | 4 26 | 27 | 28 | ### Пример 2 29 | 30 | Ввод 31 | 32 | 3 33 | 1 1 1 34 | 35 | 36 | Вывод 37 | 38 | 3 39 | 40 | 41 | ### Пример 3 42 | 43 | Ввод 44 | 45 | 10 46 | 1 2 1 2 1 2 3 1 3 1 47 | 48 | 49 | Вывод 50 | 51 | 26 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
72 | -------------------------------------------------------------------------------- /7.3 Модификация быстрой сортировки/A/problem.md: -------------------------------------------------------------------------------- 1 | # Модификация быстрой сортировки 2 | 3 | Дана последовательность a из n целых чисел (возможно повторяющихся). 4 | 5 | Ваша цель --- изменить описанный выше алгоритм `RandomizedQuickSort` так, чтобы даже при последовательностях с множеством повторяющихся элементов ожидаемое время выполнения стало $O(n \\log n)$. 6 | 7 | ## Формат ввода 8 | 9 | Первая строка содержит целое число n. В следующей строке содержится последовательность из n целых чисел $a\_0, a\_1, \\dotsc, a\_{n-1}$​. 10 | 11 | Ограничения: $1 \\le n \\le 10^5$; $1 \\le a\_i \\le 10^9$ для всех $0 \\le i \\lt n$. 12 | 13 | ## Формат вывода 14 | 15 | Вывод последовательности в неубывающем порядке. 16 | 17 | ### Пример 1 18 | 19 | Ввод 20 | 21 | 5 22 | 2 3 9 2 2 23 | 24 | 25 | Вывод 26 | 27 | 2 2 2 3 9 28 | 29 | 30 | ### Пример 2 31 | 32 | Ввод 33 | 34 | 4 35 | 1 2 3 1 36 | 37 | 38 | Вывод 39 | 40 | 1 1 2 3 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
61 | -------------------------------------------------------------------------------- /6.4 Задача «Сбор подписей»/C/problem.md: -------------------------------------------------------------------------------- 1 | # Минимальная суммарная длина отрезков 2 | 3 | Заданы n точек на прямой. 4 | 5 | Выведите минимальную длину k отрезков, покрывающих все точки. Отметим, что отрезки могут иметь нулевую длину. 6 | 7 | ## Формат ввода 8 | 9 | В первой строке находится два числа n и k. Во второй строке заданы координаты n точек $x\_i$​. 10 | 11 | Ограничения: $1 \leq n \leq 10^5$, $1 \leq k \leq 10^9$, $\-10^9 \leq x\_i \leq 10^9$ для всех i от 0 до n−1. 12 | 13 | ## Формат вывода 14 | 15 | Минимальная суммарная длина отрезков. 16 | 17 | ### Пример 1 18 | 19 | Ввод 20 | 21 | 5 2 22 | 1 1 3 4 5 23 | 24 | 25 | Вывод 26 | 27 | 2 28 | 29 | 30 | ### Пример 2 31 | 32 | Ввод 33 | 34 | 5 1000000000 35 | 1 1 3 4 5 36 | 37 | 38 | Вывод 39 | 40 | 0 41 | 42 | 43 | ### Пример 3 44 | 45 | Ввод 46 | 47 | 10 3 48 | 1 4 2 10 20 11 12 14 19 15 49 | 50 | 51 | Вывод 52 | 53 | 9 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
74 | -------------------------------------------------------------------------------- /6.1 Задача «Размен»/B/problem.md: -------------------------------------------------------------------------------- 1 | # Размен: 1, 5, 10, 20, 50 2 | 3 | Предположим, что у кассира есть бесконечное количество монет номиналами 1, 5, 10, 20 и 50. 4 | 5 | Найдите набор монет, с суммарным номиналом money, в котором наименьшее количество монет. Требуется вывести номиналы монет в этом наборе. 6 | 7 | ## Формат ввода 8 | 9 | Целое число money. 10 | 11 | Ограничения: 1≤money≤105. 12 | 13 | ## Формат вывода 14 | 15 | В первой строке выведите количество монет в наборе m. 16 | 17 | В следующей строке выведите выбранные монеты: номиналы монет. Монеты можете выводить в любом порядке. 18 | 19 | ### Пример 1 20 | 21 | Ввод 22 | 23 | 7 24 | 25 | 26 | Вывод 27 | 28 | 3 29 | 5 1 1 30 | 31 | 32 | ### Пример 2 33 | 34 | Ввод 35 | 36 | 10 37 | 38 | 39 | Вывод 40 | 41 | 1 42 | 10 43 | 44 | 45 | ### Пример 3 46 | 47 | Ввод 48 | 49 | 1 50 | 51 | 52 | Вывод 53 | 54 | 1 55 | 1 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 |
Ограничение времени2 секунды
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
76 | -------------------------------------------------------------------------------- /7.1 Двоичный поиск/D/problem.md: -------------------------------------------------------------------------------- 1 | # Минимальная длина покрывающих отрезков 2 | 3 | Заданы n точек на координатной прямой. Вам требуется покрыть все точки на прямой k отрезками одинаковой длины. 4 | 5 | Необходимо определить, какую минимальную длину могут иметь отрезки. 6 | 7 | ## Формат ввода 8 | 9 | В первой строке находится два разделенных пробелом числа n,k $(1 \leq n, k \leq 10^5$. 10 | 11 | Во второй строке заданы координаты n точек $x\_i$​ $(1 \\leq x\_i \\leq 10^9)$. 12 | 13 | ## Формат вывода 14 | 15 | Вывод должен состоять из одного числа -- минимальная длина отрезков. 16 | 17 | ### Пример 1 18 | 19 | Ввод 20 | 21 | 5 3 22 | 2 3 9 11 20 23 | 24 | 25 | Вывод 26 | 27 | 2 28 | 29 | 30 | ### Пример 2 31 | 32 | Ввод 33 | 34 | 5 2 35 | 2 3 9 11 20 36 | 37 | 38 | Вывод 39 | 40 | 9 41 | 42 | 43 | ### Пример 3 44 | 45 | Ввод 46 | 47 | 4 2 48 | 1 2 1 2 49 | 50 | 51 | Вывод 52 | 53 | 0 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
74 | -------------------------------------------------------------------------------- /3.3 Динамическое программирование/A/problem.md: -------------------------------------------------------------------------------- 1 | # Камни 2 | 3 | Вы играете в игру <<Камни>>: игру для двух игроков с двумя наборами камней по n и m штук. С каждым ходом один игрок может взять один камень (из любого набора) или два камня (по одному из обоих). Когда камень забрали, он выходит из игры. Побеждает игрок, который заберет последний камень. Первый ход за вами. 4 | 5 | Вы и ваш оппонент играете оптимально. 6 | 7 | ## Формат ввода 8 | 9 | В первой строке содержится два числа n (1≤n≤10), m (1≤m≤10) — количество ваших камней и количество камней у вашего оппонента. 10 | 11 | ## Формат вывода 12 | 13 | В единственной строке выведите Loose, если вы заведомо проиграете, и Win, иначе. 14 | 15 | ### Пример 1 16 | 17 | Ввод 18 | 19 | 10 2 20 | 21 | 22 | Вывод 23 | 24 | Loose 25 | 26 | 27 | ### Пример 2 28 | 29 | Ввод 30 | 31 | 4 5 32 | 33 | 34 | Вывод 35 | 36 | Win 37 | 38 | 39 | ### Пример 3 40 | 41 | Ввод 42 | 43 | 6 8 44 | 45 | 46 | Вывод 47 | 48 | Loose 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
69 | 70 | -------------------------------------------------------------------------------- /9.1 Односвязный список/B/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | # Нужно было решить на односвязном списке, но мне хотелось сделать без него. В принципе, делается аналогично 3 | 4 | n = int(input()) 5 | arr = list(map(int, input().split())) 6 | 7 | min_element = 0 8 | max_element = 1 9 | min_not_approved = 0 10 | 11 | # left walk search min left and max right 12 | for num in range(2, n): 13 | if arr[num] > arr[max_element] or (arr[num] - arr[min_not_approved] > arr[max_element] - arr[min_element]): 14 | if arr[max_element] < arr[min_element]: 15 | min_element = max_element 16 | 17 | if arr[min_element] > arr[min_not_approved]: 18 | min_element = min_not_approved 19 | max_element = num 20 | 21 | elif arr[num] < arr[min_element] and arr[num] < arr[min_not_approved]: 22 | min_not_approved = num 23 | 24 | print(min_element + 1, max_element + 1) 25 | 26 | # right walk search max left and min right 27 | min_element = 1 28 | max_element = 0 29 | max_not_approved = 0 30 | 31 | for num in range(2, n): 32 | if arr[num] < arr[min_element] or (arr[max_not_approved] - arr[num] > arr[max_element] - arr[min_element]): 33 | if arr[min_element] > arr[max_element]: 34 | max_element = min_element 35 | 36 | if arr[max_element] < arr[max_not_approved]: 37 | max_element = max_not_approved 38 | min_element = num 39 | 40 | elif arr[num] > arr[max_element] and arr[num] > arr[max_not_approved]: 41 | max_not_approved = num 42 | 43 | 44 | print(max_element + 1, min_element + 1) 45 | -------------------------------------------------------------------------------- /7.5 Задача «Пара ближайших точек»/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | # Задача, которой особенно горжусь, потратил почти 3 дня и нашёл решение проходящее лимиты на питоне. 3 | 4 | def _closest_pair(points, min_dist, left, right): 5 | if right - left <= 3: 6 | #print(f'points - {points[left:right]}') 7 | brute_dist = min([((points[i][0] - points[j][0]) ** 2 + (points[i][1] - points[j][1]) ** 2) ** 0.5 for i in range(left, right - 1) for j in range(i + 1, right)]) 8 | 9 | if min_dist > brute_dist: 10 | min_dist = brute_dist 11 | return 12 | 13 | m = (left + right) // 2 14 | 15 | 16 | _closest_pair(points, min_dist, left, m) 17 | _closest_pair(points, min_dist, m, right) 18 | 19 | #return min(left_pair, right_pair) 20 | 21 | def final(points, min_dist): 22 | _closest_pair(points, min_dist, 0, len(points)) 23 | 24 | close_y = [p for p in sorted(points, key = lambda f: f[1]) if abs(p[0] - points[len(points) // 2][0]) < min_dist] 25 | 26 | for i in range(len(close_y) - 1): 27 | 28 | for j in range(i + 1, min(i + 8, len(close_y))): 29 | 30 | if close_y[j][1] - close_y[i][1]> min_dist: 31 | break 32 | min_dist = min(min_dist, ((close_y[i][0] - close_y[j][0]) ** 2 + (close_y[i][1] - close_y[j][1]) ** 2) ** 0.5) 33 | return min_dist 34 | 35 | 36 | from sys import stdin 37 | n = int(stdin.readline().strip()) 38 | points = sorted(tuple(map(int, stdin.readline().strip().split())) for i in range(n)) 39 | min_dist = 10**9 40 | #t_buffer = [] 41 | print(round(final(points, min_dist), 6)) 42 | 43 | -------------------------------------------------------------------------------- /8.7 Задача «Сувениры»/A/problem.md: -------------------------------------------------------------------------------- 1 | # Распределение сувениров 2 | 3 | Три пирата делят свою добычу, в которую входят nnn предметов разной ценности. Получится у вас помочь разделить добычу поровну? 4 | 5 | ## Формат ввода 6 | 7 | Первая строка содержит целое число n. Вторая строка содержит целые числа $v\_1, v\_2, \\dotsc, v\_n$​, разделенные пробелами. 8 | 9 | Ограничения: $1 \\le n \\le 20$, $1 \\le v\_i \\le 30$ для всех i. 10 | 11 | ## Формат вывода 12 | 13 | Вывести 1, если $v\_1, v\_2, \\dotsc, v\_n$​ можно разделить на три поднабора с одинаковыми суммами; в противном случае — вывести 0. 14 | 15 | ### Пример 1 16 | 17 | Ввод 18 | 19 | 13 20 | 1 2 3 4 5 5 7 7 8 10 12 19 25 21 | 22 | 23 | Вывод 24 | 25 | 1 26 | 27 | 28 | ### Пример 2 29 | 30 | Ввод 31 | 32 | 7 33 | 1 2 3 4 5 6 7 34 | 35 | 36 | Вывод 37 | 38 | 0 39 | 40 | 41 | ### Пример 3 42 | 43 | Ввод 44 | 45 | 5 46 | 12 13 14 15 23 47 | 48 | 49 | Вывод 50 | 51 | 0 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
72 | -------------------------------------------------------------------------------- /8.8 Задача «Расставить скобки»/A/problem.md: -------------------------------------------------------------------------------- 1 | # Максимальное значение арифметического выражения 2 | 3 | Ввод содержит только строку s длиной 2n+1 для некоего n с символами $s\_0,s\_1, \\dotsc, s\_{2n}​$. Каждый символ на четной позиции s — это цифра (то есть целое число от 0 до 9), а на нечетной позиции — это одна из трех операций из +, -, \*. 4 | 5 | Найдите максимальное значение данного арифметического выражения из всех возможных порядков арифметических операций. 6 | 7 | ## Формат ввода 8 | 9 | Ограничения: $0 \\le n \\le 14$ (таким образом, строка содержит максимум 29 символов). 10 | 11 | ## Формат вывода 12 | 13 | Выведите ответ на задачу. 14 | 15 | ### Пример 1 16 | 17 | Ввод 18 | 19 | 5-8+7*4-8+9 20 | 21 | 22 | Вывод 23 | 24 | 200 25 | 26 | 27 | ### Пример 2 28 | 29 | Ввод 30 | 31 | 4+1*3*2-7 32 | 33 | 34 | Вывод 35 | 36 | 105 37 | 38 | 39 | ### Пример 3 40 | 41 | Ввод 42 | 43 | 1+1+1-1*2*3+1*2-2 44 | 45 | 46 | Вывод 47 | 48 | 48 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
69 | -------------------------------------------------------------------------------- /7.1 Двоичный поиск/C/problem.md: -------------------------------------------------------------------------------- 1 | # Подсчет количества вхождений элементов 2 | 3 | Ваша задача --- для m значений $q\_i$​ необходимо найти количество вхождений $q\_i$​ в K. 4 | 5 | ## Формат ввода 6 | 7 | Отсортированный массив K целых чисел и массив целых чисел $Q=\[q\_0,\dotsc,q\_{m-1}\]$. 8 | 9 | Первые две строки ввода содержат целое число n и последовательность $k\_0 \le k\_1 \le \dotsc \le k\_{n-1}$​ из n положительных целых чисел в возрастающем порядке. 10 | 11 | Следующие две строки содержат целое число m и m положительных целых чисел $q\_0, q\_1, \dotsc, q\_{m-1}$​. 12 | 13 | Ограничения: $1 \le n \le 10^5$; $1 \le m \le 10^5$; $1 \le k\_i \le 10^9$ для всех $0 \le i \lt n$; $1 \le q\_j \le 10^9$ для всех $0 \le j \lt m$. 14 | 15 | ## Формат вывода 16 | 17 | Для всех i от 0 до m−1 выведите количество индексов $0 \le j \le n-1$, для которых $k\_j=q\_i$​. 18 | 19 | ## Пример 20 | 21 | Ввод 22 | 23 | 7 24 | 1 2 2 2 4 4 9 25 | 5 26 | 1 2 3 4 5 27 | 28 | 29 | Вывод 30 | 31 | 1 3 0 2 0 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
52 | -------------------------------------------------------------------------------- /6.6 Задача «Максимальный оклад»/A/problem.md: -------------------------------------------------------------------------------- 1 | # Максимальный оклад 2 | 3 | В качестве последнего вопроса на собеседовании будущий начальник дает вам n бумажек с одним числом на каждой и говорит составить из них самое большое число. Получившееся число — ваша зарплата, поэтому вы очень замотивированы решить эту задачу! 4 | 5 | ## Формат ввода 6 | 7 | Первая строка ввода содержит целое число n. Вторая строка содержит целые числа $a\_1, \dotsc, a\_n$​. 8 | 9 | Ограничения: $1 \leq n \leq 100$; $1 \leq a\_i \leq 10^3$ для всех $1 \leq i \leq n$. 10 | 11 | ## Формат вывода 12 | 13 | Самое большое возможное число, которое состоит из $a\_1, \dotsc, a\_n$​. 14 | 15 | ### Пример 1 16 | 17 | Ввод 18 | 19 | 2 20 | 21 2 21 | 22 | 23 | Вывод 24 | 25 | 221 26 | 27 | 28 | ### Пример 2 29 | 30 | Ввод 31 | 32 | 5 33 | 9 4 6 1 9 34 | 35 | 36 | Вывод 37 | 38 | 99641 39 | 40 | 41 | ### Пример 3 42 | 43 | Ввод 44 | 45 | 3 46 | 23 39 92 47 | 48 | 49 | Вывод 50 | 51 | 923923 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
72 | -------------------------------------------------------------------------------- /6.5 Задача «Количество призов»/A/problem.md: -------------------------------------------------------------------------------- 1 | # Количество призов 2 | 3 | Вы занимаетесь организацией соревнований для детей, и у вас есть n конфет, которые вы раздадите в качестве призов. Вы хотите отдать эти конфеты тем, кто займет первые k мест в соревнованиях, и распределить конфеты так, чтобы за более высокое место всегда выходило больше конфет. 4 | 5 | Чтобы порадовать как можно больше детей, вам понадобится найти самое большое значение k, при котором это возможно. 6 | 7 | ## Формат ввода 8 | 9 | Целое число n. 10 | 11 | Ограничения: $1 \leq n \leq 10^9$. 12 | 13 | ## Формат вывода 14 | 15 | Единственная строка: максимальное число k, при котором n можно представить как сумму k различных положительных целых чисел. 16 | 17 | ### Пример 1 18 | 19 | Ввод 20 | 21 | 6 22 | 23 | 24 | Вывод 25 | 26 | 3 27 | 28 | 29 | ### Пример 2 30 | 31 | Ввод 32 | 33 | 8 34 | 35 | 36 | Вывод 37 | 38 | 3 39 | 40 | 41 | ### Пример 3 42 | 43 | Ввод 44 | 45 | 2 46 | 47 | 48 | Вывод 49 | 50 | 1 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
71 | -------------------------------------------------------------------------------- /10.3 Обходы графа/B/problem.md: -------------------------------------------------------------------------------- 1 | # Минимальное количество арифметических операций 2 | 3 | Задано число X. 4 | 5 | Возможны следующие преобразования с числом 6 | 7 | * X = X + c, где c -- цифра. 8 | * X = X - c, где c -- цифра. 9 | * $X = X \\cdot c$, где c -- цифра. 10 | 11 | Обратите внимание, c может принимать значение равное 0. 12 | 13 | Необходимо найти минимальное количество операций, которые необходимо применить к числу X, чтобы получить число Y. 14 | 15 | ## Формат ввода 16 | 17 | В первой строке заданы два числа X,Y. 18 | 19 | ## Формат вывода 20 | 21 | В единственной строке выведите ответ на задачу. 22 | 23 | ### Пример 1 24 | 25 | Ввод 26 | 27 | 10 1000 28 | 29 | 30 | Вывод 31 | 32 | 3 33 | 34 | 35 | ### Пример 2 36 | 37 | Ввод 38 | 39 | 2 1 40 | 41 | 42 | Вывод 43 | 44 | 1 45 | 46 | 47 | ### Пример 3 48 | 49 | Ввод 50 | 51 | 100000 1 52 | 53 | 54 | Вывод 55 | 56 | 2 57 | 58 | 59 | ## Примечание 60 | 61 | Ограничения: 62 | 63 | * $1 \\leq X, Y \\leq 10^5$ 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
84 | -------------------------------------------------------------------------------- /7.1 Двоичный поиск/C/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | def bin_search(n_k, arr_k, m_q, arr_q): 4 | final = [] 5 | for number_q in arr_q: 6 | min_index = 0 7 | max_index = n_k - 1 8 | result = 0 9 | min_index_seq = -1 10 | while max_index >= min_index: 11 | mid_index = (max_index + min_index) // 2 12 | if arr_k[mid_index] == number_q: 13 | max_index = mid_index - 1 14 | min_index_seq = mid_index 15 | elif arr_k[mid_index] > number_q: 16 | max_index = mid_index - 1 17 | else: 18 | min_index = mid_index + 1 19 | min_index = min_index_seq 20 | max_index = n_k - 1 21 | max_index_seq = min_index_seq 22 | while min_index_seq != -1 and max_index >= min_index: 23 | mid_index = (max_index + min_index) // 2 24 | if arr_k[mid_index] == number_q: 25 | min_index = mid_index + 1 26 | max_index_seq = mid_index 27 | elif arr_k[mid_index] > number_q: 28 | max_index = mid_index - 1 29 | else: 30 | min_index = mid_index + 1 31 | 32 | # while min_index_seq <= n_k - 1 and arr_k[min_index_seq] == number_q: 33 | # result += 1 34 | # min_index_seq += 1 35 | if min_index_seq == -1: 36 | final.append(0) 37 | else: 38 | final.append(max_index_seq - min_index_seq + 1) 39 | return final 40 | 41 | n = int(input()) 42 | k = list(map(int, input().split())) 43 | m = int(input()) 44 | q = list(map(int, input().split())) 45 | 46 | print(*bin_search(n, k, m, q)) 47 | -------------------------------------------------------------------------------- /7.3 Модификация быстрой сортировки/B/problem.md: -------------------------------------------------------------------------------- 1 | # Быстрая сортировка — худший вход 2 | 3 | Дана число n. Вам необходимо построить массив, на котором алгоритм быстрой сортировки выполнит наибольшее количество рекурсивных вызовов. 4 | 5 | При рассматриваемом отрезке _l,r_ функции быстрой сортировки, считайте, что точка m выбирается по формуле $m = \\lfloor \\frac{l + r}{2} \\rfloor$. 6 | 7 | ## Формат ввода 8 | 9 | Первая строка содержит единственное число n -- количество чисел в массиве. 10 | 11 | Ограничения: $1 \\le n \\le 1\\,000$ 12 | 13 | ## Формат вывода 14 | 15 | Вывод должен состоять из n разделенных пробелом чисел — элементы массива $a\_i$​. Все числа должны быть различны. 16 | 17 | Ограничения: $1 \\le a\_i \\le 10^9$ 18 | 19 | ### Пример 1 20 | 21 | Ввод 22 | 23 | 2 24 | 25 | 26 | Вывод 27 | 28 | 2 1 29 | 30 | 31 | ### Пример 2 32 | 33 | Ввод 34 | 35 | 4 36 | 37 | 38 | Вывод 39 | 40 | 2 4 1 3 41 | 42 | 43 | ## Примечание 44 | 45 | Если входные данные допускают несколько корректных последовательностей чисел, то нужно вывести любую из них. 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
66 | -------------------------------------------------------------------------------- /4.2 Задача «Сумма двух чисел»/C/problem.md: -------------------------------------------------------------------------------- 1 | # A+B строки 2 | 3 | Необходимо вычислить "кривую" сумму двух строк A и B одинаковой длины. 4 | 5 | "Кривой" суммой двух строк называется операция следующего вида: 6 | 7 | C=A+B=A1B1A2B2…An-1Bn-1AnBn​ 8 | 9 | Где n -- длина строк A и B. 10 | 11 | ## Формат ввода 12 | 13 | В первой строке записано целое число n (1≤n≤10). 14 | 15 | Вторая строка содержит строку A. (Ai∈{a,b,…,z}). 16 | 17 | Третья строка содержит строку B. (Bi∈{a,b,…,z}). 18 | 19 | ## Формат вывода 20 | 21 | Выведите одну строку, содержащую строку С=A+B. 22 | 23 | ### Пример 1 24 | 25 | Ввод 26 | 27 | 3 28 | abc 29 | def 30 | 31 | 32 | Вывод 33 | 34 | adbecf 35 | 36 | 37 | ### Пример 2 38 | 39 | Ввод 40 | 41 | 5 42 | abaca 43 | bdaef 44 | 45 | 46 | Вывод 47 | 48 | abbdaaceaf 49 | 50 | 51 | ### Пример 3 52 | 53 | Ввод 54 | 55 | 1 56 | y 57 | z 58 | 59 | 60 | Вывод 61 | 62 | yz 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
84 | -------------------------------------------------------------------------------- /4.2 Задача «Сумма двух чисел»/D/problem.md: -------------------------------------------------------------------------------- 1 | # A+B матрицы 2 | 3 | Необходимо вычислить сумму двух матриц C = A+B. 4 | 5 | ## Формат ввода 6 | 7 | В первой строке записано два целых числа n и m (1≤n,m≤10). 8 | 9 | Далее идут n строк, каждая содержит по m чисел, -- описание элементов матрицы A (−100≤Ai,j≤100). 10 | 11 | Далее идут n строк, каждая содержит по m чисел, -- описание элементов матрицы B (−100≤Bi,j≤100). 12 | 13 | ## Формат вывода 14 | 15 | Выведите n строк, каждая содержащая по m чисел, -- описание элементов матрицы С. 16 | 17 | ### Пример 1 18 | 19 | Ввод 20 | 21 | 2 3 22 | 1 2 3 23 | 4 5 6 24 | -1 -2 -3 25 | -4 -5 -6 26 | 27 | 28 | Вывод 29 | 30 | 0 0 0 31 | 0 0 0 32 | 33 | 34 | ### Пример 2 35 | 36 | Ввод 37 | 38 | 2 3 39 | 1 2 3 40 | 4 5 6 41 | 1 2 3 42 | 4 5 6 43 | 44 | 45 | Вывод 46 | 47 | 2 4 6 48 | 8 10 12 49 | 50 | 51 | ### Пример 3 52 | 53 | Ввод 54 | 55 | 1 3 56 | 1 2 3 57 | 4 5 6 58 | 59 | 60 | Вывод 61 | 62 | 5 7 9 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
83 | -------------------------------------------------------------------------------- /7.1 Двоичный поиск/A/problem.md: -------------------------------------------------------------------------------- 1 | # Двоичный поиск 2 | 3 | Ваша задача --- найти индекс элемента в сортированной последовательности равного q. 4 | 5 | ## Формат ввода 6 | 7 | Отсортированный массив K неповторяющихся целых чисел и целое число q. Первые две строки ввода содержат целое число n и последовательность $k\_0 \lt k\_1 \lt \dotsc \lt k\_{n-1}$​ из n неповторяющихся положительных целых чисел в возрастающем порядке. Следующая строка содержит целое число q. 8 | 9 | Ограничения: $1 \le n \le 3 \cdot 10^4$; $1 \le k\_i \le 10^9$ для всех $0 \le i \lt n$; $1 \le q \le 10^9$. 10 | 11 | ## Формат вывода 12 | 13 | Позиция элемента в ***K*** равного q или −1 при отсутствии такого элемента. 14 | 15 | ### Пример 1 16 | 17 | Ввод 18 | 19 | 7 20 | 1 3 7 8 9 12 15 21 | 8 22 | 23 | 24 | Вывод 25 | 26 | 3 27 | 28 | 29 | ### Пример 2 30 | 31 | Ввод 32 | 33 | 7 34 | 1 3 7 8 9 12 15 35 | 12 36 | 37 | 38 | Вывод 39 | 40 | 5 41 | 42 | 43 | ### Пример 3 44 | 45 | Ввод 46 | 47 | 3 48 | 1 2 3 49 | 4 50 | 51 | 52 | Вывод 53 | 54 | -1 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
75 | -------------------------------------------------------------------------------- /6.1 Задача «Размен»/A/problem.md: -------------------------------------------------------------------------------- 1 | # Размен: все варианты 2 | 3 | Предположим, что у кассира есть бесконечное количество монет номиналами 1, 5, 10. 4 | 5 | Найдите все наборы монет, которые в сумме дают money. Требуется вывести количество подходящих наборов монет и сами наборы. 6 | 7 | Два набора считаются различными, если мультимножества монет не совпадают. 8 | 9 | ## Формат ввода 10 | 11 | Целое число moneymoneymoney. 12 | 13 | Ограничения: 1≤money≤103. 14 | 15 | ## Формат вывода 16 | 17 | В первой строке выведите количество наборов m. 18 | 19 | В следующих mmm строк выведите сами наборы: количество монет и номиналы монет. Наборы монет можете выводить в любом порядке. 20 | 21 | ### Пример 1 22 | 23 | Ввод 24 | 25 | 10 26 | 27 | 28 | Вывод 29 | 30 | 4 31 | 1 10 32 | 2 5 5 33 | 6 1 1 1 1 1 5 34 | 10 1 1 1 1 1 1 1 1 1 1 35 | 36 | 37 | ### Пример 2 38 | 39 | Ввод 40 | 41 | 1 42 | 43 | 44 | Вывод 45 | 46 | 1 47 | 1 1 48 | 49 | 50 | ### Пример 3 51 | 52 | Ввод 53 | 54 | 5 55 | 56 | 57 | Вывод 58 | 59 | 2 60 | 1 5 61 | 5 1 1 1 1 1 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
82 | -------------------------------------------------------------------------------- /8.4 Задача «Расстояние редактирования»/A/problem.md: -------------------------------------------------------------------------------- 1 | # Расстояние редактирования 2 | 3 | В вычислительной биологии есть множество применений задаче <<Редакционное расстояние>>: обработка текстов на естественном языке, проверка правописания и множество других сфер. Например, биологи зачастую вычисляют редакционное расстояние, когда ищут мутации, вызывающие болезни. 4 | 5 | Редакционное расстояние между двумя строками определяется как минимальное число односимвольных вставок, удалений и замен, необходимых для преобразования одной строки в другую. 6 | 7 | ## Формат ввода 8 | 9 | Две отдельных строки, состоящие из строчных букв латинского алфавита. 10 | 11 | Ограничения: длина обоих строк не меньше 1 и не больше 100. 12 | 13 | ## Формат вывода 14 | 15 | Найдите редакционное расстояние между ними. 16 | 17 | ### Пример 1 18 | 19 | Ввод 20 | 21 | abacab 22 | bacacaba 23 | 24 | 25 | Вывод 26 | 27 | 3 28 | 29 | 30 | ### Пример 2 31 | 32 | Ввод 33 | 34 | aaaaaac 35 | caaaaaa 36 | 37 | 38 | Вывод 39 | 40 | 2 41 | 42 | 43 | ### Пример 3 44 | 45 | Ввод 46 | 47 | ada 48 | aba 49 | 50 | 51 | Вывод 52 | 53 | 1 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
73 | -------------------------------------------------------------------------------- /9.2 Множество/B/problem.md: -------------------------------------------------------------------------------- 1 | # Похожие названия 2 | 3 | Пара слов **интересная**, если слова отличаются ровно в одной букве. 4 | 5 | Дан набор слов одинаковой длины. Вычислите количество интересных пар. 6 | 7 | ## Формат ввода 8 | 9 | Первая строка содержит одно число n -- количество слов. 10 | 11 | Далее следуют n строк, каждая содержит ровно одну непустую строку, состоящую из не более чем 10 символов английского алфавита. Символы могут быть **верхнего и нижнего** регистра. 12 | 13 | ## Формат вывода 14 | 15 | Вывод должен содержать одно число -- количество интересных пар слов. 16 | 17 | ### Пример 1 18 | 19 | Ввод 20 | 21 | 5 22 | rom 23 | bom 24 | dom 25 | bot 26 | rot 27 | 28 | 29 | Вывод 30 | 31 | 6 32 | 33 | 34 | ### Пример 2 35 | 36 | Ввод 37 | 38 | 3 39 | aa 40 | aa 41 | aa 42 | 43 | 44 | Вывод 45 | 46 | 0 47 | 48 | 49 | ### Пример 3 50 | 51 | Ввод 52 | 53 | 6 54 | aaa 55 | aaB 56 | aBa 57 | Baa 58 | BBB 59 | abb 60 | 61 | 62 | Вывод 63 | 64 | 3 65 | 66 | 67 | ## Примечание 68 | 69 | Ограничения: 70 | 71 | * $1 \\leq n \\leq 10^5$ 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 |
Ограничение времени2 секунды
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
93 | -------------------------------------------------------------------------------- /7.2 Поиск доминирующего элемента/B/problem.md: -------------------------------------------------------------------------------- 1 | # Поиск трех доминирующих элементов 2 | 3 | Дана последовательность a из n целых чисел. 4 | 5 | Ваша задача --- проверить, содержит ли данная последовательность элементы, которые встречаются более _n/4_ раз. 6 | 7 | ## Формат ввода 8 | 9 | Первая строка содержит целое число n, следующая --- последовательность n целых неотрицательных чисел $a\_0, \\dotsc, a\_{n-1}$​. 10 | 11 | Ограничения: $1 \\le n \\le 10^5$; $0 \\le a\_i \\le 10^9$ для всех $0 \\le i \\lt n$. 12 | 13 | ## Формат вывода 14 | 15 | Выведите 1, если в последовательности содержится три элемента, которые встречаются более _n/4_ раз, и 0 в противном случае. 16 | 17 | ### Пример 1 18 | 19 | Ввод 20 | 21 | 11 22 | 0 9 2 3 9 0 2 9 2 3 3 23 | 24 | 25 | Вывод 26 | 27 | 1 28 | 29 | 30 | ### Пример 2 31 | 32 | Ввод 33 | 34 | 4 35 | 1 2 3 1 36 | 37 | 38 | Вывод 39 | 40 | 0 41 | 42 | 43 | ### Пример 3 44 | 45 | Ввод 46 | 47 | 3 48 | 0 2 1 49 | 50 | 51 | Вывод 52 | 53 | 1 54 | 55 | 56 | ### Пример 4 57 | 58 | Ввод 59 | 60 | 10 61 | 1 2 1 2 1 2 1 2 1 2 62 | 63 | 64 | Вывод 65 | 66 | 0 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
87 | -------------------------------------------------------------------------------- /8.8 Задача «Расставить скобки»/C/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.3 2 | 3 | from sys import stdin 4 | from collections import deque 5 | # Мне не захотелось писать класс односторонней очереди, взял готовую 6 | # двухстороннюю из стандартной библиотеки, она тоже прекрасно подойдет 7 | # В тестах нет отрицательных чисел, этот код только для положительных чисел и 0. 8 | 9 | text = stdin.readline().rstrip() 10 | postfix_expression = [] 11 | queue = deque() 12 | 13 | storage = 0 14 | isNumber = False 15 | for sym in text: 16 | if sym.isdigit(): 17 | storage = storage * 10 + int(sym) 18 | isNumber = True 19 | else: 20 | if isNumber: 21 | postfix_expression.append(storage) 22 | isNumber = False 23 | storage = 0 24 | 25 | if sym == '*' and queue and queue[0] == '*': 26 | while queue[0] != '*': 27 | postfix_expression.append(queue.popleft()) 28 | elif sym == '+' or sym == '-': 29 | while queue and queue[0] != '(': 30 | postfix_expression.append(queue.popleft()) 31 | elif sym == ')': 32 | while queue[0] != '(': 33 | postfix_expression.append(queue.popleft()) 34 | queue.popleft() 35 | continue 36 | queue.appendleft(sym) 37 | if isNumber: 38 | postfix_expression.append(storage) 39 | while queue: 40 | postfix_expression.append(queue.popleft()) 41 | #print(postfix_expression) 42 | for operand in postfix_expression: 43 | if isinstance(operand, int): 44 | queue.appendleft(operand) 45 | else: 46 | num_2 = queue.popleft() 47 | num_1 = queue.popleft() 48 | queue.appendleft(eval(f'{num_1}{operand}{num_2}')) 49 | 50 | answer = 0 51 | if queue: 52 | answer = queue.popleft() 53 | print(answer) 54 | -------------------------------------------------------------------------------- /10.3 Обходы графа/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.3 2 | 3 | from sys import stdin 4 | 5 | n, m = map(int, stdin.readline().split()) 6 | graph = [[] for _ in range(n + 1)] 7 | nums = [] 8 | for _ in range(m): 9 | v1, v2, t = map(int, stdin.readline().split()) 10 | if (t == 2): 11 | v1, v2 = v2, v1 12 | graph[v1].append(v2) 13 | result = [False] * (n + 1) 14 | 15 | def DFS(graph, vertex, color, result, records, isCicle): 16 | color[vertex] = 1 17 | records[vertex] = 0 18 | # result[vertex] += 1 19 | # print(f'in DFS vertex = {vertex}') 20 | games = [0] 21 | for to in graph[vertex]: 22 | # print(f'to = {to} graph = {graph[vertex]}') 23 | if color[to] == 1 and to != vertex: 24 | isCicle[0] = True 25 | return 0 26 | if not color[to]: 27 | games.append(DFS(graph, to, color, result, records, isCicle)) 28 | else: 29 | games.append(records[to]) 30 | 31 | if isCicle[0] == True: 32 | return 0 33 | records[vertex] = max(games) + 1 34 | # print(f'res = {records[vertex]}\n records = {records}') 35 | result[records[vertex]] = True 36 | color[vertex] = 2 37 | return records[vertex] 38 | 39 | color = [0] * (n + 1) 40 | """ 41 | 0 = не посещенная 42 | 1 - зашли (серая) 43 | 2 - вышли (черная) 44 | """ 45 | # used = [False for _ in range(n + 1)] 46 | isCicle = [False] 47 | records = [0] * (n + 1) 48 | for v in range(1, n + 1): 49 | if not color[v]: 50 | # print(f'start v = {v}') 51 | DFS(graph, v, color, result, records, isCicle) 52 | # print('wrong =', result) 53 | 54 | isRight = True 55 | 56 | for res in range(1, n + 1): 57 | if result[res] != True: 58 | isRight = False 59 | break 60 | 61 | print("YES" if (isRight and not isCicle[0]) or n == 1 else "NO") 62 | -------------------------------------------------------------------------------- /3.3 Динамическое программирование/B/problem.md: -------------------------------------------------------------------------------- 1 | # Камни 2 2 | 3 | Вы играете в игру <<Камни>>: игру для двух игроков с двумя наборами камней по n и m штук. С каждым ходом один игрок может забрать следующие комбинации камней: 4 | 5 | 1. Взять один камень из любого набора. 6 | 2. Взять два камня из какого-то одного набора 7 | 3. Взять два камня из одного и один из другого. 8 | 9 | Когда камень забрали, он выходит из игры. Побеждает игрок, который заберет последний камень. Первый ход за вами. 10 | 11 | Вы и ваш оппонент играете оптимально. 12 | 13 | ## Формат ввода 14 | 15 | В первой строке содержится два числа n (1≤n≤1000), m (1≤m≤1000) — количество ваших камней и количество камней у вашего оппонента. 16 | 17 | ## Формат вывода 18 | 19 | В единственной строке выведите Loose, если вы заведомо проиграете, и Win, иначе. 20 | 21 | ### Пример 1 22 | 23 | Ввод 24 | 25 | 4 4 26 | 27 | 28 | Вывод 29 | 30 | Loose 31 | 32 | 33 | ### Пример 2 34 | 35 | Ввод 36 | 37 | 17 72 38 | 39 | 40 | Вывод 41 | 42 | Win 43 | 44 | 45 | ### Пример 3 46 | 47 | Ввод 48 | 49 | 7 5 50 | 51 | 52 | Вывод 53 | 54 | Win 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
75 | 76 | -------------------------------------------------------------------------------- /6.4 Задача «Сбор подписей»/A/problem.md: -------------------------------------------------------------------------------- 1 | # Сбор подписей 2 | 3 | Ваша задача — собрать подписи всех жильцов в доме. Вам известно время, в которое каждый из жильцов находится дома. Вы хотели бы собрать все подписи, приходя в дом минимальное количество раз. Для простоты давайте предположим, что вы сразу же собираете подписи всех жильцов, находящихся дома, когда заходите. 4 | 5 | ## Формат ввода 6 | 7 | Количество сегментов в первой строке — n. Каждая из следующих n строк содержит два целых числа $l\_i$​ и $r\_i$​ (разделены пробелом), которые указывают на координаты границ i\-го сегмента. 8 | 9 | Ограничения: $1 \le n \le 100$; $0 \le l\_i \le r\_i \le 10^9$ для всех i. 10 | 11 | ## Формат вывода 12 | 13 | Минимальное количество k точек на первой строке и координаты k точек целыми числами (разделены пробелом) на второй строке. Выводить точки можно в любом порядке. При наличии нескольких наборов точек, можно вывести любой из них. 14 | 15 | ### Пример 1 16 | 17 | Ввод 18 | 19 | 3 20 | 1 3 21 | 2 5 22 | 3 6 23 | 24 | 25 | Вывод 26 | 27 | 1 28 | 3 29 | 30 | 31 | ### Пример 2 32 | 33 | Ввод 34 | 35 | 4 36 | 4 7 37 | 1 3 38 | 2 5 39 | 3 6 40 | 41 | 42 | Вывод 43 | 44 | 2 45 | 3 7 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
66 | -------------------------------------------------------------------------------- /8.3 Задача «Простой калькулятор»/A/problem.md: -------------------------------------------------------------------------------- 1 | # Примитивный калькулятор 2 | 3 | У вас есть калькулятор, который выполняет только следующие операции с целым числом x: сложить 1 и x, умножить x на 2 или умножить x на 3. Имея положительное целое число n, вы должны найти минимальное количество операций, необходимых для получения числа n из числа 1. 4 | 5 | ## Формат ввода 6 | 7 | Целое число n. 8 | 9 | Ограничения: $1 \\le n \\le 10^6$. 10 | 11 | ## Формат вывода 12 | 13 | В первой строке: k — минимальное число необходимых операций для получения n из 1. Во второй строке: последовательность промежуточных чисел. Так, вторая строка должна содержать положительные целые числа $a\_0, a\_1, \\dotsc, a\_{k}$, при которых $a0\=1, a\_{k}=n$, и для всех $1 \\le i \\le k$ $a\_{i}$​ равно $a\_{i-1}+1$, $2a\_{i-1}$​ или $3a\_{i-1}$​. Если таких последовательностей много, то можно вывести любую из них. 14 | 15 | ### Пример 1 16 | 17 | Ввод 18 | 19 | 5 20 | 21 | 22 | Вывод 23 | 24 | 3 25 | 1 3 4 5 26 | 27 | 28 | ### Пример 2 29 | 30 | Ввод 31 | 32 | 10 33 | 34 | 35 | Вывод 36 | 37 | 3 38 | 1 3 9 10 39 | 40 | 41 | ### Пример 3 42 | 43 | Ввод 44 | 45 | 17 46 | 47 | 48 | Вывод 49 | 50 | 5 51 | 1 3 4 8 16 17 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
72 | -------------------------------------------------------------------------------- /8.6 Задача о рюкзаке/A/problem.md: -------------------------------------------------------------------------------- 1 | # Наибольшее количество золота 2 | 3 | Вы нашли несколько золотых слитков. Ваша цель -- положить как можно больше золота в рюкзак с вместимостью W, то есть в нем можно унести максимум W фунтов. Каждый слиток только в одном экземпляре, вы можете или брать слиток, или нет (нельзя взять часть слитка). Хотя все слитки и выглядят одинаково на рисунке выше, они обладают разным весом — он приведен ниже. 4 | 5 | ## Формат ввода 6 | 7 | Первая строка ввода содержит целое число W (вместимость рюкзака) и количество золотых слитков n. В следующей строке приведены n целых чисел $w\_1,\\dotsc,w\_{n}$​, которые определяют вес золотых слитков. 8 | 9 | Ограничения: $1 \\le W \\le 10^4$; $1 \\le n \\le 300$; $0 \\le w\_1,\\dotsc,w\_{n} \\le 10^5$. 10 | 11 | ## Формат вывода 12 | 13 | Максимальный вес золотых слитков, который можно уместить в рюкзак со вместимостью W. 14 | 15 | ### Пример 1 16 | 17 | Ввод 18 | 19 | 10 3 20 | 1 4 9 21 | 22 | 23 | Вывод 24 | 25 | 10 26 | 27 | 28 | ### Пример 2 29 | 30 | Ввод 31 | 32 | 73 5 33 | 19 23 31 17 18 34 | 35 | 36 | Вывод 37 | 38 | 73 39 | 40 | 41 | ### Пример 3 42 | 43 | Ввод 44 | 45 | 44 3 46 | 44 43 1 47 | 48 | 49 | Вывод 50 | 51 | 44 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
72 | -------------------------------------------------------------------------------- /6.3 Задача «Рекламная компания»/A/problem.md: -------------------------------------------------------------------------------- 1 | # Рекламная кампания 2 | 3 | У вас есть популярная страница в интернете, на которой есть n рекламных мест. Вы хотите продать их рекламодателям. Аналитики рассчитывают на $clicks_1​, clicks_2​, \ldots clicks_n$​ кликов в день, соответственно. 4 | 5 | С вами связались n рекламодателей, которые готовы заплатить $price\_1$​, $price\_2​, \ldots price\_n$​ за клик. 6 | 7 | Как подобрать пары рекламных мест и рекламодателей так, чтобы получить максимальную прибыль? 8 | 9 | ## Формат ввода 10 | 11 | В первой строке приведено целое число n, во второй — последовательность целых чисел $price\_1, \dotsc, price\_n$ , в третьей — последовательность целых чисел $clicks\_1, \dotsc, clicks\_n$​. 12 | 13 | Ограничения: $1 \leq n \leq 10^3$; $0 \leq price\_i, clicks\_i \leq 10^5$ для всех $1 \leq i \leq n$. 14 | 15 | ## Формат вывода 16 | 17 | Максимальное значение $(price\_1 \cdot c\_1 + \dotsm + price\_n \cdot c\_n)$, где $c\_1, \dotsc, c\_n$ — это перестановка $clicks\_1, \dotsc, clicks\_n$​. 18 | 19 | ### Пример 1 20 | 21 | Ввод 22 | 23 | 1 24 | 23 25 | 39 26 | 27 | 28 | Вывод 29 | 30 | 897 31 | 32 | 33 | ### Пример 2 34 | 35 | Ввод 36 | 37 | 3 38 | 2 3 9 39 | 7 4 2 40 | 41 | 42 | Вывод 43 | 44 | 79 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 |
Ограничение времени2 секунды
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
65 | -------------------------------------------------------------------------------- /5.1 Задачи о числах Фибоначчи/B/problem.md: -------------------------------------------------------------------------------- 1 | # Последняя цифра числа Фибоначчи 2 | 3 | Дано число n, необходимо найти последнюю цифру n\-го числа Фибоначчи. 4 | 5 | Числа Фибоначчи растут очень быстро, поэтому при их вычислении нужно быть аккуратным с переполнением. В данной задаче, впрочем, этой проблемы можно избежать, поскольку нас интересует только последняя цифра числа Фибоначчи: если 0≤a,b≤9 --- последние цифры чисел Fi и Fi+1​ соответственно, то (a+b) mod 10 --- последняя цифра числа Fi+2​. 6 | 7 | ## Формат ввода 8 | 9 | Целое число n. 10 | 11 | Ограничения: 0≤n≤106. 12 | 13 | ## Формат вывода 14 | 15 | Последняя цифра из Fn. 16 | 17 | ### Пример 1 18 | 19 | Ввод 20 | 21 | 3 22 | 23 | 24 | Вывод 25 | 26 | 2 27 | 28 | 29 | ### Пример 2 30 | 31 | Ввод 32 | 33 | 139 34 | 35 | 36 | Вывод 37 | 38 | 1 39 | 40 | 41 | ### Пример 3 42 | 43 | Ввод 44 | 45 | 91239 46 | 47 | 48 | Вывод 49 | 50 | 6 51 | 52 | 53 | ## Примечание 54 | 55 | Будьте аккуратны с целочисленным переполнением. Значение F139\=50 095 301 248 058 391 139 327 916 261 превосходит диапазон стандартных целочисленных типов, а количество цифр в F91239 более 19 000, но последняя точно 6. 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
75 | -------------------------------------------------------------------------------- /5.2 Вычисление НОК и НОД/C/problem.md: -------------------------------------------------------------------------------- 1 | # Наибольшее число шагов алгоритма Евклида 2 | 3 | Алгоритм Евклида можно записать в рекурсивной форме: 4 | 5 | GCD(a, b): 6 | if a = 0 or b = 0: 7 | return max(a,b) 8 | return GCD(b,a mod b) 9 | 10 | Вызов функции GCD(5,0) не порождает дополнительных рекурсивных вызовов. А вызов GCD(5,2) --- порождает вызовы GCD(2,1) и GCD(1,0). 11 | 12 | Количество шагов алгоритма Евклида будет равняться количеству вызовов функции GCD для заданных значений a и b. 13 | 14 | Дано число n, найдите значения a и b (0≤a,b≤n), для которых количество вызовов функции GCD будет наибольшим. 15 | 16 | ## Формат ввода 17 | 18 | Целое число n. 19 | 20 | Ограничения: 1≤n≤109. 21 | 22 | ## Формат вывода 23 | 24 | Значения a и b (разделённые пробелом). 25 | 26 | Если существует несколько пар значений a и b, для которых количество вызовов функции GCD наибольшее, то выведите любую из таких пар. 27 | 28 | ### Пример 1 29 | 30 | Ввод 31 | 32 | 3 33 | 34 | 35 | Вывод 36 | 37 | 2 3 38 | 39 | 40 | ### Пример 2 41 | 42 | Ввод 43 | 44 | 10 45 | 46 | 47 | Вывод 48 | 49 | 5 8 50 | 51 | 52 | ### Пример 3 53 | 54 | Ввод 55 | 56 | 10000 57 | 58 | 59 | Вывод 60 | 61 | 4181 6765 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
82 | -------------------------------------------------------------------------------- /6.2 Задача «Специи»/B/problem.md: -------------------------------------------------------------------------------- 1 | # Сувениры 2 | 3 | Турист зашел в сувенирную лавку и нашел там много привлекательных вариантов подарков друзьям и родным. Всего в лавке n сувениров, стоимость i\-го сувенира $c_i$​ рублей. 4 | 5 | Определите, какое наибольшее количество сувениров сможет купить турист, если он может потратить не более S рублей. 6 | 7 | ## Формат ввода 8 | 9 | Первая строка ввода содержит количество сувениров nnn и бюджет на сувениры S. Следующие n строк указывают цену очередного сувенира. i\-я строка включает в себя цену $c_i$​. 10 | 11 | Ограничения: $1 \leq n \leq 10^3$, $0 \leq S \leq 2 \cdot 10^6$; $0 \leq c_i \leq 2 \cdot 10^6$ для всех $1 \leq i \leq n$. Все числа — целые. 12 | 13 | ## Формат вывода 14 | 15 | Максимальное количество сувениров, которые может купить турист. 16 | 17 | ### Пример 1 18 | 19 | Ввод 20 | 21 | 3 50 22 | 20 23 | 50 24 | 30 25 | 26 | 27 | Вывод 28 | 29 | 2 30 | 31 | 32 | ### Пример 2 33 | 34 | Ввод 35 | 36 | 10 1 37 | 0 38 | 1 39 | 0 40 | 1 41 | 0 42 | 1 43 | 0 44 | 1 45 | 0 46 | 1 47 | 48 | 49 | Вывод 50 | 51 | 6 52 | 53 | 54 | ### Пример 3 55 | 56 | Ввод 57 | 58 | 1 10 59 | 500 60 | 61 | 62 | Вывод 63 | 64 | 0 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
85 | -------------------------------------------------------------------------------- /9.4 Стек/C/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | # материал, который помогает понять идею https://codeforces.com/blog/entry/71687?locale=ru 3 | 4 | 5 | 6 | class Stack: 7 | def __init__(self, length): 8 | self.array = [] 9 | #self.array = [0] * length 10 | #self.cnt = 0 11 | 12 | def push(self, item): 13 | # self.array[self.cnt] = item 14 | # self.cnt += 1 15 | self.array.append(item) 16 | 17 | def pop(self): 18 | # self.cnt -= 1 19 | # item = self.array[self.cnt] 20 | 21 | # return item 22 | return self.array.pop() 23 | 24 | def size(self): 25 | return True if self.array else False 26 | 27 | def back(self): 28 | if self.size(): 29 | return self.array[-1] 30 | else: 31 | return False 32 | 33 | from sys import stdin 34 | 35 | n = int(stdin.readline().rstrip()) 36 | k = int(stdin.readline().rstrip()) 37 | queries = list(map(int, stdin.readline().split())) 38 | 39 | arr = Stack(n) 40 | temp_arr = Stack(k) 41 | inf = 3 * 10 ** 5 + 1 42 | 43 | answer = 0 44 | temp_min = inf 45 | 46 | for i in range(k): 47 | temp_arr.push(queries[i]) 48 | if temp_min > queries[i]: 49 | temp_min = queries[i] 50 | answer += temp_min 51 | temp_min = inf 52 | 53 | for i in range(k, n): 54 | 55 | if not arr.size(): 56 | cur_min = inf 57 | while temp_arr.size(): 58 | if cur_min > temp_arr.back(): 59 | cur_min = temp_arr.back() 60 | arr.push(cur_min) 61 | temp_arr.pop() 62 | temp_min = inf 63 | arr.pop() 64 | 65 | temp_arr.push(queries[i]) 66 | if temp_min > queries[i]: 67 | temp_min = queries[i] 68 | 69 | res = temp_min 70 | if arr.size(): 71 | res = min(res, arr.back()) 72 | answer += res 73 | 74 | print(answer) 75 | -------------------------------------------------------------------------------- /4.3 Задача «Максимальное произведение»/C/problem.md: -------------------------------------------------------------------------------- 1 | # Максимальное произведение трех чисел 2 | 3 | Дана последовательность целых чисел a1,…,an. Вычислите 4 | 5 | max 1≤i≠j,i≠k,j≠k≤n ai⋅aj⋅ak. 6 | 7 | Обратите внимание, что индексы i, j и k должны быть различны. Хотя в каких-то случаях значения элементов могут совпадать, то есть, например, ai\=aj​. 8 | 9 | ## Формат ввода 10 | 11 | Первая строка содержит целое число n. Следующая строка содержит n целых чисел a1,…,an (разделены пробелами). 12 | 13 | Ограничения: 3≤n≤2⋅105; −2⋅105≤a1,…,an≤2⋅105. 14 | 15 | ## Формат вывода 16 | 17 | Максимальное произведение трех элементов. 18 | 19 | ### Пример 1 20 | 21 | Ввод 22 | 23 | 3 24 | 1 2 3 25 | 26 | 27 | Вывод 28 | 29 | 6 30 | 31 | 32 | ### Пример 2 33 | 34 | Ввод 35 | 36 | 3 37 | -1 -2 -2 38 | 39 | 40 | Вывод 41 | 42 | -4 43 | 44 | 45 | ### Пример 3 46 | 47 | Ввод 48 | 49 | 4 50 | -1 -3 -2 -4 51 | 52 | 53 | Вывод 54 | 55 | -6 56 | 57 | 58 | ### Пример 4 59 | 60 | Ввод 61 | 62 | 5 63 | -1 0 -3 -2 0 64 | 65 | 66 | Вывод 67 | 68 | 0 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
89 | -------------------------------------------------------------------------------- /9.4 Стек/B/problem.md: -------------------------------------------------------------------------------- 1 | # Видимость влево 2 | 3 | Дан массив a, состоящий из n чисел. Для каждого элемента $a\_i$​ нужно сказать, сколько элементов левее него он видит. $a\_i$​ видит $a\_j$​, если $i\>j$ и $a\_i > a\_z$​ для всех $j \\leq z < i$. 4 | 5 | ## Формат ввода 6 | 7 | Первая строка содержит единственное число n ($1 \\leq n \\leq 3 \\cdot 10^5$). 8 | 9 | Вторая строка содержит n разделенных пробелом чисел $a\_i$​ ($1 \\leq a\_i \\leq 3 \\cdot 10^5$). 10 | 11 | ## Формат вывода 12 | 13 | Единственная строка вывода должна содержать n разделенных пробелом -- видимость каждого элемента влево. 14 | 15 | ### Пример 1 16 | 17 | Ввод 18 | 19 | 5 20 | 1 2 3 4 5 21 | 22 | 23 | Вывод 24 | 25 | 0 1 2 3 4 26 | 27 | 28 | ### Пример 2 29 | 30 | Ввод 31 | 32 | 5 33 | 1 2 2 1 3 34 | 35 | 36 | Вывод 37 | 38 | 0 1 0 0 4 39 | 40 | 41 | ### Пример 3 42 | 43 | Ввод 44 | 45 | 9 46 | 1 2 3 4 5 4 3 2 1 47 | 48 | 49 | Вывод 50 | 51 | 0 1 2 3 4 0 0 0 0 52 | 53 | 54 | ### Пример 4 55 | 56 | Ввод 57 | 58 | 8 59 | 1 7 2 6 3 5 5 6 60 | 61 | 62 | Вывод 63 | 64 | 0 1 0 1 0 1 0 3 65 | 66 | 67 | ### Пример 5 68 | 69 | Ввод 70 | 71 | 5 72 | 1 1 1 1 1 73 | 74 | 75 | Вывод 76 | 77 | 0 0 0 0 0 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
98 | -------------------------------------------------------------------------------- /9.2 Множество/A/problem.md: -------------------------------------------------------------------------------- 1 | # Выполнение операций с множеством 2 | 3 | Изначально у вас есть пустое множество. Далее вам поступает q запросов. Каждый запрос одного из следующих типов: 4 | 5 | * Запрос 1-ого типа: добавить число x во множество 6 | * Запрос 2-ого типа: проверить, содержится ли число x во множестве 7 | 8 | ## Формат ввода 9 | 10 | Первая строка содержит единственное число q -- количество запросов. 11 | 12 | Далее следует q строк. Каждая из этих строк может иметь один из следующих видов: 13 | 14 | * Для запроса первого типа -- "1 x" (без кавычек). 15 | * Для запроса второго типа -- "2 x" (без кавычек). 16 | 17 | ## Формат вывода 18 | 19 | Вывод должен состоять из count строк, где count -- количество запросов второго типа. Каждая строка должна содержать одно число: 20 | 21 | * Число 0, если такого числа не было во множестве 22 | * Число 1, если такое число было во множестве 23 | 24 | ## Пример 25 | 26 | Ввод 27 | 28 | 9 29 | 2 5 30 | 1 5 31 | 2 5 32 | 1 6 33 | 1 10 34 | 2 7 35 | 1 7 36 | 2 10 37 | 2 7 38 | 39 | 40 | Вывод 41 | 42 | 0 43 | 1 44 | 0 45 | 1 46 | 1 47 | 48 | 49 | ## Примечание 50 | 51 | Ограничения: 52 | 53 | * $1 \\leq q \\leq 1 \\cdot 10^5$ 54 | * Для запросов первого и второго типов выполнено $1 \\leq x \\leq 10^9$ 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
74 | -------------------------------------------------------------------------------- /4.3 Задача «Максимальное произведение»/D/problem.md: -------------------------------------------------------------------------------- 1 | # Максимальное произведение четырех чисел 2 | 3 | Дана последовательность целых чисел a1,…,an​. Вычислите 4 | 5 | max⁡1≤i≠j≠k≠l≤n ai⋅aj⋅ak⋅al​. 6 | 7 | Обратите внимание, что индексы i, j, k и l должны быть различны. Хотя в каких-то случаях значения элементов могут совпадать, то есть, например, ai\=al. 8 | 9 | ## Формат ввода 10 | 11 | Первая строка содержит целое число n. Следующая строка содержит n целых чисел aq,…,an​ (разделены пробелами). 12 | 13 | Ограничения: 4≤n≤2⋅105; −2⋅104≤a1,…,an≤2⋅104. 14 | 15 | ## Формат вывода 16 | 17 | Максимальное произведение четырех элементов. 18 | 19 | ### Пример 1 20 | 21 | Ввод 22 | 23 | 4 24 | 1 2 3 4 25 | 26 | 27 | Вывод 28 | 29 | 24 30 | 31 | 32 | ### Пример 2 33 | 34 | Ввод 35 | 36 | 4 37 | -1 -2 3 4 38 | 39 | 40 | Вывод 41 | 42 | 24 43 | 44 | 45 | ### Пример 3 46 | 47 | Ввод 48 | 49 | 5 50 | -1 -3 -2 -4 -5 51 | 52 | 53 | Вывод 54 | 55 | 120 56 | 57 | 58 | ### Пример 4 59 | 60 | Ввод 61 | 62 | 6 63 | 0 -1 0 -3 -2 100 64 | 65 | 66 | Вывод 67 | 68 | 0 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
89 | -------------------------------------------------------------------------------- /3.5 Алгоритмы «Разделяй и властвуй»/B/problem.md: -------------------------------------------------------------------------------- 1 | # Слияние сортированных последовательностей 2 | 3 | Задано n отсортированных по неубыванию последовательностей. 4 | 5 | Требуется найти отсортированную по неубыванию конкатенацию этих последовательностей. 6 | 7 | ## Формат ввода 8 | 9 | В первой строке задано одно число n (1≤n≤20) — количество отсортированных последовательностей. 10 | 11 | Каждая из следующих последовательностей задано в формате: В первой строке mi​ (1≤mi≤105) — количество элементов последовательности. 12 | 13 | Во второй сами элементы ai​ (1≤ai≤109). 14 | 15 | Гарантируется, что ∑ni\=1mi≤105. 16 | 17 | ## Формат вывода 18 | 19 | В единственной строке выведите ответ на задачу. 20 | 21 | ### Пример 1 22 | 23 | Ввод 24 | 25 | 3 26 | 3 27 | 1 2 3 28 | 2 29 | 1 2 30 | 4 31 | 3 5 6 7 32 | 33 | 34 | Вывод 35 | 36 | 1 1 2 2 3 3 5 6 7 37 | 38 | 39 | ### Пример 2 40 | 41 | Ввод 42 | 43 | 2 44 | 2 45 | 1 10 46 | 3 47 | 7 9 11 48 | 49 | 50 | Вывод 51 | 52 | 1 7 9 10 11 53 | 54 | 55 | ### Пример 3 56 | 57 | Ввод 58 | 59 | 1 60 | 10 61 | 1 2 3 4 5 6 7 8 9 10 62 | 63 | 64 | Вывод 65 | 66 | 1 2 3 4 5 6 7 8 9 10 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
87 | -------------------------------------------------------------------------------- /3.4 Рекурсивные алгоритмы/B/problem.md: -------------------------------------------------------------------------------- 1 | # Ханойские башни 2 2 | 3 | Головоломка <<Ханойские башни>> состоит из трёх стержней, пронумеруем их слева направо: 1, 2 и 3. Также в головоломке используется стопка дисков с отверстием посередине. Радиус дисков уменьшается снизу вверх. Изначально диски расположены на левом стержне (стержень 1), самый большой диск находится внизу. Диски в игре перемещаются по одному со стержня на стержень. Диск можно надеть на стержень, только если он пустой или верхний диск на нём большего размера, чем перемещаемый. Цель головоломки — перенести все диски со стержня 1 на стержень 3. 4 | 5 | Немного изменим правила. Теперь головоломка состоит из четырех стержней, а цель головоломки — перенести все диски со стержня 1 на стержень 4. Найдите минимальное количество ходов, за которое можно решить головоломку. 6 | 7 | ## Формат ввода 8 | 9 | В первой строке задано одно число n (3≤n≤10) — количество дисков на первой башне. 10 | 11 | ## Формат вывода 12 | 13 | В единственной строке выведите ответ на задачу. 14 | 15 | ### Пример 1 16 | 17 | Ввод 18 | 19 | 3 20 | 21 | 22 | Вывод 23 | 24 | 5 25 | 26 | 27 | ### Пример 2 28 | 29 | Ввод 30 | 31 | 4 32 | 33 | 34 | Вывод 35 | 36 | 9 37 | 38 | 39 | ### Пример 3 40 | 41 | Ввод 42 | 43 | 5 44 | 45 | 46 | Вывод 47 | 48 | 13 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
69 | 70 | -------------------------------------------------------------------------------- /9.1 Односвязный список/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.1 2 | 3 | class LinkedList: 4 | def __init__(self): 5 | self.head = None 6 | self.lenght = 0 7 | 8 | def see_len(self): 9 | return self.lenght 10 | 11 | def give_index(self, index): 12 | current = self.head 13 | while index>1: 14 | current = current.next 15 | index -= 1 16 | return current.value 17 | 18 | def add(self, value): # вставка в начало 19 | self.head = LinkedNode(value, self.head) 20 | self.lenght += 1 21 | 22 | def insert(self, index, value): # вставка на позицию index 23 | if self.head is None or index == 0: 24 | self.add(value) 25 | 26 | else: 27 | current = self.head 28 | while current.next is not None and index > 1: 29 | current = current.next 30 | index -= 1 31 | current.next = LinkedNode(value, current.next) 32 | self.lenght += 1 33 | 34 | def remove(self, index=1): 35 | if index == 1 or self.head.next is None: 36 | self.head = self.head.next 37 | 38 | else: 39 | current = self.head 40 | while current.next.next is not None and index > 2: 41 | current = current.next 42 | index -= 1 43 | current.next = current.next.next 44 | self.lenght -= 1 45 | 46 | 47 | 48 | class LinkedNode: 49 | 50 | def __init__(self, value, next): 51 | self.value = value 52 | self.next = next 53 | 54 | link = LinkedList() 55 | 56 | answer = [] 57 | n = int(input()) 58 | for _ in range(n): 59 | query = list(map(int, input().split())) 60 | if query[0] == 1: 61 | x, y = query[1], query[2] 62 | link.insert(x, y) 63 | elif query[0] == 2: 64 | answer.append(str(link.give_index(query[1]))) 65 | elif query[0] == 3: 66 | link.remove(query[1]) 67 | 68 | print('\n'.join(answer)) 69 | -------------------------------------------------------------------------------- /9.3 Словарь/A/problem.md: -------------------------------------------------------------------------------- 1 | # Выполнение операций со словарем 2 | 3 | Изначально у вас есть пустой словарь. Далее вам поступает q запросов. Каждый запрос одного из следующих типов: 4 | 5 | * Запрос 1-ого типа: поставить в соответствие ключу x число y 6 | * Запрос 2-ого типа: проверить, какое число соответствует ключу x. 7 | 8 | Считайте, что изначально каждому ключу соответствует число −1. 9 | 10 | ## Формат ввода 11 | 12 | Первая строка содержит единственное число q -- количество запросов. 13 | 14 | Далее следует q строк. Каждая из этих строк может иметь один из следующих видов: 15 | 16 | * Для запроса первого типа -- "1 x y" (без кавычек). 17 | * Для запроса второго типа -- "2 x" (без кавычек). 18 | 19 | ## Формат вывода 20 | 21 | Вывод должен состоять из count строк, где count -- количество запросов второго типа. Каждая строка должна содержать одно число, которое соответствует ключу. 22 | 23 | ## Пример 24 | 25 | Ввод 26 | 27 | 9 28 | 1 2 3 29 | 2 1 30 | 2 2 31 | 1 1 4 32 | 2 1 33 | 2 2 34 | 1 2 5 35 | 2 1 36 | 2 2 37 | 38 | 39 | Вывод 40 | 41 | -1 42 | 3 43 | 4 44 | 3 45 | 4 46 | 5 47 | 48 | 49 | ## Примечание 50 | 51 | Ограничения: 52 | 53 | * $1 \\leq q \\leq 1 \\cdot 10^5$ 54 | * Для запросов первого типа выполнено $1 \\leq x, y \\leq 10^9$ 55 | * Для запросов второго типа выполнено $1 \\leq x \\leq 10^9$ 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
76 | -------------------------------------------------------------------------------- /10.3 Обходы графа/A/problem.md: -------------------------------------------------------------------------------- 1 | # Рейтинг в шахматном турнире 2 | 3 | Даны mmm партий в шахматном турнире. В каждой известен победитель. Требуется определить, возможно ли однозначно определить уровень игрока? 4 | 5 | Будем считать, что у каждого игрока есть свой уникальный скрытый уровень. Игрок с большим уровнем всегда побеждает игрока с меньшим уровнем. 6 | 7 | ## Формат ввода 8 | 9 | В первой строке задано два числа n, m -- количество участников турнира и количество партий. 10 | 11 | В следующих m строках заданы партии в формате $u\_i, v\_i, t\_i$​ -- номера игроков и победитель в партии. 12 | 13 | ## Формат вывода 14 | 15 | В единственной строке вывести _YES_, если однозначно можно определить уровень игроков и _NO_, иначе. 16 | 17 | ### Пример 1 18 | 19 | Ввод 20 | 21 | 5 6 22 | 1 4 1 23 | 1 2 1 24 | 3 1 2 25 | 4 2 1 26 | 2 3 1 27 | 5 3 2 28 | 29 | 30 | Вывод 31 | 32 | YES 33 | 34 | 35 | ### Пример 2 36 | 37 | Ввод 38 | 39 | 5 1 40 | 1 3 1 41 | 42 | 43 | Вывод 44 | 45 | NO 46 | 47 | 48 | ### Пример 3 49 | 50 | Ввод 51 | 52 | 5 2 53 | 2 4 2 54 | 3 2 1 55 | 56 | 57 | Вывод 58 | 59 | NO 60 | 61 | 62 | ## Примечание 63 | 64 | Ограничения: 65 | 66 | * $1 \\leq n, m \\leq 10^5$ 67 | * $1 \\leq u\_i, v\_i \\leq 10^5$ для всех i от 1 до m 68 | * $1 \\leq t\_i \\leq 2$ для всех i от 1 до m 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
89 | -------------------------------------------------------------------------------- /10.4 Алгоритм нахождения компонент связности в графе/A/problem.md: -------------------------------------------------------------------------------- 1 | # Минимальное количество мостов 2 | 3 | В Байтландии есть n островов и m мостов. Мост не может начинаться и заканчиваться на одном острове. 4 | 5 | Вам требуется найти минимальное количество мостов, которые нужно построить, чтобы можно было добраться из любого острова в любой другой остров и сами мосты. 6 | 7 | ## Формат ввода 8 | 9 | В первой строке находятся два числа n, m -- количество островов и уже существующих мостов. 10 | 11 | В следующих m строках заданы мосты в формате u\_i, v\_i. 12 | 13 | ## Формат вывода 14 | 15 | В первой строке выведите число k -- минимальное количество мостов, которые нужно построить, чтобы можно было добраться из любого острова в любой другой остров. 16 | 17 | В следующих k строках выедите новые мосты в формате u, v. 18 | 19 | ### Пример 1 20 | 21 | Ввод 22 | 23 | 5 3 24 | 1 2 25 | 2 4 26 | 3 5 27 | 28 | 29 | Вывод 30 | 31 | 1 32 | 3 2 33 | 34 | 35 | ### Пример 2 36 | 37 | Ввод 38 | 39 | 4 3 40 | 1 2 41 | 2 3 42 | 1 3 43 | 44 | 45 | Вывод 46 | 47 | 1 48 | 4 3 49 | 50 | 51 | ### Пример 3 52 | 53 | Ввод 54 | 55 | 2 1 56 | 1 2 57 | 58 | 59 | Вывод 60 | 61 | 0 62 | 63 | 64 | ## Примечание 65 | 66 | Ограничения: 67 | 68 | * $1 \\leq n, m \\leq 10^5$ 69 | * $1 \\leq u\_i, v\_i \\leq 10^5$ для всех i от 1 до m 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
90 | -------------------------------------------------------------------------------- /9.6 Дек/A/problem.md: -------------------------------------------------------------------------------- 1 | # Выполнение операций с очередью 2 | 3 | Изначально у вас есть пустая очередь. Далее вам поступает q запросов. Каждый запрос одного из следующих типов: 4 | 5 | * Запрос 1-ого типа: положить число x в конец очереди 6 | * Запрос 2-ого типа: удалить первый элемент из очереди 7 | 8 | После каждого запроса необходимо вывести число, которое в начале очереди. Если очередь пуста, то выведите −1. 9 | 10 | Также гарантируется, что если вам поступил запрос второго типа, то очередь к этому моменту была не пустой. 11 | 12 | ## Формат ввода 13 | 14 | Первая строка содержит единственное число q -- количество запросов. 15 | 16 | Далее следует q строк. Каждая из этих строк может иметь один из следующих видов: 17 | 18 | * Для запроса первого типа -- "1 x" (без кавычек). 19 | * Для запросов второго типа -- "2" (без кавычек). 20 | 21 | ## Формат вывода 22 | 23 | Вывод должен состоять из q строк. Каждая строка должна содержать ответ на соответствующий запрос в формате front (где front -- число, которое находится в начале очереди), либо −1, если очередь была пустой. 24 | 25 | ## Пример 26 | 27 | Ввод 28 | 29 | 5 30 | 1 5 31 | 2 32 | 1 6 33 | 1 7 34 | 2 35 | 36 | 37 | Вывод 38 | 39 | 5 40 | -1 41 | 6 42 | 6 43 | 7 44 | 45 | 46 | ## Примечание 47 | 48 | Ограничения: 49 | 50 | * $1 \\leq q \\leq 10^6$ 51 | * Во всех запросах первого типа выполнено $1 \\leq x \\leq 10^6$ 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
71 | -------------------------------------------------------------------------------- /9.4 Стек/A/problem.md: -------------------------------------------------------------------------------- 1 | # Выполнение операций со стеком 2 | 3 | Изначально у вас есть пустой стек. Далее вам поступает q запросов. Каждый запрос одного из следующих типов: 4 | 5 | * Запрос 1-ого типа: положить число xxx на вершину стека 6 | * Запрос 2-ого типа: достать число, лежащее на вершине стека 7 | 8 | После каждого запроса необходимо вывести число, которое лежит на вершине стека. Если стек пустой, то выведите −1. 9 | 10 | Также гарантируется, что если вам поступил запрос второго типа, то стек к этому моменту не был пустым. 11 | 12 | ## Формат ввода 13 | 14 | Первая строка содержит единственное число q -- количество запросов. 15 | 16 | Далее следует q строк. Каждая из этих строк может иметь один из следующих видов: 17 | 18 | * Для запроса первого типа -- "1 x" (без кавычек). 19 | * Для запросов второго типа -- "2" (без кавычек). 20 | 21 | ## Формат вывода 22 | 23 | Вывод должен состоять из q строк. Каждая строка должна содержать ответ на соответствующий запрос в формате top (где top -- число, которое лежало на вершине стека), либо −1, если стек был пустым. 24 | 25 | ## Пример 26 | 27 | Ввод 28 | 29 | 5 30 | 1 5 31 | 2 32 | 1 6 33 | 1 7 34 | 2 35 | 36 | 37 | Вывод 38 | 39 | 5 40 | -1 41 | 6 42 | 7 43 | 6 44 | 45 | 46 | ## Примечание 47 | 48 | Ограничения: 49 | 50 | * $1 \\leq q \\leq 10^6$ 51 | * Во всех запросах первого типа выполнено $1 \\leq x \\leq 10^6$ 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
72 | -------------------------------------------------------------------------------- /10.3 Обходы графа/C/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.3 2 | 3 | n, m = map(int, input().split()) 4 | maximum = n * m 5 | labirinth = [[-1] * (m) for _ in range(n)] 6 | """ 7 | -2 = стена (#) 8 | -1 = пустая клетка (.) 9 | 0 = старт (S) 10 | """ 11 | start, finish = None, None 12 | for row in range(n): 13 | blocks = input() 14 | for col in range(m): 15 | block = blocks[col] 16 | if block == '#': 17 | block = -2 18 | elif block == '.': 19 | block = -1 20 | elif block == 'S': 21 | start = (row, col) 22 | block = 0 23 | elif block == 'F': 24 | finish = (row, col) 25 | block = -1 26 | labirinth[row][col] = block 27 | # print(*labirinth, sep = '\n') 28 | 29 | destination = [[maximum] * (m) for _ in range(n)] # расстояние 30 | destination[start[0]][start[1]] = 0 31 | prev = [[maximum] * (m) for _ in range(n)] 32 | prev[start[0]][start[1]] = -1 33 | # для восстановления ответа храним кортеж (предыдущая точка, направление) 34 | 35 | from collections import deque 36 | queue = deque() 37 | queue.append(start) 38 | dir_row = [0, -1, 0, 1] 39 | dir_col = [-1, 0, 1, 0] 40 | dir_sign = ['L', 'U', 'R', 'D'] 41 | while queue: 42 | row, col = queue.popleft() 43 | for shift in range(len(dir_row)): 44 | now_row = row + dir_row[shift] 45 | now_col = col + dir_col[shift] 46 | if labirinth[now_row][now_col] == - 1: 47 | labirinth[now_row][now_col] = labirinth[row][col] + 1 48 | prev[now_row][now_col] = (row, col, dir_sign[shift]) 49 | queue.append((now_row, now_col)) 50 | # print(*labirinth, sep = '\n') 51 | # print('NEXT TABLE IS PREV') 52 | # print(*prev, sep = '\n') 53 | steps = labirinth[finish[0]][finish[1]] 54 | print(steps) 55 | if steps > 0: 56 | back_track = [] 57 | move = prev[finish[0]][finish[1]] 58 | while move != -1: 59 | # print(move) 60 | back_track.append(move[2]) 61 | move = prev[move[0]][move[1]] 62 | back_track.reverse() 63 | print(''.join(back_track)) 64 | 65 | -------------------------------------------------------------------------------- /7.1 Двоичный поиск/B/problem.md: -------------------------------------------------------------------------------- 1 | # Множественный поиск ключей в отсортированной последовательности 2 | 3 | Ваша задача --- для m значений $q\_i$​ необходимо проверить, входит ли $q\_i$​ в K. 4 | 5 | ## Формат ввода 6 | 7 | Отсортированный массив K неповторяющихся целых чисел и массив целых чисел ***Q***$[q\_0,\dotsc,q\_{m-1}\]$. 8 | 9 | Первые две строки ввода содержат целое число n и последовательность $k\_0 \lt k\_1\lt \dotsc \lt k\_{n-1}$​ из n неповторяющихся положительных целых чисел в возрастающем порядке. 10 | 11 | Следующие две строки содержат целое число m и m положительных целых чисел $q\_0, q\_1, \dotsc, q\_{m-1}$​. 12 | 13 | Ограничения: $1 \le n \le 3 \cdot 10^4$; $1 \le m \le 10^5$; $1 \le k\_i \le 10^9$ для всех $0 \le i \lt n$; $1 \le q\_j \le 10^9$ для всех $0 \le j \lt m$. 14 | 15 | ## Формат вывода 16 | 17 | Для всех i от 0 до m−1 выведите индекс $0 \le j \le n-1$, чтобы $k\_j=q\_i$​ или −1 при отсутствии такого индекса. 18 | 19 | ### Пример 1 20 | 21 | Ввод 22 | 23 | 7 24 | 1 3 7 8 9 12 15 25 | 1 26 | 8 27 | 28 | 29 | Вывод 30 | 31 | 3 32 | 33 | 34 | ### Пример 2 35 | 36 | Ввод 37 | 38 | 7 39 | 1 3 7 8 9 12 15 40 | 3 41 | 1 12 3 42 | 43 | 44 | Вывод 45 | 46 | 0 47 | 5 48 | 1 49 | 50 | 51 | ### Пример 3 52 | 53 | Ввод 54 | 55 | 2 56 | 1 1000000000 57 | 3 58 | 1000000000 54321 1 59 | 60 | 61 | Вывод 62 | 63 | 1 64 | -1 65 | 0 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
86 | -------------------------------------------------------------------------------- /9.1 Односвязный список/B/problem.md: -------------------------------------------------------------------------------- 1 | # Перепад цен 2 | 3 | Дан массив a, состоящий из n чисел. Необходимо найти две пары индексов $i\_1 < j\_1$​ и $i\_2 < j\_2$​ таких, что $a\_{i\_1} - a\_{j\_1}$​​ минимально возможное и $a\_{i\_2} - a\_{j\_2}$​ максимально возможное. 4 | 5 | ## Формат ввода 6 | 7 | Первая строка содержит единственное число n -- количество чисел в массиве. 8 | 9 | Вторая строка содержит n разделенных пробелом чисел $a\_i$​, где $a\_i$​ -- число на i\-ой позиции в массиве a. 10 | 11 | ## Формат вывода 12 | 13 | Первая строка вывода должна содержать два разделенных пробелом числа $i\_1$​ и $j\_1$​. Если подходящих пар несколько, то нужно выбрать пару с минимальным значеним $i\_1$​. Если пар с минимальным значением $i\_1$​ несколько, то нужно выбрать пару с минимальным значеним $j\_1$​. 14 | 15 | Вторая строка вывода должна содержать два разделенных пробелом числа $i\_2$ и $j\_2$​. Если подходящих пар несколько, то нужно выбрать пару с минимальным значеним $i\_2$​. Если пар с минимальным значением $i\_2$​ несколько, то нужно выбрать пару с минимальным значеним $j\_2$​. 16 | 17 | ### Пример 1 18 | 19 | Ввод 20 | 21 | 6 22 | 2 1 3 5 2 4 23 | 24 | 25 | Вывод 26 | 27 | 2 4 28 | 4 5 29 | 30 | 31 | ### Пример 2 32 | 33 | Ввод 34 | 35 | 5 36 | 3 2 4 5 6 37 | 38 | 39 | Вывод 40 | 41 | 2 5 42 | 1 2 43 | 44 | 45 | ## Примечание 46 | 47 | Ограничения: 48 | 49 | * $3 \\le n \\le 10^5$ 50 | * $1 \\le a\_i \\le 10^5$ для всех $1 \\le i \\le n$ 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
70 | -------------------------------------------------------------------------------- /4.2 Задача «Сумма двух чисел»/B/problem.md: -------------------------------------------------------------------------------- 1 | # A(x) + B(x) 2 | 3 | Решите немного более сложную задачу. 4 | 5 | Необходимо вычислить сумму двух многочленов A(x)\=an⋅xn+…+a1⋅x+a0 и B(x)\=bm⋅xm+…+b1⋅x+b0​. 6 | 7 | ## Формат ввода 8 | 9 | В первой строке записано одно целое число n (0≤n≤10). В второй строке записаны числа an,an-1,…,a0 (−100≤ai≤100, an≠0). 10 | 11 | В третьей строке записано одно целое число m (0≤m≤10). В четвертой строке записаны числа bm,bm-1,…,b0 (−100≤bi≤100, bm≠0). 12 | 13 | Гарантируется, что an+bm≠0. 14 | 15 | ## Формат вывода 16 | 17 | В первой строке выведите число k — степень многочлена A(x)+B(x). 18 | 19 | В второй строке выведите коэффициенты этого многочлена: ck,ck-1,…,c1,c0​. 20 | 21 | ### Пример 1 22 | 23 | Ввод 24 | 25 | 3 26 | 1 2 3 4 27 | 2 28 | 1 0 0 29 | 30 | 31 | Вывод 32 | 33 | 3 34 | 1 3 3 4 35 | 36 | 37 | ### Пример 2 38 | 39 | Ввод 40 | 41 | 0 42 | 1 43 | 9 44 | 1 2 3 4 5 6 7 8 9 0 45 | 46 | 47 | Вывод 48 | 49 | 9 50 | 1 2 3 4 5 6 7 8 9 1 51 | 52 | 53 | ### Пример 3 54 | 55 | Ввод 56 | 57 | 1 58 | 1 1 59 | 1 60 | 1 1 61 | 62 | 63 | Вывод 64 | 65 | 1 66 | 2 2 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
88 | -------------------------------------------------------------------------------- /8.8 Задача «Расставить скобки»/A/solution.py: -------------------------------------------------------------------------------- 1 | # Python 3.12.3 2 | """ 3 | Хороший комментарий с направлением мысли из чатика по основам алгоротмов: 4 | "В общем, если вдруг кому интересно: задача поиска максимального значения подвыражений решается довольно легко — достаточно при формировании очередного узла дерева выражения учитывать не только значения, полученные в результате применения оператора к его потомкам, но и самих потомков. E.G. внешняя операция == -, минимум слева == 2, максимум == 4, минимум справа == 5, максимум == 10 — исходный алгоритм, максимизируя это выражение, найдет -1 (разность наибольшего левого операнда и наименьшего правого), мы же возьмем 10, поскольку это наибольший правый операнд и он больше любого из возможных значений разности, тем самым из исходного выражения исчезнет оператор - и его левый операнд" 5 | """ 6 | from sys import stdin 7 | 8 | text = stdin.readline().rstrip() 9 | digits = [int(text[i]) for i in range(len(text)) if i % 2 == 0] 10 | 11 | operations = [text[i] for i in range(len(text)) if i % 2] 12 | n = len(digits) 13 | mins = [[(10 ** 9)] * (n + 1) for _ in range(n + 1)] 14 | maxs = [[(-10 ** 9)] * (n + 1) for _ in range(n + 1)] 15 | 16 | for i in range(n): 17 | mins[i][i] = digits[i] 18 | maxs[i][i] = digits[i] 19 | 20 | for s in range(n): 21 | for l in range(n - s): 22 | r = s + l 23 | for m in range(l, r): 24 | for m_ in range(1, min(4, r - m) + 1): # из-за того, что нужно 25 | # смотреть и на результаты за участниками непосредственно выражения. Когда завезут правильные тесты нужно будет 26 | # убрать этот фор и заменить в нижеследующих выражениях m_ на 1 27 | #print(m_, m, r) 28 | a = eval(f'{mins[l][m]}{operations[m]}{mins[m_ + m][r]}') 29 | b = eval(f'{mins[l][m]}{operations[m]}{maxs[m_ + m][r]}') 30 | c = eval(f'{maxs[l][m]}{operations[m]}{mins[m_ + m][r]}') 31 | d = eval(f'{maxs[l][m]}{operations[m]}{maxs[m_ + m][r]}') 32 | 33 | mins[l][r] = min(mins[l][r], a, b, c ,d) 34 | maxs[l][r] = max(maxs[l][r], a, b, c ,d) 35 | print(maxs[0][n-1]) 36 | -------------------------------------------------------------------------------- /6.6 Задача «Максимальный оклад»/C/problem.md: -------------------------------------------------------------------------------- 1 | # Расстановка королей на шахматной доске 2 | 3 | Шахматы — очень интересная древнейшая настольная игра для двух игроков. Для решения этой задаче необязательно знать шахматные правила, но это может быть полезно. 4 | 5 | В шахматах король — самая важная фигура. Король может сделать ход на любую из 8 соседних клеток шахматной доски. Соседними считаются клетки слева, справа, сверху, снизу и 4 по диагонали от рассматриваемой. В шахматной партии на игровом поле ровно один король каждого цвета. 6 | 7 | Рассмотри задачу-головоломку о нескольких шахматных королях на доске произвольного размера. 8 | 9 | Рассмотрим шахматную доску с _r_ строками и _c_ столбцами. Найдите наибольшее количество королей, которых можно разместить на доске $r \times c$, с выполнение следующих условий: 10 | 11 | 1. В любой клетке на доске может находиться не более одного короля. 12 | 2. У любого короля есть по крайней мере один возможный ход на свободную клетку на доске. 13 | 14 | ## Формат ввода 15 | 16 | Единственная строка содержит два целых числа r и c. 17 | 18 | Ограничения: $1 \le r, c \le 100$. 19 | 20 | ## Формат вывода 21 | 22 | Наибольшее количество королей. 23 | 24 | ### Пример 1 25 | 26 | Ввод 27 | 28 | 5 1 29 | 30 | 31 | Вывод 32 | 33 | 3 34 | 35 | 36 | ### Пример 2 37 | 38 | Ввод 39 | 40 | 3 3 41 | 42 | 43 | Вывод 44 | 45 | 8 46 | 47 | 48 | ### Пример 3 49 | 50 | Ввод 51 | 52 | 4 4 53 | 54 | 55 | Вывод 56 | 57 | 12 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 |
Ограничение времени2 секунды
Ограничение памяти512.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
78 | -------------------------------------------------------------------------------- /9.4 Стек/C/problem.md: -------------------------------------------------------------------------------- 1 | # Сумма минимумов на отрезках 2 | 3 | Дан массив a, состоящий из n чисел и число k ($1 \\leq k \\leq n$). Вам необходимо найти сумму значений минимального элемента на всех отрезках этого массива длины k. 4 | 5 | ## Формат ввода 6 | 7 | Первая строка содержит единственное число n. 8 | 9 | Вторая строка содержит единственное число k. 10 | 11 | Третья строка содержит n разделенных пробелом чисел $a\_i$​. 12 | 13 | ## Формат вывода 14 | 15 | Единственная строка вывода должна содержать одно число -- сумму минимумов. 16 | 17 | ### Пример 1 18 | 19 | Ввод 20 | 21 | 5 22 | 3 23 | 1 2 3 4 5 24 | 25 | 26 | Вывод 27 | 28 | 6 29 | 30 | 31 | ### Пример 2 32 | 33 | Ввод 34 | 35 | 5 36 | 2 37 | 1 2 2 1 3 38 | 39 | 40 | Вывод 41 | 42 | 5 43 | 44 | 45 | ### Пример 3 46 | 47 | Ввод 48 | 49 | 9 50 | 3 51 | 1 2 3 4 5 4 3 2 1 52 | 53 | 54 | Вывод 55 | 56 | 16 57 | 58 | 59 | ### Пример 4 60 | 61 | Ввод 62 | 63 | 8 64 | 8 65 | 1 7 2 6 3 5 5 6 66 | 67 | 68 | Вывод 69 | 70 | 1 71 | 72 | 73 | ### Пример 5 74 | 75 | Ввод 76 | 77 | 5 78 | 1 79 | 1 1 1 1 1 80 | 81 | 82 | Вывод 83 | 84 | 5 85 | 86 | 87 | ## Примечание 88 | 89 | Ограничения: 90 | 91 | * $1 \\leq n \\leq 3 \\cdot 10^5$ 92 | * $1 \\leq k \\leq n$ 93 | * $1 \\leq a\_i \\leq 3 \\cdot 10^5$ для всех $1 \\leq i \\leq n$ 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
114 | -------------------------------------------------------------------------------- /10.5 Задача поиска кратчайшего пути в графе/A/problem.md: -------------------------------------------------------------------------------- 1 | # Маршрут курьера 2 | 3 | Дан взвешенный, неориентированный, связанный граф состоящий из n вершин и m ребер. 4 | 5 | Гарантируется, что в графе нет кратных ребер. 6 | 7 | Вам требуется построить оптимальный маршрут курьера от вершины-склада V до всех вершин-заказов $O\_1, O\_2, O\_3$​ и обратно до склада V. 8 | 9 | Гарантируется, что $V, O\_1, O\_2, O\_3$ попарно различны. 10 | 11 | Другими словами, Вам требуется построить оптимальный маршрут вида $V ... O\_i ... O\_j ... O\_K ... V$. 12 | 13 | ## Формат ввода 14 | 15 | В первой строке задано шесть чисел n , m, $V, O\_1, O\_2, O\_3$​ -- количество вершин, количество ребер, номер вершины-склада и номера вершин-заказов соответственно. 16 | 17 | В следующих m строках заданы ребра $u\_i, v\_i$, $c\_i$​ -- начало ребра, конец ребра, вес ребра. 18 | 19 | ## Формат вывода 20 | 21 | В первой строке выведите количество вершин в оптимальном пути. 22 | 23 | Во второй строке выведите оптимальный путь. 24 | 25 | ## Пример 26 | 27 | Ввод 28 | 29 | 5 10 3 2 4 5 30 | 2 1 3873 31 | 3 1 7914 32 | 4 2 2158 33 | 5 3 6471 34 | 1 5 9621 35 | 4 1 5954 36 | 2 3 4959 37 | 4 5 8410 38 | 2 5 8420 39 | 4 3 4064 40 | 41 | 42 | Вывод 43 | 44 | 5 45 | 3 4 2 5 3 46 | 47 | 48 | ## Примечание 49 | 50 | Ограничения: 51 | 52 | * $4 \\leq n \\leq 10^5$ 53 | * $n - 1 \\leq m \\leq 10^5$ 54 | * $1 \\leq V, O\_1, O\_2, O\_3 \\leq n$ 55 | * $1 \\leq u\_i, v\_i \\leq n$ для всех i от 1 до m 56 | * $1 \\leq c\_i \\leq 10^4$ для всех i от 1 до m 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
76 | -------------------------------------------------------------------------------- /4.3 Задача «Максимальное произведение»/B/problem.md: -------------------------------------------------------------------------------- 1 | # Максимальное произведение — контрпример 2 | 3 | Рассмотрим псевдокод поиска двух максимальных элементов массива: 4 | 5 | 6 | MaxPairwiseProduct(A[1..n]): 7 | m1 = A[1] 8 | m2 = A[2] 9 | if m2 > m1: 10 | swap(m1, m2) 11 | 12 | for i from 3 to n: 13 | if A[i] > m1: 14 | m2 = m1 15 | m1 = A[i] 16 | else: 17 | if A[i] > m2: 18 | m2 = A[i] 19 | return m1 * m2 20 | 21 | Определите, можно ли построить такой пример входных данных, чтобы количество сравнений в алгоритме `MaxPairwiseProduct` было больше 1.5n. 22 | 23 | ## Формат ввода 24 | 25 | Целое число n. 26 | 27 | Ограничения: 2≤n≤200 000. 28 | 29 | ## Формат вывода 30 | 31 | В единственной строке выведите `No`, если подходящих входных данных не существует. Иначе в первой строке выведите `Yes`, а во второй строке n чисел a1,a2,…,an​ (0≤ai≤200 000) — найденный контрпример. 32 | 33 | Если походящих последовательностей несколько, выведите любую из них. 34 | 35 | ### Пример 1 36 | 37 | Ввод 38 | 39 | 2 40 | 41 | 42 | Вывод 43 | 44 | No 45 | 46 | 47 | ### Пример 2 48 | 49 | Ввод 50 | 51 | 10 52 | 53 | 54 | Вывод 55 | 56 | Yes 57 | 10 1 2 3 4 5 6 7 8 9 58 | 59 | 60 | Ограничение памяти 61 | 62 | 256.0 Мб 63 | 64 | Ограничение времени 65 | 66 | 1 с 67 | 68 | Ввод 69 | 70 | стандартный ввод или input.txt 71 | 72 | Вывод 73 | 74 | стандартный вывод или output.txt 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
94 | -------------------------------------------------------------------------------- /6.6 Задача «Максимальный оклад»/B/problem.md: -------------------------------------------------------------------------------- 1 | # Теннисный турнир 2 | 3 | В теннисном турнире принимают участие n роботов-спортсменов. Про каждого из них известно, насколько хорошо он играет. Умение i\-го робота описывается числом $a\_i$​. В игре двух роботов всегда побеждает тот, у кого умение играть в теннис больше. В этой задаче мы будем полагать, что все значения $a\_i$​ различны. 4 | 5 | В каждом раунде теннисного турнира роботы разбиваются на пары. Если количество продолжающих участие в турнире нечетное, то один из роботов без игры проходит в следующий раунд. После игры в каждой из пар, в следующий раунд выходит победитель, а проигравший выбывает из турнира. 6 | 7 | Определите, какое наибольше количество игр в турнире может выиграть k\-й робот-спортсмен. 8 | 9 | ## Формат ввода 10 | 11 | В первой строке входных данных заданы число роботов n и интересующий нас номер k. Во второй строке записаны n чисел $a\_i$​. 12 | 13 | Ограничения: $1 \le n \le 1000$, $1 \le k \le n$, $1 \le a\_i \le n$. Все $a\_i$​ различны. 14 | 15 | ## Формат вывода 16 | 17 | Выведите наибольшее количество игр в турнире, которые может выиграть робот с номером k. 18 | 19 | ### Пример 1 20 | 21 | Ввод 22 | 23 | 4 2 24 | 1 2 4 3 25 | 26 | 27 | Вывод 28 | 29 | 1 30 | 31 | 32 | ### Пример 2 33 | 34 | Ввод 35 | 36 | 5 3 37 | 1 2 3 4 5 38 | 39 | 40 | Вывод 41 | 42 | 2 43 | 44 | 45 | ### Пример 3 46 | 47 | Ввод 48 | 49 | 4 2 50 | 1 2 3 4 51 | 52 | 53 | Вывод 54 | 55 | 1 56 | 57 | 58 | ## Примечание 59 | 60 | Обратите внимание, что в описании турнира не фиксируется способ распределения роботов на пары. 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
81 | -------------------------------------------------------------------------------- /8.5 Задача LCS/A/problem.md: -------------------------------------------------------------------------------- 1 | # Наибольшая общая подпоследовательность 2 | 3 | Мы имеем две последовательности $A=(a\_1, a\_2, \\dotsc, a\_n)$ и $B=(b\_1, b\_2, \\dotsc, b\_m)$, их общая подпоследовательность длиной p — это набор p индексов 4 | 5 | $1 \\leq i\_1 < i\_2 < \\dotsb < i\_p \\leq n$ , 6 | $1 \\leq j\_1 < j\_2 < \\dotsb < j\_p \\leq m$. 7 | 8 | при котором 9 | 10 | $a\_{i\_1} =~b\_{j\_1}$ , 11 | $a\_{i\_2} =~b\_{j\_2}$​​ , 12 | $\vdots$ 13 | $a\_{i\_p} =~b\_{j\_p}$ ​​. 14 | 15 | Наибольшая общая подпоследовательность — это общая подпоследовательность, обладающая самой большой длиной из всех подпоследовательностей. 16 | 17 | Такая задача может применяться в сопоставлении данных (например, утилита diff, операция слияния в разных системах управления версиями), биоинформатике (поиск сходств в генах разных видов) и других сферах. 18 | 19 | ## Формат ввода 20 | 21 | Первая строка: n. Вторая строка: $a\_1, a\_2, \\dotsc, a\_n$​. Третья строка: m. Четвертая строка: $b\_1, b\_2, \\dotsc, b\_m$​. 22 | 23 | Ограничения: $1 \\le n, m \\le 100$; $\-10^9 \\le a\_i,b\_i \\le 10^9$ для всех i. 24 | 25 | ## Формат вывода 26 | 27 | Выведите длину наибольшей общей подпоследовательности. 28 | 29 | ### Пример 1 30 | 31 | Ввод 32 | 33 | 5 34 | 1 2 5 4 9 35 | 8 36 | 18 3 2 8 0 4 7 9 37 | 38 | 39 | Вывод 40 | 41 | 3 42 | 43 | 44 | ### Пример 2 45 | 46 | Ввод 47 | 48 | 2 49 | 1 1 50 | 3 51 | 1 1 1 52 | 53 | 54 | Вывод 55 | 56 | 2 57 | 58 | 59 | ### Пример 3 60 | 61 | Ввод 62 | 63 | 3 64 | 13 17 37 65 | 5 66 | 37 73 13 31 23 67 | 68 | 69 | Вывод 70 | 71 | 1 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
92 | -------------------------------------------------------------------------------- /8.5 Задача LCS/B/problem.md: -------------------------------------------------------------------------------- 1 | # Наибольшая общая подпоследовательность трех последовательностей 2 | 3 | Имея три последовательности $A=(a\_1, a\_2, \\dotsc, a\_n)$, $B=(b\_1, b\_2, \\dotsc, b\_m)$ и $C=(c\_1, c\_2, \\dotsc, c\_l)$, нужно найти длину наибольшей общей подпоследовательности для них, то есть наибольшее неотрицательное целое число ppp, при котором существуют индексы 4 | 5 | $1 \\leq i\_1 < i\_2 < \\dotsb < i\_p \\leq n$ , 6 | $1 \\leq j\_1 < j\_2 < \\dotsb < j\_p \\leq m$ , 7 | $1 \\leq k\_1 < k\_2 < \\dotsb < k\_p \\leq l$ 8 | 9 | при котором 10 | 11 | $a\_{i\_1} =~b\_{j\_1} = c\_{k\_1}$ ​, 12 | $a\_{i\_2} =~b\_{j\_2} = c\_{k\_2}$​​ , 13 | $\vdots\$ 14 | $a\_{i\_p} =~b\_{j\_p} = c\_{k\_p}$​​. 15 | 16 | ## Формат ввода 17 | 18 | Первая строка: $n$. Вторая строка: $a\_1, a\_2, \\dotsc, a\_n$​. Третья строка: $m$. Четвертая строка: $b\_1, b\_2, \\dotsc, b\_m$. Пятая строка: $l$. Шестая строка: $c\_1, c\_2, \\dotsc, c\_l$​. 19 | 20 | Ограничения: $1 \\le n,m,l \\le 100$; $\-10^9 \\le a\_i,b\_i,c\_i \\le 10^9$. 21 | 22 | ## Формат вывода 23 | 24 | Выведите длину наибольшей общей подпоследовательности трех массивов. 25 | 26 | ### Пример 1 27 | 28 | Ввод 29 | 30 | 4 31 | 1 2 3 4 32 | 4 33 | 3 2 4 1 34 | 3 35 | 3 2 4 36 | 37 | 38 | Вывод 39 | 40 | 2 41 | 42 | 43 | ### Пример 2 44 | 45 | Ввод 46 | 47 | 3 48 | 1 2 4 49 | 2 50 | 2 4 51 | 4 52 | 4 2 2 1 53 | 54 | 55 | Вывод 56 | 57 | 1 58 | 59 | 60 | ### Пример 3 61 | 62 | Ввод 63 | 64 | 3 65 | 5 19 18 66 | 2 67 | 19 7 68 | 4 69 | 1 19 2 45 70 | 71 | 72 | Вывод 73 | 74 | 1 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
95 | -------------------------------------------------------------------------------- /7.5 Задача «Пара ближайших точек»/A/problem.md: -------------------------------------------------------------------------------- 1 | # Ближайшие точки 2 | 3 | Заданы n точек на плоскости. 4 | 5 | Ваша задача --- найти ближайшую пару точек из заданного множества. 6 | 7 | ## Формат ввода 8 | 9 | Первая строка содержит n точек. Каждая из следующих n строк определяет точку $(x\_i,y\_i)$. 10 | 11 | Ограничения: $2 \\le n \\le 10^5$; $-10^9 \\le x\_i,y\_i \\le 10^9$ -- целые числа. 12 | 13 | ## Формат вывода 14 | 15 | Минимальное расстояние. 16 | 17 | ### Пример 1 18 | 19 | Ввод 20 | 21 | 2 22 | 0 0 23 | 3 4 24 | 25 | 26 | Вывод 27 | 28 | 5.000000 29 | 30 | 31 | ### Пример 2 32 | 33 | Ввод 34 | 35 | 11 36 | 4 4 37 | -2 -2 38 | -3 -4 39 | -1 3 40 | 2 3 41 | -4 0 42 | 1 1 43 | -1 -1 44 | 3 -1 45 | -4 2 46 | -2 4 47 | 48 | 49 | Вывод 50 | 51 | 1.414214 52 | 53 | 54 | ### Пример 3 55 | 56 | Ввод 57 | 58 | 3 59 | 0 0 60 | 1 1 61 | 0 0 62 | 63 | 64 | Вывод 65 | 66 | 0.000000 67 | 68 | 69 | ## Примечание 70 | 71 | Помните, что расстояние между точками $(x\_1,y\_1)$ и $(x\_2,y\_2)$ равно $\\sqrt{(x\_1-x\_2)^2+(y\_1-y\_2)^2}$​. Так, хотя ввод и содержит только целые числа, ответ необязательно будет целым числом, и потому вам нужно обратить внимание на точность при выводе результатов. 72 | 73 | Абсолютное значение разницы между ответом вашей программы и оптимальным значением не должно превышать $10^{-5}$. Для этого ваш ответ должен содержать не более и не менее шести значащих цифр в дробной части. Иначе даже правильно вычисленный результат может не пройти нашу систему проверки из-за ошибок при округлении. Незначащие нули на проверку не влияют. 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
93 | -------------------------------------------------------------------------------- /10.2 Представление графа в памяти компьютера/B/problem.md: -------------------------------------------------------------------------------- 1 | # Робот-пылесос 2 | 3 | Недавно Вы купили робот-пылесос. Через некоторое время Вы заметили баг в поведении пылесоса: иногда пылесос упирается в стенку или мебель. Правда ли пылесос убирает всю комнату? Для ответа на вопрос Вы получили доступ к плану комнаты и последовательности действий пылесоса. 4 | 5 | Комната имеет форму прямоугольника $n \\times m$ клеток. Каждая клетка либо пустая, либо занятая. 6 | 7 | Робот пылесос умеет делать поворот вправо/влево и ехать вперед. Если в ходе выполнения действий робот-пылесос пытается выехать за границу комнаты (упирается в стенку) или пытается заехать на мебель, то он остается на месте. 8 | 9 | Изначально, робот пылесос находится в пустой клетке (r, c) и повернут вверх. Посчитайте количество клеток, которые посетит робот пылесос, включая стартовую. 10 | 11 | ## Формат ввода 12 | 13 | В первой строке заданы два числа n, m -- размер комнаты. 14 | 15 | В следующих n строках задан план комнаты. Если j\-я клетка в i\-й строке занята, то $s\_{i,j} =$ _#_. Если же j\-я клетка в i\-й строке свободна, то $\=s\_{i,j}$ _._. 16 | 17 | Далее даны два числа r и c -- стартовое положение робота-пылесоса. 18 | 19 | В следующей строке задано количество действий q робота-пылесоса. Далее следует строка длины q, задающая действия пылесоса в порядке выполнения. Символ _L_ задает поворот налево. Символ _R_ задает поворот направо. Символ _M_ задает движение вперёд. 20 | 21 | ## Формат вывода 22 | 23 | Количество клеток, которые посетит робот пылесос, включая стартовую. 24 | 25 | ## Пример 26 | 27 | Ввод 28 | 29 | 3 3 30 | ### 31 | ... 32 | ..# 33 | 2 2 34 | 6 35 | RMLLMM 36 | 37 | 38 | Вывод 39 | 40 | 3 41 | 42 | 43 | ## Примечание 44 | 45 | Ограничения: 46 | 47 | * $1 \\leq n, m \\leq 1000$ 48 | * $1 \\leq r \\leq n$ 49 | * $1 \\leq c \\leq m$ 50 | * $1 \\leq q \\leq 10^5$. 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
71 | -------------------------------------------------------------------------------- /6.3 Задача «Рекламная компания»/B/problem.md: -------------------------------------------------------------------------------- 1 | # Реклама на билбордах 2 | 3 | Рассмотрим задачу менеджера рекламного агентства. 4 | 5 | Есть n билбордов, на которых можно размещать рекламные объявления. Планирование размещения проводится на w недель вперед. Модель размещения рекламы разрешает сохранить одно и тоже объявление несколько недель на одном билборде, перенести объявление на следующей неделе на другой билборд. Размещать одно объявление на разных, не обязательно последовательных, неделях будущего периода. _Однако на одной неделе не может быть рекламных объявлений от одного рекламодателя на разных билбордах_. 6 | 7 | k рекламодателей хотят разместить рекламу. Заявки подают рекламодатели в формате аукциона, но не знают заявок конкурентов. Известно, что i\-й рекламодатель подал заявку на размещение своей рекламы максимум на $w\_i$​ недель с оплатой $c\_i$​ за каждую неделю размещения, т.е. рекламное объявление i\-го рекламодателя может быть размещено от 0 до $w\_i$​ в течение периода (при размещении рекламы в течение m недель оплата за нее составит $m \cdot c\_i$​). 8 | 9 | Менеджеру нужно выбрать, в какие недели и на каких билбордах разместить рекламу рекламодателей. 10 | 11 | Требуется максимизировать прибыль от размещения рекламы. 12 | 13 | ## Формат ввода 14 | 15 | Первая строка содержит три разделённых пробелами числа n, k и w ($1 \leq n \leq 10^3, 1 \leq k \leq 10^5, 1 \leq w \leq 10^2$). 16 | 17 | Далее каждая из k строк содержит по два разделённых пробелом числа — $c\_i$​ и $w\_i$​ ($1 \leq c\_i \leq 10^2, 1 \leq w\_i \leq w$). 18 | 19 | ## Формат вывода 20 | 21 | Вывод должен состоять из одного значения величины _max\_profit_ — ответ на задачу. 22 | 23 | ### Пример 1 24 | 25 | Ввод 26 | 27 | 2 4 3 28 | 5 1 29 | 2 2 30 | 4 3 31 | 1 3 32 | 33 | 34 | Вывод 35 | 36 | 21 37 | 38 | 39 | ### Пример 2 40 | 41 | Ввод 42 | 43 | 1 1 1 44 | 1 1 45 | 46 | 47 | Вывод 48 | 49 | 1 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 |
Ограничение времени3 секунды
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
70 | -------------------------------------------------------------------------------- /9.1 Односвязный список/A/problem.md: -------------------------------------------------------------------------------- 1 | # Выполнение операций со списком 2 | 3 | Изначально у вас есть пустой список. Далее вам поступает q запросов. Каждый запрос одного из следующих типов: 4 | 5 | * Запрос 1-ого типа: добавить число y после x\-ого числа в списке. Если $x\=0$, то нужно сделать число y новым началом списка 6 | * Запрос 2-ого типа: вывести число, которое находится на позиции x в списке 7 | * Запрос 3-его типа: удалить число, которое находится на позиции x в списке 8 | 9 | После каждого запроса второго типа необходимо вывести число, являющееся ответом. Гарантируется, что в списке в этот момент находилось хотя бы x элементов. 10 | 11 | Также гарантируется, что если вам поступил запрос первого или третьего типа, то список к этому моменту содержал хотя бы x элементов. 12 | 13 | ## Формат ввода 14 | 15 | Первая строка содержит единственное число q -- количество запросов. 16 | 17 | Далее следует q строк. Каждая из этих строк может иметь один из следующих видов: 18 | 19 | * Для запроса первого типа -- "1 x y" (без кавычек) 20 | * Для запросов второго типа -- "2 x" (без кавычек) 21 | * Для запросов третьего типа -- "3 x" (без кавычек) 22 | 23 | ## Формат вывода 24 | 25 | Вывод должен состоять из count строк, где count -- количество запросов второго типа. Каждая строка должна содержать ответ на соответствующий запрос в формате value (где value -- число, которое находится на позиции x). 26 | 27 | ## Пример 28 | 29 | Ввод 30 | 31 | 8 32 | 1 0 5 33 | 2 1 34 | 3 1 35 | 1 0 6 36 | 1 0 7 37 | 2 2 38 | 1 1 5 39 | 2 2 40 | 41 | 42 | Вывод 43 | 44 | 5 45 | 6 46 | 5 47 | 48 | 49 | ## Примечание 50 | 51 | Пусть $size\_i$​ -- размер списка в момент i\-ого запроса. 52 | 53 | Ограничения: 54 | 55 | * $1 \\leq q \\leq 5 \\cdot 10^3$ 56 | * Для запросов первого типа $0 \\leq x \\leq size\_i$​ и $1 \\leq y \\leq 10^6$. 57 | * Для запросов второго типа $1 \\leq x \\leq size\_i$​ 58 | * Для запросов третьего типа $1 \\leq x \\leq size\_i$​ 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
78 | -------------------------------------------------------------------------------- /6.2 Задача «Специи»/A/problem.md: -------------------------------------------------------------------------------- 1 | # Специи 2 | 3 | Вор пробрался в лавку специй и нашел там nnn видов специй. В его рюкзак можно сложить до W фунтов, поэтому забрать все он не сможет. Предположим, в лавке находится $w_i$ фунтов специй с номером i и стоимостью $c_i$ долларов. 4 | 5 | Как унести максимально дорогую добычу? Если вор заберет $u_1$​ фунтов специй с номером 1, $u_2$​ фунтов специй с номером 2, $u_3$​ фунтов специй с номером 3 и т. д., общая ценность украденного составит 6 | ```math 7 | с_1 \cdot \frac{u_1}{w_1} + с_2 \cdot \frac{u_2}{w_2} + с_3 \cdot \frac{u_3}{w_3} + \ldots c_n \cdot \frac{u_n}{w_n} 8 | ``` 9 | 10 | Вор хотел бы найти максимальное значение этого выражения при следующих ограничениях: $u_i \leq w_i​, u_1+u_2 + \ldots +u_n \leq W$. 11 | 12 | ## Формат ввода 13 | 14 | Первая строка ввода содержит n специй и вместимость рюкзака W. Следующие n строк указывают цену и вес специй. i\-я строка включает в себя цену $c_i$ и вес $w_i$​ i\-й специи. 15 | 16 | Ограничения: $1 \leq n \leq 10^3$, $0 \leq W \leq 2 \cdot 10^6$; $0 \leq c_i \leq 2 \cdot 10^6$, $0 < w_i \leq 2 \cdot 10^6$ для всех $1 \leq i \leq n$. Все числа — целые. 17 | 18 | ## Формат вывода 19 | 20 | Максимальное значение специй, которые вместятся в рюкзак. 21 | 22 | ### Пример 1 23 | 24 | Ввод 25 | 26 | 3 50 27 | 60 20 28 | 100 50 29 | 120 30 30 | 31 | 32 | Вывод 33 | 34 | 180.000 35 | 36 | 37 | ### Пример 2 38 | 39 | Ввод 40 | 41 | 1 10 42 | 500 30 43 | 44 | 45 | Вывод 46 | 47 | 166.667 48 | 49 | 50 | ### Пример 3 51 | 52 | Ввод 53 | 54 | 1 1000 55 | 500 30 56 | 57 | 58 | Вывод 59 | 60 | 500.000 61 | 62 | 63 | ## Примечание 64 | 65 | Хотя ввод для этой задачи и состоит из целых чисел, вывести необходимо нецелое число. Таким образом, абсолютное значение разницы между ответом вашей программы и оптимальным значением не должно превышать $10^{-3}$. Рекомендуем выводить ответ более точно, например, содержащий не меньше четырех цифр в дробной части, иначе даже правильно вычисленный ответ может стать неправильным из-за проблем с округлением. 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
86 | -------------------------------------------------------------------------------- /10.3 Обходы графа/C/problem.md: -------------------------------------------------------------------------------- 1 | # Выход из лабиринта 2 | 3 | Задан лабиринт. Лабиринт представляет собой прямоугольник n на m клеток. Каждая клетка может находится в одном из четырех состояний: 4 | 5 | * Пустая клетка . 6 | * Стена #. 7 | * Вход в лабиринт S. 8 | * Выход из лабиринта F. 9 | 10 | Гарантируется, что в лабиринте один вход и один выход. Также гарантируется, что контур лабиринта состоит из стены. 11 | 12 | Изначально Вы находитесь в стартовой клетке. Вы можете двигаться вверх U, вниз D, вправо R, влево L. Вам требуется вывести кратчайший выход из лабиринта с помощью символов UDRL. 13 | 14 | Если выйти из лабиринта невозможно, то выведите −1. 15 | 16 | ## Формат ввода 17 | 18 | В первой строке заданы два числа n,m. 19 | 20 | В следующих n строках задан лабиринт. 21 | 22 | ## Формат вывода 23 | 24 | Если выйти из лабиринта невозможно, то выведите единственное число −1. 25 | 26 | Если же выход из лабиринта существует, то в первой строке выведите кратчайшее расстояние до выхода, а во второй сам путь. 27 | 28 | ### Пример 1 29 | 30 | Ввод 31 | 32 | 7 7 33 | ####### 34 | #...#.# 35 | #...#.# 36 | #.#.#.# 37 | #.#F#.# 38 | #....S# 39 | ####### 40 | 41 | 42 | Вывод 43 | 44 | 3 45 | LLU 46 | 47 | 48 | ### Пример 2 49 | 50 | Ввод 51 | 52 | 9 9 53 | ######### 54 | #...#...# 55 | #..F#.### 56 | #...#.#.# 57 | #.###.#.# 58 | #.S...#.# 59 | ##..###.# 60 | #.......# 61 | ######### 62 | 63 | 64 | Вывод 65 | 66 | 6 67 | LUUURR 68 | 69 | 70 | ### Пример 3 71 | 72 | Ввод 73 | 74 | 11 11 75 | ########### 76 | #.#.......# 77 | #.#.##..### 78 | #...#.#.#.# 79 | #####.#.#.# 80 | #.#.#.....# 81 | #.#.#.##### 82 | #.#...F.#.# 83 | #.#S#####.# 84 | #.........# 85 | ########### 86 | 87 | 88 | Вывод 89 | 90 | 4 91 | URRR 92 | 93 | 94 | ## Примечание 95 | 96 | Ограничения: 97 | 98 | * $1 \\leq n \\cdot m \\leq 10^5$ 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
119 | -------------------------------------------------------------------------------- /10.3 Обходы графа/D/problem.md: -------------------------------------------------------------------------------- 1 | # Выход из лабиринта: один ключ 2 | 3 | Задан лабиринт. Лабиринт представляет собой прямоугольник n на m клеток. Каждая клетка может находится в одном из шести состояний: 4 | 5 | * Пустая клетка . 6 | * Стена #. 7 | * Вход в лабиринт S. 8 | * Выход из лабиринта F. 9 | * Дверь с замком D. 10 | * Ключ от двери K. 11 | 12 | Гарантируется, что в лабиринте один вход, один выход, одну дверь и один ключ. Также гарантируется, что контур лабиринта состоит из стены. 13 | 14 | Изначально Вы находитесь в стартовой клетке. Вы можете двигаться вверх U, вниз D, вправо R, влево L, подобрать ключ P. Только после того, как ключ подобран, есть возможность попасть в клетку D. Подобрать ключ можно только один раз. Требуется вывести кратчайший выход из лабиринта с помощью символов UDRLP. 15 | 16 | Если выйти из лабиринта невозможно, то выведите −1. 17 | 18 | ## Формат ввода 19 | 20 | В первой строке заданы два числа n, m. 21 | 22 | В следующих nnn строках задан лабиринт. 23 | 24 | ## Формат вывода 25 | 26 | Если выйти из лабиринта невозможно, то выведите единственное число −1. 27 | 28 | Если же выход из лабиринта существует, то в первой строке выведите кратчайшее расстояние до выхода, а во второй сам путь. 29 | 30 | ### Пример 1 31 | 32 | Ввод 33 | 34 | 7 7 35 | ####### 36 | #K..#F# 37 | #...#D# 38 | #.#.#.# 39 | #.#.#.# 40 | #....S# 41 | ####### 42 | 43 | 44 | Вывод 45 | 46 | 21 47 | LLLLUUUUPDDDDRRRRUUUU 48 | 49 | 50 | ### Пример 2 51 | 52 | Ввод 53 | 54 | 7 7 55 | ####### 56 | #...#.# 57 | #.D.#.# 58 | #.#.#K# 59 | #.#F#.# 60 | #....S# 61 | ####### 62 | 63 | 64 | Вывод 65 | 66 | 3 67 | LLU 68 | 69 | 70 | ### Пример 3 71 | 72 | Ввод 73 | 74 | 7 7 75 | ####### 76 | #F#..K# 77 | #.#...# 78 | #.#.#.# 79 | #.###S# 80 | #D....# 81 | ####### 82 | 83 | 84 | Вывод 85 | 86 | 16 87 | UUUPDDDDLLLLUUUU 88 | 89 | 90 | ## Примечание 91 | 92 | Ограничения: 93 | 94 | * $1 \\leq n \\cdot m \\leq 10^5$ 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
115 | -------------------------------------------------------------------------------- /3.4 Рекурсивные алгоритмы/A/problem.md: -------------------------------------------------------------------------------- 1 | # Ханойские башни 2 | 3 | Головоломка <<Ханойские башни>> состоит из трёх стержней, пронумеруем их слева направо: 1, 2 и 3. Также в головоломке используется стопка дисков с отверстием посередине. Радиус дисков уменьшается снизу вверх. Изначально диски расположены на левом стержне (стержень 1), самый большой диск находится внизу. Диски в игре перемещаются по одному со стержня на стержень. Диск можно надеть на стержень, только если он пустой или верхний диск на нём большего размера, чем перемещаемый. Цель головоломки — перенести все диски со стержня 1 на стержень 3. 4 | 5 | Требуется найти последовательность ходов, которая решает головоломку <<Ханойские башни>>. 6 | 7 | ## Формат ввода 8 | 9 | В первой строке задано одно число n (3≤n≤10) — количество дисков на первой башне. 10 | 11 | ## Формат вывода 12 | 13 | В первой строке выведите количество операций k. 14 | 15 | В следующих k строках выведите по два числа в каждой xi,yi (1≤xi,yi≤3) — переместить верхний диск со стержня xi​ на стержень yi​. 16 | 17 | ### Пример 1 18 | 19 | Ввод 20 | 21 | 3 22 | 23 | 24 | Вывод 25 | 26 | 7 27 | 1 3 28 | 1 2 29 | 3 2 30 | 1 3 31 | 2 1 32 | 2 3 33 | 1 3 34 | 35 | 36 | ### Пример 2 37 | 38 | Ввод 39 | 40 | 4 41 | 42 | 43 | Вывод 44 | 45 | 15 46 | 1 2 47 | 1 3 48 | 2 3 49 | 1 2 50 | 3 1 51 | 3 2 52 | 1 2 53 | 1 3 54 | 2 3 55 | 2 1 56 | 3 1 57 | 2 3 58 | 1 2 59 | 1 3 60 | 2 3 61 | 62 | 63 | ### Пример 3 64 | 65 | Ввод 66 | 67 | 5 68 | 69 | 70 | Вывод 71 | 72 | 31 73 | 1 3 74 | 1 2 75 | 3 2 76 | 1 3 77 | 2 1 78 | 2 3 79 | 1 3 80 | 1 2 81 | 3 2 82 | 3 1 83 | 2 1 84 | 3 2 85 | 1 3 86 | 1 2 87 | 3 2 88 | 1 3 89 | 2 1 90 | 2 3 91 | 1 3 92 | 2 1 93 | 3 2 94 | 3 1 95 | 2 1 96 | 2 3 97 | 1 3 98 | 1 2 99 | 3 2 100 | 1 3 101 | 2 1 102 | 2 3 103 | 1 3 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 |
Ограничение времени1 секунда
Ограничение памяти256.0Mb
Вводстандартный ввод или input.txt
Выводстандартный вывод или output.txt
125 | --------------------------------------------------------------------------------