├── AtCoder └── ABC │ └── 163 │ ├── A.cpp │ ├── B.cpp │ ├── C.cpp │ ├── D.cpp │ ├── E.cpp │ ├── F.cpp │ └── F_Euler.cpp ├── CodeChef └── Cook72 │ └── ChefFed.cpp ├── Codeforces ├── EDU │ └── SegmentTree │ │ └── 1 │ │ ├── 1 │ │ ├── A.cpp │ │ ├── B.cpp │ │ └── C.cpp │ │ ├── 2 │ │ ├── A.cpp │ │ ├── B.cpp │ │ ├── C.cpp │ │ └── D.cpp │ │ └── 4 │ │ └── B.cpp ├── Gyms │ ├── 100003 │ │ ├── A.py │ │ ├── B.py │ │ ├── C.py │ │ ├── D.py │ │ ├── E.py │ │ ├── F.py │ │ ├── H.py │ │ ├── J.py │ │ └── Readme.md │ ├── 101190 │ │ ├── A.cpp │ │ ├── E.cpp │ │ ├── F.cpp │ │ ├── H.cpp │ │ ├── J.cpp │ │ └── Readme.md │ ├── 102777 │ │ ├── A.py │ │ ├── B.py │ │ ├── C.py │ │ ├── D.py │ │ ├── E.py │ │ ├── F.py │ │ ├── G_dfs.py │ │ ├── G_dsu.py │ │ ├── H_formula.cpp │ │ ├── H_generator.cpp │ │ ├── H_matrix.cpp │ │ ├── H_precalc.cpp │ │ ├── I.cpp │ │ ├── J.py │ │ ├── K.py │ │ └── Readme.md │ └── 103993 │ │ ├── A.py │ │ ├── B.py │ │ ├── C.py │ │ ├── D.py │ │ ├── E.py │ │ ├── F.py │ │ ├── G.cpp │ │ ├── H.cpp │ │ ├── I.cpp │ │ ├── J.cpp │ │ └── Readme.md └── Rounds │ ├── 121 (191) │ └── E.cpp │ ├── 167 (272) │ └── D.cpp │ ├── 197 (339) │ ├── C_Bfs.cpp │ └── C_Dp.cpp │ ├── 219 (373) │ └── B.cpp │ ├── 226 (385) │ └── C.cpp │ ├── 228 (388) │ └── B.cpp │ ├── 258 (451) │ ├── B.cpp │ ├── B.java │ └── B.py │ ├── 278 (488) │ └── B.cpp │ ├── 279 (490) │ ├── B.cpp │ └── E.cpp │ ├── 287 (507) │ └── C.cpp │ ├── 317 (571) │ └── A.cpp │ ├── 335 (606) │ └── A.cpp │ ├── 386 (746) │ └── G.cpp │ ├── 394 (761) │ └── C.cpp │ ├── 432 (850) │ └── B.cpp │ ├── 453 (901) │ └── A.cpp │ ├── 457 (916) │ └── C.cpp │ ├── 464 (939) │ ├── A.cpp │ ├── B.cpp │ ├── C.cpp │ ├── D.cpp │ ├── E.cpp │ └── F.cpp │ ├── 479 (977) │ └── E.cpp │ ├── 482 (979) │ └── C.cpp │ ├── 494 (1003) │ └── D.cpp │ ├── 498 (1006) │ └── C.cpp │ ├── 511 (1034) │ └── B.cpp │ ├── 521 (1077) │ └── D.cpp │ ├── 539 (1109) │ └── D.cpp │ ├── 541 (1131) │ └── A.cpp │ ├── 553 (1151) │ └── E.cpp │ ├── 555 (1157) │ └── B.cpp │ ├── 570 (1183) │ ├── D.cpp │ └── G.cpp │ ├── 575 (1196) │ └── D.cpp │ ├── 585 (1215) │ └── B.cpp │ ├── 589 (1228) │ ├── B.cpp │ └── C.cpp │ ├── 593 (1236) │ └── B.cpp │ ├── 598 (1256) │ └── A.cpp │ ├── 625 (1320) │ └── B.cpp │ ├── 629 (1328) │ └── D.cpp │ ├── 636 (1343) │ ├── A.cpp │ ├── B.cpp │ ├── C.cpp │ ├── D.cpp │ ├── E.cpp │ └── F.cpp │ ├── 637 (1340) │ ├── A.cpp │ ├── B.cpp │ ├── C.cpp │ └── D.cpp │ ├── 637 (1341) │ ├── A.cpp │ └── B.cpp │ ├── 666 (1396) │ ├── A.cpp │ ├── A.java │ └── A.py │ ├── 794 (1685) │ └── C.cpp │ ├── 799 (1692) │ ├── E.cpp │ └── H.cpp │ ├── 834 (1759) │ ├── A.py │ ├── B.py │ ├── C.py │ ├── D.py │ ├── E.py │ ├── F.py │ ├── G.cpp │ └── Readme.md │ ├── 835 (1760) │ ├── A.py │ ├── B.py │ ├── C.py │ ├── C_2.py │ ├── D.py │ ├── E.py │ ├── E_2.py │ ├── F.py │ ├── G.cpp │ └── Readme.md │ ├── Croc │ └── 2012 │ │ └── 2 (176) │ │ └── A.py │ ├── Educational │ ├── 12 (665) │ │ └── D.cpp │ ├── 120 (1622) │ │ ├── A.cpp │ │ ├── B.cpp │ │ ├── C.cpp │ │ └── D.cpp │ ├── 129 (1681) │ │ └── F.cpp │ ├── 22 (813) │ │ └── A.cpp │ ├── 25 (825) │ │ └── C.cpp │ ├── 27 (845) │ │ └── B.cpp │ ├── 30 (873) │ │ └── D.cpp │ ├── 35 (911) │ │ ├── A.cpp │ │ └── G.cpp │ ├── 36 (915) │ │ └── C.cpp │ ├── 74 (1238) │ │ └── C.cpp │ ├── 84 (1327) │ │ └── C.cpp │ └── 87 (1354) │ │ ├── A.cpp │ │ ├── B.cpp │ │ ├── C1_Formula.cpp │ │ ├── C_TernarySearch.cpp │ │ ├── D.cpp │ │ └── E.cpp │ ├── Global │ └── 6 (1266) │ │ ├── D.cpp │ │ └── E.cpp │ ├── GoodBye │ └── 2021 │ │ ├── A.cpp │ │ ├── B.cpp │ │ ├── C.cpp │ │ └── D.cpp │ ├── Polynomial (1774) │ ├── A.py │ ├── B.py │ ├── C.py │ ├── D.py │ ├── E.cpp │ └── Readme.md │ ├── TechnoCup │ └── 2020 │ │ └── Qual 3 │ │ └── D.cpp │ └── VK Cup │ ├── 2012 │ └── Round 2 Div2 (169) │ │ └── A.cpp │ ├── 2018 │ └── Qual 2 (929) │ │ ├── A.cpp │ │ ├── B.cpp │ │ └── C.cpp │ └── 2022 │ └── Qual (Engine) │ ├── A.py │ ├── B.py │ ├── C.py │ ├── D1.py │ ├── D2_Generator.cpp │ ├── D2_Generator.py │ ├── D2_Solution.py │ └── Readme.md ├── Google Code Jam └── 2020 │ └── Round 2 │ ├── A.cpp │ └── B.cpp ├── KRSU └── ICPC │ └── 2022 │ └── Qualification │ ├── A.py │ ├── B.py │ ├── C.py │ ├── D.py │ ├── E.py │ ├── F.cpp │ ├── G.py │ ├── H.cpp │ └── Readme.md ├── LeetCode ├── p0024_swap_nodes_in_pairs.go ├── p0041_first_missing_positive.go ├── p0054_spiral_matrix.go ├── p0054_spiral_matrix_iterator.go ├── p0059_spiral_matrix_2_iterator.go ├── p0060_permutation_sequence.go ├── p0228_summary_ranges.go ├── p0258_add_digits.go ├── p0319_bulb_switcher.go ├── p0347_top_k_frequent_counting_sort.go ├── p0347_top_k_frequent_partition.go ├── p0399_evaluate_division.go ├── p0530_minimum_difference_in_bst.go ├── p0547_number_of_provinces.go ├── p0649_dota2_senate.go ├── p0703_kth_largest.go ├── p0705_design_hashet_bool_array.go ├── p0705_design_hashset_buckets.go ├── p0744_find_smallest_greater.go ├── p0783_minimum_distance_in_bst.go ├── p0785_is_graph_bipartite_bfs.go ├── p0837_new_21_game.go ├── p0839_similar_string_groups.go ├── p0934_shortest_bridge.go ├── p1027_longest_arithmetic_subsequence.go ├── p1035_uncrossed_lines.go ├── p1091_shortest_path_binary_matrix.go ├── p1114_print_in_order_barrier.py ├── p1114_print_in_order_count_down_latch.java ├── p1114_print_in_order_event.py ├── p1115_print_foobar_semaphore.java ├── p1115_print_foobar_semaphore.py ├── p1116_zero_even_odd_semaphore.py ├── p1116_zero_odd_even_semaphore.java ├── p1140_stone_game_2.go ├── p1146_snapshot_array.go ├── p1161_maximum_level_sum_dfs.go ├── p1187_make_array_increasing.go ├── p1232_check_straight_line.go ├── p1318_minimum_flips_make_or_equals.go ├── p1351_count_negative_in_sorted_matrix.go ├── p1376_time_needed_to_inform.go ├── p1396_design_underground_system.go ├── p1406_stone_game_3.go ├── p1456_max_number_of_vowels.go ├── p1491_average_salary.go ├── p1498_number_of_subsequences.go ├── p1502_can_make_arithmetic_progression_linear.go ├── p1502_can_make_arithmetic_progression_sort.go ├── p1547_cut_the_stick_iterative.go ├── p1547_cut_the_stick_recursive.go ├── p1557_minimum_number_of_vertices.go ├── p1569_reorder_array_same_bst.go ├── p1572_matrix_diagonal_sum.go ├── p1579_remove_max_number_of_edges.go ├── p1603_design_parking.go ├── p1697_checking_existence_of_paths.go ├── p1721_swapping_nodes.go ├── p1732_find_the_highest_altitude.go ├── p1799_maximize_score.go ├── p1802_maximum_value_in_bounded_array.go ├── p1822_sign_of_the_product.go ├── p1964_longest_valid_obstacle_course.go ├── p2090_k_radius_prefix_sums.go ├── p2101_detonate_maximum_bombs.go ├── p2130_max_twin_sum.go ├── p2140_solving_questions.go ├── p2215_find_the_difference.go ├── p2328_number_of_increasing_paths.go ├── p2352_equal_row_column_pairs_cube.go ├── p2352_equal_row_column_pairs_hash.go ├── p2448_minimal_cost_make_equal.go ├── p2466_count_ways_to_build_string.go ├── p2542_maximum_subsequence_score.go ├── p2659_make_array_empty.go ├── p2670_distinct_difference_array.go ├── p2671_frequency_tracker.go ├── p2672_adjacent_elements_same_color.go ├── p2673_make_paths_equal.go ├── p2706_buy_two_chocolates.go ├── p2707_extra_characters.go ├── p2708_maximum_strength_bitmasks.go ├── p2709_gcd_traversal_bfs.go └── utils │ ├── dsu.go │ ├── graph │ ├── strictly_connected_components.go │ └── topological_sort.go │ ├── int_heap.go │ ├── matrix_iterator.go │ ├── partition.go │ └── spiral_iterator.go ├── NlogN ├── 2023 │ └── Winter │ │ └── Div A │ │ └── Day 5 │ │ ├── A.py │ │ ├── B.py │ │ ├── C.py │ │ ├── D.py │ │ ├── E.cpp │ │ └── Readme.md └── Misis_Winter_2022 │ └── SegmentTree │ └── Base_01_02 │ ├── A.cpp │ ├── B.cpp │ ├── C.cpp │ ├── D.cpp │ ├── E.cpp │ ├── F.cpp │ ├── G.cpp │ ├── H.cpp │ └── I.cpp ├── Polygon ├── __Solution_Go.go ├── __Solution_Java.java ├── checker.cpp ├── gen_rand.cpp ├── problem_lib.h ├── test_script ├── test_script_groups ├── testlib.h ├── tutorials │ ├── freemarker.md │ ├── polygon.md │ └── requirements.md ├── validator.cpp └── validator_groups.cpp ├── README.md ├── RuCode └── 2020 │ ├── AB │ ├── B.cpp │ └── statements.pdf │ └── Qual │ ├── A.cpp │ ├── B.cpp │ ├── C.cpp │ ├── D.cpp │ ├── E.cpp │ ├── F.cpp │ ├── G.cpp │ ├── H.cpp │ ├── I.py │ ├── J.py │ ├── K.cpp │ ├── L_double.cpp │ ├── L_int128.cpp │ └── problems.pdf ├── SortMe ├── Task19.cpp ├── Task26.cpp ├── Task27.cpp ├── Task30.cpp ├── Task34.cpp └── Task35.cpp ├── VOSh ├── 2020 │ └── School │ │ ├── A.py │ │ ├── B.py │ │ ├── C.py │ │ ├── D.py │ │ └── E.py └── 2021 │ └── School │ └── 3 │ └── A.cpp ├── Yandex └── Trainings │ ├── Intensives │ ├── 1 │ │ ├── A.py │ │ ├── B.py │ │ ├── C.py │ │ ├── D.py │ │ └── E.py │ ├── 2 │ │ ├── A.py │ │ ├── B.py │ │ ├── C.py │ │ ├── D.py │ │ └── E.py │ ├── 3 │ │ ├── A_counter.py │ │ ├── A_sorted.py │ │ ├── B_age_square.py │ │ ├── B_prefix_sums.py │ │ ├── B_two_pointers.py │ │ ├── C.py │ │ ├── D.py │ │ └── E.py │ └── 4 │ │ ├── A.py │ │ ├── B.py │ │ ├── C.py │ │ ├── D_dfs.py │ │ ├── D_topsort_queue.py │ │ └── E.py │ ├── S2 │ ├── 1 │ │ └── DivB │ │ │ └── E.java │ ├── 3 │ │ └── DivA │ │ │ ├── A.java │ │ │ ├── B.java │ │ │ ├── C.java │ │ │ └── E.java │ └── 4 │ │ └── DivB │ │ ├── A_PairsSort.java │ │ └── A_SortedMap.java │ ├── S3 │ └── 23.03.13. Sprint │ │ ├── A.py │ │ ├── B.py │ │ ├── C.py │ │ ├── D.py │ │ ├── E.py │ │ └── Readme.md │ └── S4 │ └── Bruteforce │ └── MaxCut │ ├── non_recursive_dp_2_n.cpp │ ├── non_recursive_dp_2_n.py │ ├── non_recursive_dp_gray_code_2_n.cpp │ ├── non_recursive_dp_gray_code_2_n.py │ ├── non_recursive_gray_code_n_2_n.cpp │ ├── non_recursive_gray_code_n_2_n.py │ └── recursive_n_2_n.py ├── course ├── int_float │ ├── A.cpp │ ├── A.java │ ├── B.cpp │ ├── B.java │ ├── C.cpp │ ├── C.java │ ├── D.cpp │ ├── D.java │ ├── E.cpp │ ├── E.java │ ├── F.cpp │ ├── F.java │ ├── G.cpp │ ├── G.java │ ├── H.cpp │ ├── H.java │ ├── I.cpp │ ├── I.java │ ├── J.cpp │ ├── J.java │ ├── K.cpp │ ├── K.java │ ├── L.cpp │ ├── L.java │ ├── M.cpp │ ├── M.java │ ├── N.cpp │ ├── N.java │ ├── O.cpp │ ├── O.java │ ├── P.cpp │ └── P.java ├── string │ ├── A.cpp │ ├── A.java │ ├── B.cpp │ ├── B.java │ ├── C.cpp │ ├── C.java │ ├── D.cpp │ ├── D.java │ ├── E.cpp │ ├── E.java │ ├── F.cpp │ ├── F.java │ ├── G.cpp │ ├── G.java │ ├── H.cpp │ ├── H.java │ ├── I.cpp │ ├── I.java │ ├── J.cpp │ ├── J.java │ ├── K.cpp │ ├── K.java │ ├── L.cpp │ ├── L.java │ ├── M.cpp │ ├── M.java │ ├── N.cpp │ ├── N.java │ ├── O.cpp │ ├── O.java │ ├── P.cpp │ ├── P.java │ ├── Q.cpp │ ├── Q.java │ ├── R.cpp │ ├── R.java │ ├── S.cpp │ ├── S.java │ ├── T.cpp │ ├── T.java │ ├── U.cpp │ ├── U.java │ ├── V.cpp │ ├── V.java │ ├── W.cpp │ ├── W.java │ ├── X.cpp │ ├── X.java │ ├── Y.cpp │ ├── Y.java │ ├── Z.cpp │ └── Z.java └── templates │ ├── __Solution.cpp │ ├── __Solution.java │ └── __Solution.py ├── src ├── __Solution_CF.cpp ├── __Solution_CF.java └── __Stress.cpp └── tmp └── ICPC 2022 Southern and Volga Russia Qualification Contest └── Readme.md /Codeforces/Gyms/100003/A.py: -------------------------------------------------------------------------------- 1 | file_name = 'aisle' 2 | 3 | with open(file_name + '.in', 'r') as f_in: 4 | def read_string(): 5 | return f_in.readline().strip() 6 | 7 | 8 | def read_ints(): 9 | return map(int, read_string().split()) 10 | 11 | 12 | def read_int(): 13 | return int(read_string()) 14 | 15 | 16 | n, l, w, x, y, a = read_ints() 17 | 18 | 19 | def get_ans(): 20 | ans = -1 21 | 22 | max_seat_in_row = l // x 23 | 24 | max_passes = w // a 25 | for passes in range(1, max_passes + 1): 26 | max_seat_rows = (w - passes * a) // y 27 | 28 | if n > max_seat_rows * max_seat_in_row: 29 | continue 30 | 31 | max_rows_near_passes = min(max_seat_rows, 2 * passes) 32 | max_seats_near_passes = min(n, max_rows_near_passes * max_seat_in_row) 33 | 34 | ans = max(ans, max_seats_near_passes) 35 | 36 | return ans 37 | 38 | 39 | ans = get_ans() 40 | with open(file_name + '.out', 'w') as f_out: 41 | f_out.write(str(ans) + '\n') 42 | -------------------------------------------------------------------------------- /Codeforces/Gyms/100003/C.py: -------------------------------------------------------------------------------- 1 | file_name = 'codes' 2 | 3 | with open(file_name + '.in', 'r') as f_in: 4 | def read_string(): 5 | return f_in.readline().strip() 6 | 7 | 8 | def read_ints(): 9 | return map(int, read_string().split()) 10 | 11 | 12 | def read_int(): 13 | return int(read_string()) 14 | 15 | 16 | n, k = read_ints() 17 | words = [read_string() for _ in range(n)] 18 | 19 | 20 | def get_ans(): 21 | ans = [] 22 | 23 | prefixes = dict() 24 | for word in words: 25 | if len(word) <= k: 26 | ans.append(word) 27 | else: 28 | prefixes[word[:k + 1]] = word 29 | 30 | ans.extend(prefixes.values()) 31 | 32 | return ans 33 | 34 | 35 | ans = get_ans() 36 | with open(file_name + '.out', 'w') as f_out: 37 | f_out.write(str(len(ans)) + '\n') 38 | f_out.write('\n'.join(ans)) 39 | -------------------------------------------------------------------------------- /Codeforces/Gyms/100003/D.py: -------------------------------------------------------------------------------- 1 | file_name = 'dfs' 2 | 3 | with open(file_name + '.in', 'r') as f_in: 4 | def read_string(): 5 | return f_in.readline().strip() 6 | 7 | 8 | def read_ints(): 9 | return map(int, read_string().split()) 10 | 11 | 12 | def read_int(): 13 | return int(read_string()) 14 | 15 | 16 | n, k = read_ints() 17 | order = [read_int() for _ in range(k)] 18 | 19 | 20 | def get_ans(): 21 | ans = [] 22 | 23 | first = [-1] * (n + 1) 24 | last = [-1] * (n + 1) 25 | for i, v in enumerate(order): 26 | if first[v] == -1: 27 | first[v] = i 28 | 29 | last[v] = i 30 | 31 | stack = [] 32 | cur_children = [-1] * (n + 1) 33 | 34 | root = 0 35 | stack.append(root) 36 | for i, v in enumerate(order): 37 | if i == first[v]: 38 | for p in stack: 39 | if p == root: 40 | continue 41 | 42 | if cur_children[p] <= v: 43 | ans.append((p, v)) 44 | 45 | parent = stack[-1] 46 | cur_children[parent] = v 47 | 48 | stack.append(v) 49 | 50 | if i == last[v]: 51 | stack.pop(-1) 52 | 53 | return ans 54 | 55 | 56 | ans = get_ans() 57 | with open(file_name + '.out', 'w') as f_out: 58 | f_out.write(str(len(ans)) + '\n') 59 | 60 | edges = [f'{a} {b}' for a, b in ans] 61 | f_out.write('\n'.join(edges)) 62 | -------------------------------------------------------------------------------- /Codeforces/Gyms/100003/E.py: -------------------------------------------------------------------------------- 1 | from collections import defaultdict 2 | 3 | file_name = 'gems' 4 | 5 | with open(file_name + '.in', 'r') as f_in: 6 | def read_string(): 7 | return f_in.readline().strip() 8 | 9 | 10 | def read_ints(): 11 | return map(int, read_string().split()) 12 | 13 | 14 | def read_int(): 15 | return int(read_string()) 16 | 17 | 18 | n, k = read_ints() 19 | text = read_string() 20 | 21 | goods = [read_string() for _ in range(k)] 22 | 23 | 24 | def get_ans(): 25 | ans = 0 26 | 27 | starts = defaultdict(list) 28 | for start, end in goods: 29 | starts[end].append(start) 30 | 31 | counts = defaultdict(int) 32 | for letter in text: 33 | for start in starts[letter]: 34 | ans += counts[start] 35 | counts[letter] += 1 36 | 37 | return ans 38 | 39 | 40 | ans = get_ans() 41 | with open(file_name + '.out', 'w') as f_out: 42 | f_out.write(str(ans) + '\n') 43 | -------------------------------------------------------------------------------- /Codeforces/Gyms/100003/F.py: -------------------------------------------------------------------------------- 1 | file_name = 'numbers' 2 | 3 | with open(file_name + '.in', 'r') as f_in: 4 | def read_string(): 5 | return f_in.readline().strip() 6 | 7 | 8 | def read_ints(): 9 | return map(int, read_string().split()) 10 | 11 | 12 | def read_int(): 13 | return int(read_string()) 14 | 15 | 16 | n, k = read_ints() 17 | 18 | 19 | def get_ans(): 20 | inf = 9 * 10**18 21 | max_size = 0 22 | while k ** max_size <= inf // k: 23 | max_size += 1 24 | 25 | goods = [[0] * k for _ in range(max_size)] 26 | for size in range(1, max_size): 27 | for first in range(k): 28 | goods[size][first] += sum(goods[size - 1]) 29 | 30 | if size % 2 == 0 and first != 0: 31 | goods[size][first] += 1 # f000 32 | 33 | ans = [0] 34 | 35 | need = n - 1 36 | for size in range(max_size - 1, -1, -1): 37 | if ans[-1] != 0 and size % 2 == 1: 38 | if need == 0: 39 | # found ans (f000) 40 | ans.extend([0] * size) 41 | return ans 42 | else: 43 | need -= 1 44 | 45 | for first in range(k): 46 | if goods[size][first] <= need: 47 | need -= goods[size][first] 48 | continue 49 | 50 | ans.append(first) 51 | break 52 | 53 | return [-1] 54 | 55 | 56 | ans = get_ans() 57 | 58 | decimal_ans = 0 59 | for digit in ans: 60 | decimal_ans *= k 61 | decimal_ans += digit 62 | 63 | with open(file_name + '.out', 'w') as f_out: 64 | f_out.write(str(decimal_ans) + '\n') 65 | -------------------------------------------------------------------------------- /Codeforces/Gyms/100003/H.py: -------------------------------------------------------------------------------- 1 | file_name = 'shelves' 2 | 3 | with open(file_name + '.in', 'r') as f_in: 4 | def read_string(): 5 | return f_in.readline().strip() 6 | 7 | 8 | def read_ints(): 9 | return map(int, read_string().split()) 10 | 11 | 12 | def read_int(): 13 | return int(read_string()) 14 | 15 | 16 | left_size, right_size = read_ints() 17 | left_heights = list(read_ints()) 18 | right_heights = list(read_ints()) 19 | 20 | 21 | def get_ans(): 22 | left_starts = [0] * (left_size + 1) 23 | for i in range(left_size): 24 | left_starts[i + 1] = left_starts[i] + left_heights[i] 25 | 26 | right_starts = [0] * (right_size + 1) 27 | for j in range(right_size): 28 | right_starts[j + 1] = right_starts[j] + right_heights[j] 29 | 30 | segments = [] 31 | for i in range(left_size): 32 | end = left_starts[i] + left_heights[i] 33 | segments.append((end, left_starts[i], i, 0)) 34 | 35 | for j in range(right_size): 36 | end = right_starts[j] + right_heights[j] 37 | segments.append((end, right_starts[j], j, 1)) 38 | 39 | ans = [[] for _ in range(2)] 40 | 41 | last_end = -1 42 | segments.sort() 43 | for end, start, index, side in segments: 44 | if start >= last_end: 45 | last_end = end 46 | ans[side].append(index + 1) 47 | 48 | return ans 49 | 50 | 51 | left_ans, right_ans = get_ans() 52 | with open(file_name + '.out', 'w') as f_out: 53 | f_out.write(f'{len(left_ans)} {len(right_ans)}' + '\n') 54 | f_out.write(' '.join(map(str, left_ans)) + '\n') 55 | f_out.write(' '.join(map(str, right_ans)) + '\n') 56 | -------------------------------------------------------------------------------- /Codeforces/Gyms/100003/J.py: -------------------------------------------------------------------------------- 1 | file_name = 'sum' 2 | 3 | with open(file_name + '.in', 'r') as f_in: 4 | def read_string(): 5 | return f_in.readline().strip() 6 | 7 | 8 | def read_ints(): 9 | return map(int, read_string().split()) 10 | 11 | 12 | def read_int(): 13 | return int(read_string()) 14 | 15 | 16 | a_str, b_str, c_str = [read_string() for _ in range(3)] 17 | 18 | 19 | def get_ans(): 20 | def separate(x): 21 | x = str(x) 22 | 23 | last_zero = len(x) 24 | while last_zero - 1 > 0 and x[last_zero - 1] == '0': 25 | last_zero -= 1 26 | 27 | return int(x[:last_zero]), len(x) - last_zero 28 | 29 | a, az = separate(a_str) 30 | b, bz = separate(b_str) 31 | c, cz = separate(c_str) 32 | 33 | max_zeros = max(az, bz, cz) 34 | 35 | ans = [max_zeros - az, max_zeros - bz, max_zeros - cz] 36 | no_ans = [] 37 | 38 | # a + b = c * 10^k 39 | ab, abz = separate(a + b) 40 | if ab == c: 41 | ans[2] += abz 42 | return ans 43 | 44 | # a + b * 10^k = c 45 | if c >= a: 46 | ca, caz = separate(c - a) 47 | if ca == b: 48 | ans[1] += caz 49 | return ans 50 | 51 | # a * 10^k + b = c 52 | if b >= a: 53 | cb, cbz = separate(c - b) 54 | if cb == a: 55 | ans[0] += cbz 56 | return ans 57 | 58 | return no_ans 59 | 60 | 61 | ans = get_ans() 62 | 63 | with open(file_name + '.out', 'w') as f_out: 64 | if len(ans) == 0: 65 | f_out.write('NO' + '\n') 66 | else: 67 | f_out.write('YES' + '\n') 68 | ans_str = map(str, ans) 69 | f_out.write(' '.join(ans_str) + '\n') 70 | -------------------------------------------------------------------------------- /Codeforces/Gyms/100003/Readme.md: -------------------------------------------------------------------------------- 1 | ## Всероссийская командная олимпиада школьников по программированию 2008-2009 2 | 3 | ## [Link to Codeforces](https://codeforces.com/gym/100003) 4 | -------------------------------------------------------------------------------- /Codeforces/Gyms/101190/F.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | using ll = int64_t; 6 | using vi = vector; 7 | using vll = vector; 8 | 9 | void init_io(const string& filename) { 10 | ios::sync_with_stdio(false); 11 | cin.tie(nullptr); 12 | 13 | if (filename.size() > 0) { 14 | freopen((filename + ".in").c_str(), "rt", stdin); 15 | freopen((filename + ".out").c_str(), "wt", stdout); 16 | } 17 | 18 | cout << setprecision(10) << fixed; 19 | } 20 | 21 | void solve() { 22 | string s; 23 | cin >> s; 24 | 25 | reverse(s.begin(), s.end()); 26 | 27 | int n = s.size(); 28 | 29 | string types = "CW"; 30 | vector a(1, 0); 31 | 32 | for (auto& ch : s) { 33 | int v = types.find(ch); 34 | a.push_back(v); 35 | } 36 | 37 | vector prefs(2, vll(n + 1, 0)); 38 | 39 | for (int i = 1; i <= n; ++i) { 40 | for (int t = 0; t < types.size(); ++t) { 41 | prefs[t][i] = prefs[t][i - 1]; 42 | } 43 | 44 | prefs[a[i]][i] += i; 45 | } 46 | 47 | vector dp(n + 1, 0.0); 48 | vector pref_dp(n + 1, 0.0); 49 | for (int i = 1; i <= n; ++i) { 50 | dp[i] = pref_dp[i - 1] + prefs[1 - a[i]][i - 1]; 51 | dp[i] /= i; 52 | pref_dp[i] = pref_dp[i - 1] + dp[i]; 53 | } 54 | 55 | cout << dp[n] << endl; 56 | } 57 | 58 | int main() { 59 | init_io("foreign"); 60 | solve(); 61 | 62 | return 0; 63 | } 64 | -------------------------------------------------------------------------------- /Codeforces/Gyms/101190/Readme.md: -------------------------------------------------------------------------------- 1 | ## ICPC 2016-2017 NEERC 2 | 3 | ## [Link to Codeforces](https://codeforces.com/gym/101190) 4 | 5 | ## [Official site](https://neerc.ifmo.ru/archive/2016.html) 6 | 7 | ## [Official editorial](https://neerc.ifmo.ru/archive/2016/neerc-2016-review.pdf) 8 | -------------------------------------------------------------------------------- /Codeforces/Gyms/102777/A.py: -------------------------------------------------------------------------------- 1 | s = input() 2 | 3 | b = 0 4 | for c in s[::-1]: 5 | if c == '0': 6 | b += 1 7 | else: 8 | break 9 | 10 | print(b) 11 | -------------------------------------------------------------------------------- /Codeforces/Gyms/102777/B.py: -------------------------------------------------------------------------------- 1 | morse = [ 2 | '.-', 3 | '-...', 4 | '-.-.', 5 | '-..', 6 | '.', 7 | '..-.', 8 | '--.', 9 | '....', 10 | '..', 11 | '.---', 12 | '-.-', 13 | '.-..', 14 | '--', 15 | '-.', 16 | '---', 17 | '.--.', 18 | '--.-', 19 | '.-.', 20 | '...', 21 | '-', 22 | '..-', 23 | '...-', 24 | '.--', 25 | '-..-', 26 | '-.--', 27 | '--..' 28 | ] 29 | 30 | s = input() 31 | 32 | codes = [] 33 | for ch in s: 34 | code = morse[ord(ch) - ord('a')] 35 | codes.append(code) 36 | 37 | encoded = ''.join(codes) 38 | 39 | is_p = (encoded == encoded[::-1]) 40 | print('YES' if is_p else 'NO') 41 | 42 | -------------------------------------------------------------------------------- /Codeforces/Gyms/102777/C.py: -------------------------------------------------------------------------------- 1 | def read_ints(): 2 | return map(int, input().split()) 3 | 4 | 5 | n, m, x, y = read_ints() 6 | 7 | rainbow_size = 7 8 | d = (x - 1 + y - 1) % rainbow_size 9 | 10 | print(d + 1) 11 | 12 | -------------------------------------------------------------------------------- /Codeforces/Gyms/102777/D.py: -------------------------------------------------------------------------------- 1 | def read_ints(): 2 | return map(int, input().split()) 3 | 4 | 5 | def read_int(): 6 | return int(input()) 7 | 8 | 9 | duration = read_int() 10 | 11 | 12 | def get_answer(): 13 | m_in_h = 60 14 | h_in_day = 24 15 | m_in_day = m_in_h * h_in_day 16 | 17 | def get_digits(time): 18 | h = time // m_in_h 19 | m = time % m_in_h 20 | 21 | h1 = h // 10 22 | h2 = h % 10 23 | 24 | m1 = m // 10 25 | m2 = m % 10 26 | 27 | return (h1, h2, m1, m2) 28 | 29 | 30 | for start in range(m_in_day): 31 | end = (start + duration) % m_in_day 32 | 33 | sd = get_digits(start) 34 | ed = get_digits(end) 35 | if len(set(sd) | set(ed)) == 8: 36 | h1, h2, m1, m2 = sd 37 | return f'{h1}{h2}:{m1}{m2}' 38 | 39 | return 'PASS' 40 | 41 | 42 | ans = get_answer() 43 | print(ans) 44 | 45 | -------------------------------------------------------------------------------- /Codeforces/Gyms/102777/F.py: -------------------------------------------------------------------------------- 1 | def read_ints(): 2 | return map(int, input().split()) 3 | 4 | 5 | def read_int(): 6 | return int(input()) 7 | 8 | 9 | s = input() 10 | 11 | 12 | def get_answer(): 13 | good = [ 14 | 2, 3, 5, 7, 11, 19, 41, 61, 89, 409, 449, 499, 881, 991, 6469, 6949, 9001, 9049, 9649, 9949, 60649, 15 | 666649, 946669, 60000049, 66000049, 66600049 16 | ] 17 | good = sorted(good, reverse=True) 18 | 19 | for p in good: 20 | ps = str(p) 21 | 22 | removed = [] 23 | pi = 0 24 | for i in range(len(s)): 25 | if pi < len(ps) and s[i] == ps[pi]: 26 | pi += 1 27 | else: 28 | removed.append(i) 29 | 30 | if pi == len(ps): 31 | if len(removed) == 0: 32 | removed = [-1] 33 | 34 | return p, removed 35 | 36 | raise Exception("IDK") 37 | 38 | 39 | p, removed = get_answer() 40 | print(p) 41 | print(*removed) 42 | 43 | -------------------------------------------------------------------------------- /Codeforces/Gyms/102777/G_dfs.py: -------------------------------------------------------------------------------- 1 | from typing import List 2 | 3 | 4 | def read_ints(): 5 | return map(int, input().split()) 6 | 7 | 8 | def read_int(): 9 | return int(input()) 10 | 11 | 12 | n, e_count = read_ints() 13 | edges = [tuple(read_ints()) for _ in range(e_count)] 14 | 15 | graph = [[] for _ in range(n)] 16 | for a, b in edges: 17 | graph[a].append(b) 18 | graph[b].append(a) 19 | 20 | 21 | def dfs(v, used): 22 | if used[v]: 23 | return 0 24 | 25 | used[v] = True 26 | 27 | cnt = 1 28 | for v_to in graph[v]: 29 | cnt += dfs(v_to, used) 30 | return cnt 31 | 32 | ans = 0 33 | 34 | used = [False] * n 35 | for v in range(n): 36 | if dfs(v, used) > 1: 37 | ans += 1 38 | 39 | print(ans) 40 | 41 | -------------------------------------------------------------------------------- /Codeforces/Gyms/102777/G_dsu.py: -------------------------------------------------------------------------------- 1 | from typing import List 2 | 3 | 4 | def read_ints(): 5 | return map(int, input().split()) 6 | 7 | 8 | def read_int(): 9 | return int(input()) 10 | 11 | 12 | n, e_count = read_ints() 13 | edges = [tuple(read_ints()) for _ in range(e_count)] 14 | 15 | 16 | class DSU: 17 | __slots__ = [ 18 | 'parents', 19 | 'sizes', 20 | ] 21 | 22 | parents: List[int] 23 | sizes: List[int] 24 | 25 | def __init__(self, n): 26 | self.parents = list(range(n)) 27 | self.sizes = [1] * n 28 | 29 | def _get(self, v): 30 | if v == self.parents[v]: 31 | return v 32 | 33 | return self._get(self.parents[v]) 34 | 35 | def merge(self, a, b): 36 | a = self._get(a) 37 | b = self._get(b) 38 | 39 | if a == b: 40 | return 41 | 42 | if self.sizes[a] < self.sizes[b]: 43 | a, b = b, a 44 | 45 | self.parents[b] = a 46 | self.sizes[a] += self.sizes[b] 47 | 48 | def is_group(self, v): 49 | return v == self._get(v) and self.sizes[v] > 1 50 | 51 | 52 | dsu = DSU(n) 53 | for a, b in edges: 54 | dsu.merge(a, b) 55 | 56 | ans = 0 57 | for v in range(n): 58 | if dsu.is_group(v): 59 | ans += 1 60 | 61 | print(ans) 62 | 63 | -------------------------------------------------------------------------------- /Codeforces/Gyms/102777/H_formula.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | using ll = int64_t; 6 | 7 | const mod = 1e9 + 7; 8 | 9 | ll binpow(ll base, ll power) { 10 | if (power == 0) { 11 | return 1; 12 | } 13 | 14 | auto half = binpow(base, power >> 1); 15 | auto res = half * half; 16 | if (power % 2 == 1) { 17 | res = res * base; 18 | } 19 | 20 | return res; 21 | } 22 | 23 | ll normalize(ll& x) { 24 | x %= mod; 25 | if (x < 0) x += mod; 26 | return x; 27 | } 28 | 29 | int main() { 30 | ll n; 31 | cin >> n; 32 | 33 | auto get_answer = [&]() { 34 | ll res = -2 * (1 + 1) * n + 5 * binpow(3, n) - 3 * 1 - 5; 35 | res -= 13 * (n % 2 ? -1 : 1); 36 | 37 | normalize(res); 38 | s 39 | res *= binpow(16, mod - 2); 40 | 41 | return normalize(res); 42 | } 43 | 44 | cout << get_answer() << "\n"; 45 | 46 | return 0; 47 | } 48 | -------------------------------------------------------------------------------- /Codeforces/Gyms/102777/H_generator.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | using ll = int64_t; 6 | 7 | int main() { 8 | ios::sync_with_stdio(false); 9 | cin.tie(nullptr); 10 | 11 | int max_n = 1e9 + 1; 12 | ll mod = 1e9 + 7; 13 | 14 | int block = 1e6; 15 | 16 | ll fp2 = 1, fpp3 = 1; 17 | for (int i = 3, it = 3; i < max_n; ++i, ++it) { 18 | ll f = 2 * fp2 + 3 * fpp3 + i; 19 | f %= mod; 20 | 21 | if (it == 3) { 22 | cout << ", " << fpp3 << ", " << fp2; 23 | } 24 | 25 | if (it == block) { 26 | it = 0; 27 | } 28 | 29 | 30 | fpp3 = fp2; 31 | fp2 = f; 32 | } 33 | 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /Codeforces/Gyms/102777/I.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | using ll = int64_t; 6 | 7 | class BinaryJumps { 8 | private: 9 | vector> jumps; 10 | int log_2; 11 | 12 | public: 13 | BinaryJumps(vector& base_jumps, ll max_steps) { 14 | log_2 = 0; 15 | while ((1LL << log_2) <= max_steps) ++log_2; 16 | 17 | int n = base_jumps.size(); 18 | jumps.assign(log_2, vector(n + 1, 0)); 19 | 20 | for (int v = 0; v < n; ++v) { 21 | jumps[0][v + 1] = base_jumps[v]; 22 | } 23 | 24 | for (int b = 0; b + 1 < log_2; ++b) { 25 | for (int v = 0; v < jumps[b].size(); ++v) { 26 | int p = jumps[b][v]; 27 | jumps[b + 1][v] = jumps[b][p]; 28 | } 29 | } 30 | } 31 | 32 | int jump(int v, ll steps) { 33 | for (int b = log_2; b >= 0; --b) { 34 | ll cur_step = (1LL << b); 35 | if (steps >= cur_step) { 36 | steps -= cur_step; 37 | v = jumps[b][v]; 38 | } 39 | } 40 | 41 | return v; 42 | } 43 | }; 44 | 45 | int main() { 46 | ios::sync_with_stdio(false); 47 | cin.tie(nullptr); 48 | 49 | int n, q; 50 | cin >> n >> q; 51 | 52 | vector lefts(n); 53 | for (int& v : lefts) cin >> v; 54 | 55 | vector rights(n); 56 | for (int& v : rights) cin >> v; 57 | 58 | ll max_steps = 1e15; 59 | BinaryJumps lj(lefts, max_steps); 60 | BinaryJumps rj(rights, max_steps); 61 | 62 | while (q --> 0){ 63 | int x; 64 | ll a, b; 65 | int c; 66 | 67 | cin >> x >> a >> b >> c; 68 | 69 | if (c == 0) { 70 | x = lj.jump(x, a); 71 | x = rj.jump(x, b); 72 | } else { 73 | x = rj.jump(x, b); 74 | x = lj.jump(x, a); 75 | } 76 | 77 | cout << x << "\n"; 78 | } 79 | 80 | return 0; 81 | } 82 | -------------------------------------------------------------------------------- /Codeforces/Gyms/102777/J.py: -------------------------------------------------------------------------------- 1 | def read_int(): 2 | return int(input()) 3 | 4 | 5 | def read_strings(): 6 | return input().split() 7 | 8 | 9 | def read_ints(): 10 | return map(int, read_strings()) 11 | 12 | 13 | n, m, k = read_ints() 14 | 15 | def get_answer(n, m, k): 16 | k += 1 17 | 18 | if n > m: 19 | n, m = m, n 20 | 21 | lw = 0 22 | rw = (n - 1) // 2 + 1 23 | 24 | while rw - lw > 1: 25 | mw = (lw + rw) // 2 26 | 27 | cnt = 2 * mw * (n + m - 2 * mw) 28 | if cnt < k: 29 | lw = mw 30 | else: 31 | rw = mw 32 | 33 | k -= 2 * lw * (n + m - 2 * lw) 34 | 35 | lx, ly = rw, rw 36 | rx, ry = n - lx + 1, m - ly + 1 37 | 38 | cx, cy = lx, ly - 1 39 | 40 | delta = min(ry - cy, k) 41 | cy += delta 42 | k -= delta 43 | 44 | delta = min(rx - cx, k) 45 | cx += delta 46 | k -= delta 47 | 48 | delta = min(cy - ly, k) 49 | cy -= delta 50 | k -= delta 51 | 52 | delta = min(cx - lx, k) 53 | cx -= delta 54 | k -= delta 55 | 56 | d = cx + cy - 2 57 | color = d % 7 58 | return color + 1 59 | 60 | 61 | ans = get_answer(n, m, k) 62 | print(ans) 63 | 64 | -------------------------------------------------------------------------------- /Codeforces/Gyms/102777/K.py: -------------------------------------------------------------------------------- 1 | def read_int(): 2 | return int(input()) 3 | 4 | 5 | def read_strings(): 6 | return input().split() 7 | 8 | 9 | def read_ints(): 10 | return map(int, read_strings()) 11 | 12 | 13 | max_n = 10**6 + 1 14 | dp = list(range(max_n)) 15 | 16 | for d in range(1, max_n): 17 | dp[d] = min(dp[d], dp[d - 1] + 1) 18 | for x in range(2 * d, min((d + 1) * d, max_n), d): 19 | dp[x] = min(dp[x], dp[d] + 1) 20 | 21 | q = read_int() 22 | queries = [read_int() for _ in range(q)] 23 | 24 | for n in queries: 25 | print(dp[n]) 26 | 27 | -------------------------------------------------------------------------------- /Codeforces/Gyms/102777/Readme.md: -------------------------------------------------------------------------------- 1 | ## Qualification contest to ICPC 2019 Central Russia Regional Contest 2 | 3 | ## [Link to Codeforces](https://codeforces.com/gym/102777) 4 | 5 | ## [My editorial](https://drive.google.com/file/d/1RDwgVwHh_uIB5mVQhF6-3rTyO0GSZ9T3/) 6 | -------------------------------------------------------------------------------- /Codeforces/Gyms/103993/A.py: -------------------------------------------------------------------------------- 1 | def read_ints(): 2 | return map(int, input().split()) 3 | 4 | 5 | n, a, b, d = read_ints() 6 | 7 | b = min(b, a * d) 8 | 9 | left_start = n - n % d 10 | left_ans = (left_start // d) * b + (n - left_start) * a 11 | 12 | right_start = left_start + d 13 | right_ans = (right_start // d) * b + (right_start - n) * a 14 | 15 | ans = min(left_ans, right_ans) 16 | print(ans) 17 | -------------------------------------------------------------------------------- /Codeforces/Gyms/103993/B.py: -------------------------------------------------------------------------------- 1 | def read_ints(): 2 | return map(int, input().split()) 3 | 4 | 5 | def read_int(): 6 | return int(input()) 7 | 8 | 9 | t = read_int() 10 | for _ in range(t): 11 | n = read_int() 12 | 13 | p = [0] * n 14 | p[0] = 1 15 | for i in range(1, n): 16 | p[i] = n - i + 1 17 | 18 | print(*p) 19 | -------------------------------------------------------------------------------- /Codeforces/Gyms/103993/C.py: -------------------------------------------------------------------------------- 1 | def read_ints(): 2 | return map(int, input().split()) 3 | 4 | 5 | def read_int(): 6 | return int(input()) 7 | 8 | 9 | n, k = read_ints() 10 | s = input() 11 | 12 | rev = False 13 | 14 | left, right = 0, n - 1 15 | for _ in range(k): 16 | if s[left] != s[right]: 17 | rev = not rev 18 | left += 1 19 | right -= 1 20 | 21 | if rev: 22 | s = s[::-1] 23 | 24 | print(s[left:right + 1]) 25 | -------------------------------------------------------------------------------- /Codeforces/Gyms/103993/D.py: -------------------------------------------------------------------------------- 1 | def read_ints(): 2 | return map(int, input().split()) 3 | 4 | 5 | def read_int(): 6 | return int(input()) 7 | 8 | 9 | n = read_int() 10 | removed = list(str(digit) for digit in read_ints()) 11 | 12 | ans = 0 13 | 14 | password_length = 6 15 | for i in range(10**password_length): 16 | password = str(i) 17 | while len(password) < 6: 18 | password = '0' + password 19 | 20 | can = True 21 | for digit in password: 22 | if digit in removed: 23 | can = False 24 | 25 | if len(set(password)) != 2: 26 | can = False 27 | 28 | password = ''.join(sorted(password)) 29 | 30 | left_half = int(password[:password_length // 2]) 31 | right_half = int(password[password_length // 2:]) 32 | 33 | if left_half % 111 != 0 or right_half % 111 != 0: 34 | can = False 35 | 36 | if can: 37 | ans += 1 38 | 39 | print(ans) -------------------------------------------------------------------------------- /Codeforces/Gyms/103993/E.py: -------------------------------------------------------------------------------- 1 | def read_ints(): 2 | return map(int, input().split()) 3 | 4 | 5 | def read_int(): 6 | return int(input()) 7 | 8 | 9 | n, d = read_ints() 10 | a = list(read_ints()) 11 | 12 | for start in range(d): 13 | values = [] 14 | for i in range(start, n, d): 15 | values.append(a[i]) 16 | values.sort() 17 | 18 | j = 0 19 | for i in range(start, n, d): 20 | a[i] = values[j] 21 | j += 1 22 | 23 | can = a == sorted(a) 24 | print('YES' if can else 'NO') 25 | -------------------------------------------------------------------------------- /Codeforces/Gyms/103993/F.py: -------------------------------------------------------------------------------- 1 | def read_ints(): 2 | return map(int, input().split()) 3 | 4 | 5 | def read_int(): 6 | return int(input()) 7 | 8 | 9 | n = read_int() 10 | covered = list(ch == '1' for ch in input()) 11 | covered.insert(0, False) 12 | 13 | costs = list(read_ints()) 14 | costs.insert(0, 0) 15 | 16 | COVERED = 1 17 | NOT_COVERED = 0 18 | 19 | neg_inf = -10**18 20 | dp = [[neg_inf] * (n + 1) for _ in range(2)] 21 | 22 | dp[NOT_COVERED][0] = 0 23 | for i in range(1, n + 1): 24 | if covered[i]: 25 | dp[NOT_COVERED][i] = max( 26 | dp[NOT_COVERED][i], 27 | dp[NOT_COVERED][i - 1] + costs[i - 1] 28 | ) 29 | 30 | dp[COVERED][i] = max( 31 | dp[COVERED][i], 32 | dp[COVERED][i - 1] + costs[i] 33 | ) 34 | 35 | dp[COVERED][i] = max( 36 | dp[COVERED][i], 37 | dp[NOT_COVERED][i - 1] + costs[i] 38 | ) 39 | else: 40 | dp[NOT_COVERED][i] = max( 41 | dp[NOT_COVERED][i], 42 | dp[NOT_COVERED][i - 1] 43 | ) 44 | 45 | dp[NOT_COVERED][i] = max( 46 | dp[NOT_COVERED][i], 47 | dp[COVERED][i - 1] 48 | ) 49 | 50 | ans = max(dp[NOT_COVERED][n], dp[COVERED][n]) 51 | print(ans) 52 | -------------------------------------------------------------------------------- /Codeforces/Gyms/103993/G.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | using ll = int64_t; 6 | 7 | int main() { 8 | int n; 9 | cin >> n; 10 | 11 | vector a(n); 12 | for (auto& v : a) cin >> v; 13 | 14 | multiset ms(a.begin(), a.end()); 15 | for (int it = 0; it < n - 1; ++it) { 16 | auto left_it = ms.begin(); 17 | auto right_it = prev(ms.end()); 18 | 19 | ll new_score = (*left_it + *right_it) / 2; 20 | ms.erase(left_it); 21 | ms.erase(right_it); 22 | ms.insert(new_score); 23 | } 24 | 25 | ll ans = *ms.begin(); 26 | cout << ans << "\n"; 27 | 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /Codeforces/Gyms/103993/H.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | using ll = int64_t; 6 | 7 | int main() { 8 | int n, last_page; 9 | cin >> n >> last_page; 10 | 11 | int first_page = 1; 12 | 13 | vector> already_read(n); 14 | for (auto& student : already_read) { 15 | cin >> student.first >> student.second; 16 | } 17 | 18 | const int START = 0, CHECK = 1, END = 2; 19 | 20 | vector> events; 21 | events.emplace_back(first_page, CHECK); 22 | events.emplace_back(last_page, CHECK); 23 | 24 | for (auto& [student_first, student_last] : already_read) { 25 | if (student_first > first_page) { 26 | events.emplace_back(student_first - 1, CHECK); 27 | } 28 | events.emplace_back(student_first, START); 29 | events.emplace_back(student_last, END); 30 | if (student_last < last_page) { 31 | events.emplace_back(student_last + 1, CHECK); 32 | } 33 | } 34 | 35 | sort(events.begin(), events.end()); 36 | 37 | int first_not_checked = last_page + 1; 38 | int last_not_checked = first_page - 1; 39 | 40 | int open = 0; 41 | for (auto& [page, status] : events) { 42 | if (START == status) { 43 | open++; 44 | } 45 | if (CHECK == status) { 46 | if (0 == open) { 47 | first_not_checked = min(first_not_checked, page); 48 | last_not_checked = max(last_not_checked, page); 49 | } 50 | } 51 | if (END == status) { 52 | open--; 53 | } 54 | } 55 | 56 | int ans = max(0, last_not_checked - first_not_checked + 1); 57 | cout << ans << "\n"; 58 | 59 | return 0; 60 | } 61 | -------------------------------------------------------------------------------- /Codeforces/Gyms/103993/I.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | using ll = int64_t; 6 | 7 | int main() { 8 | int n, need; 9 | ll last_x; 10 | cin >> n >> need >> last_x; 11 | 12 | vector stands(n); 13 | for (auto& x : stands) cin >> x; 14 | sort(stands.begin(), stands.end()); 15 | 16 | ll first_x = 0; 17 | 18 | auto can = [&](ll power) { 19 | ll max_light_x = first_x + power; 20 | ll max_covered = -1; 21 | 22 | int used = 0; 23 | int last_possible = -1; 24 | for (int x : stands) { 25 | if (x <= max_light_x) { 26 | last_possible = x; 27 | } else { 28 | if (last_possible > max_light_x) return false; 29 | 30 | ++used; 31 | max_covered = last_possible + power; 32 | max_light_x = max_covered + power; 33 | last_possible = x; 34 | } 35 | } 36 | 37 | if (max_covered < last_x && last_possible <= max_light_x) { 38 | ++used; 39 | max_covered = last_possible + power; 40 | max_light_x = max_covered + power; 41 | last_possible = -1; 42 | } 43 | 44 | return used <= need && max_covered >= last_x; 45 | }; 46 | 47 | ll left = 0, right = last_x; 48 | while (right - left > 1) { 49 | ll mid = (left + right) / 2; 50 | 51 | if (can(mid)) right = mid; 52 | else left = mid; 53 | } 54 | 55 | cout << right << "\n"; 56 | 57 | return 0; 58 | } 59 | -------------------------------------------------------------------------------- /Codeforces/Gyms/103993/J.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | using ll = int64_t; 6 | 7 | int main() { 8 | int n; 9 | cin >> n; 10 | 11 | string s; 12 | cin >> s; 13 | 14 | auto get_answer = [&]() { 15 | const int one = '1', zero = '0'; 16 | 17 | int first_one = -1; 18 | for (int i = 0; i < n; ++i) { 19 | if (one == s[i]) { 20 | first_one = i; 21 | break; 22 | } 23 | } 24 | 25 | if (-1 == first_one) { 26 | return string(1, '0'); 27 | } 28 | 29 | string large_s = s.substr(first_one, n - first_one); 30 | 31 | int first_zero_after = -1; 32 | for (int i = 0; i < large_s.size(); ++i) { 33 | if (zero == large_s[i]) { 34 | first_zero_after = i; 35 | break; 36 | } 37 | } 38 | 39 | if (first_zero_after == -1) { 40 | return large_s; 41 | } 42 | 43 | vector large(large_s.size()); 44 | for (int i = 0; i < large.size(); ++i) large[i] = large_s[i] - zero; 45 | 46 | vector best = large; 47 | for (int start = 0; start < first_zero_after; ++start) { 48 | vector cur = large; 49 | for (int i = first_zero_after, j = start; i < large.size(); ++i, ++j) { 50 | cur[i] |= large[j]; 51 | } 52 | best = max(best, cur); 53 | } 54 | 55 | string best_s; 56 | for (int bit : best) best_s += (char)(bit + zero); 57 | 58 | return best_s; 59 | }; 60 | 61 | cout << get_answer() << "\n"; 62 | 63 | return 0; 64 | } 65 | -------------------------------------------------------------------------------- /Codeforces/Gyms/103993/Readme.md: -------------------------------------------------------------------------------- 1 | ## ICPC 2022 Southern and Volga Russia Qualification Contest 2 | 3 | ## [Link to Codeforces](https://codeforces.com/gym/103993) 4 | -------------------------------------------------------------------------------- /Codeforces/Rounds/494 (1003)/D.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | using namespace std; 7 | 8 | typedef vector vi; 9 | typedef long long ll; 10 | 11 | const char SPACE = ' ', ENDL = '\n'; 12 | 13 | int ri() { 14 | int v; 15 | cin >> v; 16 | return v; 17 | } 18 | 19 | vi rvi(int n) { 20 | vi a(n); 21 | for (int i = 0; i < n; ++i) cin >> a[i]; 22 | return a; 23 | } 24 | 25 | int main() { 26 | ios::sync_with_stdio(false); 27 | cin.tie(nullptr); 28 | cout.tie(nullptr); 29 | 30 | #ifndef ONLINE_JUDGE 31 | freopen("input.txt", "r", stdin); 32 | freopen("output.txt", "w", stdout); 33 | #endif 34 | 35 | int tests = 36 | #ifdef ONLINE_JUDGE 37 | 1; 38 | #else 39 | ri(); 40 | #endif 41 | 42 | /* 43 | #greedy 44 | #binary representation 45 | */ 46 | 47 | for (int t = 0; t < tests; ++t) { 48 | int n = ri(); 49 | int q = ri(); 50 | vi a = rvi(n); 51 | 52 | vi cnt(32, 0); 53 | for (int v : a) { 54 | int d = 0; 55 | while (v > 1) { 56 | v /= 2; 57 | ++d; 58 | } 59 | 60 | cnt[d]++; 61 | } 62 | 63 | while (q-- > 0) { 64 | int query = ri(); 65 | 66 | int ans = 0; 67 | for (int d = 30; d >= 0; --d) { 68 | int t = query / (1 << d); 69 | t = min(t, cnt[d]); 70 | 71 | query -= t * (1 << d); 72 | ans += t; 73 | } 74 | 75 | if (query != 0) { 76 | cout << -1; 77 | } 78 | else { 79 | cout << ans; 80 | } 81 | 82 | cout << ENDL; 83 | } 84 | } 85 | 86 | return 0; 87 | } -------------------------------------------------------------------------------- /Codeforces/Rounds/521 (1077)/D.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | using namespace std; 7 | 8 | typedef vector vi; 9 | typedef long long ll; 10 | 11 | const char SPACE = ' ', ENDL = '\n'; 12 | 13 | int ri() { 14 | int v; 15 | cin >> v; 16 | return v; 17 | } 18 | 19 | vi rvi(int n) { 20 | vi a(n); 21 | for (int i = 0; i < n; ++i) cin >> a[i]; 22 | return a; 23 | } 24 | 25 | int main() { 26 | ios::sync_with_stdio(false); 27 | cin.tie(nullptr); 28 | cout.tie(nullptr); 29 | 30 | #ifndef ONLINE_JUDGE 31 | freopen("input.txt", "r", stdin); 32 | freopen("output.txt", "w", stdout); 33 | #endif 34 | 35 | int tests = 36 | #ifdef ONLINE_JUDGE 37 | 1; 38 | #else 39 | ri(); 40 | #endif 41 | 42 | /* 43 | #array 44 | #counting 45 | #binary search 46 | */ 47 | 48 | for (int t = 0; t < tests; ++t) { 49 | int n = ri(); 50 | int k = ri(); 51 | vi a = rvi(n); 52 | 53 | vi cnt(2e5 + 1, 0); 54 | for (int v : a) cnt[v]++; 55 | 56 | int left = 0, right = n + 1; 57 | while (right - left > 1) { 58 | int mid = (left + right) / 2; 59 | 60 | int size = 0; 61 | for (int v = 0; v <= 2e5; ++v) { 62 | size += cnt[v] / mid; 63 | } 64 | 65 | if (size >= k) { 66 | left = mid; 67 | } 68 | else { 69 | right = mid; 70 | } 71 | } 72 | 73 | vi ans; 74 | for (int v = 0; v <= 2e5; ++v) { 75 | int delta = cnt[v] / left; 76 | delta = min(delta, k); 77 | 78 | for (int j = 0; j < delta; ++j) { 79 | ans.push_back(v); 80 | } 81 | 82 | k -= delta; 83 | } 84 | 85 | for (int v : ans) { 86 | cout << v << SPACE; 87 | } 88 | cout << ENDL; 89 | } 90 | 91 | return 0; 92 | } -------------------------------------------------------------------------------- /Codeforces/Rounds/555 (1157)/B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace std; 8 | 9 | typedef vector vi; 10 | typedef long long ll; 11 | 12 | const char SPACE = ' ', ENDL = '\n'; 13 | 14 | int ri() { 15 | int v; 16 | cin >> v; 17 | return v; 18 | } 19 | 20 | vi rvi(int n) { 21 | vi a(n); 22 | for (int i = 0; i < n; ++i) cin >> a[i]; 23 | return a; 24 | } 25 | 26 | int main() { 27 | ios::sync_with_stdio(false); 28 | cin.tie(nullptr); 29 | cout.tie(nullptr); 30 | 31 | #ifndef ONLINE_JUDGE 32 | freopen("input.txt", "r", stdin); 33 | freopen("output.txt", "w", stdout); 34 | #endif 35 | 36 | int tests = 37 | #ifdef ONLINE_JUDGE 38 | 1; 39 | #else 40 | ri(); 41 | #endif 42 | 43 | /* 44 | #long arithmetic 45 | */ 46 | 47 | for (int t = 0; t < tests; ++t) { 48 | int n = ri(); 49 | 50 | string a; 51 | cin >> a; 52 | 53 | vi f = rvi(9); 54 | f.insert(f.begin(), 0); 55 | 56 | for (int i = 0; i < n; ++i) { 57 | int d = a[i] - '0'; 58 | if (d < f[d]) { 59 | for (int j = i; j < n; ++j) { 60 | int dd = a[j] - '0'; 61 | if (dd <= f[dd]) { 62 | a[j] = (char)(f[dd] + '0'); 63 | } 64 | else { 65 | break; 66 | } 67 | } 68 | 69 | break; 70 | } 71 | } 72 | 73 | cout << a << endl; 74 | } 75 | 76 | return 0; 77 | } -------------------------------------------------------------------------------- /Codeforces/Rounds/799 (1692)/E.cpp: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | 4 | using namespace std; 5 | 6 | void init_io() { 7 | ios::sync_with_stdio(false); 8 | cin.tie(nullptr); 9 | 10 | cout << setprecision(10) << fixed; 11 | } 12 | 13 | using ll = int64_t; 14 | 15 | void solve_test() { 16 | int n, s; 17 | cin >> n >> s; 18 | 19 | vector a(n); 20 | for (int& v : a) cin >> v; 21 | 22 | auto get_ans = [&]() { 23 | vector pref(n + 1, 0); 24 | for (int i = 0; i < n; ++i) { 25 | pref[i + 1] = pref[i] + a[i]; 26 | } 27 | 28 | vector lefts(n + 1, n + 1); 29 | vector rights(n + 1, -1); 30 | 31 | for (int i = 0; i <= n; ++i) { 32 | rights[pref[i]] = i; 33 | } 34 | 35 | for (int i = n; i >= 0; --i) { 36 | lefts[pref[i]] = i; 37 | } 38 | 39 | int best = 0; 40 | for (int rs = s; rs <= n; ++rs) { 41 | int ls = rs - s; 42 | 43 | int cur = rights[rs] - lefts[ls]; 44 | best = max(best, cur); 45 | } 46 | 47 | if (0 == best) return -1; 48 | return n - best; 49 | }; 50 | 51 | cout << get_ans() << "\n"; 52 | } 53 | 54 | int main() { 55 | init_io(); 56 | 57 | int t; 58 | cin >> t; 59 | 60 | while (t --> 0) { 61 | solve_test(); 62 | } 63 | 64 | return 0; 65 | } 66 | -------------------------------------------------------------------------------- /Codeforces/Rounds/799 (1692)/H.cpp: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | 4 | using namespace std; 5 | 6 | void init_io() { 7 | ios::sync_with_stdio(false); 8 | cin.tie(nullptr); 9 | 10 | cout << setprecision(10) << fixed; 11 | } 12 | 13 | using ll = int64_t; 14 | 15 | void solve_test() { 16 | int n; 17 | cin >> n; 18 | 19 | vector a(n); 20 | for (int& v : a) cin >> v; 21 | 22 | int inf = numeric_limits::max(); 23 | 24 | map> value_to_min_d; 25 | map value_to_cnt; 26 | 27 | for (int v : a) { 28 | value_to_min_d[v] = { inf, -1 }; 29 | value_to_cnt[v] = 0; 30 | } 31 | 32 | ll ans = -inf; 33 | pair> ans_triple = { -1, { -1, -1 } }; 34 | 35 | for (int i = 0; i < n; ++i) { 36 | int v = a[i]; 37 | 38 | value_to_cnt[v]++; 39 | int cnt = value_to_cnt[v]; 40 | 41 | int d = 2 * cnt - i; 42 | 43 | auto d_i = pair(d, i); 44 | value_to_min_d[v] = min(value_to_min_d[v], d_i); 45 | 46 | auto& [min_d, min_i] = value_to_min_d[v]; 47 | 48 | ll cur_sum = d - min_d + 1; 49 | if (ans < cur_sum) { 50 | ans = cur_sum; 51 | ans_triple = { v, { min_i, i } }; 52 | } 53 | } 54 | 55 | auto& [ans_v, ans_lr] = ans_triple; 56 | auto& [ans_l, ans_r] = ans_lr; 57 | 58 | cout << ans_v << " " << ans_l + 1 << " " << ans_r + 1 << "\n"; 59 | } 60 | 61 | int main() { 62 | init_io(); 63 | 64 | int t; 65 | cin >> t; 66 | 67 | while (t --> 0) { 68 | solve_test(); 69 | } 70 | 71 | return 0; 72 | } 73 | -------------------------------------------------------------------------------- /Codeforces/Rounds/834 (1759)/A.py: -------------------------------------------------------------------------------- 1 | def read_int(): 2 | return int(input()) 3 | 4 | 5 | def read_ints(): 6 | return map(int, input().split()) 7 | 8 | 9 | universum = 'Yes' * 100 10 | 11 | 12 | def solve_test(): 13 | s = input() 14 | 15 | def get_ans(): 16 | return s in universum 17 | 18 | print('YES' if get_ans() else 'NO') 19 | 20 | 21 | t = read_int() 22 | for _ in range(t): 23 | solve_test() 24 | -------------------------------------------------------------------------------- /Codeforces/Rounds/834 (1759)/B.py: -------------------------------------------------------------------------------- 1 | def read_int(): 2 | return int(input()) 3 | 4 | 5 | def read_ints(): 6 | return map(int, input().split()) 7 | 8 | 9 | def solve_test(): 10 | n, s = read_ints() 11 | b = list(read_ints()) 12 | 13 | def get_ans(): 14 | if len(set(b)) != len(b): 15 | return False 16 | 17 | expected = s + sum(b) 18 | 19 | actual = 0 20 | n = 0 21 | 22 | while actual < expected: 23 | n += 1 24 | actual += n 25 | 26 | return actual == expected and n >= max(b) 27 | 28 | 29 | print("YES" if get_ans() else 'NO') 30 | 31 | 32 | t = read_int() 33 | for _ in range(t): 34 | solve_test() 35 | -------------------------------------------------------------------------------- /Codeforces/Rounds/834 (1759)/C.py: -------------------------------------------------------------------------------- 1 | def read_int(): 2 | return int(input()) 3 | 4 | 5 | def read_ints(): 6 | return map(int, input().split()) 7 | 8 | 9 | def solve_test(): 10 | l, r, x = read_ints() 11 | a, b = read_ints() 12 | 13 | def get_ans(): 14 | ids = [a, b, l, r] 15 | 16 | from collections import defaultdict 17 | g = defaultdict(list) 18 | 19 | for f in ids: 20 | for t in ids: 21 | if abs(f - t) >= x: 22 | g[f].append(t) 23 | 24 | d = defaultdict(lambda: -1) 25 | 26 | from collections import deque 27 | q = deque() 28 | 29 | d[a] = 0 30 | q.append(a) 31 | 32 | while len(q) > 0: 33 | v = q.pop() 34 | for v_to in g[v]: 35 | if d[v_to] == -1: 36 | d[v_to] = d[v] + 1 37 | q.append(v_to) 38 | 39 | return d[b] 40 | 41 | print(get_ans()) 42 | 43 | 44 | t = read_int() 45 | for _ in range(t): 46 | solve_test() 47 | -------------------------------------------------------------------------------- /Codeforces/Rounds/834 (1759)/D.py: -------------------------------------------------------------------------------- 1 | def read_int(): 2 | return int(input()) 3 | 4 | 5 | def read_ints(): 6 | return map(int, input().split()) 7 | 8 | 9 | def calc(n, p): 10 | res = 0 11 | while n % p == 0: 12 | res += 1 13 | n //= p 14 | 15 | return res 16 | 17 | 18 | def solve_test(): 19 | n, m = read_ints() 20 | 21 | def get_ans(): 22 | p2 = calc(n, 2) 23 | p5 = calc(n, 5) 24 | 25 | k = 1 26 | while p2 < p5 and k * 2 <= m: 27 | k *= 2 28 | p2 += 1 29 | 30 | while p5 < p2 and k * 5 <= m: 31 | k *= 5 32 | p5 += 1 33 | 34 | while k * 10 <= m: 35 | k *= 10 36 | 37 | ans_k = m - m % k 38 | 39 | return n * ans_k 40 | 41 | print(get_ans()) 42 | 43 | 44 | t = read_int() 45 | for _ in range(t): 46 | solve_test() 47 | -------------------------------------------------------------------------------- /Codeforces/Rounds/834 (1759)/E.py: -------------------------------------------------------------------------------- 1 | def read_int(): 2 | return int(input()) 3 | 4 | 5 | def read_ints(): 6 | return map(int, input().split()) 7 | 8 | 9 | def solve_test(): 10 | n, s = read_ints() 11 | a = list(read_ints()) 12 | a = sorted(a) 13 | 14 | def get_ans(): 15 | 16 | ans = 0 17 | 18 | total = 3 19 | for i in range(total): 20 | ms = [2] * total 21 | ms[i] = 3 22 | 23 | res = 0 24 | 25 | cur = s 26 | j = 0 27 | 28 | for v in a: 29 | while j < len(ms) and cur <= v: 30 | cur *= ms[j] 31 | j += 1 32 | 33 | if cur <= v: 34 | break 35 | 36 | res += 1 37 | cur += v // 2 38 | 39 | ans = max(ans, res) 40 | 41 | return ans 42 | 43 | print(get_ans()) 44 | 45 | 46 | t = read_int() 47 | for _ in range(t): 48 | solve_test() 49 | -------------------------------------------------------------------------------- /Codeforces/Rounds/834 (1759)/F.py: -------------------------------------------------------------------------------- 1 | def read_int(): 2 | return int(input()) 3 | 4 | 5 | def read_ints(): 6 | return map(int, input().split()) 7 | 8 | 9 | def solve_test(): 10 | n, p = read_ints() 11 | x = list(read_ints()) 12 | 13 | 14 | def get_ans(): 15 | k = x[-1] 16 | 17 | seen = set(x) 18 | 19 | ld = 0 20 | while ld in seen and ld < k: 21 | ld += 1 22 | 23 | md = p - 1 24 | while md in seen and md > k: 25 | md -= 1 26 | 27 | if ld == k: 28 | return md - k 29 | 30 | # x += p - k 31 | last_not_max = n - 2 32 | while last_not_max >= 0 and x[last_not_max] == p - 1: 33 | last_not_max -= 1 34 | 35 | if last_not_max < 0: 36 | x.insert(0, 0) 37 | last_not_max += 1 38 | 39 | x[last_not_max] += 1 40 | for i in range(last_not_max + 1, len(x)): 41 | x[i] = 0 42 | 43 | for d in x: 44 | seen.add(d) 45 | 46 | nd = k - 1 47 | while nd in seen and nd >= 0: 48 | nd -= 1 49 | 50 | return p - k + max(0, nd) 51 | 52 | print(get_ans()) 53 | 54 | 55 | t = read_int() 56 | for _ in range(t): 57 | solve_test() 58 | -------------------------------------------------------------------------------- /Codeforces/Rounds/834 (1759)/G.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | void solve_test() { 6 | int n; 7 | cin >> n; 8 | 9 | vector b(n / 2); 10 | for (auto& v : b) cin >> v; 11 | 12 | auto get_ans = [&]() { 13 | vector no_ans = { -1 }; 14 | 15 | set b_tree(b.begin(), b.end()); 16 | if (b_tree.size() != b.size()) return no_ans; 17 | 18 | set> free; 19 | for (int i = 1; i <= n; ++i) free.insert(i); 20 | for (int v : b) free.erase(v); 21 | 22 | vector p; 23 | 24 | reverse(b.begin(), b.end()); 25 | for (int v : b) { 26 | auto it = free.upper_bound(v); 27 | if (it == free.end()) { 28 | return no_ans; 29 | } 30 | 31 | p.push_back(v); 32 | p.push_back(*it); 33 | free.erase(it); 34 | } 35 | 36 | reverse(p.begin(), p.end()); 37 | return p; 38 | }; 39 | 40 | auto ans = get_ans(); 41 | for (auto& v : ans) cout << v << " "; 42 | cout << "\n"; 43 | } 44 | 45 | int main() { 46 | int t; 47 | cin >> t; 48 | 49 | while (t --> 0) { 50 | solve_test(); 51 | } 52 | 53 | return 0; 54 | } 55 | -------------------------------------------------------------------------------- /Codeforces/Rounds/834 (1759)/Readme.md: -------------------------------------------------------------------------------- 1 | ## Codeforces Round 834 (Div. 3) 2 | 3 | ## [Link to Codeforces](https://codeforces.com/contest/1759) 4 | -------------------------------------------------------------------------------- /Codeforces/Rounds/835 (1760)/A.py: -------------------------------------------------------------------------------- 1 | from threading import stack_size 2 | 3 | mb = 1024 * 1024 4 | stack_size(128 * mb) 5 | 6 | 7 | def read_int(): 8 | return int(input()) 9 | 10 | 11 | def read_ints(): 12 | return map(int, input().split()) 13 | 14 | 15 | def solve_test(): 16 | a = list(read_ints()) 17 | 18 | ans = sum(a) - min(a) - max(a) 19 | print(ans) 20 | 21 | 22 | tests = read_int() 23 | for test in range(tests): 24 | solve_test() 25 | -------------------------------------------------------------------------------- /Codeforces/Rounds/835 (1760)/B.py: -------------------------------------------------------------------------------- 1 | from threading import stack_size 2 | 3 | mb = 1024 * 1024 4 | stack_size(128 * mb) 5 | 6 | 7 | def read_int(): 8 | return int(input()) 9 | 10 | 11 | def read_ints(): 12 | return map(int, input().split()) 13 | 14 | 15 | def solve_test(): 16 | n = read_int() 17 | text = input() 18 | 19 | max_letter = max(text) 20 | ans = ord(max_letter) - ord('a') + 1 21 | print(ans) 22 | 23 | 24 | tests = read_int() 25 | for test in range(tests): 26 | solve_test() 27 | -------------------------------------------------------------------------------- /Codeforces/Rounds/835 (1760)/C.py: -------------------------------------------------------------------------------- 1 | from threading import stack_size 2 | 3 | mb = 1024 * 1024 4 | stack_size(128 * mb) 5 | 6 | 7 | def read_int(): 8 | return int(input()) 9 | 10 | 11 | def read_ints(): 12 | return map(int, input().split()) 13 | 14 | 15 | def solve_test(): 16 | n = read_int() 17 | a = list(read_ints()) 18 | 19 | neg_inf = min(a) - 1 20 | a.insert(0, neg_inf) 21 | 22 | pref_max = [neg_inf] * (n + 1) 23 | for i in range(1, n + 1): 24 | pref_max[i] = max(pref_max[i - 1], a[i]) 25 | 26 | suff_max = [neg_inf] * (n + 2) 27 | for i in range(n, 0, -1): 28 | suff_max[i] = max(suff_max[i + 1], a[i]) 29 | 30 | ans = [ 31 | a[i] - max(pref_max[i - 1], suff_max[i + 1]) 32 | for i in range(1, n + 1) 33 | ] 34 | 35 | print(' '.join(map(str, ans))) 36 | 37 | 38 | tests = read_int() 39 | for test in range(tests): 40 | solve_test() 41 | -------------------------------------------------------------------------------- /Codeforces/Rounds/835 (1760)/C_2.py: -------------------------------------------------------------------------------- 1 | from threading import stack_size 2 | 3 | mb = 1024 * 1024 4 | stack_size(128 * mb) 5 | 6 | 7 | def read_int(): 8 | return int(input()) 9 | 10 | 11 | def read_ints(): 12 | return map(int, input().split()) 13 | 14 | 15 | def solve_test(): 16 | n = read_int() 17 | a = list(read_ints()) 18 | 19 | neg_inf = min(a) - 1 20 | 21 | max_score = max(a) 22 | max_index = a.index(max_score) 23 | 24 | a[max_index] = neg_inf 25 | second_max_score = max(a) 26 | a[max_index] = max_score 27 | 28 | ans = [v - max_score for v in a] 29 | ans[max_index] = max_score - second_max_score 30 | 31 | print(' '.join(map(str, ans))) 32 | 33 | 34 | tests = read_int() 35 | for test in range(tests): 36 | solve_test() 37 | -------------------------------------------------------------------------------- /Codeforces/Rounds/835 (1760)/D.py: -------------------------------------------------------------------------------- 1 | from threading import stack_size 2 | 3 | mb = 1024 * 1024 4 | stack_size(128 * mb) 5 | 6 | 7 | def read_int(): 8 | return int(input()) 9 | 10 | 11 | def read_ints(): 12 | return map(int, input().split()) 13 | 14 | 15 | def solve_test(): 16 | n = read_int() 17 | a = list(read_ints()) 18 | 19 | inf = max(a) + 1 20 | 21 | a.insert(0, inf) 22 | a.append(inf) 23 | 24 | min_value = min(a) 25 | min_index = a.index(min_value) 26 | 27 | pref_decreasing = True 28 | for i in range(min_index): 29 | pref_decreasing &= a[i] >= a[i + 1] 30 | 31 | suff_increasing = True 32 | for i in range(min_index, len(a) - 1): 33 | suff_increasing &= a[i] <= a[i + 1] 34 | 35 | good = pref_decreasing and suff_increasing 36 | print('YES' if good else 'NO') 37 | 38 | 39 | tests = read_int() 40 | for test in range(tests): 41 | solve_test() 42 | -------------------------------------------------------------------------------- /Codeforces/Rounds/835 (1760)/E.py: -------------------------------------------------------------------------------- 1 | from threading import stack_size 2 | 3 | mb = 1024 * 1024 4 | stack_size(128 * mb) 5 | 6 | 7 | def read_int(): 8 | return int(input()) 9 | 10 | 11 | def read_ints(): 12 | return map(int, input().split()) 13 | 14 | 15 | def solve_test(): 16 | n = read_int() 17 | a = list(read_ints()) 18 | 19 | pref_ones = [0] * (n + 1) 20 | for i in range(n): 21 | pref_ones[i + 1] = pref_ones[i] + a[i] 22 | 23 | total = 0 24 | for i in range(n): 25 | if a[i] == 0: 26 | total += pref_ones[i] 27 | 28 | def get_01(left, right): 29 | cnt_1 = pref_ones[right] - pref_ones[left] 30 | cnt_0 = (right - left) - cnt_1 31 | return cnt_0, cnt_1 32 | 33 | best = total 34 | for i in range(n): 35 | p0, p1 = get_01(0, i) 36 | s0, s1 = get_01(i + 1, n) 37 | 38 | cur = total 39 | 40 | if a[i] == 0: 41 | cur -= p1 42 | cur += s0 43 | else: 44 | cur += p1 45 | cur -= s0 46 | 47 | best = max(best, cur) 48 | 49 | print(best) 50 | 51 | 52 | tests = read_int() 53 | for test in range(tests): 54 | solve_test() 55 | -------------------------------------------------------------------------------- /Codeforces/Rounds/835 (1760)/E_2.py: -------------------------------------------------------------------------------- 1 | from threading import stack_size 2 | 3 | mb = 1024 * 1024 4 | stack_size(128 * mb) 5 | 6 | 7 | def read_int(): 8 | return int(input()) 9 | 10 | 11 | def read_ints(): 12 | return map(int, input().split()) 13 | 14 | 15 | def solve_test(): 16 | n = read_int() 17 | a = list(read_ints()) 18 | 19 | def calc(): 20 | ones = 0 21 | inversions = 0 22 | for v in a: 23 | if v == 1: 24 | ones += 1 25 | else: 26 | inversions += ones 27 | 28 | return inversions 29 | 30 | best = calc() 31 | 32 | first_zero = -1 33 | for i, v in enumerate(a): 34 | if v == 0: 35 | first_zero = i 36 | break 37 | 38 | if first_zero != -1: 39 | a[first_zero] = 1 40 | best = max(best, calc()) 41 | a[first_zero] = 0 42 | 43 | last_one = -1 44 | for i, v in enumerate(a): 45 | if v == 1: 46 | last_one = i 47 | 48 | if last_one != -1: 49 | a[last_one] = 0 50 | best = max(best, calc()) 51 | a[last_one] = 1 52 | 53 | print(best) 54 | 55 | 56 | tests = read_int() 57 | for test in range(tests): 58 | solve_test() 59 | -------------------------------------------------------------------------------- /Codeforces/Rounds/835 (1760)/F.py: -------------------------------------------------------------------------------- 1 | from threading import stack_size 2 | 3 | mb = 1024 * 1024 4 | stack_size(128 * mb) 5 | 6 | 7 | def read_int(): 8 | return int(input()) 9 | 10 | 11 | def read_ints(): 12 | return map(int, input().split()) 13 | 14 | 15 | def solve_test(): 16 | n, need, days = read_ints() 17 | a = list(read_ints()) 18 | 19 | def get_ans(): 20 | a.sort(reverse=True) 21 | 22 | def can(delay): 23 | total = 0 24 | for day in range(days): 25 | index = day % (delay + 1) 26 | if index < n: 27 | total += a[index] 28 | 29 | return total >= need 30 | 31 | left, right = -1, days + 1 # can, can't 32 | while right - left > 1: 33 | mid = (left + right) // 2 34 | if can(mid): 35 | left = mid 36 | else: 37 | right = mid 38 | 39 | return left 40 | 41 | ans = get_ans() 42 | if ans < 0: 43 | print("Impossible") 44 | elif ans >= days: 45 | print("Infinity") 46 | else: 47 | print(ans) 48 | 49 | 50 | tests = read_int() 51 | for test in range(tests): 52 | solve_test() 53 | -------------------------------------------------------------------------------- /Codeforces/Rounds/835 (1760)/G.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | void solve_test() { 6 | int n, a, b; 7 | cin >> n >> a >> b; 8 | 9 | using edge = pair; 10 | vector> g(n + 1); 11 | 12 | for (int e = 0; e < n - 1; ++e) { 13 | int f, t, w; 14 | cin >> f >> t >> w; 15 | g[f].emplace_back(t, w); 16 | g[t].emplace_back(f, w); 17 | } 18 | 19 | auto calc_xors = [&](int start, int restricted) { 20 | vector xors; 21 | 22 | function dfs = [&](int v, int p, int path_xor) { 23 | if (v == restricted && path_xor != 0) { 24 | return; 25 | } 26 | 27 | xors.push_back(path_xor); 28 | 29 | for (auto& [to, w] : g[v]) { 30 | if (to != p) { 31 | dfs(to, v, path_xor ^ w); 32 | } 33 | } 34 | }; 35 | 36 | dfs(start, -1, 0); 37 | 38 | return xors; 39 | }; 40 | 41 | auto get_ans = [&](){ 42 | auto a_xors = calc_xors(a, b); 43 | 44 | auto b_xors = calc_xors(b, -1); 45 | b_xors.erase(b_xors.begin()); // can't teleport to b 46 | 47 | set b_set(b_xors.begin(), b_xors.end()); 48 | for (int a_xor : a_xors) { 49 | if (b_set.count(a_xor)) return true; 50 | } 51 | return false; 52 | }; 53 | 54 | bool can = get_ans(); 55 | cout << (can ? "YES" : "NO") << "\n"; 56 | } 57 | 58 | int main() { 59 | int t; 60 | cin >> t; 61 | 62 | while (t --> 0) { 63 | solve_test(); 64 | } 65 | 66 | return 0; 67 | } 68 | -------------------------------------------------------------------------------- /Codeforces/Rounds/835 (1760)/Readme.md: -------------------------------------------------------------------------------- 1 | ## Codeforces Round 835 (Div. 4) 2 | 3 | ## [Link to Codeforces](https://codeforces.com/contest/1760) 4 | -------------------------------------------------------------------------------- /Codeforces/Rounds/Educational/120 (1622)/A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int t; 5 | std::cin >> t; 6 | 7 | auto solve_test = []() { 8 | std::vector lengths(3); 9 | for (auto& length : lengths) std::cin >> length; 10 | 11 | auto can = [&]() { 12 | for (int i = 0; i < 3; ++i) { 13 | int l1 = lengths[i], l2 = lengths[(i + 1) % 3], l3 = lengths[(i + 2) % 3]; 14 | 15 | // l2 == l3, l1 = 2 * k 16 | if (l2 == l3 && l1 % 2 == 0) return true; 17 | 18 | // l1 = a + b; l2 == a, l3 == b 19 | if (l1 == l2 + l3) return true; 20 | } 21 | 22 | return false; 23 | }; 24 | 25 | bool ans = can(); 26 | std::cout << (ans ? "YES" : "NO") << "\n"; 27 | }; 28 | 29 | while (t --> 0) solve_test(); 30 | 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /Codeforces/Rounds/Educational/120 (1622)/B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int t; 5 | std::cin >> t; 6 | 7 | auto solve_test = []() { 8 | int n; 9 | std::cin >> n; 10 | 11 | std::vector p(n); 12 | for (auto& v : p) std::cin >> v; 13 | 14 | std::string s; 15 | std::cin >> s; 16 | 17 | auto get_answer = [&]() { 18 | std::vector pos(n + 1); 19 | for (int i = 0; i < n; ++i) pos[p[i]] = i; 20 | 21 | std::vector q(n); 22 | 23 | int value = 1; 24 | for (int v = 1; v <= n; ++v) { 25 | int i = pos[v]; 26 | if ('0' == s[i]) q[i] = value++; 27 | } 28 | for (int v = 1; v <= n; ++v) { 29 | int i = pos[v]; 30 | if ('1' == s[i]) q[i] = value++; 31 | } 32 | return q; 33 | }; 34 | 35 | std::vector q = get_answer(); 36 | for (int v : q) std::cout << v << " "; 37 | std::cout << "\n"; 38 | }; 39 | 40 | while (t --> 0) solve_test(); 41 | 42 | return 0; 43 | } 44 | -------------------------------------------------------------------------------- /Codeforces/Rounds/Educational/120 (1622)/C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using ll = int64_t; 4 | 5 | int main() { 6 | int t; 7 | std::cin >> t; 8 | 9 | auto solve_test = []() { 10 | int n; 11 | std::cin >> n; 12 | 13 | ll k; 14 | std::cin >> k; 15 | 16 | std::vector a(n); 17 | for (auto& v : a) std::cin >> v; 18 | 19 | auto get_answer = [&]() { 20 | std::sort(a.begin(), a.end()); 21 | 22 | std::vector pref(n + 1, 0); 23 | for (int i = 0; i < n; ++i) { 24 | pref[i + 1] = pref[i] + a[i]; 25 | } 26 | 27 | ll smallest = a.front(); 28 | ll ans = smallest + (n - 1); 29 | for (int i = 1; i <= n; ++i) { 30 | ll res = pref[i] - k + (n - i) * smallest; 31 | ll denom = (n - i + 1); 32 | 33 | if (res <= 0) res = 0; 34 | else res = (res - 1) / denom + 1; 35 | 36 | //std::cerr << i << " " << res << " " << pref[i] << " " << k << " " << (n - i) << " " << denom << "\n"; 37 | 38 | res += (n - i); 39 | if (ans > res) ans = res; 40 | } 41 | 42 | return std::max((ll)0, ans); 43 | }; 44 | 45 | ll ans = get_answer(); 46 | std::cout << ans << "\n"; 47 | }; 48 | 49 | while (t --> 0) solve_test(); 50 | 51 | return 0; 52 | } 53 | -------------------------------------------------------------------------------- /Codeforces/Rounds/Educational/25 (825)/C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | using namespace std; 7 | 8 | typedef vector vi; 9 | typedef long long ll; 10 | 11 | const char SPACE = ' ', ENDL = '\n'; 12 | 13 | int ri() { 14 | int v; 15 | cin >> v; 16 | return v; 17 | } 18 | 19 | vi rvi(int n) { 20 | vi a(n); 21 | for (int i = 0; i < n; ++i) cin >> a[i]; 22 | return a; 23 | } 24 | 25 | /** 26 | #array 27 | #sort 28 | */ 29 | 30 | int main() { 31 | ios::sync_with_stdio(false); 32 | cin.tie(nullptr); 33 | cout.tie(nullptr); 34 | 35 | #ifndef ONLINE_JUDGE 36 | freopen("input.txt", "r", stdin); 37 | freopen("output.txt", "w", stdout); 38 | #endif 39 | 40 | 41 | int tests = 42 | #ifdef ONLINE_JUDGE 43 | 1; 44 | #else 45 | ri(); 46 | #endif 47 | 48 | for (int t = 0; t < tests; ++t) { 49 | int n = ri(); 50 | ll k = ri(); 51 | vi a = rvi(n); 52 | 53 | sort(a.begin(), a.end()); 54 | 55 | int answer = 0; 56 | 57 | for (int d : a) { 58 | while (2 * k < d) { 59 | k = 2 * k; 60 | ++answer; 61 | } 62 | 63 | k = max(k, (ll)d); 64 | } 65 | 66 | cout << answer << endl; 67 | } 68 | 69 | return 0; 70 | } -------------------------------------------------------------------------------- /Codeforces/Rounds/Educational/74 (1238)/C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | using namespace std; 10 | 11 | typedef vector vi; 12 | typedef long long ll; 13 | 14 | const int MODULO = 1e9 + 7; 15 | 16 | typedef ll mod_t; 17 | 18 | const char SPACE = ' ', ENDL = '\n'; 19 | 20 | int ri() { 21 | int v; 22 | cin >> v; 23 | return v; 24 | } 25 | 26 | ll rll() { 27 | ll v; 28 | cin >> v; 29 | return v; 30 | } 31 | 32 | vi rvi(int n) { 33 | vi a(n); 34 | for (int i = 0; i < n; ++i) cin >> a[i]; 35 | return a; 36 | } 37 | 38 | int main() { 39 | ios::sync_with_stdio(false); 40 | cin.tie(nullptr); 41 | cout.tie(nullptr); 42 | 43 | #ifndef ONLINE_JUDGE 44 | freopen("input.txt", "r", stdin); 45 | freopen("output.txt", "w", stdout); 46 | #endif 47 | 48 | int tests = 49 | #ifdef ONLINE_JUDGED 50 | 1; 51 | #else 52 | ri(); 53 | #endif 54 | 55 | /* 56 | #dp 57 | #linear 58 | #compress 59 | */ 60 | 61 | for (int t = 0; t < tests; ++t) { 62 | int h = ri(); 63 | int n = ri(); 64 | vi p = rvi(n); 65 | p.push_back(0); 66 | reverse(p.begin(), p.end()); 67 | 68 | vi dp(n + 1, h + 1); 69 | dp[n] = 0; 70 | 71 | for (int i = n - 1; i >= 0; --i) { 72 | if (i <= n - 2) { 73 | if (p[i + 1] == p[i] + 1) { 74 | // p[i], p[i] + 1, p[i] + 2 75 | dp[i] = min(dp[i], dp[i + 2]); 76 | } 77 | } 78 | 79 | dp[i] = min(dp[i], dp[i + 1] + (i > 0)); 80 | } 81 | 82 | cout << dp[0] << ENDL; 83 | } 84 | 85 | return 0; 86 | } -------------------------------------------------------------------------------- /Codeforces/Rounds/GoodBye/2021/A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int t; 5 | std::cin >> t; 6 | 7 | 8 | auto solve_test = [&]() { 9 | int n; 10 | std::cin >> n; 11 | 12 | std::vector a(n); 13 | for (int& v : a) std::cin >> v; 14 | 15 | auto get_answer = [&]() { 16 | std::map counts; 17 | for (int v : a) counts[std::abs(v)]++; 18 | 19 | int answer = 0; 20 | for (auto& [value, count] : counts) { 21 | int max_distinct = 1 + (value != -value); 22 | answer += std::min(count, max_distinct); 23 | } 24 | 25 | return answer; 26 | }; 27 | 28 | int answer = get_answer(); 29 | std::cout << answer << "\n"; 30 | }; 31 | 32 | while (t --> 0) solve_test(); 33 | 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /Codeforces/Rounds/GoodBye/2021/B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int t; 5 | std::cin >> t; 6 | 7 | 8 | auto solve_test = [&]() { 9 | int n; 10 | std::cin >> n; 11 | 12 | std::string s; 13 | std::cin >> s; 14 | 15 | auto get_answer = [&]() { 16 | // corner case 17 | if (1 == n) return s + s; 18 | 19 | char beside = '\0'; 20 | 21 | int last = 0; 22 | for (int i = 0; i < n; ++i) { 23 | char next = (i + 1 == n ? 'z' + 1 : s[i + 1]); 24 | if (s[i] > next) { 25 | beside = s[i]; 26 | last = i + 1; 27 | } else if (s[i] < next) { 28 | last = i; 29 | break; 30 | } else { 31 | if (beside > next) { 32 | last = i + 1; 33 | } else { 34 | last = i; 35 | break; 36 | } 37 | } 38 | } 39 | 40 | std::string ans = ""; 41 | for (int i = 0; i <= last; ++i) ans += s[i]; 42 | for (int i = last; i >= 0; --i) ans += s[i]; 43 | 44 | return ans; 45 | }; 46 | 47 | std::string answer = get_answer(); 48 | std::cout << answer << "\n"; 49 | }; 50 | 51 | while (t --> 0) solve_test(); 52 | 53 | return 0; 54 | } 55 | -------------------------------------------------------------------------------- /Codeforces/Rounds/GoodBye/2021/C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int t; 5 | std::cin >> t; 6 | 7 | 8 | auto solve_test = [&]() { 9 | int n; 10 | std::cin >> n; 11 | 12 | std::vector a(n); 13 | for (int& v : a) std::cin >> v; 14 | 15 | auto get_answer = [&]() { 16 | int answer = std::max(0, n - 2); 17 | for (int left = 0; left < n; ++left) { 18 | for (int right = left + 1; right < n; ++right) { 19 | int count = 0; 20 | for (int k = 0; k < n; ++k) { 21 | if ((a[k] - a[left]) * (right - left) != (a[right] - a[left]) * (k - left)) { 22 | ++count; 23 | } 24 | } 25 | answer = std::min(answer, count); 26 | } 27 | } 28 | 29 | return answer; 30 | }; 31 | 32 | int answer = get_answer(); 33 | std::cout << answer << "\n"; 34 | }; 35 | 36 | while (t --> 0) solve_test(); 37 | 38 | return 0; 39 | } 40 | -------------------------------------------------------------------------------- /Codeforces/Rounds/Polynomial (1774)/A.py: -------------------------------------------------------------------------------- 1 | def read_int(): 2 | return int(input()) 3 | 4 | 5 | def read_ints(): 6 | return map(int, input().split()) 7 | 8 | 9 | def solve_test(): 10 | n = read_int() 11 | s = input() 12 | 13 | s = s[1:] 14 | ones = s.count('1') 15 | 16 | plus_count = ones // 2 17 | minus_count = ones - plus_count 18 | 19 | ans = [] 20 | for v in s: 21 | if v == '0': 22 | ans.append('+') 23 | else: 24 | if plus_count > 0: 25 | plus_count -= 1 26 | ans.append('+') 27 | else: 28 | ans.append('-') 29 | 30 | print(''.join(ans)) 31 | 32 | 33 | t = read_int() 34 | for _ in range(t): 35 | solve_test() 36 | -------------------------------------------------------------------------------- /Codeforces/Rounds/Polynomial (1774)/B.py: -------------------------------------------------------------------------------- 1 | def read_int(): 2 | return int(input()) 3 | 4 | 5 | def read_ints(): 6 | return map(int, input().split()) 7 | 8 | 9 | def solve_test(): 10 | n, m, k = read_ints() 11 | a = list(read_ints()) 12 | 13 | def get_answer(): 14 | if m < k: 15 | return False 16 | 17 | sorted_a = sorted(a, reverse=True) 18 | 19 | small_size = n // k 20 | large_size = small_size + 1 21 | 22 | large_count = n % k 23 | small_count = k - large_count 24 | 25 | limits = [large_size] * large_count 26 | limits.extend([small_size] * small_count) 27 | 28 | for index, count in enumerate(sorted_a[:k]): 29 | if limits[index] < count: 30 | return False 31 | 32 | return True 33 | 34 | print('YES' if get_answer() else 'NO') 35 | 36 | t = read_int() 37 | for _ in range(t): 38 | solve_test() 39 | -------------------------------------------------------------------------------- /Codeforces/Rounds/Polynomial (1774)/C.py: -------------------------------------------------------------------------------- 1 | def read_int(): 2 | return int(input()) 3 | 4 | 5 | def read_ints(): 6 | return map(int, input().split()) 7 | 8 | 9 | def solve_test(): 10 | n = read_int() 11 | s = list(map(int, input())) 12 | 13 | left = 0 14 | right = 0 15 | 16 | ans = [0] * (n - 1) 17 | last = -1 18 | last_ans = 1 19 | for i, v in enumerate(s): 20 | if i > 0 and last != v: 21 | ans[i] = left + right + 1 22 | last_ans = ans[i] 23 | else: 24 | ans[i] = last_ans 25 | 26 | if v == 0: 27 | right += 1 28 | else: 29 | left += 1 30 | 31 | last = v 32 | 33 | print(" ".join(map(str, ans))) 34 | 35 | 36 | t = read_int() 37 | for _ in range(t): 38 | solve_test() 39 | -------------------------------------------------------------------------------- /Codeforces/Rounds/Polynomial (1774)/D.py: -------------------------------------------------------------------------------- 1 | def read_int(): 2 | return int(input()) 3 | 4 | 5 | def read_ints(): 6 | return map(int, input().split()) 7 | 8 | 9 | def solve_test(): 10 | n, m = read_ints() 11 | a = [list(read_ints()) for _ in range(n)] 12 | 13 | def get_ans(): 14 | counts = list(map(sum, a)) 15 | 16 | total = sum(counts) 17 | if total % n != 0: 18 | return None 19 | 20 | need = total // n 21 | 22 | steps = [] 23 | 24 | for column in range(m): 25 | heavy = [] 26 | light = [] 27 | 28 | for row in range(n): 29 | if counts[row] > need and a[row][column] == 1: 30 | heavy.append(row) 31 | if counts[row] < need and a[row][column] == 0: 32 | light.append(row) 33 | 34 | size = min(len(heavy), len(light)) 35 | for i in range(size): 36 | steps.append( 37 | ' '.join(map(str, (heavy[i] + 1, light[i] + 1, column + 1))) 38 | ) 39 | counts[heavy[i]] -= 1 40 | counts[light[i]] += 1 41 | 42 | if not all(map(lambda count: count == need, counts)): 43 | return None 44 | 45 | return steps 46 | 47 | ans = get_ans() 48 | if ans is None: 49 | return "-1" 50 | 51 | ans_str = [str(len(ans))] 52 | ans_str.extend(ans) 53 | 54 | return '\n'.join(ans_str) 55 | 56 | 57 | t = read_int() 58 | 59 | answers = [] 60 | for _ in range(t): 61 | answers.append(solve_test()) 62 | 63 | print("\n".join(answers)) 64 | -------------------------------------------------------------------------------- /Codeforces/Rounds/Polynomial (1774)/Readme.md: -------------------------------------------------------------------------------- 1 | ## Polynomial Round 2022 (Div 1 + Div 2) 2 | 3 | [Link to contest](https://codeforces.com/contest/1774) 4 | -------------------------------------------------------------------------------- /Codeforces/Rounds/VK Cup/2022/Qual (Engine)/A.py: -------------------------------------------------------------------------------- 1 | def read_int(): 2 | return int(input()) 3 | 4 | 5 | n = read_int() 6 | a = [read_int() for _ in range(n)] 7 | 8 | ans = [-1] 9 | for i, dist in enumerate(a, 1): 10 | prev_ans = ans[-1] 11 | cur_ans = max(prev_ans + 1, dist - i) 12 | ans.append(cur_ans) 13 | 14 | print(*ans[1:], sep='\n') 15 | -------------------------------------------------------------------------------- /Codeforces/Rounds/VK Cup/2022/Qual (Engine)/C.py: -------------------------------------------------------------------------------- 1 | def read_int(): 2 | return int(input()) 3 | 4 | 5 | def read_ints(): 6 | return map(int, input().split()) 7 | 8 | 9 | def solve_test(): 10 | n = read_int() 11 | a = list(read_ints()) 12 | 13 | def get_ans(): 14 | moving = 1 15 | pushed = 2 16 | fixed = 3 17 | 18 | modes = dict() 19 | 20 | for x in a: 21 | if x not in modes: 22 | modes[x] = moving 23 | elif modes[x] == moving or modes[x] == pushed: 24 | modes[x] = fixed 25 | modes[x + 1] = pushed 26 | 27 | events = list(modes.items()) 28 | 29 | events.sort() 30 | 31 | max_segment_length = 0 32 | 33 | last_moving = -1 34 | last = -1 35 | 36 | prev_moving = 0 37 | cur_moving = 0 38 | 39 | cur = 0 40 | 41 | for x, mode in events: 42 | if last < x - 2: 43 | prev_moving = 0 44 | 45 | if last == x - 2: 46 | prev_moving = cur_moving 47 | 48 | if last_moving < x - 1: 49 | cur_moving = 0 50 | 51 | if last < x - 1: 52 | cur = 0 53 | 54 | if mode == moving: 55 | cur_moving += 1 56 | last_moving = x 57 | 58 | cur += min(1, x - last) 59 | last = x 60 | 61 | max_segment_length = max(max_segment_length, prev_moving + cur) 62 | 63 | return max_segment_length 64 | 65 | ans = get_ans() 66 | print(ans) 67 | 68 | 69 | def solve(): 70 | tests = read_int() 71 | for test in range(tests): 72 | solve_test() 73 | 74 | 75 | if __name__ == '__main__': 76 | solve() 77 | -------------------------------------------------------------------------------- /Codeforces/Rounds/VK Cup/2022/Qual (Engine)/Readme.md: -------------------------------------------------------------------------------- 1 | ## VK Cup 2022 Qualifier (Engine - Algorithm) 2 | 3 | [Link to contest](https://codeforces.com/contest/1769/) 4 | -------------------------------------------------------------------------------- /KRSU/ICPC/2022/Qualification/A.py: -------------------------------------------------------------------------------- 1 | def read_int(): 2 | return int(input()) 3 | 4 | 5 | n = read_int() 6 | k = read_int() 7 | 8 | ans = 0 9 | while n > 0: 10 | n //= k 11 | ans += 1 12 | 13 | print(ans) 14 | -------------------------------------------------------------------------------- /KRSU/ICPC/2022/Qualification/B.py: -------------------------------------------------------------------------------- 1 | def read_int(): 2 | return int(input()) 3 | 4 | 5 | iterations = read_int() 6 | 7 | it_in_sec = 10**8 8 | sec_in_min = 60 9 | min_in_hour = 60 10 | hour_in_day = 24 11 | 12 | seconds = iterations // it_in_sec 13 | 14 | minutes = seconds // sec_in_min 15 | seconds %= sec_in_min 16 | 17 | hours = minutes // min_in_hour 18 | minutes %= min_in_hour 19 | 20 | days = hours // hour_in_day 21 | hours %= hour_in_day 22 | 23 | print(days, hours, minutes, seconds) 24 | -------------------------------------------------------------------------------- /KRSU/ICPC/2022/Qualification/C.py: -------------------------------------------------------------------------------- 1 | def read_int(): 2 | return int(input()) 3 | 4 | 5 | def read_ints(): 6 | return map(int, input().split()) 7 | 8 | 9 | a = list(read_ints()) 10 | a = list(set(a)) 11 | a = sorted(a) 12 | 13 | if len(a) == 1: 14 | print(a[0]) 15 | else: 16 | n = len(a) 17 | deltas = [] 18 | for i in range(1, n): 19 | deltas.append(a[i] - a[0]) 20 | 21 | def gcd(a, b): 22 | return b if a == 0 else gcd(b % a, a) 23 | 24 | g = 0 25 | for delta in deltas: 26 | g = gcd(g, delta) 27 | 28 | a_1 = a[0] 29 | a_last = a[-1] 30 | size = (a_last - a_1) // g + 1 31 | 32 | s = (a_1 + a_last) * size // 2 33 | print(s) 34 | -------------------------------------------------------------------------------- /KRSU/ICPC/2022/Qualification/E.py: -------------------------------------------------------------------------------- 1 | from math import log 2 | 3 | 4 | def read_int(): 5 | return int(input()) 6 | 7 | 8 | def read_ints(): 9 | return map(int, input().split()) 10 | 11 | 12 | def get_ans(n): 13 | p = n // 2 14 | q = 0 15 | 16 | if n % 2 == 1 and p >= 2: 17 | p -= 2 18 | q += 1 19 | 20 | mod = 2022 21 | ans = pow(2, p, mod) * pow(5, q, mod) 22 | ans %= mod 23 | 24 | return ans 25 | 26 | 27 | n = read_int() 28 | print(get_ans(n)) 29 | -------------------------------------------------------------------------------- /KRSU/ICPC/2022/Qualification/F.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | using ll = int64_t; 6 | 7 | int main() { 8 | ll left, right; 9 | cin >> left >> right; 10 | 11 | ll max_possible_yes = 5; 12 | 13 | auto get_answer = [&]() { 14 | ll size = (right - left + 1); 15 | if (size > max_possible_yes) { 16 | return false; 17 | } 18 | 19 | /* 20 | vector squares; 21 | for (ll a = 0; a * a <= right; ++a) squares.push_back(a * a); 22 | 23 | auto check = [&](ll x) { 24 | for (int ai = 0, bi = squares.size() - 1; squares[ai] * 2 <= x; ++ai) { 25 | ll a2 = squares[ai]; 26 | while (bi > ai && squares[bi] > x - a2) --bi; 27 | if (a2 + squares[bi] == x) return true; 28 | } 29 | 30 | return false; 31 | }; 32 | */ 33 | 34 | auto check = [&](ll x) { 35 | for (ll a = 0; 2 * a * a <= x; ++a) { 36 | ll b2 = x - a * a; 37 | 38 | ll b = sqrt(b2); 39 | while (b * b > b2) --b; 40 | while ((b + 1) * (b + 1) <= b2) ++b; 41 | 42 | if (b * b == b2) return true; 43 | } 44 | 45 | return false; 46 | }; 47 | 48 | bool can = true; 49 | for (ll x = left; x <= right; ++x) can &= check(x); 50 | 51 | return can; 52 | }; 53 | 54 | cout << (get_answer() ? "Yes" : "No") << "\n"; 55 | 56 | return 0; 57 | } 58 | -------------------------------------------------------------------------------- /KRSU/ICPC/2022/Qualification/G.py: -------------------------------------------------------------------------------- 1 | def read_int(): 2 | return int(input()) 3 | 4 | 5 | def read_ints(): 6 | return map(int, input().split()) 7 | 8 | 9 | t1 = list(read_ints()) 10 | t2 = list(read_ints()) 11 | 12 | 13 | def scalar(xa, ya, xb, yb): 14 | return xa * xb + ya * yb 15 | 16 | 17 | def vector(xa, ya, xb, yb): 18 | return xa * yb - xb * ya 19 | 20 | 21 | def len_2(x, y): 22 | return x * x + y * y 23 | 24 | 25 | class Triangle: 26 | 27 | def __init__(self, t): 28 | self.v = [] 29 | for i in range(3): 30 | self.v.append((t[2 * i], t[2 * i + 1])) 31 | 32 | def vec(self, i, j): 33 | xs, ys = self.v[i] 34 | xe, ye = self.v[j] 35 | return xe - xs, ye - ys 36 | 37 | def len2(self, i, j): 38 | x, y = self.vec(i, j) 39 | return len_2(x, y) 40 | 41 | def square(self): 42 | ax, ay = self.vec(0, 1) 43 | bx, by = self.vec(0, 2) 44 | 45 | return abs(vector(ax, ay, bx, by)) 46 | 47 | def get_sides(self): 48 | return [self.len2(i, (i + 1) % 3) for i in range(3)] 49 | 50 | 51 | def get_ans(): 52 | tr_1 = Triangle(t1) 53 | tr_2 = Triangle(t2) 54 | 55 | s1 = tr_1.square() 56 | s2 = tr_2.square() 57 | 58 | if s1 > s2: 59 | return 1 60 | 61 | if s1 < s2: 62 | return 2 63 | 64 | sides_1 = tr_1.get_sides() 65 | sides_2 = tr_2.get_sides() 66 | 67 | if sorted(sides_1) == sorted(sides_2): 68 | return 0 69 | 70 | return 3 71 | 72 | 73 | ans = get_ans() 74 | print(ans) 75 | -------------------------------------------------------------------------------- /KRSU/ICPC/2022/Qualification/H.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | using ll = int64_t; 6 | 7 | int main() { 8 | int a, b, x, y; 9 | cin >> a >> b >> x >> y; 10 | 11 | int mod = 1000 * 1000 + 7; 12 | 13 | vector dp(b + 1, 0); 14 | vector can(b + 1, false); 15 | dp[a] = 1; 16 | can[a] = true; 17 | 18 | for (int i = a, lim = b / y; i < b; ++i) { 19 | if (i + x <= b) { 20 | int j = i + x; 21 | dp[j] += dp[i]; 22 | can[j] = can[j] | can[i]; 23 | if (dp[j] > mod) dp[j] -= mod; 24 | } 25 | 26 | if (i <= lim) { 27 | int j = i * y; 28 | dp[j] += dp[i]; 29 | can[j] = can[j] | can[i]; 30 | if (dp[j] > mod) dp[j] -= mod; 31 | } 32 | } 33 | 34 | int ans = can[b] ? dp[b] : -1; 35 | cout << ans << "\n"; 36 | 37 | return 0; 38 | } 39 | -------------------------------------------------------------------------------- /KRSU/ICPC/2022/Qualification/Readme.md: -------------------------------------------------------------------------------- 1 | ## ICPC 2022 Kyrgyzstan Qualification Contest 2 | 3 | ## [Link to KRSU](https://olymp.krsu.edu.kg/ContestProblemset.aspx?contest=786) 4 | 5 | Statements in **[one file](https://drive.google.com/file/d/1vKUyR6Q5o8OFWvunxNdGJk2aa3fRp3oE)** 6 | 7 | Problems could be submitted **[here](https://olymp.krsu.edu.kg/GeneralProblemset.aspx)** (from 3452 to 3459). 8 | 9 | ## [My editorial](https://drive.google.com/file/d/1-V47jSExEM5eXBrMfjcDEgyQ-pVdxp1X) 10 | -------------------------------------------------------------------------------- /LeetCode/p0024_swap_nodes_in_pairs.go: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * type ListNode struct { 4 | * Val int 5 | * Next *ListNode 6 | * } 7 | */ 8 | func swapPairs(head *ListNode) *ListNode { 9 | root := &ListNode { 10 | Val: -1, 11 | Next: head, 12 | } 13 | 14 | for cur := root; cur.Next != nil && cur.Next.Next != nil; cur = cur.Next.Next { 15 | left := cur.Next 16 | right := left.Next 17 | 18 | left.Next = right.Next 19 | right.Next = left 20 | cur.Next = right 21 | } 22 | 23 | return root.Next 24 | } 25 | -------------------------------------------------------------------------------- /LeetCode/p0041_first_missing_positive.go: -------------------------------------------------------------------------------- 1 | func firstMissingPositive(nums []int) int { 2 | n := len(nums) 3 | for i := range nums { 4 | for num := nums[i]; 1 <= num && num <= n; num = nums[i] { 5 | if num == i + 1 { 6 | break 7 | } 8 | 9 | newNum := nums[num - 1] 10 | if newNum == num { 11 | nums[i] = -1 12 | break 13 | } 14 | 15 | nums[i] = newNum 16 | nums[num - 1] = num 17 | } 18 | } 19 | 20 | for i, num := range nums { 21 | if num != i + 1 { 22 | return i + 1 23 | } 24 | } 25 | 26 | return n + 1 27 | } 28 | -------------------------------------------------------------------------------- /LeetCode/p0054_spiral_matrix.go: -------------------------------------------------------------------------------- 1 | func spiralOrder(matrix [][]int) []int { 2 | xSize, ySize := len(matrix), len(matrix[0]) 3 | 4 | total := xSize * ySize 5 | answer := make([]int, 0, total) 6 | 7 | steps := [...][2]int { 8 | { 0, 1 }, 9 | { 1, 0 }, 10 | { 0, -1 }, 11 | { -1, 0 }, 12 | } 13 | 14 | used := make([]bool, total) 15 | 16 | canStep := func(nextX, nextY int) (canStep bool, cell int) { 17 | if nextX < 0 || xSize <= nextX { 18 | return false, -1 19 | } 20 | 21 | if nextY < 0 || ySize <= nextY { 22 | return false, -1 23 | } 24 | 25 | cell = nextX * ySize + nextY 26 | return !used[cell], cell 27 | } 28 | 29 | direction := 0 30 | for x, y := -steps[direction][0], -steps[direction][1]; len(answer) < total; { 31 | step := &steps[direction] 32 | nextX, nextY := x + step[0], y + step[1] 33 | 34 | canStep, cell := canStep(nextX, nextY) 35 | if !canStep { 36 | direction = (direction + 1) % 4 37 | } else { 38 | answer = append(answer, matrix[nextX][nextY]) 39 | used[cell] = true 40 | x, y = nextX, nextY 41 | } 42 | } 43 | 44 | return answer 45 | } 46 | -------------------------------------------------------------------------------- /LeetCode/p0060_permutation_sequence.go: -------------------------------------------------------------------------------- 1 | import ( 2 | "strings" 3 | ) 4 | 5 | func getPermutation(n int, k int) string { 6 | facts := make([]int, n + 1) 7 | facts[0] = 1 8 | for i := 1; i <= n; i++ { 9 | facts[i] = facts[i - 1] * i 10 | } 11 | 12 | k-- 13 | 14 | var sb strings.Builder 15 | 16 | used := make([]bool, n + 1) 17 | for i := n - 1; i >= 0; i-- { 18 | for cur := 1; cur <= n; cur++ { 19 | if used[cur] { 20 | continue 21 | } 22 | 23 | if k >= facts[i] { 24 | k -= facts[i] 25 | } else { 26 | used[cur] = true 27 | sb.WriteRune(rune(cur + int('0'))) 28 | break 29 | } 30 | } 31 | } 32 | 33 | return sb.String() 34 | } 35 | -------------------------------------------------------------------------------- /LeetCode/p0228_summary_ranges.go: -------------------------------------------------------------------------------- 1 | func summaryRanges(nums []int) []string { 2 | segs := make([][2]int, 0) 3 | last := -1 4 | 5 | for _, value := range nums { 6 | if last < 0 || segs[last][1] + 1 < value { 7 | segs = append(segs, [2]int{ value, value }) 8 | last++ 9 | } else { 10 | segs[last][1] = value 11 | } 12 | } 13 | 14 | n := len(segs) 15 | segsStr := make([]string, n) 16 | 17 | for i, seg := range segs { 18 | start, end := seg[0], seg[1] 19 | 20 | if start < end { 21 | segsStr[i] = fmt.Sprintf("%d->%d", start, end) 22 | } else { 23 | segsStr[i] = fmt.Sprintf("%d", start) 24 | } 25 | } 26 | 27 | return segsStr 28 | } 29 | -------------------------------------------------------------------------------- /LeetCode/p0258_add_digits.go: -------------------------------------------------------------------------------- 1 | func addDigits(num int) int { 2 | if num == 0 { 3 | return 0 4 | } 5 | 6 | return (num - 1) % 9 + 1 7 | } 8 | -------------------------------------------------------------------------------- /LeetCode/p0319_bulb_switcher.go: -------------------------------------------------------------------------------- 1 | import( 2 | "math" 3 | ) 4 | 5 | func bulbSwitch(n int) int { 6 | n64 := float64(n) 7 | return int(math.Sqrt(n64)) 8 | } 9 | -------------------------------------------------------------------------------- /LeetCode/p0347_top_k_frequent_counting_sort.go: -------------------------------------------------------------------------------- 1 | func topKFrequent(nums []int, k int) []int { 2 | counts := make(map[int]int) 3 | for _, value := range nums { 4 | counts[value]++ 5 | } 6 | 7 | countToValues := make(map[int][]int) 8 | for value, count := range counts { 9 | countToValues[count] = append(countToValues[count], value) 10 | } 11 | 12 | answer := make([]int, 0, k) 13 | for count := len(nums); count > 0; count-- { 14 | countValues := countToValues[count] 15 | for i := 0; i < len(countValues) && len(answer) < k; i++ { 16 | answer = append(answer, countValues[i]) 17 | } 18 | } 19 | 20 | return answer 21 | } 22 | -------------------------------------------------------------------------------- /LeetCode/p0347_top_k_frequent_partition.go: -------------------------------------------------------------------------------- 1 | type ValueCount struct { 2 | Value int 3 | Count int 4 | } 5 | 6 | func partition(values []ValueCount, left, right int) int { 7 | mid := left + rand.Intn(right - left + 1) 8 | midCount := values[mid].Count 9 | 10 | values[mid], values[right] = values[right], values[mid] 11 | 12 | firstLarger := left 13 | for i := left; i < right; i++ { 14 | if values[i].Count < midCount { 15 | values[i], values[firstLarger] = values[firstLarger], values[i] 16 | firstLarger++ 17 | } 18 | } 19 | 20 | values[firstLarger], values[right] = values[right], values[firstLarger] 21 | 22 | return firstLarger 23 | } 24 | 25 | func findKthStatistic(values []ValueCount, k int) { 26 | k-- 27 | 28 | for left, right := 0, len(values) - 1; left <= right; { 29 | mid := partition(values, left, right) 30 | 31 | if mid == k { 32 | break 33 | } 34 | 35 | if mid > k { 36 | right = mid - 1 37 | } else { 38 | left = mid + 1 39 | } 40 | } 41 | } 42 | 43 | func topKFrequent(nums []int, k int) []int { 44 | counts := make(map[int]int) 45 | for _, value := range nums { 46 | counts[value]++ 47 | } 48 | 49 | n := len(counts) 50 | 51 | values := make([]ValueCount, 0, n) 52 | for value, count := range counts { 53 | values = append(values, ValueCount { 54 | Value: value, 55 | Count: -count, 56 | }) 57 | } 58 | 59 | findKthStatistic(values, k) 60 | 61 | answer := make([]int, k) 62 | for i := 0; i < k; i++ { 63 | answer[i] = values[i].Value 64 | } 65 | 66 | return answer 67 | } 68 | -------------------------------------------------------------------------------- /LeetCode/p0530_minimum_difference_in_bst.go: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * type TreeNode struct { 4 | * Val int 5 | * Left *TreeNode 6 | * Right *TreeNode 7 | * } 8 | */ 9 | func getMinimumDifference(root *TreeNode) int { 10 | values := make([]int, 0) 11 | 12 | var dfs func(*TreeNode) 13 | 14 | dfs = func(node *TreeNode) { 15 | if node == nil { 16 | return 17 | } 18 | 19 | values = append(values, node.Val) 20 | 21 | dfs(node.Left) 22 | dfs(node.Right) 23 | } 24 | 25 | dfs(root) 26 | 27 | sort.Ints(values) 28 | 29 | ans := int(1e9) 30 | for i := 1; i < len(values); i++ { 31 | if ans > values[i] - values[i - 1] { 32 | ans = values[i] - values[i - 1] 33 | } 34 | } 35 | 36 | return ans 37 | } 38 | -------------------------------------------------------------------------------- /LeetCode/p0547_number_of_provinces.go: -------------------------------------------------------------------------------- 1 | func findCircleNum(isConnected [][]int) int { 2 | var dfs func(int) bool 3 | 4 | n := len(isConnected) 5 | used := make([]bool, n) 6 | dfs = func(v int) bool { 7 | if used[v] { 8 | return false 9 | } 10 | 11 | used[v] = true 12 | 13 | for to, edge := range isConnected[v] { 14 | if edge == 1 { 15 | dfs(to) 16 | } 17 | } 18 | 19 | return true 20 | } 21 | 22 | components := 0 23 | for v := range used { 24 | if dfs(v) { 25 | components++ 26 | } 27 | } 28 | 29 | return components 30 | } 31 | -------------------------------------------------------------------------------- /LeetCode/p0649_dota2_senate.go: -------------------------------------------------------------------------------- 1 | func predictPartyVictory(senate string) string { 2 | n := len(senate) 3 | 4 | radiant := make([]int, 0) 5 | dire := make([]int, 0) 6 | 7 | for i, letter := range senate { 8 | if 'R' == letter { 9 | radiant = append(radiant, i) 10 | } else { 11 | dire = append(dire, i) 12 | } 13 | } 14 | 15 | ir, id := 0, 0 16 | 17 | for ; ir < len(radiant) && id < len(dire); { 18 | if radiant[ir] < dire[id] { 19 | radiant = append(radiant, radiant[ir] + n) 20 | } else { 21 | dire = append(dire, dire[id] + n) 22 | } 23 | ir++ 24 | id++ 25 | } 26 | 27 | if ir == len(radiant) { 28 | return "Dire" 29 | } else { 30 | return "Radiant" 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /LeetCode/p0703_kth_largest.go: -------------------------------------------------------------------------------- 1 | // Example from https://pkg.go.dev/container/heap 2 | 3 | // An IntHeap is a min-heap of ints. 4 | type IntHeap []int 5 | 6 | func (h IntHeap) Len() int { return len(h) } 7 | func (h IntHeap) Less(i, j int) bool { return h[i] < h[j] } 8 | func (h IntHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] } 9 | func (h IntHeap) Peek() int { return h[0] } 10 | 11 | func (h *IntHeap) Push(value any) { 12 | // Push and Pop use pointer receivers because they modify the slice's length, 13 | // not just its contents. 14 | *h = append(*h, value.(int)) 15 | } 16 | 17 | func (h *IntHeap) Pop() any { 18 | old := *h 19 | n := len(old) 20 | value := old[n-1] 21 | *h = old[0 : n-1] 22 | return value 23 | } 24 | 25 | type KthLargest struct { 26 | h *IntHeap 27 | k int 28 | } 29 | 30 | func Constructor(k int, nums []int) KthLargest { 31 | largest := KthLargest { 32 | h: &IntHeap{}, 33 | k: k, 34 | } 35 | 36 | for _, value := range nums { 37 | largest.Add(value) 38 | } 39 | 40 | return largest 41 | } 42 | 43 | func (this *KthLargest) Add(val int) int { 44 | heap.Push(this.h, val) 45 | if this.h.Len() > this.k { 46 | heap.Pop(this.h) 47 | } 48 | return this.h.Peek() 49 | } 50 | 51 | 52 | /** 53 | * Your KthLargest object will be instantiated and called as such: 54 | * obj := Constructor(k, nums); 55 | * param_1 := obj.Add(val); 56 | */ 57 | -------------------------------------------------------------------------------- /LeetCode/p0705_design_hashet_bool_array.go: -------------------------------------------------------------------------------- 1 | type MyHashSet struct { 2 | used []bool 3 | } 4 | 5 | 6 | func Constructor() MyHashSet { 7 | maxKey := 1000 * 1000 8 | return MyHashSet { 9 | used: make([]bool, maxKey + 1), 10 | } 11 | } 12 | 13 | 14 | func (this *MyHashSet) Add(key int) { 15 | this.used[key] = true 16 | } 17 | 18 | 19 | func (this *MyHashSet) Remove(key int) { 20 | this.used[key] = false 21 | } 22 | 23 | 24 | func (this *MyHashSet) Contains(key int) bool { 25 | return this.used[key] 26 | } 27 | 28 | 29 | /** 30 | * Your MyHashSet object will be instantiated and called as such: 31 | * obj := Constructor(); 32 | * obj.Add(key); 33 | * obj.Remove(key); 34 | * param_3 := obj.Contains(key); 35 | */ 36 | -------------------------------------------------------------------------------- /LeetCode/p0705_design_hashset_buckets.go: -------------------------------------------------------------------------------- 1 | type MyHashSet struct { 2 | capacity int 3 | buckets [][]int 4 | } 5 | 6 | 7 | func Constructor() MyHashSet { 8 | maxOperations := 10 * 1000 9 | capacityBits := 0 10 | for ; (1 << capacityBits) < maxOperations; capacityBits++ { } 11 | 12 | capacity := (1 << capacityBits) 13 | 14 | return MyHashSet { 15 | capacity: capacity, 16 | buckets: make([][]int, capacity), 17 | } 18 | } 19 | 20 | func (this *MyHashSet) find(key int) (*[]int, int) { 21 | hash := key & (this.capacity - 1) 22 | 23 | bucket := &(this.buckets[hash]) 24 | position := -1 25 | 26 | for index, value := range *bucket { 27 | if value == key { 28 | position = index 29 | break 30 | } 31 | } 32 | 33 | return bucket, position 34 | } 35 | 36 | func (this *MyHashSet) Add(key int) { 37 | bucket, position := this.find(key) 38 | if position == -1 { 39 | (*bucket) = append(*bucket, key) 40 | } 41 | } 42 | 43 | 44 | func (this *MyHashSet) Remove(key int) { 45 | bucket, position := this.find(key) 46 | if position != -1 { 47 | (*bucket) = append((*bucket)[:position], (*bucket)[position+1:]...) 48 | } 49 | } 50 | 51 | 52 | func (this *MyHashSet) Contains(key int) bool { 53 | _, position := this.find(key) 54 | return position != -1 55 | } 56 | 57 | 58 | /** 59 | * Your MyHashSet object will be instantiated and called as such: 60 | * obj := Constructor(); 61 | * obj.Add(key); 62 | * obj.Remove(key); 63 | * param_3 := obj.Contains(key); 64 | */ 65 | -------------------------------------------------------------------------------- /LeetCode/p0744_find_smallest_greater.go: -------------------------------------------------------------------------------- 1 | func nextGreatestLetter(letters []byte, target byte) byte { 2 | pos := sort.Search(len(letters), func(index int) bool { 3 | return letters[index] > target 4 | }) 5 | 6 | if pos == len(letters) { 7 | pos = 0 8 | } 9 | 10 | return letters[pos] 11 | } 12 | -------------------------------------------------------------------------------- /LeetCode/p0783_minimum_distance_in_bst.go: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * type TreeNode struct { 4 | * Val int 5 | * Left *TreeNode 6 | * Right *TreeNode 7 | * } 8 | */ 9 | func minDiffInBST(root *TreeNode) int { 10 | values := make([]int, 0) 11 | 12 | var dfs func(*TreeNode) 13 | 14 | dfs = func(node *TreeNode) { 15 | if node == nil { 16 | return 17 | } 18 | 19 | values = append(values, node.Val) 20 | 21 | dfs(node.Left) 22 | dfs(node.Right) 23 | } 24 | 25 | dfs(root) 26 | 27 | sort.Ints(values) 28 | 29 | ans := int(1e9) 30 | for i := 1; i < len(values); i++ { 31 | if ans > values[i] - values[i - 1] { 32 | ans = values[i] - values[i - 1] 33 | } 34 | } 35 | 36 | return ans 37 | } 38 | -------------------------------------------------------------------------------- /LeetCode/p0785_is_graph_bipartite_bfs.go: -------------------------------------------------------------------------------- 1 | func isBipartite(graph [][]int) bool { 2 | n := len(graph) 3 | colors := make([]int, n) 4 | 5 | for start := range graph { 6 | if 0 != colors[start] { 7 | continue 8 | } 9 | 10 | q := make([]int, 0) 11 | 12 | q = append(q, start) 13 | colors[start] = 1 14 | 15 | for it := 0; it < len(q); it++ { 16 | v := q[it] 17 | vColor := colors[v] 18 | 19 | for _, to := range graph[v] { 20 | toColor := colors[to] 21 | if 0 == toColor { 22 | q = append(q, to) 23 | colors[to] = -vColor 24 | } else { 25 | if colors[to] != -vColor { 26 | return false 27 | } 28 | } 29 | } 30 | } 31 | } 32 | 33 | return true 34 | } 35 | -------------------------------------------------------------------------------- /LeetCode/p0837_new_21_game.go: -------------------------------------------------------------------------------- 1 | func new21Game(n int, k int, maxPts int) float64 { 2 | prob := 1.0 / float64(maxPts) 3 | 4 | dp := make([]float64, n + 1) 5 | windowSum := 0.0 6 | 7 | dp[0] = 1.0 8 | 9 | for i := 0; i <= n; i++ { 10 | notUsed := i - maxPts - 1 11 | if 0 <= notUsed && notUsed < k { 12 | windowSum -= dp[i - maxPts - 1] 13 | } 14 | 15 | if i > 0 { 16 | dp[i] = windowSum * prob 17 | } 18 | 19 | if i < k { 20 | windowSum += dp[i] 21 | } 22 | } 23 | 24 | answer := 0.0 25 | for i := k; i <= n; i++ { 26 | answer += dp[i] 27 | } 28 | 29 | return answer 30 | } 31 | -------------------------------------------------------------------------------- /LeetCode/p1027_longest_arithmetic_subsequence.go: -------------------------------------------------------------------------------- 1 | import "fmt" 2 | 3 | func longestArithSeqLength(nums []int) int { 4 | n := len(nums) 5 | 6 | maxDelta := 500 7 | 8 | dp := make([][]int, n) 9 | for i := range dp { 10 | dp[i] = make([]int, maxDelta * 2 + 1) 11 | } 12 | 13 | ans := 0 14 | for i, num := range nums { 15 | for last := 0; last < i; last++ { 16 | delta := num - nums[last] + maxDelta 17 | if dp[i][delta] < dp[last][delta] + 1 { 18 | dp[i][delta] = dp[last][delta] + 1 19 | } 20 | 21 | if ans < dp[i][delta] { 22 | ans = dp[i][delta] 23 | } 24 | } 25 | } 26 | 27 | return ans + 1 28 | } 29 | -------------------------------------------------------------------------------- /LeetCode/p1035_uncrossed_lines.go: -------------------------------------------------------------------------------- 1 | func max(a, b int) int { 2 | if a < b { 3 | return b 4 | } else { 5 | return a 6 | } 7 | } 8 | 9 | func maxUncrossedLines(nums1 []int, nums2 []int) int { 10 | n1, n2 := len(nums1), len(nums2) 11 | if n1 < n2 { 12 | nums1, nums2 = nums2, nums1 13 | n1, n2 = n2, n1 14 | } 15 | 16 | dp := make([][]int, 2) 17 | for it := range dp { 18 | dp[it] = make([]int, n2 + 1) 19 | } 20 | 21 | for i1, val1 := range nums1 { 22 | prevDp := dp[i1 % 2] 23 | curDp := dp[1 - i1 % 2] 24 | 25 | curDp[0] = prevDp[0] 26 | for i2, val2 := range nums2 { 27 | curDp[i2 + 1] = max( 28 | prevDp[i2 + 1], 29 | curDp[i2], 30 | ) 31 | 32 | if val1 == val2 { 33 | curDp[i2 + 1] = max( 34 | curDp[i2 + 1], 35 | prevDp[i2] + 1, 36 | ) 37 | } 38 | } 39 | } 40 | 41 | return dp[n1 % 2][n2] 42 | } 43 | -------------------------------------------------------------------------------- /LeetCode/p1091_shortest_path_binary_matrix.go: -------------------------------------------------------------------------------- 1 | func shortestPathBinaryMatrix(grid [][]int) int { 2 | q := [][3]int { 3 | [3]int{ -1, -1, 0, }, 4 | } 5 | 6 | n := len(grid) 7 | 8 | endX, endY := n - 1, n - 1 9 | 10 | for i := 0; i < len(q); i++ { 11 | v := q[i] 12 | x, y, d := v[0], v[1], v[2] 13 | 14 | if x == endX && y == endY { 15 | return d 16 | } 17 | 18 | for dx := -1; dx <= 1; dx++ { 19 | for dy := -1; dy <= 1; dy++ { 20 | tx, ty := x + dx, y + dy 21 | if tx < 0 || n <= tx { 22 | continue 23 | } 24 | 25 | if ty < 0 || n <= ty { 26 | continue 27 | } 28 | 29 | if grid[tx][ty] == 1 { 30 | continue 31 | } 32 | 33 | grid[tx][ty] = 1 34 | q = append(q, [3]int{ tx, ty, d + 1, } ) 35 | } 36 | } 37 | } 38 | 39 | return -1 40 | } 41 | -------------------------------------------------------------------------------- /LeetCode/p1114_print_in_order_barrier.py: -------------------------------------------------------------------------------- 1 | from threading import Barrier 2 | 3 | class Foo: 4 | def __init__(self): 5 | self.b2 = Barrier(2) 6 | self.b3 = Barrier(2) 7 | 8 | 9 | def first(self, printFirst: 'Callable[[], None]') -> None: 10 | # printFirst() outputs "first". Do not change or remove this line. 11 | printFirst() 12 | self.b2.wait() 13 | 14 | 15 | def second(self, printSecond: 'Callable[[], None]') -> None: 16 | self.b2.wait() 17 | # printSecond() outputs "second". Do not change or remove this line. 18 | printSecond() 19 | self.b3.wait() 20 | 21 | 22 | def third(self, printThird: 'Callable[[], None]') -> None: 23 | self.b3.wait() 24 | # printThird() outputs "third". Do not change or remove this line. 25 | printThird() 26 | -------------------------------------------------------------------------------- /LeetCode/p1114_print_in_order_count_down_latch.java: -------------------------------------------------------------------------------- 1 | import java.util.concurrent.CountDownLatch; 2 | 3 | class Foo { 4 | 5 | CountDownLatch l2, l3; 6 | 7 | public Foo() { 8 | this.l2 = new CountDownLatch(1); 9 | this.l3 = new CountDownLatch(1); 10 | } 11 | 12 | public void first(Runnable printFirst) throws InterruptedException { 13 | // printFirst.run() outputs "first". Do not change or remove this line. 14 | printFirst.run(); 15 | l2.countDown(); 16 | } 17 | 18 | public void second(Runnable printSecond) throws InterruptedException { 19 | l2.await(); 20 | // printSecond.run() outputs "second". Do not change or remove this line. 21 | printSecond.run(); 22 | l3.countDown(); 23 | } 24 | 25 | public void third(Runnable printThird) throws InterruptedException { 26 | l3.await(); 27 | // printThird.run() outputs "third". Do not change or remove this line. 28 | printThird.run(); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /LeetCode/p1114_print_in_order_event.py: -------------------------------------------------------------------------------- 1 | from threading import Event 2 | 3 | class Foo: 4 | def __init__(self): 5 | self.e2 = Event() 6 | self.e3 = Event() 7 | 8 | 9 | def first(self, printFirst: 'Callable[[], None]') -> None: 10 | # printFirst() outputs "first". Do not change or remove this line. 11 | printFirst() 12 | self.e2.set() 13 | 14 | 15 | def second(self, printSecond: 'Callable[[], None]') -> None: 16 | self.e2.wait() 17 | # printSecond() outputs "second". Do not change or remove this line. 18 | printSecond() 19 | self.e3.set() 20 | 21 | 22 | def third(self, printThird: 'Callable[[], None]') -> None: 23 | self.e3.wait() 24 | # printThird() outputs "third". Do not change or remove this line. 25 | printThird() 26 | -------------------------------------------------------------------------------- /LeetCode/p1115_print_foobar_semaphore.java: -------------------------------------------------------------------------------- 1 | import java.util.concurrent.Semaphore; 2 | 3 | class FooBar { 4 | private int n; 5 | 6 | Semaphore canFoo, canBar; 7 | 8 | public FooBar(int n) { 9 | this.n = n; 10 | this.canFoo = new Semaphore(1); 11 | this.canBar = new Semaphore(0); 12 | } 13 | 14 | public void foo(Runnable printFoo) throws InterruptedException { 15 | for (int i = 0; i < n; i++) { 16 | canFoo.acquire(); 17 | // printFoo.run() outputs "foo". Do not change or remove this line. 18 | printFoo.run(); 19 | canBar.release(); 20 | } 21 | } 22 | 23 | public void bar(Runnable printBar) throws InterruptedException { 24 | for (int i = 0; i < n; i++) { 25 | canBar.acquire(); 26 | // printBar.run() outputs "bar". Do not change or remove this line. 27 | printBar.run(); 28 | canFoo.release(); 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /LeetCode/p1115_print_foobar_semaphore.py: -------------------------------------------------------------------------------- 1 | from threading import Semaphore 2 | 3 | class FooBar: 4 | def __init__(self, n): 5 | self.n = n 6 | self.can_foo = Semaphore(1) 7 | self.can_bar = Semaphore(0) 8 | 9 | 10 | def foo(self, printFoo: 'Callable[[], None]') -> None: 11 | 12 | for i in range(self.n): 13 | self.can_foo.acquire() 14 | # printFoo() outputs "foo". Do not change or remove this line. 15 | printFoo() 16 | self.can_bar.release() 17 | 18 | def bar(self, printBar: 'Callable[[], None]') -> None: 19 | 20 | for i in range(self.n): 21 | self.can_bar.acquire() 22 | # printBar() outputs "bar". Do not change or remove this line. 23 | printBar() 24 | self.can_foo.release() 25 | -------------------------------------------------------------------------------- /LeetCode/p1116_zero_even_odd_semaphore.py: -------------------------------------------------------------------------------- 1 | from threading import Semaphore 2 | 3 | class ZeroEvenOdd: 4 | def __init__(self, n): 5 | self.n = n 6 | 7 | self.can_zero = Semaphore(1) 8 | self.can_odd = Semaphore(0) 9 | self.can_even = Semaphore(0) 10 | 11 | 12 | # printNumber(x) outputs "x", where x is an integer. 13 | def zero(self, printNumber: 'Callable[[int], None]') -> None: 14 | for i in range(1, self.n + 1): 15 | self.can_zero.acquire() 16 | printNumber(0) 17 | 18 | released = self.can_odd if i % 2 == 1 else self.can_even 19 | released.release() 20 | 21 | 22 | def even(self, printNumber: 'Callable[[int], None]') -> None: 23 | for i in range(2, self.n + 1, 2): 24 | self.can_even.acquire() 25 | printNumber(i) 26 | self.can_zero.release() 27 | 28 | 29 | def odd(self, printNumber: 'Callable[[int], None]') -> None: 30 | for i in range(1, self.n + 1, 2): 31 | self.can_odd.acquire() 32 | printNumber(i) 33 | self.can_zero.release() 34 | -------------------------------------------------------------------------------- /LeetCode/p1116_zero_odd_even_semaphore.java: -------------------------------------------------------------------------------- 1 | import java.util.concurrent.Semaphore; 2 | 3 | class ZeroEvenOdd { 4 | private int n; 5 | 6 | Semaphore canZero, canOdd, canEven; 7 | 8 | public ZeroEvenOdd(int n) { 9 | this.n = n; 10 | 11 | this.canZero = new Semaphore(1); 12 | this.canOdd = new Semaphore(0); 13 | this.canEven = new Semaphore(0); 14 | } 15 | 16 | // printNumber.accept(x) outputs "x", where x is an integer. 17 | public void zero(IntConsumer printNumber) throws InterruptedException { 18 | for (int i = 1; i <= n; ++i) { 19 | canZero.acquire(); 20 | printNumber.accept(0); 21 | 22 | (i % 2 == 1 ? canOdd : canEven).release(); 23 | } 24 | } 25 | 26 | public void even(IntConsumer printNumber) throws InterruptedException { 27 | for (int i = 2; i <= n; i += 2) { 28 | canEven.acquire(); 29 | printNumber.accept(i); 30 | canZero.release(); 31 | } 32 | } 33 | 34 | public void odd(IntConsumer printNumber) throws InterruptedException { 35 | for (int i = 1; i <= n; i += 2) { 36 | canOdd.acquire(); 37 | printNumber.accept(i); 38 | canZero.release(); 39 | } 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /LeetCode/p1140_stone_game_2.go: -------------------------------------------------------------------------------- 1 | // Explanation 2 | // https://leetcode.com/problems/stone-game-ii/solutions/3564740/golang-recursive-dp-with-editorial/ 3 | 4 | type Solver struct { 5 | n int 6 | suffSums []int 7 | dp [][]int 8 | } 9 | 10 | func createSolver(piles []int) *Solver { 11 | n := len(piles) 12 | 13 | suffSums := make([]int, n + 1) 14 | for i := n - 1; i >= 0; i-- { 15 | suffSums[i] = suffSums[i + 1] + piles[i] 16 | } 17 | 18 | dp := make([][]int, n + 1) 19 | for i := range dp { 20 | dp[i] = make([]int, n + 1) 21 | for j := range dp[i] { 22 | dp[i][j] = -1 23 | } 24 | } 25 | 26 | return &Solver { 27 | n: n, 28 | suffSums: suffSums, 29 | dp: dp, 30 | } 31 | } 32 | 33 | func max(a, b int) int { 34 | if a > b { 35 | return a 36 | } 37 | return b 38 | } 39 | 40 | func (solver *Solver) calculate(start, m int) (ans int) { 41 | if start >= solver.n { 42 | return 0 43 | } 44 | 45 | ans = solver.dp[start][m] 46 | if ans >= 0 { 47 | return ans 48 | } 49 | 50 | fullSuffix := solver.suffSums[start] 51 | for taken := 1; taken <= 2 * m; taken++ { 52 | ans = max( 53 | ans, 54 | fullSuffix - solver.calculate(start + taken, max(taken, m)), 55 | ) 56 | } 57 | 58 | solver.dp[start][m] = ans 59 | return ans 60 | } 61 | 62 | func stoneGameII(piles []int) int { 63 | solver := createSolver(piles) 64 | return solver.calculate(0, 1) 65 | } 66 | -------------------------------------------------------------------------------- /LeetCode/p1146_snapshot_array.go: -------------------------------------------------------------------------------- 1 | type SnapshotArray struct { 2 | traces [][][2]int 3 | version int 4 | } 5 | 6 | 7 | func Constructor(length int) SnapshotArray { 8 | traces := make([][][2]int, length) 9 | for i := range traces { 10 | traces[i] = append(traces[i], [2]int{-1, 0}) 11 | } 12 | 13 | return SnapshotArray { 14 | traces: traces, 15 | version: 0, 16 | } 17 | } 18 | 19 | 20 | func (this *SnapshotArray) Set(index int, val int) { 21 | this.traces[index] = append(this.traces[index], [2]int{this.version, val}) 22 | } 23 | 24 | 25 | func (this *SnapshotArray) Snap() int { 26 | this.version++ 27 | return this.version - 1 28 | } 29 | 30 | 31 | func (this *SnapshotArray) Get(index int, snap_id int) int { 32 | trace := this.traces[index] 33 | 34 | pos := sort.Search(len(trace), func(i int) bool { 35 | return trace[i][0] > snap_id 36 | }) 37 | return trace[pos - 1][1] 38 | } 39 | 40 | 41 | /** 42 | * Your SnapshotArray object will be instantiated and called as such: 43 | * obj := Constructor(length); 44 | * obj.Set(index,val); 45 | * param_2 := obj.Snap(); 46 | * param_3 := obj.Get(index,snap_id); 47 | */ 48 | -------------------------------------------------------------------------------- /LeetCode/p1161_maximum_level_sum_dfs.go: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * type TreeNode struct { 4 | * Val int 5 | * Left *TreeNode 6 | * Right *TreeNode 7 | * } 8 | */ 9 | import ( 10 | "math" 11 | ) 12 | 13 | func maxLevelSum(root *TreeNode) int { 14 | levelSums := make(map[int]int) 15 | 16 | var dfs func(node *TreeNode, level int) 17 | dfs = func(node *TreeNode, level int) { 18 | if node == nil { 19 | return 20 | } 21 | 22 | levelSums[level] += node.Val 23 | 24 | dfs(node.Left, level + 1) 25 | dfs(node.Right, level + 1) 26 | } 27 | 28 | dfs(root, 1) 29 | 30 | bestLevel, bestSum := 0, math.MinInt 31 | 32 | for level, levelSum := range levelSums { 33 | if bestSum < levelSum { 34 | bestSum = levelSum 35 | bestLevel = level 36 | } 37 | } 38 | 39 | return bestLevel 40 | } 41 | -------------------------------------------------------------------------------- /LeetCode/p1232_check_straight_line.go: -------------------------------------------------------------------------------- 1 | func checkStraightLine(coordinates [][]int) bool { 2 | /* 3 | A = y[1] - y[0] 4 | B = x[0] - x[1] 5 | C = -A * x[0] - B * y[0] 6 | */ 7 | 8 | x0, y0 := coordinates[0][0], coordinates[0][1] 9 | x1, y1 := coordinates[1][0], coordinates[1][1] 10 | 11 | a, b := y1 - y0, x0 - x1 12 | c := - a * x0 - b * y0 13 | 14 | for _, point := range coordinates { 15 | x, y := point[0], point[1] 16 | 17 | d := a * x + b * y + c 18 | if d != 0 { 19 | return false 20 | } 21 | } 22 | 23 | return true 24 | } 25 | -------------------------------------------------------------------------------- /LeetCode/p1318_minimum_flips_make_or_equals.go: -------------------------------------------------------------------------------- 1 | func minFlips(a int, b int, c int) int { 2 | ans := 0 3 | 4 | for a > 0 || b > 0 || c > 0 { 5 | aBit, bBit, cBit := a & 1, b & 1, c & 1 6 | if cBit == 0 { 7 | ans += aBit + bBit 8 | } else { 9 | if aBit + bBit == 0 { 10 | ans++ 11 | } 12 | } 13 | 14 | a >>= 1 15 | b >>= 1 16 | c >>= 1 17 | } 18 | 19 | return ans 20 | } 21 | -------------------------------------------------------------------------------- /LeetCode/p1351_count_negative_in_sorted_matrix.go: -------------------------------------------------------------------------------- 1 | func countNegatives(grid [][]int) int { 2 | rowSize, colSize := len(grid), len(grid[0]) 3 | 4 | ans := 0 5 | for row, lastNegativeCol := 0, colSize; row < rowSize; row++ { 6 | for ; lastNegativeCol > 0 && grid[row][lastNegativeCol - 1] < 0; lastNegativeCol-- {} 7 | ans += colSize - lastNegativeCol 8 | } 9 | 10 | return ans 11 | } 12 | -------------------------------------------------------------------------------- /LeetCode/p1376_time_needed_to_inform.go: -------------------------------------------------------------------------------- 1 | func numOfMinutes(n int, headId int, managers []int, informTimes []int) int { 2 | graph := make([][]int, n) 3 | for v, manager := range managers { 4 | if v == headId { 5 | continue 6 | } 7 | 8 | graph[manager] = append(graph[manager], v) 9 | } 10 | 11 | var calculateTime func(int) int 12 | calculateTime = func(v int) int { 13 | maxChildTime := 0 14 | for _, child := range graph[v] { 15 | childTime := calculateTime(child) 16 | if maxChildTime < childTime { 17 | maxChildTime = childTime 18 | } 19 | } 20 | 21 | return maxChildTime + informTimes[v] 22 | } 23 | 24 | return calculateTime(headId) 25 | } 26 | -------------------------------------------------------------------------------- /LeetCode/p1406_stone_game_3.go: -------------------------------------------------------------------------------- 1 | func signum(x int) int { 2 | if x < 0 { return -1 } 3 | if x > 0 { return 1 } 4 | return 0 5 | } 6 | 7 | func stoneGameIII(stoneValue []int) string { 8 | n := len(stoneValue) 9 | 10 | maxTaken := 3 11 | dp := make([]int, maxTaken + 1) 12 | 13 | inf := math.MaxInt 14 | 15 | suffSum := 0 16 | 17 | for i := n - 1; i >= 0; i-- { 18 | suffSum += stoneValue[i] 19 | 20 | bestResult := inf 21 | for taken := 1; taken <= maxTaken && i + taken <= n; taken++ { 22 | result := dp[(i + taken) % maxTaken] 23 | if bestResult > result { 24 | bestResult = result 25 | } 26 | } 27 | 28 | dp[i % maxTaken] = suffSum - bestResult 29 | } 30 | 31 | sign := signum(2 * dp[0] - suffSum) 32 | 33 | // sign > 0 -> alice 34 | // sign < 0 -> bob 35 | // sign = 0 - tie 36 | 37 | return []string{ 38 | "Bob", 39 | "Tie", 40 | "Alice", 41 | }[sign + 1] 42 | } 43 | -------------------------------------------------------------------------------- /LeetCode/p1456_max_number_of_vowels.go: -------------------------------------------------------------------------------- 1 | import ( 2 | "strings" 3 | ) 4 | 5 | func maxVowels(s string, k int) int { 6 | vowels := "aeiou" 7 | 8 | n := len(s) 9 | isVowel := make([]bool, n) 10 | 11 | for i, letter := range s { 12 | isVowel[i] = strings.ContainsRune(vowels, letter) 13 | } 14 | 15 | maxVowelsCount := 0 16 | 17 | // (left; right] 18 | for right, vowelsCount := 0, 0; right < n; right++ { 19 | left := right - k 20 | if left >= 0 && isVowel[left] { 21 | vowelsCount-- 22 | } 23 | 24 | if isVowel[right] { 25 | vowelsCount++ 26 | } 27 | 28 | if maxVowelsCount < vowelsCount { 29 | maxVowelsCount = vowelsCount 30 | } 31 | } 32 | 33 | return maxVowelsCount 34 | } 35 | -------------------------------------------------------------------------------- /LeetCode/p1491_average_salary.go: -------------------------------------------------------------------------------- 1 | func average(salary []int) float64 { 2 | n := len(salary) 3 | 4 | minSalary, maxSalary := 1000 * 1000 * 1000, 0 5 | for i := 0; i + 1 < n; i += 2 { 6 | smallSalary, largeSalary := salary[i], salary[i + 1] 7 | if smallSalary > largeSalary { 8 | smallSalary, largeSalary = largeSalary, smallSalary 9 | } 10 | if minSalary > smallSalary { 11 | minSalary = smallSalary 12 | } 13 | if maxSalary < largeSalary { 14 | maxSalary = largeSalary 15 | } 16 | } 17 | 18 | if n % 2 == 1 { 19 | lastSalary := salary[n - 1] 20 | if minSalary > lastSalary { 21 | minSalary = lastSalary 22 | } 23 | if maxSalary < lastSalary { 24 | maxSalary = lastSalary 25 | } 26 | } 27 | 28 | sum := 0 29 | for _, value := range salary { 30 | sum += value 31 | } 32 | 33 | sum -= minSalary 34 | sum -= maxSalary 35 | 36 | return float64(sum) / float64(n - 2) 37 | } 38 | -------------------------------------------------------------------------------- /LeetCode/p1498_number_of_subsequences.go: -------------------------------------------------------------------------------- 1 | func numSubseq(nums []int, target int) int { 2 | n := len(nums) 3 | 4 | sort.Ints(nums) 5 | 6 | usedPows := make([]bool, n) 7 | 8 | for left, right := 0, n - 1; left < n; left++ { 9 | for ; right >= left && nums[right] + nums[left] > target; right-- {} 10 | 11 | // nums[right] + nums[left] <= target 12 | if left <= right { 13 | free := right - left 14 | usedPows[free] = true 15 | } 16 | } 17 | 18 | answer := 0 19 | 20 | mod := 1000 * 1000 * 1000 + 7 21 | pow := 1 22 | for _, usedPow := range usedPows { 23 | if usedPow { 24 | answer += pow 25 | if answer >= mod { 26 | answer -= mod 27 | } 28 | } 29 | 30 | pow += pow 31 | if pow >= mod { 32 | pow -= mod 33 | } 34 | } 35 | 36 | return answer 37 | } 38 | -------------------------------------------------------------------------------- /LeetCode/p1502_can_make_arithmetic_progression_linear.go: -------------------------------------------------------------------------------- 1 | // O(N) solution 2 | func canMakeArithmeticProgression(arr []int) bool { 3 | values := make(map[int]bool) 4 | for _, value := range arr { 5 | values[value] = true 6 | } 7 | 8 | min, max := arr[0], arr[0] 9 | for _, value := range arr { 10 | if min > value { 11 | min = value 12 | } 13 | 14 | if max < value { 15 | max = value 16 | } 17 | } 18 | 19 | delta := max - min 20 | n := len(arr) 21 | if delta % (n - 1) != 0 { 22 | return false 23 | } 24 | 25 | delta /= (n - 1) 26 | 27 | for i := 0; i < n; i++ { 28 | expected := min + i * delta 29 | if !values[expected] { 30 | return false 31 | } 32 | } 33 | 34 | return true 35 | } 36 | -------------------------------------------------------------------------------- /LeetCode/p1502_can_make_arithmetic_progression_sort.go: -------------------------------------------------------------------------------- 1 | func canMakeArithmeticProgression(arr []int) bool { 2 | sort.Ints(arr) 3 | 4 | delta := arr[1] - arr[0] 5 | for i, value := range arr { 6 | if value - arr[0] != i * delta { 7 | return false 8 | } 9 | } 10 | 11 | return true 12 | } 13 | -------------------------------------------------------------------------------- /LeetCode/p1547_cut_the_stick_iterative.go: -------------------------------------------------------------------------------- 1 | func minCost(size int, cuts []int) int { 2 | sort.Ints(cuts) 3 | cuts = append([]int{0}, cuts...) 4 | cuts = append(cuts, size) 5 | 6 | n := len(cuts) - 1 7 | 8 | inf := size * (n + 1) 9 | 10 | dp := make([][]int, n) 11 | for start := range dp { 12 | dp[start] = make([]int, n + 1) 13 | for end := start; end <= n; end++ { 14 | dp[start][end] = inf 15 | } 16 | 17 | dp[start][start + 1] = 0 18 | } 19 | 20 | for shift := 2; shift <= n; shift++ { 21 | for end := shift; end <= n; end++ { 22 | start := end - shift 23 | length := cuts[end] - cuts[start] 24 | for mid := start + 1; mid < end; mid++ { 25 | cost := dp[start][mid] + dp[mid][end] + length 26 | if dp[start][end] > cost { 27 | dp[start][end] = cost 28 | } 29 | } 30 | } 31 | } 32 | 33 | return dp[0][n] 34 | } 35 | -------------------------------------------------------------------------------- /LeetCode/p1547_cut_the_stick_recursive.go: -------------------------------------------------------------------------------- 1 | func minCost(size int, cuts []int) int { 2 | sort.Ints(cuts) 3 | cuts = append([]int{0}, cuts...) 4 | cuts = append(cuts, size) 5 | 6 | n := len(cuts) - 1 7 | 8 | inf := size * (n + 1) 9 | 10 | dp := make([][]int, n) 11 | for start := range dp { 12 | dp[start] = make([]int, n + 1) 13 | for end := start; end <= n; end++ { 14 | dp[start][end] = inf 15 | } 16 | 17 | dp[start][start + 1] = 0 18 | } 19 | 20 | var calculate func(int, int) int 21 | calculate = func(start, end int) int { 22 | if dp[start][end] < inf { 23 | return dp[start][end] 24 | } 25 | 26 | length := cuts[end] - cuts[start] 27 | for mid := start + 1; mid < end; mid++ { 28 | cost := calculate(start, mid) + calculate(mid, end) + length 29 | if dp[start][end] > cost { 30 | dp[start][end] = cost 31 | } 32 | } 33 | 34 | return dp[start][end] 35 | } 36 | 37 | return calculate(0, n) 38 | } 39 | -------------------------------------------------------------------------------- /LeetCode/p1557_minimum_number_of_vertices.go: -------------------------------------------------------------------------------- 1 | func findSmallestSetOfVertices(n int, edges [][]int) []int { 2 | inDegrees := make([]int, n) 3 | for _, edge := range edges { 4 | inDegrees[edge[1]]++ 5 | } 6 | 7 | ans := make([]int, 0) 8 | for v, inDegree := range inDegrees { 9 | if inDegree == 0 { 10 | ans = append(ans, v) 11 | } 12 | } 13 | 14 | return ans 15 | } 16 | -------------------------------------------------------------------------------- /LeetCode/p1569_reorder_array_same_bst.go: -------------------------------------------------------------------------------- 1 | func numOfWays(nums []int) int { 2 | var mod int64 = 1000 * 1000 * 1000 + 7 3 | 4 | n := len(nums) 5 | binom := make([][]int64, n + 1) 6 | for i := 0; i <= n; i++ { 7 | binom[i] = make([]int64, i + 1) 8 | binom[i][0] = 1 9 | binom[i][i] = 1 10 | for j := 1; j < i; j++ { 11 | binom[i][j] = (binom[i - 1][j - 1] + binom[i - 1][j]) % mod 12 | } 13 | } 14 | 15 | used := make([]bool, n + 1) 16 | 17 | var ans int64 = 1 18 | for _, root := range nums { 19 | left := root 20 | for ; left >= 1 && !used[left]; left-- { } 21 | 22 | right := root 23 | for ; right <= n && !used[right]; right++ { } 24 | 25 | ans *= binom[right - left - 2][root - left - 1] 26 | ans %= mod 27 | 28 | used[root] = true 29 | } 30 | 31 | ans += mod - 1 32 | ans %= mod 33 | 34 | return int(ans) 35 | } 36 | -------------------------------------------------------------------------------- /LeetCode/p1572_matrix_diagonal_sum.go: -------------------------------------------------------------------------------- 1 | func diagonalSum(mat [][]int) int { 2 | answer := 0 3 | 4 | n := len(mat) 5 | for i, row := range mat { 6 | answer += row[i] + row[n - i - 1] 7 | } 8 | 9 | if n % 2 == 1 { 10 | answer -= mat[n / 2][n / 2] 11 | } 12 | 13 | return answer 14 | } 15 | -------------------------------------------------------------------------------- /LeetCode/p1603_design_parking.go: -------------------------------------------------------------------------------- 1 | type ParkingSystem struct { 2 | free [3]int 3 | } 4 | 5 | 6 | func Constructor(big int, medium int, small int) ParkingSystem { 7 | return ParkingSystem { 8 | free: [3]int{ 9 | big, 10 | medium, 11 | small, 12 | }, 13 | } 14 | } 15 | 16 | 17 | func (this *ParkingSystem) AddCar(carType int) bool { 18 | carType-- 19 | if this.free[carType] == 0 { 20 | return false 21 | } 22 | 23 | this.free[carType]-- 24 | return true 25 | } 26 | 27 | 28 | /** 29 | * Your ParkingSystem object will be instantiated and called as such: 30 | * obj := Constructor(big, medium, small); 31 | * param_1 := obj.AddCar(carType); 32 | */ 33 | -------------------------------------------------------------------------------- /LeetCode/p1721_swapping_nodes.go: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * type ListNode struct { 4 | * Val int 5 | * Next *ListNode 6 | * } 7 | */ 8 | func len(head* ListNode) int { 9 | n := 0 10 | for cur := head; cur != nil; cur = cur.Next { 11 | n++ 12 | } 13 | return n 14 | } 15 | 16 | func get(head* ListNode, need int) *ListNode { 17 | cur := head 18 | for pos := 1; pos < need; pos++ { 19 | cur = cur.Next 20 | } 21 | return cur 22 | } 23 | 24 | func swapNodes(head *ListNode, k int) *ListNode { 25 | n := len(head) 26 | 27 | left := get(head, k) 28 | right := get(head, n - k + 1) 29 | 30 | left.Val, right.Val = right.Val, left.Val 31 | 32 | return head 33 | } 34 | -------------------------------------------------------------------------------- /LeetCode/p1732_find_the_highest_altitude.go: -------------------------------------------------------------------------------- 1 | func largestAltitude(gain []int) int { 2 | ans := 0 3 | 4 | sum := 0 5 | for _, v := range gain { 6 | sum += v 7 | if ans < sum { 8 | ans = sum 9 | } 10 | } 11 | 12 | return ans 13 | } 14 | -------------------------------------------------------------------------------- /LeetCode/p1799_maximize_score.go: -------------------------------------------------------------------------------- 1 | func gcd(a, b int) int { 2 | for ; a != 0; a, b = b % a, a {} 3 | return b 4 | } 5 | 6 | func getBit(mask, bit int) bool { 7 | return ((mask >> bit) & 1) != 0 8 | } 9 | 10 | func maxScore(nums []int) int { 11 | n := len(nums) 12 | 13 | g := make([][]int, n) 14 | for i, vi := range nums { 15 | g[i] = make([]int, n) 16 | for j, vj := range nums { 17 | g[i][j] = gcd(vi, vj) 18 | } 19 | } 20 | 21 | size := 1 << n 22 | 23 | dp := make([]int, size) 24 | 25 | for mask := 1; mask < size; mask++ { 26 | dp[mask] = -1 27 | 28 | bitCount := bits.OnesCount(uint(mask)) 29 | if bitCount % 2 == 1 { 30 | continue 31 | } 32 | 33 | res := dp[mask] 34 | 35 | iteration := bitCount / 2 36 | for first := 0; first < n; first++ { 37 | if !getBit(mask, first) { 38 | continue 39 | } 40 | 41 | maskWithoutFirst := mask ^ (1 << first) 42 | for second := first + 1; second < n; second++ { 43 | if !getBit(mask, second) { 44 | continue 45 | } 46 | 47 | prevMask := maskWithoutFirst ^ (1 << second) 48 | 49 | firstSecondRes := dp[prevMask] + g[first][second] * iteration 50 | if res < firstSecondRes { 51 | res = firstSecondRes 52 | } 53 | } 54 | } 55 | 56 | dp[mask] = res 57 | } 58 | 59 | return dp[size - 1] 60 | } 61 | -------------------------------------------------------------------------------- /LeetCode/p1802_maximum_value_in_bounded_array.go: -------------------------------------------------------------------------------- 1 | func maxValue(n int, index int, maxSum int) int { 2 | var sum func(int, int) int64 3 | sum = func(right, left int) int64 { 4 | size := right - left + 1 5 | return int64(size) * int64(right + left) / 2 6 | } 7 | 8 | var max func(int, int) int 9 | max = func(a, b int) int { 10 | if a > b { 11 | return a 12 | } 13 | return b 14 | } 15 | 16 | leftDistance, rightDistance := index, n - index - 1 17 | 18 | left, right := 0, maxSum + 1 19 | for left + 1 < right { 20 | mid := (left + right) / 2 21 | 22 | leftSum := sum(mid, max(0, mid - leftDistance)) 23 | rightSum := sum(mid, max(0, mid - rightDistance)) 24 | 25 | totalSum := leftSum + rightSum - int64(mid) + int64(n) 26 | if totalSum <= int64(maxSum) { 27 | left = mid 28 | } else { 29 | right = mid 30 | } 31 | } 32 | 33 | return left + 1 34 | } 35 | -------------------------------------------------------------------------------- /LeetCode/p1822_sign_of_the_product.go: -------------------------------------------------------------------------------- 1 | func signum(num int) int { 2 | if num < 0 { 3 | return -1 4 | } 5 | if num > 0 { 6 | return 1 7 | } 8 | return 0 9 | } 10 | 11 | func arraySign(nums []int) int { 12 | answer := 1 13 | 14 | for _, num := range nums { 15 | answer *= signum(num) 16 | } 17 | 18 | return answer 19 | } 20 | -------------------------------------------------------------------------------- /LeetCode/p1964_longest_valid_obstacle_course.go: -------------------------------------------------------------------------------- 1 | func longestObstacleCourseAtEachPosition(obstacles []int) []int { 2 | n := len(obstacles) 3 | 4 | lenToMin := make([]int, 1, n + 1) 5 | lenToMin[0] = -1 6 | 7 | answer := make([]int, n) 8 | for i, value := range obstacles { 9 | firstLarger := sort.Search(len(lenToMin), func(mid int) bool { 10 | return lenToMin[mid] > value 11 | }) 12 | 13 | if len(lenToMin) == firstLarger { 14 | lenToMin = append(lenToMin, -1) 15 | } 16 | 17 | answer[i] = firstLarger 18 | lenToMin[firstLarger] = value 19 | } 20 | 21 | return answer 22 | } 23 | -------------------------------------------------------------------------------- /LeetCode/p2090_k_radius_prefix_sums.go: -------------------------------------------------------------------------------- 1 | func getAverages(nums []int, k int) []int { 2 | n := len(nums) 3 | prefs := make([]int64, n + 1) 4 | for i, v := range nums { 5 | prefs[i + 1] = prefs[i] + int64(v) 6 | } 7 | 8 | ans := make([]int, n) 9 | for i := range ans { 10 | ans[i] = -1 11 | } 12 | 13 | size := 2 * k + 1 14 | for i := range prefs { 15 | left := i - k 16 | right := i + k 17 | 18 | if left > 0 && right < len(prefs) { 19 | sum := prefs[right] - prefs[left - 1] 20 | ans[i - 1] = int(sum / int64(size)) 21 | } 22 | } 23 | 24 | return ans 25 | } 26 | -------------------------------------------------------------------------------- /LeetCode/p2101_detonate_maximum_bombs.go: -------------------------------------------------------------------------------- 1 | func maximumDetonation(bombs [][]int) int { 2 | var detonates func(int, int) bool 3 | detonates = func(from, to int) bool { 4 | dx := int64(bombs[to][0] - bombs[from][0]) 5 | dy := int64(bombs[to][1] - bombs[from][1]) 6 | r := int64(bombs[from][2]) 7 | 8 | return dx * dx + dy * dy <= r * r 9 | } 10 | 11 | n := len(bombs) 12 | 13 | graph := make([][]int, n) 14 | for i := range graph { 15 | for j := range bombs { 16 | if detonates(i, j) { 17 | graph[i] = append(graph[i], j) 18 | } 19 | } 20 | } 21 | 22 | best := 0 23 | 24 | for start := range graph { 25 | q := []int { start } 26 | 27 | used := make([]bool, n) 28 | used[start] = true 29 | 30 | for i := 0; i < len(q); i++ { 31 | v := q[i] 32 | for _, to := range graph[v] { 33 | if used[to] { 34 | continue 35 | } 36 | 37 | used[to] = true 38 | q = append(q, to) 39 | } 40 | } 41 | 42 | if best < len(q) { 43 | best = len(q) 44 | } 45 | } 46 | 47 | return best 48 | } 49 | -------------------------------------------------------------------------------- /LeetCode/p2130_max_twin_sum.go: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * type ListNode struct { 4 | * Val int 5 | * Next *ListNode 6 | * } 7 | */ 8 | func len(head* ListNode) int { 9 | n := 0 10 | for cur := head; cur != nil; cur = cur.Next { 11 | n++ 12 | } 13 | return n 14 | } 15 | 16 | func get(head* ListNode, need int) *ListNode { 17 | cur := head 18 | for pos := 0; pos < need; pos++ { 19 | cur = cur.Next 20 | } 21 | return cur 22 | } 23 | 24 | func reverse(start *ListNode, end *ListNode) *ListNode { 25 | var cur *ListNode = nil 26 | next := start 27 | for ; next != end; { 28 | nextNext := next.Next 29 | next.Next = cur 30 | cur, next = next, nextNext 31 | } 32 | 33 | return cur 34 | } 35 | 36 | func pairSum(head *ListNode) int { 37 | n := len(head) 38 | 39 | rightStart := get(head, n / 2) 40 | leftStart := reverse(head, rightStart) 41 | 42 | ans := 0 43 | for left, right := leftStart, rightStart; left != nil; left, right = left.Next, right.Next { 44 | sum := left.Val + right.Val 45 | if ans < sum { 46 | ans = sum 47 | } 48 | } 49 | return ans 50 | } 51 | -------------------------------------------------------------------------------- /LeetCode/p2140_solving_questions.go: -------------------------------------------------------------------------------- 1 | func mostPoints(questions [][]int) int64 { 2 | n := len(questions) 3 | 4 | dp := make([]int64, n + 1) 5 | dp[n] = 0 6 | 7 | for i := n - 1; i >= 0; i-- { 8 | res := dp[i + 1] 9 | 10 | points, delay := questions[i][0], questions[i][1] 11 | 12 | answered := int64(points) 13 | 14 | first := i + delay + 1 15 | if first <= n { 16 | answered += dp[first] 17 | } 18 | 19 | if res < answered { 20 | res = answered 21 | } 22 | 23 | dp[i] = res 24 | } 25 | 26 | return dp[0] 27 | } 28 | -------------------------------------------------------------------------------- /LeetCode/p2215_find_the_difference.go: -------------------------------------------------------------------------------- 1 | func toSet(arr []int) map[int]bool { 2 | set := make(map[int]bool) 3 | for _, value := range arr { 4 | set[value] = true 5 | } 6 | return set 7 | } 8 | 9 | func findDifference(nums1 []int, nums2 []int) [][]int { 10 | sets := []map[int]bool{ toSet(nums1), toSet(nums2) } 11 | 12 | answer := make([][]int, len(sets)) 13 | for i, set := range sets { 14 | diff := answer[i] 15 | otherSet := sets[1 - i] 16 | for value := range set { 17 | if !otherSet[value] { 18 | diff = append(diff, value) 19 | } 20 | } 21 | answer[i] = diff 22 | } 23 | 24 | return answer 25 | } 26 | -------------------------------------------------------------------------------- /LeetCode/p2352_equal_row_column_pairs_cube.go: -------------------------------------------------------------------------------- 1 | func equalPairs(grid [][]int) int { 2 | ans := 0 3 | 4 | for _, row := range grid { 5 | for c := range row { 6 | equal := true 7 | for i := range grid { 8 | equal = equal && (row[i] == grid[i][c]) 9 | } 10 | if equal { 11 | ans++ 12 | } 13 | } 14 | } 15 | 16 | return ans 17 | } 18 | -------------------------------------------------------------------------------- /LeetCode/p2352_equal_row_column_pairs_hash.go: -------------------------------------------------------------------------------- 1 | func isPrime(x int) bool { 2 | for d := 2; d * d <= x; d++ { 3 | if x % d == 0 { 4 | return false 5 | } 6 | } 7 | 8 | return true 9 | } 10 | 11 | func genPrime(start int) int64 { 12 | for ; !isPrime(start); start++ { } 13 | return int64(start) 14 | } 15 | 16 | type Hasher struct { 17 | mod int64 18 | mult int64 19 | } 20 | 21 | func initHasher(maxValue int) *Hasher { 22 | return &Hasher { 23 | mod: genPrime(1000 * 1000 * 1000 + 123), 24 | mult: genPrime(maxValue + 456), 25 | } 26 | } 27 | 28 | func (hasher *Hasher) calculate(array []int) int { 29 | var hash int64 = 0 30 | for _, value := range array { 31 | hash *= hasher.mult 32 | hash += int64(value) 33 | hash %= hasher.mod 34 | } 35 | 36 | return int(hash) 37 | } 38 | 39 | func equalPairs(grid [][]int) int { 40 | maxValue := 100 * 1000 41 | hasher := initHasher(maxValue) 42 | 43 | rowCounts := make(map[int]int) 44 | for _, row := range grid { 45 | rowCounts[hasher.calculate(row)]++ 46 | } 47 | 48 | extractColumn := func(columnIndex int) []int { 49 | column := make([]int, len(grid)) 50 | for i := range grid { 51 | column[i] = grid[i][columnIndex] 52 | } 53 | return column 54 | } 55 | 56 | ans := 0 57 | 58 | for columnIndex := range grid[0] { 59 | column := extractColumn(columnIndex) 60 | ans += rowCounts[hasher.calculate(column)] 61 | } 62 | 63 | return ans 64 | } 65 | -------------------------------------------------------------------------------- /LeetCode/p2448_minimal_cost_make_equal.go: -------------------------------------------------------------------------------- 1 | func minCost(nums []int, costs []int) int64 { 2 | n := len(nums) 3 | 4 | values := make([][2]int64, n) 5 | for i, cost := range costs { 6 | values[i] = [2]int64{ 7 | int64(nums[i]), 8 | int64(cost), 9 | } 10 | } 11 | 12 | sort.Slice(values, func(i, j int) bool { 13 | return values[i][0] < values[j][0] 14 | }) 15 | 16 | prefs := make([][2]int64, n + 1) 17 | suffs := make([][2]int64, n + 2) 18 | 19 | prefs[0] = [2]int64{ 20 | 0, 21 | 0, 22 | } 23 | 24 | for i, numCost := range values { 25 | cost := numCost[1] 26 | prefs[i + 1] = [2]int64{ 27 | prefs[i][0] + int64(cost), 28 | prefs[i][1] + int64(cost) * int64(numCost[0]), 29 | } 30 | } 31 | 32 | suffs[n + 1] = [2]int64{ 33 | 0, 34 | 0, 35 | } 36 | 37 | for i := n - 1; i >= 0; i-- { 38 | cost := values[i][1] 39 | 40 | suffs[i + 1] = [2]int64{ 41 | suffs[i + 2][0] + int64(cost), 42 | suffs[i + 2][1] + int64(cost) * int64(values[i][0]), 43 | } 44 | } 45 | 46 | ans := int64(math.MaxInt64) 47 | 48 | for i, numCost := range values { 49 | num := numCost[0] 50 | 51 | left := int64(num) * prefs[i][0] - prefs[i][1] 52 | right := suffs[i + 2][1] - int64(num) * suffs[i + 2][0] 53 | 54 | if ans > left + right { 55 | ans = left + right 56 | } 57 | } 58 | 59 | return ans 60 | } 61 | -------------------------------------------------------------------------------- /LeetCode/p2466_count_ways_to_build_string.go: -------------------------------------------------------------------------------- 1 | func countGoodStrings(low int, high int, zero int, one int) int { 2 | mod := 1000 * 1000 * 1000 + 7 3 | 4 | dp := make([]int, high + 1) 5 | dp[0] = 1 6 | 7 | for i := 1; i <= high; i++ { 8 | res := 0 9 | if i >= zero { 10 | res += dp[i - zero] 11 | if res >= mod { 12 | res -= mod 13 | } 14 | } 15 | 16 | if i >= one { 17 | res += dp[i - one] 18 | if res >= mod { 19 | res -= mod 20 | } 21 | } 22 | 23 | dp[i] = res 24 | } 25 | 26 | ans := 0 27 | for i := low; i <= high; i++ { 28 | ans += dp[i] 29 | if ans >= mod { 30 | ans -= mod 31 | } 32 | } 33 | 34 | return ans 35 | } 36 | -------------------------------------------------------------------------------- /LeetCode/p2659_make_array_empty.go: -------------------------------------------------------------------------------- 1 | func countOperationsToEmptyArray(nums []int) int64 { 2 | n := len(nums) 3 | 4 | pos := make(map[int]int) 5 | for i, value := range nums { 6 | pos[value] = i 7 | } 8 | 9 | sort.Ints(nums) 10 | 11 | ans := int64(n) 12 | for i := n - 2; i >= 0; i-- { 13 | if pos[nums[i]] > pos[nums[i + 1]] { 14 | ans += int64(n - 1 - i) 15 | } 16 | } 17 | 18 | return ans 19 | } 20 | -------------------------------------------------------------------------------- /LeetCode/p2670_distinct_difference_array.go: -------------------------------------------------------------------------------- 1 | func distinctDifferenceArray(nums []int) []int { 2 | n := len(nums) 3 | answer := make([]int, n) 4 | 5 | set := make(map[int]bool) 6 | for i, value := range nums { 7 | set[value] = true 8 | answer[i] += len(set) 9 | } 10 | 11 | set = make(map[int]bool) 12 | for i := n - 1; i >= 0; i-- { 13 | answer[i] -= len(set) 14 | value := nums[i] 15 | set[value] = true 16 | } 17 | 18 | return answer 19 | } 20 | -------------------------------------------------------------------------------- /LeetCode/p2671_frequency_tracker.go: -------------------------------------------------------------------------------- 1 | type FrequencyTracker struct { 2 | valueToFreq map[int]int 3 | freqToCount map[int]int 4 | } 5 | 6 | 7 | func Constructor() FrequencyTracker { 8 | return FrequencyTracker { 9 | valueToFreq: make(map[int]int), 10 | freqToCount: make(map[int]int), 11 | } 12 | } 13 | 14 | 15 | func (this *FrequencyTracker) Add(number int) { 16 | oldFreq := this.valueToFreq[number] 17 | if oldFreq > 0 { 18 | this.freqToCount[oldFreq]-- 19 | } 20 | 21 | this.valueToFreq[number]++ 22 | this.freqToCount[oldFreq + 1]++ 23 | } 24 | 25 | 26 | func (this *FrequencyTracker) DeleteOne(number int) { 27 | oldFreq := this.valueToFreq[number] 28 | if oldFreq == 0 { 29 | return 30 | } 31 | 32 | this.freqToCount[oldFreq]-- 33 | this.valueToFreq[number]-- 34 | 35 | if oldFreq > 1 { 36 | this.freqToCount[oldFreq - 1]++ 37 | } 38 | } 39 | 40 | 41 | func (this *FrequencyTracker) HasFrequency(frequency int) bool { 42 | return this.freqToCount[frequency] > 0 43 | } 44 | 45 | 46 | /** 47 | * Your FrequencyTracker object will be instantiated and called as such: 48 | * obj := Constructor(); 49 | * obj.Add(number); 50 | * obj.DeleteOne(number); 51 | * param_3 := obj.HasFrequency(frequency); 52 | */ 53 | -------------------------------------------------------------------------------- /LeetCode/p2672_adjacent_elements_same_color.go: -------------------------------------------------------------------------------- 1 | func colorTheArray(n int, queries [][]int) []int { 2 | colors := make([]int, n) 3 | 4 | numSegs := 0 5 | numColors := 0 6 | 7 | q := len(queries) 8 | answers := make([]int, q) 9 | 10 | for i, query := range queries { 11 | index, color := query[0], query[1] 12 | 13 | if colors[index] == 0 { 14 | numColors++ 15 | numSegs++ 16 | } else { 17 | if index > 0 && colors[index - 1] == colors[index] { 18 | numSegs++ 19 | } 20 | if index + 1 < n && colors[index + 1] == colors[index] { 21 | numSegs++ 22 | } 23 | } 24 | 25 | colors[index] = color 26 | 27 | if index > 0 && colors[index - 1] == colors[index] { 28 | numSegs-- 29 | } 30 | 31 | if index + 1 < n && colors[index + 1] == colors[index] { 32 | numSegs-- 33 | } 34 | 35 | answers[i] = numColors - numSegs 36 | } 37 | 38 | return answers 39 | } 40 | -------------------------------------------------------------------------------- /LeetCode/p2673_make_paths_equal.go: -------------------------------------------------------------------------------- 1 | func minIncrements(n int, costs []int) int { 2 | path := make([]int, n + 1) 3 | for i, cost := range costs { 4 | path[i + 1] = cost 5 | } 6 | 7 | answer := 0 8 | for i := n; i > 0; i-- { 9 | left := i * 2 10 | if left <= n { 11 | right := left + 1 12 | 13 | left_path, right_path := path[left], path[right] 14 | if left_path < right_path { 15 | left_path, right_path = right_path, left_path 16 | } 17 | 18 | answer += left_path - right_path 19 | path[i] += left_path 20 | } 21 | } 22 | 23 | return answer 24 | } 25 | -------------------------------------------------------------------------------- /LeetCode/p2706_buy_two_chocolates.go: -------------------------------------------------------------------------------- 1 | func buyChoco(prices []int, money int) int { 2 | sort.Ints(prices) 3 | 4 | total := prices[0] + prices[1] 5 | if total > money { 6 | return money 7 | } 8 | 9 | return money - total 10 | } 11 | -------------------------------------------------------------------------------- /LeetCode/p2707_extra_characters.go: -------------------------------------------------------------------------------- 1 | func minExtraChar(s string, dictionary []string) int { 2 | n := len(s) 3 | 4 | words := make(map[string]bool) 5 | for _, word := range dictionary { 6 | words[word] = true 7 | } 8 | 9 | dp := make([]int, n + 1) 10 | for start := n - 1; start >= 0; start-- { 11 | dp[start] = dp[start + 1] + 1 12 | 13 | for end := start; end <= n; end++ { 14 | word := s[start : end] 15 | if words[word] { 16 | if dp[start] > dp[end] { 17 | dp[start] = dp[end] 18 | } 19 | } 20 | } 21 | } 22 | 23 | return dp[0] 24 | } 25 | -------------------------------------------------------------------------------- /LeetCode/p2708_maximum_strength_bitmasks.go: -------------------------------------------------------------------------------- 1 | func maxStrength(nums []int) int64 { 2 | ans := int64(nums[0]) 3 | 4 | n := len(nums) 5 | for mask, lim := 1, (1 << n); mask < lim; mask++ { 6 | strength := int64(1) 7 | for i, num := range nums { 8 | if ((mask >> i) & 1) == 0 { 9 | continue 10 | } 11 | 12 | strength *= int64(num) 13 | } 14 | 15 | if ans < strength { 16 | ans = strength 17 | } 18 | } 19 | 20 | return ans 21 | } 22 | -------------------------------------------------------------------------------- /LeetCode/p2709_gcd_traversal_bfs.go: -------------------------------------------------------------------------------- 1 | func canTraverseAllPairs(nums []int) bool { 2 | hasOnes := false 3 | for _, val := range nums { 4 | if val == 1 { 5 | hasOnes = true 6 | } 7 | } 8 | 9 | if hasOnes { 10 | return len(nums) == 1 11 | } 12 | 13 | maxA := 100 * 1000 14 | 15 | used := make([]bool, maxA + 10) 16 | for _, num := range nums { 17 | used[num] = true 18 | } 19 | 20 | size := maxA + maxA + 10 21 | 22 | graph := make([][]int, size) 23 | for d := 2; d <= maxA; d++ { 24 | v := maxA + 1 + d 25 | for i := d; i <= maxA; i += d { 26 | if used[i] { 27 | graph[v] = append(graph[v], i) 28 | graph[i] = append(graph[i], v) 29 | } 30 | } 31 | } 32 | 33 | vis := make([]bool, size) 34 | 35 | start := nums[0] 36 | q := []int { start } 37 | vis[start] = true 38 | 39 | for i := 0; i < len(q); i++ { 40 | v := q[i] 41 | for _, to := range graph[v] { 42 | if vis[to] { 43 | continue 44 | } 45 | 46 | vis[to] = true 47 | q = append(q, to) 48 | } 49 | } 50 | 51 | for _, num := range nums { 52 | if !vis[num] { 53 | return false 54 | } 55 | } 56 | 57 | return true 58 | } 59 | -------------------------------------------------------------------------------- /LeetCode/utils/dsu.go: -------------------------------------------------------------------------------- 1 | // DSU is 'disjoint set union', also known as 'union-find' 2 | // Details: 3 | // - [e-maxx]: https://e-maxx.ru/algo/dsu 4 | // - [cp-algorithms]: https://cp-algorithms.com/data_structures/disjoint_set_union.html 5 | // - [CF Edu]: https://codeforces.com/edu/course/2/lesson/7 6 | type DSU struct { 7 | parents []int 8 | sizes []int 9 | } 10 | 11 | // Returns 'root' of component with vertex 'v' 12 | // Performs 'path compression' euristic during search 13 | func (dsu *DSU) Get(v int) int { 14 | p := dsu.parents[v] 15 | if p == v { 16 | return p 17 | } 18 | 19 | dsu.parents[v] = dsu.Get(p) 20 | return dsu.parents[v] 21 | } 22 | 23 | // Tries to merge components with vertices 'a' and 'b' 24 | // Returns 'true' if actual merge was done 25 | func (dsu *DSU) Merge(a int, b int) bool { 26 | ra := dsu.Get(a) 27 | rb := dsu.Get(b) 28 | 29 | if ra == rb { 30 | return false 31 | } 32 | 33 | sa := dsu.sizes[ra] 34 | sb := dsu.sizes[rb] 35 | 36 | if sa < sb { 37 | ra, rb = rb, ra 38 | sa, sb = sb, sa 39 | } 40 | 41 | dsu.parents[rb] = ra 42 | dsu.sizes[ra] += sb 43 | 44 | return true 45 | } 46 | 47 | // Creates DSU instance with 'n' non-connected vertices 48 | func makeDSU(size int) *DSU { 49 | parents := make([]int, size) 50 | sizes := make([]int, size) 51 | for v := 0; v < size; v++ { 52 | parents[v] = v 53 | sizes[v] = 1 54 | } 55 | 56 | return &DSU { 57 | parents: parents, 58 | sizes: sizes, 59 | } 60 | } 61 | -------------------------------------------------------------------------------- /LeetCode/utils/graph/topological_sort.go: -------------------------------------------------------------------------------- 1 | func topologicalSort(graph [][]int) (order []int) { 2 | n := len(graph) 3 | 4 | order = make([]int, 0, n) 5 | used := make([]bool, n) 6 | 7 | var topologicalSortDfs func(int) 8 | topologicalSortDfs = func(v int) { 9 | if used[v] { 10 | return 11 | } 12 | 13 | used[v] = true 14 | 15 | for _, to := range graph[v] { 16 | topologicalSortDfs(to) 17 | } 18 | 19 | order = append(order, v) 20 | } 21 | 22 | for v := range graph { 23 | topologicalSortDfs(v) 24 | } 25 | 26 | return order 27 | } 28 | -------------------------------------------------------------------------------- /LeetCode/utils/int_heap.go: -------------------------------------------------------------------------------- 1 | // Example from https://pkg.go.dev/container/heap 2 | 3 | // An IntHeap is a min-heap of ints. 4 | type IntHeap []int 5 | 6 | func (h IntHeap) Len() int { return len(h) } 7 | func (h IntHeap) Less(i, j int) bool { return h[i] < h[j] } 8 | func (h IntHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] } 9 | func (h IntHeap) Peek() int { return h[0] } 10 | 11 | func (h *IntHeap) Push(value any) { 12 | // Push and Pop use pointer receivers because they modify the slice's length, 13 | // not just its contents. 14 | *h = append(*h, value.(int)) 15 | } 16 | 17 | func (h *IntHeap) Pop() any { 18 | old := *h 19 | n := len(old) 20 | value := old[n-1] 21 | *h = old[0 : n-1] 22 | return value 23 | } 24 | 25 | func CreateHeap() *IntHeap { 26 | return &IntHeap{} 27 | } 28 | -------------------------------------------------------------------------------- /LeetCode/utils/matrix_iterator.go: -------------------------------------------------------------------------------- 1 | // provides interface for iterator over matrix cells 2 | type MatrixIterator interface { 3 | Has() bool 4 | Get() (int, int, bool) 5 | } 6 | 7 | type Step [2]int 8 | 9 | var LEFT = Step{0, 1} 10 | var RIGHT = Step{0, -1} 11 | var DOWN = Step{1, 0} 12 | var UP = Step{-1, 0} 13 | 14 | var steps = [...]Step { 15 | LEFT, 16 | RIGHT, 17 | DOWN, 18 | UP, 19 | } 20 | 21 | func checkIndex(index, size int) bool { 22 | return 0 <= index && index < size 23 | } 24 | 25 | func checkCell(x, y, n int) bool { 26 | return checkIndex(x, n) && checkIndex(y, n) 27 | } 28 | -------------------------------------------------------------------------------- /LeetCode/utils/partition.go: -------------------------------------------------------------------------------- 1 | func partition(values []int, left, right int) int { 2 | mid := left + rand.Intn(right - left + 1) 3 | midValue := values[mid] 4 | 5 | values[mid], values[right] = values[right], values[mid] 6 | 7 | firstLarger := left 8 | for i := left; i < right; i++ { 9 | if values[i] < midValue { 10 | values[i], values[firstLarger] = values[firstLarger], values[i] 11 | firstLarger++ 12 | } 13 | } 14 | 15 | values[firstLarger], values[right] = values[right], values[firstLarger] 16 | 17 | return firstLarger 18 | } 19 | 20 | func findKthStatistic(values []int, k int) { 21 | k-- 22 | 23 | for left, right := 0, len(values) - 1; left <= right; { 24 | mid := partition(values, left, right) 25 | 26 | if mid == k { 27 | break 28 | } 29 | 30 | if mid > k { 31 | right = mid - 1 32 | } else { 33 | left = mid + 1 34 | } 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /NlogN/2023/Winter/Div A/Day 5/A.py: -------------------------------------------------------------------------------- 1 | def read_ints(): 2 | return map(int, input().split()) 3 | 4 | 5 | def read_int(): 6 | return int(input()) 7 | 8 | 9 | 10 | n = read_int() 11 | a = list(read_ints()) 12 | 13 | 14 | colors = [-1] 15 | for color in a: 16 | if colors[-1] != color: 17 | colors.append(color) 18 | 19 | 20 | max_c = max(colors) 21 | merges = [0] * (max_c + 1) 22 | 23 | from collections import Counter 24 | counts = Counter(colors) 25 | 26 | for i, color in enumerate(colors[1:-1], 1): 27 | if colors[i - 1] == colors[i + 1]: 28 | merges[color] += 1 29 | 30 | colors.pop(0) 31 | 32 | ans, ans_color = -1, -1 33 | for color in colors: 34 | cur_ans = len(colors) - counts[color] - merges[color] 35 | if ans < cur_ans: 36 | ans = cur_ans 37 | ans_color = color 38 | 39 | print(ans, ans_color) 40 | -------------------------------------------------------------------------------- /NlogN/2023/Winter/Div A/Day 5/B.py: -------------------------------------------------------------------------------- 1 | def read_ints(): 2 | return map(int, input().split()) 3 | 4 | 5 | def read_int(): 6 | return int(input()) 7 | 8 | 9 | l, r = (list(input()) for _ in range(2)) 10 | 11 | l = l[::-1] 12 | r = r[::-1] 13 | 14 | while len(l) < len(r): 15 | l.append('0') 16 | 17 | 18 | while len(l) > 0 and l[-1] == r[-1]: 19 | l.pop() 20 | r.pop() 21 | 22 | print(len(l)) 23 | -------------------------------------------------------------------------------- /NlogN/2023/Winter/Div A/Day 5/C.py: -------------------------------------------------------------------------------- 1 | def read_ints(): 2 | return map(int, input().split()) 3 | 4 | 5 | def read_int(): 6 | return int(input()) 7 | 8 | 9 | n, day, transport = read_ints() 10 | classes = [tuple(read_ints()) for _ in range(n)] 11 | 12 | offline, online = 0, 1 13 | 14 | classes.append((day, day, online)) 15 | n += 1 16 | 17 | classes.sort() 18 | 19 | home, outside = 1, 0 20 | 21 | neg_inf = -(day + day + 1) 22 | dp = [[neg_inf] * (n + 1) for _ in [home, outside]] 23 | 24 | dp[home][0] = 0 25 | last_end = 0 26 | 27 | 28 | for i in range(n): 29 | cur_start, cur_end, class_type = classes[i] 30 | 31 | free_time = cur_start - last_end 32 | 33 | ## outside - outside 34 | rest_between_outside = max(0, free_time - 2 * transport) 35 | dp[outside][i + 1] = max(dp[outside][i + 1], dp[outside][i] + rest_between_outside) 36 | 37 | ## home - outside 38 | rest_before_transport = free_time - transport 39 | if rest_before_transport >= 0: 40 | dp[outside][i + 1] = max(dp[outside][i + 1], dp[home][i] + rest_before_transport) 41 | 42 | if class_type == online: 43 | class_duration = cur_end - cur_start 44 | 45 | ## home - home 46 | dp[home][i + 1] = max(dp[home][i + 1], dp[home][i] + free_time + class_duration) 47 | 48 | ## outside - home 49 | rest_after_transport = free_time - transport 50 | if rest_after_transport >= 0: 51 | dp[home][i + 1] = max(dp[home][i + 1], dp[outside][i] + rest_after_transport + class_duration) 52 | 53 | last_end = cur_end 54 | 55 | print(dp[home][-1]) 56 | -------------------------------------------------------------------------------- /NlogN/2023/Winter/Div A/Day 5/D.py: -------------------------------------------------------------------------------- 1 | def read_ints(): 2 | return map(int, input().split()) 3 | 4 | 5 | def read_int(): 6 | return int(input()) 7 | 8 | 9 | x_size, y_size = read_ints() 10 | a = [input() for _ in range(x_size)] 11 | 12 | 13 | cube, line, z_bot, z_top, trident = range(5) 14 | shifts = [ 15 | [(0, 1), (1, 0), (1, 1)], # cube 16 | [(0, 1), (0, 2), (0, 3)], # line 17 | [(0, 1), (-1, 1), (-1, 2)], # z_bot 18 | [(0, 1), (1, 1), (1, 2)], # z_top 19 | ] 20 | 21 | other = len(shifts) 22 | 23 | def get_type(x, y): 24 | if a[x][y] == '.': 25 | return -1 26 | 27 | for i, fs in enumerate(shifts): 28 | cnt = 0 29 | for xs, ys in fs: 30 | if 0 <= x + xs < x_size and 0 <= y + ys < y_size: 31 | if a[x][y] == a[x + xs][y + ys]: 32 | cnt += 1 33 | 34 | if cnt == 3: 35 | return i 36 | 37 | return other 38 | 39 | 40 | counts = [0] * (other + 2) 41 | for it in range(2): 42 | for x in range(x_size): 43 | for y in range(y_size): 44 | t = get_type(x, y) 45 | counts[t + 1] += 1 46 | 47 | a_transposed = [[a[x][y] for x in range(x_size)] for y in range(y_size)] 48 | 49 | a = a_transposed 50 | x_size, y_size = y_size, x_size 51 | 52 | shifts[z_bot], shifts[z_top] = shifts[z_top], shifts[z_bot] 53 | 54 | counts = counts[1:] 55 | counts[cube] //= 2 # calculated twice 56 | 57 | counts[other] -= 6 * counts[cube] 58 | for t in [line, z_bot, z_top]: 59 | counts[other] -= 7 * counts[t] 60 | 61 | counts[other] //= 2 # calculated twice 62 | counts[other] //= 4 # 4 letters -> 1 figure 63 | 64 | print(*counts, sep='\n') 65 | -------------------------------------------------------------------------------- /NlogN/2023/Winter/Div A/Day 5/Readme.md: -------------------------------------------------------------------------------- 1 | ### [Link to Codeforces](https://codeforces.com/group/23vhuv8RYv/contest/420110) 2 | -------------------------------------------------------------------------------- /Polygon/checker.cpp: -------------------------------------------------------------------------------- 1 | #include "problem_lib.h" 2 | 3 | using answer_t = ll; 4 | 5 | void quit_answer(answer_t expected, answer_t actual, InStream & stream) { 6 | stream.quitf( 7 | _wa, 8 | "answer is not best: expected answer %lld, found answer %lld", 9 | expected, actual 10 | ); 11 | } 12 | 13 | bool better(answer_t first, answer_t second) { 14 | 15 | } 16 | 17 | int main(int argc, char * argv[]) 18 | { 19 | registerTestlibCmd(argc, argv); 20 | 21 | // read input 22 | 23 | auto read_answer = [&](InStream & stream) { 24 | return answer_t{}; 25 | }; 26 | 27 | auto read_answer_from = [&](InStream & stream) { 28 | answer_t answer = read_answer(stream); 29 | 30 | stream.quitif( 31 | !stream.seekEof(), 32 | _pe, 33 | "Extra information in the file" 34 | ); 35 | 36 | return answer; 37 | }; 38 | 39 | // read answers (jury and participant) 40 | answer_t ja = read_answer_from(ans); 41 | answer_t pa = read_answer_from(ouf); 42 | 43 | if (better(pa, ja)) quit_answer(ja, pa, ans); 44 | if (better(ja, pa)) quit_answer(ja, pa, ouf); 45 | 46 | quitf(_ok, "OK (answer %lld)", pa); 47 | } 48 | -------------------------------------------------------------------------------- /Polygon/gen_rand.cpp: -------------------------------------------------------------------------------- 1 | #include "problem_lib.h" 2 | 3 | int main(int argc, char **argv) { 4 | registerGen(argc, argv, 1); 5 | 6 | int n = opt("n"); 7 | 8 | int minA = opt("minA"); 9 | int maxA = opt("maxA"); 10 | 11 | auto gen_test = [&]() { 12 | vi a(n); 13 | for (auto& v : a) v = rnd.next(minA, maxA); 14 | 15 | println(n); 16 | println(a); 17 | }; 18 | 19 | gen_test(); 20 | } 21 | -------------------------------------------------------------------------------- /Polygon/test_script: -------------------------------------------------------------------------------- 1 | <#assign desc = "Generators"/> 2 | 3 | <#assign a_rand = "a_rand"/> 4 | <#assign q_rand = "q_rand"/> 5 | 6 | <#assign desc = "Functions"/> 7 | 8 | <#function div a b> 9 | <#return (a / b)?long> 10 | 11 | 12 | <#function ceil a b> 13 | <#return div(a - 1, b) + 1/> 14 | 15 | 16 | <#function min a b> 17 | <#return [a, b]?sort?first> 18 | 19 | 20 | <#function max a b> 21 | <#return [a, b]?sort?last> 22 | 23 | 24 | <#function pow base power> 25 | <#assign res = 1/> 26 | <#list 1..power as it> 27 | <#assign res = res * base/> 28 | 29 | <#return res> 30 | 31 | 32 | <#function fact n> 33 | <#assign res = 1/> 34 | <#list 1..n as it> 35 | <#assign res = res * it/> 36 | 37 | <#return res> 38 | 39 | 40 | <#assign desc = "Constraints"/> 41 | 42 | <#assign minN = 1/> 43 | <#assign maxN = pow(10, 6)/> 44 | 45 | <#assign minA = 1/> 46 | <#assign maxA = pow(10, 9)/> 47 | 48 | <#assign minQ = 1/> 49 | <#assign maxQ = 3 * pow(10, 5)/> 50 | 51 | <#assign desc = "Small tests"/> 52 | 53 | <#assign smallN = 10/> 54 | <#assign smallA = pow(10, 3)/> 55 | <#assign smallQ = 100/> 56 | 57 | <#list minN..smallN as n> 58 | ${a_rand} -n=${n} -minA=${minA} -maxA=${smallA} | ${q_rand} -q=${smallQ} > $ 59 | 60 | 61 | <#assign desc = "Large tests"/> 62 | 63 | ${a_rand} -n=${maxN} -minA=${minA} -maxA=${maxA} | ${q_rand} -q=${minQ} > $ 64 | ${a_rand} -n=${maxN} -minA=${minA} -maxA=${maxA} | ${q_rand} -q=${maxQ} > $ 65 | ${a_rand} -n=${maxN} -minA=${minA} -maxA=${smallA} | ${q_rand} -q=${maxQ} > $ 66 | ${a_rand} -n=${maxN} -minA=${maxA - smallA} -maxA=${maxA} | ${q_rand} -q=${maxQ} > $ 67 | -------------------------------------------------------------------------------- /Polygon/test_script_groups: -------------------------------------------------------------------------------- 1 | <#assign largeNs = [minN - 1, 100, pow(10, 4), maxN]/> 2 | <#macro script0 group> 3 | <#assign desc = "samples"/> 4 | 5 | <#macro script1 group> 6 | <#assign desc = "n <= 100"/> 7 | 8 | <#macro script2 group> 9 | <#assign desc = "n <= 10**4"/> 10 | 11 | <#macro script3 group> 12 | <#assign desc = "full"/> 13 | 14 | <#assign scripts = [script0, script1, script2, script3]/> 15 | <#assign groupsCount = scripts?size/> 16 | <#list 0.. 17 | <#assign script = scripts[group_index]/> 18 | <@script group = group_index/> 19 | 20 | -------------------------------------------------------------------------------- /Polygon/validator.cpp: -------------------------------------------------------------------------------- 1 | #include "problem_lib.h" 2 | 3 | int main(int argc, char* argv[]) 4 | { 5 | registerValidation(argc, argv); 6 | 7 | const int MIN_N = 1, MAX_N = 1e6; 8 | const int MIN_A = 1, MAX_A = 1e9; 9 | const int MIN_Q = 1, MAX_Q = 3e5; 10 | 11 | int n = read_int(MIN_N, MAX_N, "n", SPACE_SEP); 12 | int q = read_int(MIN_Q, MAX_Q, "q"); 13 | 14 | vi a = read_ints(n, MIN_A, MAX_A, "a"); 15 | 16 | inf.readEof(); 17 | 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /Polygon/validator_groups.cpp: -------------------------------------------------------------------------------- 1 | #include "problem_lib.h" 2 | 3 | int main(int argc, char* argv[]) 4 | { 5 | registerValidation(argc, argv); 6 | 7 | const int minN = 1, maxN = 1e6; 8 | 9 | struct group_data { int maxN; }; 10 | 11 | vector groups = { 12 | {maxN}, // samples 13 | {100}, // group 1 14 | {1e4}, // group 2 15 | {minN} // group 3 16 | }; 17 | 18 | int group_index = (validator.group() != "") ? stoi(validator.group()) : 0; 19 | auto const& group = groups[group_index]; 20 | 21 | int n = read_int(minN, group.maxN, "n"); 22 | inf.readEof(); 23 | 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Competitive programming 2 | 3 | My solutions and templates for solving and preparing competitive programming problems. 4 | 5 | ## [Polygon](https://github.com/Slamur/competitive-programming/tree/master/Polygon) 6 | 7 | Templates for problem preparation via Polygon and testlib. 8 | 9 | ## [Templates](https://github.com/Slamur/competitive-programming/tree/master/course/templates) 10 | 11 | Templates for problem solving with fast IO and some util functions. 12 | -------------------------------------------------------------------------------- /RuCode/2020/AB/statements.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Slamur/competitive-programming/a42cc25758002fc15dfb12ac7f0da643d280b549/RuCode/2020/AB/statements.pdf -------------------------------------------------------------------------------- /RuCode/2020/Qual/I.py: -------------------------------------------------------------------------------- 1 | n, k = [int(s) for s in input().split()] 2 | 3 | facts = [1] * (n + 1) 4 | for i in range(1, n + 1): 5 | facts[i] = facts[i - 1] * i 6 | 7 | ans = sum(v**k for v in facts) 8 | 9 | while ans % 10 == 0: 10 | ans //= 10 11 | 12 | print(ans % 10) -------------------------------------------------------------------------------- /RuCode/2020/Qual/J.py: -------------------------------------------------------------------------------- 1 | class vect: 2 | 3 | def __init__(self, x, y): 4 | self.x = x 5 | self.y = y 6 | 7 | def len2(self): 8 | return self.x * self.x + self.y * self.y 9 | 10 | def minus(self, other): 11 | return vect(self.x - other.x, self.y - other.y) 12 | 13 | def cos(self, other): 14 | return self.x * other.x + self.y * other.y 15 | 16 | def sin(self, other): 17 | return self.x * other.y - self.y * other.x 18 | 19 | 20 | def square(a, b): 21 | return abs(a.sin(b)) 22 | 23 | 24 | def getAnswer(n, circles): 25 | mults = [] 26 | squares = [] 27 | 28 | for circle in circles: 29 | mult = 1 30 | for j in range(len(circle)): 31 | next = (j + 1) % len(circle) 32 | len2 = circle[j].minus(circle[next]).len2() 33 | mult *= len2 34 | 35 | mults.append(mult) 36 | 37 | sq = square(circle[1].minus(circle[0]), circle[2].minus(circle[0])) 38 | squares.append(sq * sq) 39 | 40 | used = [False] * n 41 | 42 | ans = 0 43 | 44 | for i in range(n): 45 | if used[i]: 46 | continue 47 | 48 | cnt = 0 49 | for j in range(i, n): 50 | if mults[i] * squares[j] == mults[j] * squares[i]: 51 | cnt += 1 52 | used[j] = True 53 | 54 | ans = max(ans, cnt) 55 | 56 | return ans 57 | 58 | 59 | n = int(input()) 60 | circles = [] 61 | for i in range(n): 62 | coords = list(map(int, input().split())) 63 | 64 | circle = [] 65 | for j in range(0, len(coords), 2): 66 | x = coords[j] 67 | y = coords[j + 1] 68 | circle.append(vect(x, y)) 69 | 70 | circles.append(circle) 71 | 72 | ans = getAnswer(n, circles) 73 | print(ans) -------------------------------------------------------------------------------- /RuCode/2020/Qual/problems.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Slamur/competitive-programming/a42cc25758002fc15dfb12ac7f0da643d280b549/RuCode/2020/Qual/problems.pdf -------------------------------------------------------------------------------- /SortMe/Task27.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n, k; 5 | std::cin >> n >> k; 6 | 7 | std::vector> queries(n); 8 | for (auto& [a, b] : queries) std::cin >> a >> b; 9 | 10 | std::vector is_prime(k + 1, true); 11 | is_prime[0] = is_prime[1] = false; 12 | for (int i = 2; i * i <= k; ++i) { 13 | if (is_prime[i]) { 14 | for (int j = i * i; j <= k; j += i) is_prime[j] = false; 15 | } 16 | } 17 | 18 | std::vector pref(k + 1, 0); 19 | for (int i = 1; i <= k; ++i) { 20 | pref[i] = pref[i - 1] + is_prime[i]; 21 | } 22 | 23 | for (auto& [a, b] : queries) { 24 | std::cout << pref[std::max(a, b)] - pref[std::min(a, b) - 1] << "\n"; 25 | } 26 | 27 | return 0; 28 | } 29 | 30 | -------------------------------------------------------------------------------- /SortMe/Task30.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using ll = int64_t; 4 | 5 | int main() { 6 | int n; 7 | std::cin >> n; 8 | 9 | std::vector words(n); 10 | for (auto& word : words) std::cin >> word; 11 | 12 | ll answer = 0; 13 | 14 | std::unordered_map mask_counts; 15 | 16 | auto get_count = [&](int mask) { 17 | auto it = mask_counts.find(mask); 18 | return (mask_counts.end() == it ? 0 : it -> second); 19 | }; 20 | 21 | for (auto& word : words) { 22 | int mask = 0; 23 | for (char letter : word) { 24 | mask ^= (1 << (letter - 'a')); 25 | } 26 | 27 | answer += get_count(mask); 28 | for (int letter = 0; letter < 26; ++letter) { 29 | answer += get_count(mask ^ (1 << letter)); 30 | } 31 | 32 | mask_counts[mask]++; 33 | } 34 | 35 | std::cout << answer << std::endl; 36 | 37 | return 0; 38 | } 39 | -------------------------------------------------------------------------------- /SortMe/Task34.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | std::cout << 0 << std::endl; 5 | 6 | return 0; 7 | } 8 | -------------------------------------------------------------------------------- /SortMe/Task35.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n, k; 5 | std::cin >> n >> k; 6 | 7 | std::vector> players(n); 8 | for (auto& [w, a] : players) std::cin >> w >> a; 9 | 10 | int block_size = n / k; 11 | 12 | std::vector> gambles_by_side(k); 13 | for (auto& [w, a] : players) gambles_by_side[w - 1].push_back(a); 14 | 15 | int sum = 0; 16 | for (auto& [w, a]: players) sum += a; 17 | 18 | for (auto& gambles : gambles_by_side) { 19 | sort(gambles.rbegin(), gambles.rend()); 20 | for (size_t i = block_size * (k - 1); i < gambles.size(); ++i) { 21 | sum -= (k + 1) * gambles[i]; 22 | } 23 | } 24 | 25 | std::cout << sum << std::endl; 26 | 27 | return 0; 28 | } 29 | 30 | -------------------------------------------------------------------------------- /VOSh/2020/School/A.py: -------------------------------------------------------------------------------- 1 | def read_ints(): 2 | # return list(map(int, input().split())) 3 | return [int(i) for i in input().split()] 4 | 5 | 6 | def read_int(): 7 | return read_ints()[0] 8 | 9 | 10 | def solve(): 11 | k = read_int() 12 | n = read_int() 13 | 14 | left = n // k 15 | right = left + 1 16 | 17 | left_x = left * k 18 | right_x = right * k 19 | 20 | ans = min(n - left_x, right_x - n) 21 | print(ans) 22 | 23 | 24 | solve() 25 | -------------------------------------------------------------------------------- /VOSh/2020/School/B.py: -------------------------------------------------------------------------------- 1 | def read_ints(): 2 | # return list(map(int, input().split())) 3 | return [int(i) for i in input().split()] 4 | 5 | 6 | def read_int(): 7 | return read_ints()[0] 8 | 9 | 10 | def get_answer(cruassans, eclers): 11 | d = 1 * 1 - 2 * 2 12 | 13 | d12 = cruassans - 2 * eclers 14 | d21 = eclers - 2 * cruassans 15 | 16 | no_answer = [-1] 17 | 18 | if d12 % d != 0 or d21 % d != 0: 19 | return no_answer 20 | 21 | b12 = d12 // d 22 | b21 = d21 // d 23 | 24 | if b12 < 0 or b21 < 0: 25 | return no_answer 26 | 27 | return [b21, b12] 28 | 29 | 30 | def solve(): 31 | cruassans = read_int() 32 | eclers = read_int() 33 | 34 | answer = get_answer(cruassans, eclers) 35 | print(*answer, sep=' ') 36 | 37 | 38 | solve() 39 | -------------------------------------------------------------------------------- /VOSh/2020/School/C.py: -------------------------------------------------------------------------------- 1 | def read_ints(): 2 | # return list(map(int, input().split())) 3 | return [int(i) for i in input().split()] 4 | 5 | 6 | def read_int(): 7 | return read_ints()[0] 8 | 9 | 10 | def get_answer(n, columns): 11 | columns_new = [-1] * n 12 | for row in range(n): 13 | column = columns[row] 14 | 15 | row_new = column 16 | column_new = n - 1 - row 17 | 18 | columns_new[row_new] = column_new 19 | 20 | return columns_new 21 | 22 | 23 | def solve(): 24 | n = read_int() 25 | columns = [read_int() - 1 for _ in range(n)] 26 | 27 | columns_new = get_answer(n, columns) 28 | 29 | answer_strings = [str(answer + 1) for answer in columns_new] 30 | print('\n'.join(answer_strings)) 31 | 32 | 33 | solve() 34 | -------------------------------------------------------------------------------- /VOSh/2020/School/D.py: -------------------------------------------------------------------------------- 1 | def read_ints(): 2 | # return list(map(int, input().split())) 3 | return [int(i) for i in input().split()] 4 | 5 | 6 | def read_int(): 7 | return read_ints()[0] 8 | 9 | 10 | import math 11 | 12 | 13 | # возвращаем res * res <= x 14 | def int_sqrt(x): 15 | res = int(math.sqrt(x)) 16 | 17 | while res * res > x: 18 | res -= 1 19 | 20 | while (res + 1) * (res + 1) <= x: 21 | res += 1 22 | 23 | return res 24 | 25 | 26 | def solve(): 27 | n = read_int() - 1 28 | 29 | left_square_root = int_sqrt(n) 30 | left_square = left_square_root * left_square_root 31 | 32 | right_square_root = left_square_root + 1 33 | right_square = right_square_root * right_square_root 34 | 35 | delta = n - left_square 36 | 37 | row = 0 38 | column = left_square_root 39 | 40 | go_down = min(left_square_root, delta) 41 | 42 | row += go_down 43 | delta -= go_down 44 | 45 | go_left = min(left_square_root, delta) 46 | 47 | column -= go_left 48 | 49 | if left_square_root % 2 == 0: 50 | row, column = column, row 51 | 52 | print(row + 1, column + 1) 53 | 54 | 55 | solve() 56 | -------------------------------------------------------------------------------- /VOSh/2020/School/E.py: -------------------------------------------------------------------------------- 1 | def read_ints(): 2 | # return list(map(int, input().split())) 3 | return [int(i) for i in input().split()] 4 | 5 | 6 | def read_int(): 7 | return read_ints()[0] 8 | 9 | 10 | def solve(): 11 | n = read_int() 12 | a = [read_int() for _ in range(n)] 13 | 14 | pref_sums = [0] * (n + 1) 15 | for i in range(n): 16 | pref_sums[i + 1] = pref_sums[i] + a[i] 17 | 18 | can_rights = [True] * n 19 | for i in range(n - 2, -1, -1): 20 | can_rights[i] = (pref_sums[i + 1] > a[i + 1]) and can_rights[i + 1] 21 | 22 | min_value = a[0] 23 | min_count = 0 24 | for value in a: 25 | if value == min_value: 26 | min_count += 1 27 | 28 | can = [False] * n 29 | for i in range(n): 30 | cant_left = (a[i] == min_value and min_count > 1) 31 | can_left = not cant_left 32 | 33 | can_right = can_rights[i] 34 | 35 | can[i] = can_left and can_right 36 | 37 | for ans in can: 38 | print(1 if ans else 0) 39 | 40 | 41 | solve() 42 | -------------------------------------------------------------------------------- /VOSh/2021/School/3/A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | /* 5 | https://codeforces.com/gym/103382/problem/1 6 | 7 | 1) Перейдем к 0-индексации 8 | 2) Лемма: если в каждом купе N мест, то места i-ого купе находятся в полуинтервале [n * i; n * i + k) 9 | 2) Для основных мест N = 4, поэтому выведем места [4 * room; 4 * room + 4) 10 | 3) Вычтем из номера дополнительных мест 45 для удобства поиска (чтобы номера начинались аналогично с 0) 11 | 4) Также обратим внимание, что доп. места нумеруются в обратном порядке относительно номеров купе, 12 | поэтому зададим обратную нумерацию: i-е купе - номер 10 - i 13 | 5) Так как для дополнительных мест N = 2, то получаем итоговую формулу полуинтервала 14 | [45 + 2 * (10 - room); 45 + 2 * (10 - room) + 2) 15 | */ 16 | int main() { 17 | int room; 18 | cin >> room; // [1; 11] 19 | --room; // [0; 10] 20 | 21 | for (int place = 0; place < 4; ++place) { 22 | cout << place + 4 * room + 1 << "\n"; 23 | } 24 | 25 | // 45 <= place -> 26 | for (int place = 0; place < 2; ++place) { 27 | cout << place + (10 - room) * 2 + 45 << "\n"; 28 | } 29 | 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /Yandex/Trainings/Intensives/1/A.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | 3 | next_height = 1 4 | 5 | # O(sqrt(n)) complexity 6 | while next_height <= n: 7 | n -= next_height 8 | next_height += 1 9 | 10 | print(next_height - 1) 11 | -------------------------------------------------------------------------------- /Yandex/Trainings/Intensives/1/B.py: -------------------------------------------------------------------------------- 1 | path = input() 2 | 3 | parts = path.split("/") 4 | 5 | ans = [""] 6 | for part in parts: 7 | if "" == part: 8 | continue 9 | if "." == part: 10 | continue 11 | if ".." == part: 12 | if len(ans) > 1: 13 | ans.pop() 14 | continue 15 | ans.append(part) 16 | 17 | if len(ans) == 1: 18 | ans.append("") 19 | 20 | ans_path = "/".join(ans) 21 | print(ans_path) 22 | -------------------------------------------------------------------------------- /Yandex/Trainings/Intensives/1/C.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | a = list(map(int, input().split())) 3 | 4 | ans_old_price, ans_new_price = 1, 1 5 | ans = (-1, -1) 6 | 7 | has = 1000 8 | volume = 1000 9 | 10 | pref_min = 0 11 | 12 | for i in range(n): 13 | new_price = a[i] 14 | if a[pref_min] > new_price: 15 | pref_min = i 16 | 17 | old_price = a[pref_min] 18 | 19 | # profit = (new_price - old_price) * (money / old_price) 20 | # profit = (new_price / old_price - 1) * money 21 | # max_profit <-> max(new_price / old_price) 22 | 23 | # ans_new / ans_old < new / old 24 | # ans_new * old < new * ans_old 25 | 26 | if ans_new_price * old_price < new_price * ans_old_price: 27 | ans = (pref_min, i) 28 | ans_old_price, ans_new_price = old_price, new_price 29 | 30 | start, end = ans 31 | print(start + 1, end + 1) 32 | -------------------------------------------------------------------------------- /Yandex/Trainings/Intensives/1/D.py: -------------------------------------------------------------------------------- 1 | MINUTES_IN_HOUR = 60 2 | HOURS_IN_DAY = 24 3 | MINUTES_IN_DAY = MINUTES_IN_HOUR * HOURS_IN_DAY 4 | 5 | 6 | def parse_time(time_str): 7 | h, m = map(int, time_str.split(":")) 8 | return h * MINUTES_IN_HOUR + m 9 | 10 | 11 | n = int(input()) 12 | a = list(map(parse_time, input().split())) 13 | 14 | a.sort() 15 | a.append(a[0] + MINUTES_IN_DAY) 16 | 17 | ans = MINUTES_IN_DAY 18 | for i in range(n): 19 | ans = min(ans, a[i + 1] - a[i]) 20 | print(ans) 21 | -------------------------------------------------------------------------------- /Yandex/Trainings/Intensives/1/E.py: -------------------------------------------------------------------------------- 1 | s = input() 2 | 3 | 4 | def get_ans(): 5 | if len(s) == 1: 6 | return "" 7 | 8 | letters = list(s) 9 | n = len(letters) 10 | 11 | all_a = True 12 | for i in range(n // 2): 13 | if letters[i] != 'a': 14 | letters[i] = 'a' 15 | all_a = False 16 | break 17 | 18 | if all_a: 19 | letters[-1] = 'b' 20 | 21 | return "".join(letters) 22 | 23 | 24 | print(get_ans()) 25 | -------------------------------------------------------------------------------- /Yandex/Trainings/Intensives/2/A.py: -------------------------------------------------------------------------------- 1 | def read_set(): 2 | input() 3 | return set(map(int, input().split())) 4 | 5 | 6 | total = 3 7 | min_need = 2 8 | sets = [read_set() for _ in range(total)] 9 | 10 | from collections import defaultdict 11 | cnts = defaultdict(int) 12 | 13 | for number_set in sets: 14 | for value in number_set: 15 | cnts[value] += 1 16 | 17 | 18 | ans = [] 19 | for value, cnt in cnts.items(): 20 | if cnt >= min_need: 21 | ans.append(value) 22 | 23 | ans.sort() 24 | print(*ans) 25 | -------------------------------------------------------------------------------- /Yandex/Trainings/Intensives/2/B.py: -------------------------------------------------------------------------------- 1 | def read_ints(): 2 | return map(int, input().split()) 3 | 4 | 5 | n, k = read_ints() 6 | a = list(read_ints()) 7 | 8 | 9 | def get_ans(): 10 | window = set() 11 | for i, v in enumerate(a): 12 | if v in window: 13 | return True 14 | 15 | window.add(v) 16 | if i >= k: 17 | window.remove(a[i - k]) 18 | 19 | return False 20 | 21 | 22 | print("YES" if get_ans() else "NO") 23 | -------------------------------------------------------------------------------- /Yandex/Trainings/Intensives/2/C.py: -------------------------------------------------------------------------------- 1 | replaces = set(input().split()) 2 | max_len = max(map(len, replaces)) 3 | 4 | 5 | def try_shortify(word): 6 | limit = min(max_len, len(word)) 7 | for prefix_len in range(limit): 8 | if word[:prefix_len + 1] in replaces: 9 | return word[:prefix_len + 1] 10 | 11 | return word 12 | 13 | 14 | text = input().split() 15 | 16 | ans = list(map(try_shortify, text)) 17 | print(*ans) 18 | -------------------------------------------------------------------------------- /Yandex/Trainings/Intensives/2/D.py: -------------------------------------------------------------------------------- 1 | def read_ints(): 2 | return map(int, input().split()) 3 | 4 | 5 | n = int(input()) 6 | a = list(read_ints()) 7 | 8 | 9 | from collections import defaultdict 10 | cnts = defaultdict(int) 11 | 12 | for v in a: 13 | cnts[v] += 1 14 | 15 | _, ans_v = max((cnt, v) for v, cnt in cnts.items()) 16 | print(ans_v) 17 | -------------------------------------------------------------------------------- /Yandex/Trainings/Intensives/2/E.py: -------------------------------------------------------------------------------- 1 | def second_transform(formula): 2 | return formula.lower() 3 | 4 | 5 | def third_transform(formula): 6 | vowels = "aeoiu" 7 | return "".join(map(lambda c: "?" if c in vowels else c, formula)) 8 | 9 | 10 | needs_count = int(input()) 11 | needs = input().split() 12 | 13 | first = set(needs) 14 | second = dict() 15 | third = dict() 16 | 17 | for i, formula in enumerate(needs): 18 | sf = second_transform(formula) 19 | tf = third_transform(sf) 20 | 21 | if not sf in second: 22 | second[sf] = i 23 | 24 | if not tf in third: 25 | third[tf] = i 26 | 27 | 28 | def match(formula): 29 | if formula in first: 30 | return formula 31 | 32 | sf = second_transform(formula) 33 | if sf in second: 34 | return needs[second[sf]] 35 | 36 | tf = third_transform(sf) 37 | if tf in third: 38 | return needs[third[tf]] 39 | 40 | return "" 41 | 42 | 43 | formulas_count = int(input()) 44 | formulas = input().split() 45 | answer = list(map(match, formulas)) 46 | print(*answer) 47 | -------------------------------------------------------------------------------- /Yandex/Trainings/Intensives/3/A_counter.py: -------------------------------------------------------------------------------- 1 | from collections import Counter 2 | 3 | 4 | s = input() 5 | t = input() 6 | 7 | is_anagram = Counter(s) == Counter(t) 8 | print('YES' if is_anagram else 'NO') 9 | -------------------------------------------------------------------------------- /Yandex/Trainings/Intensives/3/A_sorted.py: -------------------------------------------------------------------------------- 1 | s = input() 2 | t = input() 3 | 4 | is_anagram = sorted(s) == sorted(t) 5 | print('YES' if is_anagram else 'NO') 6 | -------------------------------------------------------------------------------- /Yandex/Trainings/Intensives/3/B_age_square.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | a = list(map(int, input().split())) 3 | 4 | max_age = 120 5 | 6 | cnts = [0] * (max_age + 1) 7 | for age in a: 8 | cnts[age] += 1 9 | 10 | ans = 0 11 | 12 | for x in range(max_age + 1): 13 | for y in range(max_age + 1): 14 | not_invited = False 15 | not_invited |= y * 2 <= x + 14 16 | not_invited |= y > x 17 | not_invited |= y > 100 > x 18 | if not not_invited: 19 | ans += cnts[x] * (cnts[y] - (1 if x == y else 0)) 20 | 21 | print(ans) 22 | -------------------------------------------------------------------------------- /Yandex/Trainings/Intensives/3/B_prefix_sums.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | a = list(map(int, input().split())) 3 | 4 | max_age = 120 5 | 6 | cnts = [0] * (max_age + 1) 7 | for age in a: 8 | cnts[age] += 1 9 | 10 | pref = [0] * (max_age + 1) 11 | for age in range(1, max_age + 1): 12 | pref[age] = pref[age - 1] + cnts[age] 13 | 14 | ans = 0 15 | for age in a: 16 | last_not_invited = (age + 14) // 2 17 | last_invited = age 18 | 19 | if last_not_invited < last_invited: 20 | ans += (pref[last_invited] - pref[last_not_invited] - 1) # subtract myself 21 | 22 | print(ans) 23 | -------------------------------------------------------------------------------- /Yandex/Trainings/Intensives/3/B_two_pointers.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | a = list(map(int, input().split())) 3 | 4 | max_age = 120 5 | 6 | cnts = [0] * (max_age + 1) 7 | for age in a: 8 | cnts[age] += 1 9 | 10 | ans = 0 11 | 12 | y = 0 13 | total_count = 0 14 | for x in range(max_age + 1): 15 | total_count += cnts[x] 16 | while y <= x and y * 2 <= x + 14: 17 | total_count -= cnts[y] 18 | y += 1 19 | 20 | if y <= x: 21 | ans += cnts[x] * (total_count - 1) # subtract myself 22 | 23 | print(ans) 24 | -------------------------------------------------------------------------------- /Yandex/Trainings/Intensives/3/C.py: -------------------------------------------------------------------------------- 1 | def read_ints(): 2 | return map(int, input().split()) 3 | 4 | 5 | def read_int(): 6 | return int(input()) 7 | 8 | 9 | n = read_int() 10 | a = list(read_ints()) 11 | 12 | pref = [0] * (n + 1) 13 | for i in range(n): 14 | delta = 1 if a[i] > 0 else 0 15 | pref[i + 1] = pref[i] + delta 16 | 17 | ans = [] 18 | 19 | q = read_int() 20 | for _ in range(q): 21 | left, right = read_ints() 22 | ans.append(pref[right] - pref[left - 1]) 23 | 24 | print("\n".join(map(str, ans))) 25 | -------------------------------------------------------------------------------- /Yandex/Trainings/Intensives/3/D.py: -------------------------------------------------------------------------------- 1 | def read_ints(): 2 | return map(int, input().split()) 3 | 4 | 5 | n, k = read_ints() 6 | xs = list(read_ints()) 7 | 8 | 9 | def can(min_dist): 10 | cnt = 0 11 | last = xs[0] - min_dist 12 | for x in xs: 13 | if last + min_dist <= x: 14 | cnt += 1 15 | last = x 16 | 17 | return cnt >= k 18 | 19 | 20 | left, right = 0, xs[-1] - xs[0] + 1 21 | while right - left > 1: 22 | mid = (left + right) // 2 23 | if can(mid): 24 | left = mid 25 | else: 26 | right = mid 27 | 28 | print(left) -------------------------------------------------------------------------------- /Yandex/Trainings/Intensives/3/E.py: -------------------------------------------------------------------------------- 1 | def read_ints(): 2 | return map(int, input().split()) 3 | 4 | 5 | n, k = read_ints() 6 | a = list(read_ints()) 7 | 8 | n += 1 9 | a.append(0) 10 | 11 | a.sort(reverse=True) 12 | fictive = a.index(0) 13 | 14 | pref = [0] * (n + 1) 15 | for i in range(n): 16 | pref[i + 1] = pref[i] + a[i] 17 | 18 | from collections import defaultdict 19 | cnts = defaultdict(int) 20 | for v in a: 21 | cnts[v] += 1 22 | 23 | 24 | def calc(min_power): 25 | cnt_larger = 0 26 | total_power = 0 27 | 28 | right = n - 1 29 | for left in range(n): 30 | while left < right and a[left] + a[right] <= min_power: 31 | right -= 1 32 | 33 | if left < right: 34 | total_power += (pref[right + 1] - pref[left + 1]) + (right - left) * a[left] 35 | cnt_larger += (right - left) 36 | 37 | cnt_equal = 0 38 | for i in range(n): 39 | if i == fictive: 40 | continue 41 | 42 | need = min_power - a[i] 43 | if need > a[i]: 44 | continue 45 | 46 | need_cnt = cnts.get(need, 0) 47 | if need == a[i]: 48 | need_cnt -= 1 # remove itself 49 | 50 | cnt_equal += need_cnt 51 | 52 | possible = (k <= cnt_larger + cnt_equal) 53 | total_power += max(0, k - cnt_larger) * min_power 54 | 55 | return possible, total_power 56 | 57 | 58 | def can(min_power): 59 | possible, _ = calc(min_power) 60 | return possible 61 | 62 | 63 | min_value, max_value = -10**6 - 1, 10**6 + 1 64 | left, right = min_value * 2 - 1, max_value * 2 + 1 65 | while right - left > 1: 66 | mid = (left + right) // 2 67 | if can(mid): 68 | left = mid 69 | else: 70 | right = mid 71 | 72 | _, total_power = calc(left) 73 | print(total_power) 74 | -------------------------------------------------------------------------------- /Yandex/Trainings/Intensives/4/A.py: -------------------------------------------------------------------------------- 1 | def read_ints(): 2 | return map(int, input().split()) 3 | 4 | 5 | def read_int(): 6 | return int(input()) 7 | 8 | 9 | groups_count = read_int() 10 | group_sizes = list(read_ints()) 11 | 12 | rooms_count = read_int() 13 | room_sizes = list(read_ints()) 14 | 15 | group_sizes.sort() 16 | room_sizes.sort() 17 | 18 | ans = 0 19 | 20 | room_index = 0 21 | for group_size in group_sizes: 22 | while room_index < rooms_count and room_sizes[room_index] < group_size: 23 | room_index += 1 24 | 25 | if room_index < rooms_count: 26 | ans += 1 27 | room_index += 1 28 | 29 | print(ans) 30 | -------------------------------------------------------------------------------- /Yandex/Trainings/Intensives/4/B.py: -------------------------------------------------------------------------------- 1 | def read_ints(): 2 | return map(int, input().split()) 3 | 4 | 5 | def read_int(): 6 | return int(input()) 7 | 8 | 9 | n = read_int() 10 | lectures = [tuple(read_ints()) for _ in range(n)] 11 | 12 | segments = sorted((end, start) for start, end in lectures) 13 | 14 | ans = 0 15 | 16 | last_end = -1 17 | for end, start in segments: 18 | if last_end <= start: 19 | ans += 1 20 | last_end = end 21 | 22 | print(ans) -------------------------------------------------------------------------------- /Yandex/Trainings/Intensives/4/C.py: -------------------------------------------------------------------------------- 1 | def read_ints(): 2 | return map(int, input().split()) 3 | 4 | 5 | def read_int(): 6 | return int(input()) 7 | 8 | 9 | table_length, socks_count, queries_count = read_ints() 10 | socks = [tuple(read_ints()) for _ in range(socks_count)] 11 | queries = [read_int() for _ in range(queries_count)] 12 | 13 | thickness = [0] * (table_length + 2) 14 | for left, right in socks: 15 | thickness[left] += 1 16 | thickness[right + 1] -= 1 17 | 18 | for x in range(1, len(thickness)): 19 | thickness[x] += thickness[x - 1] 20 | 21 | ans = [thickness[query] for query in queries] 22 | print("\n".join(map(str, ans))) 23 | -------------------------------------------------------------------------------- /Yandex/Trainings/Intensives/4/D_dfs.py: -------------------------------------------------------------------------------- 1 | from collections import deque 2 | 3 | 4 | def read_ints(): 5 | return map(int, input().split()) 6 | 7 | 8 | def read_int(): 9 | return int(input()) 10 | 11 | 12 | n = read_int() 13 | graph = [[] for _ in range(n)] 14 | 15 | for _ in range(n - 1): 16 | v_from, v_to = read_ints() 17 | v_from -= 1 18 | v_to -= 1 19 | graph[v_from].append(v_to) 20 | graph[v_to].append(v_from) 21 | 22 | sizes = [0] * n 23 | 24 | 25 | def dfs(v_from, p=-1): 26 | sizes[v_from] = 1 27 | for v_to in graph[v_from]: 28 | if v_to == p: 29 | continue 30 | sizes[v_from] += dfs(v_to, p=v_from) 31 | return sizes[v_from] 32 | 33 | 34 | root = 0 35 | dfs(root) 36 | 37 | print(" ".join(map(str, sizes))) 38 | -------------------------------------------------------------------------------- /Yandex/Trainings/Intensives/4/D_topsort_queue.py: -------------------------------------------------------------------------------- 1 | from collections import deque 2 | 3 | 4 | def read_ints(): 5 | return map(int, input().split()) 6 | 7 | 8 | def read_int(): 9 | return int(input()) 10 | 11 | 12 | n = read_int() 13 | graph = [[] for _ in range(n)] 14 | 15 | for _ in range(n - 1): 16 | v_from, v_to = read_ints() 17 | v_from -= 1 18 | v_to -= 1 19 | graph[v_from].append(v_to) 20 | graph[v_to].append(v_from) 21 | 22 | root = 0 23 | degrees = [len(graph[v]) for v in range(n)] 24 | degrees[root] += 1 # fictive super root 25 | 26 | leaves = deque( 27 | filter(lambda v: degrees[v] == 1, range(n)) 28 | ) 29 | 30 | sizes = [0] * n 31 | 32 | used = [False] * n 33 | while len(leaves) > 0: 34 | v_from = leaves.popleft() 35 | sizes[v_from] = 1 36 | used[v_from] = True 37 | 38 | for v_to in graph[v_from]: 39 | if used[v_to]: 40 | sizes[v_from] += sizes[v_to] 41 | else: 42 | degrees[v_to] -= 1 43 | if degrees[v_to] == 1: 44 | leaves.append(v_to) 45 | 46 | print(" ".join(map(str, sizes))) 47 | -------------------------------------------------------------------------------- /Yandex/Trainings/Intensives/4/E.py: -------------------------------------------------------------------------------- 1 | def read_ints(): 2 | return map(int, input().split()) 3 | 4 | 5 | def read_int(): 6 | return int(input()) 7 | 8 | 9 | def read_string(): 10 | return input() 11 | 12 | 13 | need_name = read_string() 14 | n = read_int() 15 | names = [read_string() for _ in range(n)] 16 | 17 | 18 | def to_spaced(name): 19 | spaces = 0 20 | for c in name: 21 | if ' ' == c: 22 | spaces += 1 23 | else: 24 | break 25 | 26 | return [spaces, name[spaces:]] 27 | 28 | 29 | spaced_names = list(map(to_spaced, names)) 30 | 31 | path = [[-1, ""]] 32 | for spaces, name in spaced_names: 33 | # [0] - spaces, [1] - name 34 | while path[-1][0] >= spaces: 35 | path.pop() 36 | 37 | if path[-1][0] + 1 != spaces: 38 | raise Exception() 39 | 40 | path.append([spaces, name]) 41 | if name == need_name: 42 | break 43 | 44 | path_names = [name for _, name in path] 45 | print("/".join(path_names)) 46 | -------------------------------------------------------------------------------- /Yandex/Trainings/S3/23.03.13. Sprint/A.py: -------------------------------------------------------------------------------- 1 | from collections import deque, defaultdict 2 | 3 | 4 | with open('input.txt', 'r') as f_in: 5 | lines = deque( 6 | line.rstrip() 7 | for line in f_in.readlines() 8 | ) 9 | 10 | 11 | def read_line(): 12 | return lines.popleft() 13 | 14 | 15 | def read_int(): 16 | return int(read_line()) 17 | 18 | 19 | def read_ints(): 20 | return map(int, read_line().split()) 21 | 22 | 23 | q = read_int() 24 | 25 | train = deque() 26 | counts = defaultdict(int) 27 | 28 | ADD_RIGHT, DELETE_RIGHT, GET_COUNT = 'add', 'delete', 'get' 29 | 30 | answers = [] 31 | for _ in range(q): 32 | params = read_line().split() 33 | command = params[0] 34 | if ADD_RIGHT == command: 35 | count = int(params[1]) 36 | name = params[2] 37 | 38 | counts[name] += count 39 | train.append((count, name)) 40 | 41 | if DELETE_RIGHT == command: 42 | count = int(params[1]) 43 | while len(train) and count > 0: 44 | last_count, last_name = train.pop() 45 | removed = min(count, last_count) 46 | 47 | count -= removed 48 | counts[last_name] -= removed 49 | 50 | last_count -= removed 51 | if last_count > 0: 52 | train.append((last_count, last_name)) 53 | 54 | if GET_COUNT == command: 55 | name = params[1] 56 | 57 | answer = counts[name] 58 | answers.append(answer) 59 | 60 | print('\n'.join(map(str, answers))) 61 | -------------------------------------------------------------------------------- /Yandex/Trainings/S3/23.03.13. Sprint/B.py: -------------------------------------------------------------------------------- 1 | from collections import deque 2 | import heapq 3 | 4 | 5 | with open('input.txt', 'r') as f_in: 6 | lines = deque( 7 | line.rstrip() 8 | for line in f_in.readlines() 9 | ) 10 | 11 | 12 | def read_line(): 13 | return lines.popleft() 14 | 15 | 16 | def read_int(): 17 | return int(read_line()) 18 | 19 | 20 | def read_ints(): 21 | return map(int, read_line().split()) 22 | 23 | 24 | n, w = read_ints() 25 | segments = [tuple([*read_ints(), i + 1]) for i in range(n)] 26 | 27 | segments.sort() 28 | 29 | inf = w + 1 30 | ends = [(inf, -1)] 31 | 32 | levels = [] 33 | for start, width, index in segments: 34 | end = start + width 35 | 36 | smallest_end, smallest_level = ends[0] 37 | if smallest_end > start: 38 | smallest_level = len(levels) 39 | levels.append([]) 40 | else: 41 | heapq.heappop(ends) 42 | 43 | levels[smallest_level].append(index) 44 | heapq.heappush(ends, (end, smallest_level)) 45 | 46 | print(len(levels)) 47 | 48 | order = [] 49 | for level in levels: 50 | order.extend(level) 51 | 52 | print(*order) -------------------------------------------------------------------------------- /Yandex/Trainings/S3/23.03.13. Sprint/C.py: -------------------------------------------------------------------------------- 1 | from collections import deque 2 | 3 | 4 | with open('input.txt', 'r') as f_in: 5 | lines = deque( 6 | line.rstrip() 7 | for line in f_in.readlines() 8 | ) 9 | 10 | 11 | def read_line(): 12 | return lines.popleft() 13 | 14 | 15 | def read_int(): 16 | return int(read_line()) 17 | 18 | 19 | def read_ints(): 20 | return map(int, read_line().split()) 21 | 22 | 23 | n = read_int() 24 | times = [tuple(read_ints()) for _ in range(n)] 25 | 26 | max_time = 0 27 | for index in range(2): 28 | max_time = max(max_time, sum(time[index] for time in times)) 29 | 30 | inf = max_time + 1 31 | 32 | dp = [[inf] * (max_time + 1) for _ in range(n + 1)] 33 | 34 | dp[0][0] = 0 35 | for i, time in enumerate(times): 36 | first, second = time 37 | 38 | prev_dp = dp[i] 39 | cur_dp= dp[i + 1] 40 | 41 | for ft in range(max_time + 1): 42 | cur_dp[ft] = prev_dp[ft] + second 43 | 44 | if ft >= first: 45 | cur_dp[ft] = min(cur_dp[ft], prev_dp[ft - first]) 46 | 47 | ans_dp = dp[n] 48 | 49 | answers = [max(ft, st) for ft, st in enumerate(ans_dp)] 50 | 51 | ans = min(answers) 52 | 53 | ft = answers.index(ans) 54 | st = ans_dp[ft] 55 | 56 | path = [] 57 | for i in range(n - 1, -1, -1): 58 | first, second = times[i] 59 | 60 | step = -1 61 | if dp[i][ft] + second == st: 62 | st -= second 63 | step = 2 64 | else: 65 | ft -= first 66 | step = 1 67 | 68 | path.append(step) 69 | 70 | path.reverse() 71 | print(*path) 72 | 73 | -------------------------------------------------------------------------------- /Yandex/Trainings/S3/23.03.13. Sprint/Readme.md: -------------------------------------------------------------------------------- 1 | ### Решения задач для [спринта](https://contest.yandex.ru/contest/46304) [Яндекс.Тренировок 3.0](https://yandex.ru/yaintern/algorithm-training) 2 | -------------------------------------------------------------------------------- /Yandex/Trainings/S4/Bruteforce/MaxCut/non_recursive_dp_2_n.py: -------------------------------------------------------------------------------- 1 | def solve(): 2 | n = int(input()) 3 | 4 | graph = [list(map(int, input().split())) for _ in range(n)] 5 | 6 | def get_bit(mask, bit): 7 | return (mask >> bit) & 1 8 | 9 | subsets = (1 << n) 10 | cuts = [0] * subsets 11 | 12 | v0s = [0] * subsets 13 | 14 | indexes = dict( 15 | (1 << v, v) 16 | for v in range(n) 17 | ) 18 | 19 | for v in range(n): 20 | v_graph = graph[v] 21 | total_sum = sum(v_graph[:v]) 22 | 23 | pref_subsets = (1 << v) 24 | v0s[0] = 0 25 | 26 | for subset in range(1, pref_subsets): 27 | prev_subset = subset & (subset - 1) 28 | smallest_bit = subset ^ prev_subset 29 | 30 | smallest_u = indexes[smallest_bit] 31 | v0s[subset] = v0s[prev_subset] + v_graph[smallest_u] 32 | 33 | for subset in range(pref_subsets - 1, -1, -1): 34 | cut = cuts[subset] 35 | 36 | v_0 = v0s[subset] 37 | v_1 = total_sum - v_0 38 | 39 | cuts[subset] = max(cuts[subset], cut + v_0) 40 | 41 | v_subset = subset | (1 << v) 42 | cuts[v_subset] = max(cuts[v_subset], cut + v_1) 43 | 44 | ans_cut, ans_subset = max( 45 | zip(cuts, range(subsets)) 46 | ) 47 | 48 | ans_parts = [get_bit(ans_subset, bit) for bit in range(n)] 49 | 50 | print(ans_cut) 51 | print(*[part + 1 for part in ans_parts]) 52 | 53 | if __name__ == '__main__': 54 | solve() 55 | -------------------------------------------------------------------------------- /Yandex/Trainings/S4/Bruteforce/MaxCut/non_recursive_dp_gray_code_2_n.py: -------------------------------------------------------------------------------- 1 | def solve(): 2 | n = int(input()) 3 | 4 | graph = [list(map(int, input().split())) for _ in range(n)] 5 | 6 | def get_bit(mask, bit): 7 | return (mask >> bit) & 1 8 | 9 | subsets = (1 << n) 10 | cuts = [0] 11 | 12 | indexes = dict( 13 | (1 << v, v) 14 | for v in range(n) 15 | ) 16 | 17 | for v in range(n): 18 | v_graph = graph[v] 19 | total_sum = sum(v_graph[:v]) 20 | 21 | pref_subsets = (1 << v) 22 | 23 | cuts.extend(cuts) 24 | 25 | v_0 = 0 26 | prev_subset = 0 27 | cuts[1 << v] = total_sum 28 | 29 | for i in range(1, pref_subsets): 30 | subset = i ^ (i >> 1) 31 | 32 | diff_bit = subset ^ prev_subset 33 | diff_u = indexes[diff_bit] 34 | 35 | prev_subset = subset 36 | 37 | w_delta = v_graph[diff_u] 38 | v_0 += w_delta if get_bit(subset, diff_u) else -w_delta 39 | 40 | cuts[subset] += v_0 41 | cuts[subset | (1 << v)] += total_sum - v_0 42 | 43 | ans_cut, ans_subset = max( 44 | zip(cuts, range(subsets)) 45 | ) 46 | 47 | ans_parts = [get_bit(ans_subset, bit) for bit in range(n)] 48 | 49 | print(ans_cut) 50 | print(*[part + 1 for part in ans_parts]) 51 | 52 | if __name__ == '__main__': 53 | solve() 54 | -------------------------------------------------------------------------------- /Yandex/Trainings/S4/Bruteforce/MaxCut/non_recursive_gray_code_n_2_n.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | using vi = vector; 6 | 7 | int get_bit(int mask, int bit) { 8 | return (mask >> bit) & 1; 9 | } 10 | 11 | void solve() { 12 | int n; 13 | cin >> n; 14 | 15 | vector graph(n, vi(n)); 16 | for (auto& row : graph) for (auto& edge : row) cin >> edge; 17 | 18 | map indexes; 19 | for (int v = 0; v < n; ++v) indexes[1 << v] = v; 20 | 21 | int cut = 0; 22 | int prev_subset = 0; 23 | 24 | int max_cut = cut, max_subset = prev_subset; 25 | 26 | int subsets = (1 << n) >> 1; 27 | 28 | for (int i = 1; i < subsets; ++i) { 29 | int subset = i ^ (i >> 1); 30 | 31 | int diff_bit = subset ^ prev_subset; 32 | int diff_v = indexes[diff_bit]; 33 | 34 | int v_part = get_bit(subset, diff_v); 35 | 36 | auto& v_graph = graph[diff_v]; 37 | for (int u = 0; u < n; ++u) { 38 | int w_delta = v_graph[u]; 39 | cut += get_bit(subset, u) == v_part ? -w_delta : w_delta; 40 | } 41 | 42 | if (max_cut < cut) { 43 | max_cut = cut; 44 | max_subset = subset; 45 | } 46 | 47 | prev_subset = subset; 48 | } 49 | 50 | cout << max_cut << "\n"; 51 | for (int v = 0; v < n; ++v, max_subset >>= 1) { 52 | int part = max_subset & 1; 53 | cout << part + 1 << " "; 54 | } 55 | cout << "\n"; 56 | } 57 | 58 | int main() { 59 | solve(); 60 | return 0; 61 | } 62 | -------------------------------------------------------------------------------- /Yandex/Trainings/S4/Bruteforce/MaxCut/non_recursive_gray_code_n_2_n.py: -------------------------------------------------------------------------------- 1 | def solve(): 2 | n = int(input()) 3 | 4 | graph = [list(map(int, input().split())) for _ in range(n)] 5 | 6 | def get_bit(mask, bit): 7 | return (mask >> bit) & 1 8 | 9 | indexes = dict( 10 | (1 << v, v) 11 | for v in range(n) 12 | ) 13 | 14 | subsets = (1 << n) >> 1 15 | 16 | cut = 0 17 | prev_subset = 0 18 | 19 | ans_cut, ans_subset = cut, prev_subset 20 | 21 | for i in range(1, subsets): 22 | subset = i ^ (i >> 1) 23 | 24 | diff_bit = subset ^ prev_subset 25 | diff_v = indexes[diff_bit] 26 | 27 | prev_subset = subset 28 | 29 | v_graph = graph[diff_v] 30 | v_part = get_bit(subset, diff_v) 31 | 32 | for u, edge in enumerate(v_graph): 33 | cut += -edge if get_bit(subset, u) else edge 34 | 35 | if ans_cut < cut: 36 | ans_cut, ans_subset = cut, subset 37 | 38 | ans_parts = [get_bit(ans_subset, bit) for bit in range(n)] 39 | 40 | print(ans_cut) 41 | print(*[part + 1 for part in ans_parts]) 42 | 43 | if __name__ == '__main__': 44 | solve() 45 | -------------------------------------------------------------------------------- /Yandex/Trainings/S4/Bruteforce/MaxCut/recursive_n_2_n.py: -------------------------------------------------------------------------------- 1 | def solve(): 2 | n = int(input()) 3 | 4 | graph = [list(map(int, input().split())) for _ in range(n)] 5 | 6 | def get_bit(mask, bit): 7 | return (mask >> bit) & 1 8 | 9 | def calc(v, parts_mask, prefix_cut): 10 | if v == n: 11 | return (prefix_cut, parts_mask) 12 | 13 | ans = None 14 | for v_part in range(2): 15 | v_delta = 0 16 | for u in range(v): 17 | if get_bit(parts_mask, u) != v_part: 18 | v_delta += graph[u][v] 19 | 20 | parts_mask ^= (v_part << v) 21 | v_ans = calc(v + 1, parts_mask, prefix_cut + v_delta) 22 | parts_mask ^= (v_part << v) 23 | 24 | if ans is None or ans < v_ans: 25 | ans = v_ans 26 | 27 | return ans 28 | 29 | ans_cut, ans_parts_mask = calc(0, 0, 0) 30 | ans_parts = [get_bit(ans_parts_mask, bit) for bit in range(n)] 31 | 32 | print(ans_cut) 33 | print(*[part + 1 for part in ans_parts]) 34 | 35 | if __name__ == '__main__': 36 | solve() 37 | -------------------------------------------------------------------------------- /course/int_float/A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | using ll = int64_t; 6 | using ld = long double; 7 | 8 | const char SPACE = ' ', ENDL = '\n'; 9 | 10 | ////////////////////////////////////////////////////////////////// 11 | 12 | template 13 | T read() { 14 | T value; 15 | cin >> value; 16 | return value; 17 | } 18 | 19 | int ri() { 20 | return read(); 21 | } 22 | 23 | ll rll() { 24 | return read(); 25 | } 26 | 27 | ////////////////////////////////////////////////////////////////// 28 | 29 | bool yn(bool result, string yes = "YES", string no = "NO") { 30 | cout << (result ? yes : no) << ENDL; 31 | return result; 32 | } 33 | 34 | ////////////////////////////////////////////////////////////////// 35 | 36 | ld sqrt_ld(ld value) { 37 | return sqrt(value); 38 | } 39 | 40 | ////////////////////////////////////////////////////////////////// 41 | 42 | void init_io() { 43 | string file_name = ""; 44 | if (!file_name.empty()) { 45 | string input_file_name = file_name + ".in"; 46 | freopen(input_file_name.c_str(), "rt", stdin); 47 | 48 | string output_file_name = file_name + ".out"; 49 | freopen(output_file_name.c_str(), "wt", stdout); 50 | } 51 | 52 | ios::sync_with_stdio(false); 53 | cin.tie(nullptr); 54 | 55 | cout << setprecision(10) << fixed; 56 | } 57 | 58 | void solve() { 59 | int w = ri(); 60 | bool can = (w % 2 == 0 && w - 2 > 0); 61 | yn(can); 62 | } 63 | 64 | int main() { 65 | init_io(); 66 | solve(); 67 | return 0; 68 | } -------------------------------------------------------------------------------- /course/int_float/B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | using ll = int64_t; 6 | using ld = long double; 7 | 8 | const char SPACE = ' ', ENDL = '\n'; 9 | 10 | ////////////////////////////////////////////////////////////////// 11 | 12 | template 13 | T read() { 14 | T value; 15 | cin >> value; 16 | return value; 17 | } 18 | 19 | int ri() { 20 | return read(); 21 | } 22 | 23 | ll rll() { 24 | return read(); 25 | } 26 | 27 | ////////////////////////////////////////////////////////////////// 28 | 29 | bool yn(bool result, string yes = "YES", string no = "NO") { 30 | cout << (result ? yes : no) << ENDL; 31 | return result; 32 | } 33 | 34 | ////////////////////////////////////////////////////////////////// 35 | 36 | ld sqrt_ld(ld value) { 37 | return sqrt(value); 38 | } 39 | 40 | ////////////////////////////////////////////////////////////////// 41 | 42 | void init_io() { 43 | string file_name = ""; 44 | if (!file_name.empty()) { 45 | string input_file_name = file_name + ".in"; 46 | freopen(input_file_name.c_str(), "rt", stdin); 47 | 48 | string output_file_name = file_name + ".out"; 49 | freopen(output_file_name.c_str(), "wt", stdout); 50 | } 51 | 52 | ios::sync_with_stdio(false); 53 | cin.tie(nullptr); 54 | 55 | cout << setprecision(10) << fixed; 56 | } 57 | 58 | void solve() { 59 | int n = ri(); 60 | int m = ri(); 61 | int a = ri(); 62 | 63 | ll w = (n - 1) / a + 1; 64 | ll h = (m - 1) / a + 1; 65 | 66 | cout << w * h << endl; 67 | } 68 | 69 | int main() { 70 | init_io(); 71 | solve(); 72 | return 0; 73 | } -------------------------------------------------------------------------------- /course/int_float/C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | using ll = int64_t; 6 | using ld = long double; 7 | 8 | const char SPACE = ' ', ENDL = '\n'; 9 | 10 | ////////////////////////////////////////////////////////////////// 11 | 12 | template 13 | T read() { 14 | T value; 15 | cin >> value; 16 | return value; 17 | } 18 | 19 | int ri() { 20 | return read(); 21 | } 22 | 23 | ll rll() { 24 | return read(); 25 | } 26 | 27 | ////////////////////////////////////////////////////////////////// 28 | 29 | bool yn(bool result, string yes = "YES", string no = "NO") { 30 | cout << (result ? yes : no) << ENDL; 31 | return result; 32 | } 33 | 34 | ////////////////////////////////////////////////////////////////// 35 | 36 | ld sqrt_ld(ld value) { 37 | return sqrt(value); 38 | } 39 | 40 | ////////////////////////////////////////////////////////////////// 41 | 42 | void init_io() { 43 | string file_name = ""; 44 | if (!file_name.empty()) { 45 | string input_file_name = file_name + ".in"; 46 | freopen(input_file_name.c_str(), "rt", stdin); 47 | 48 | string output_file_name = file_name + ".out"; 49 | freopen(output_file_name.c_str(), "wt", stdout); 50 | } 51 | 52 | ios::sync_with_stdio(false); 53 | cin.tie(nullptr); 54 | 55 | cout << setprecision(10) << fixed; 56 | } 57 | 58 | void solve() { 59 | int tests = ri(); 60 | for (int test = 0; test < tests; ++test) { 61 | ll left = ri(), right = ri(); 62 | ll sum = (left + right) * (right - left + 1) / 2; 63 | cout << sum << ENDL; 64 | } 65 | } 66 | 67 | int main() { 68 | init_io(); 69 | solve(); 70 | return 0; 71 | } -------------------------------------------------------------------------------- /course/int_float/D.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | using ll = int64_t; 6 | using ld = long double; 7 | 8 | const char SPACE = ' ', ENDL = '\n'; 9 | 10 | ////////////////////////////////////////////////////////////////// 11 | 12 | template 13 | T read() { 14 | T value; 15 | cin >> value; 16 | return value; 17 | } 18 | 19 | int ri() { 20 | return read(); 21 | } 22 | 23 | ll rll() { 24 | return read(); 25 | } 26 | 27 | ////////////////////////////////////////////////////////////////// 28 | 29 | bool yn(bool result, string yes = "YES", string no = "NO") { 30 | cout << (result ? yes : no) << ENDL; 31 | return result; 32 | } 33 | 34 | ////////////////////////////////////////////////////////////////// 35 | 36 | ld sqrt_ld(ld value) { 37 | return sqrt(value); 38 | } 39 | 40 | ////////////////////////////////////////////////////////////////// 41 | 42 | void init_io() { 43 | string file_name = ""; 44 | if (!file_name.empty()) { 45 | string input_file_name = file_name + ".in"; 46 | freopen(input_file_name.c_str(), "rt", stdin); 47 | 48 | string output_file_name = file_name + ".out"; 49 | freopen(output_file_name.c_str(), "wt", stdout); 50 | } 51 | 52 | ios::sync_with_stdio(false); 53 | cin.tie(nullptr); 54 | 55 | cout << setprecision(10) << fixed; 56 | } 57 | 58 | void solve() { 59 | ll n = rll(); 60 | ll ans = n / 2 - (n % 2) * n; 61 | cout << ans << ENDL; 62 | } 63 | 64 | int main() { 65 | init_io(); 66 | solve(); 67 | return 0; 68 | } -------------------------------------------------------------------------------- /course/int_float/I.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | using ll = int64_t; 6 | using ld = long double; 7 | 8 | const char SPACE = ' ', ENDL = '\n'; 9 | 10 | ////////////////////////////////////////////////////////////////// 11 | 12 | template 13 | T read() { 14 | T value; 15 | cin >> value; 16 | return value; 17 | } 18 | 19 | int ri() { 20 | return read(); 21 | } 22 | 23 | ll rll() { 24 | return read(); 25 | } 26 | 27 | ////////////////////////////////////////////////////////////////// 28 | 29 | bool yn(bool result, string yes = "YES", string no = "NO") { 30 | cout << (result ? yes : no) << ENDL; 31 | return result; 32 | } 33 | 34 | ////////////////////////////////////////////////////////////////// 35 | 36 | ld sqrt_ld(ld value) { 37 | return sqrt(value); 38 | } 39 | 40 | ////////////////////////////////////////////////////////////////// 41 | 42 | void init_io() { 43 | string file_name = "pobeda"; 44 | if (!file_name.empty()) { 45 | string input_file_name = file_name + ".in"; 46 | freopen(input_file_name.c_str(), "rt", stdin); 47 | 48 | string output_file_name = file_name + ".out"; 49 | freopen(output_file_name.c_str(), "wt", stdout); 50 | } 51 | 52 | ios::sync_with_stdio(false); 53 | cin.tie(nullptr); 54 | 55 | cout << setprecision(10) << fixed; 56 | } 57 | 58 | void solve() { 59 | ll a = rll(); 60 | ll b = rll(); 61 | ll c = rll(); 62 | ll d = rll(); 63 | 64 | ll first = min(a, b); 65 | ll second = min(c, d); 66 | 67 | ll answer = sqrt_ld(first + second); 68 | cout << answer << ENDL; 69 | } 70 | 71 | int main() { 72 | init_io(); 73 | solve(); 74 | return 0; 75 | } -------------------------------------------------------------------------------- /course/int_float/L.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | using ll = int64_t; 6 | using ld = long double; 7 | 8 | const char SPACE = ' ', ENDL = '\n'; 9 | 10 | ////////////////////////////////////////////////////////////////// 11 | 12 | template 13 | T read() { 14 | T value; 15 | cin >> value; 16 | return value; 17 | } 18 | 19 | int ri() { 20 | return read(); 21 | } 22 | 23 | ll rll() { 24 | return read(); 25 | } 26 | 27 | ////////////////////////////////////////////////////////////////// 28 | 29 | bool yn(bool result, string yes = "YES", string no = "NO") { 30 | cout << (result ? yes : no) << ENDL; 31 | return result; 32 | } 33 | 34 | ////////////////////////////////////////////////////////////////// 35 | 36 | ld sqrt_ld(ld value) { 37 | return sqrt(value); 38 | } 39 | 40 | ////////////////////////////////////////////////////////////////// 41 | 42 | void init_io() { 43 | string file_name = ""; 44 | if (!file_name.empty()) { 45 | string input_file_name = file_name + ".in"; 46 | freopen(input_file_name.c_str(), "rt", stdin); 47 | 48 | string output_file_name = file_name + ".out"; 49 | freopen(output_file_name.c_str(), "wt", stdout); 50 | } 51 | 52 | ios::sync_with_stdio(false); 53 | cin.tie(nullptr); 54 | 55 | cout << setprecision(10) << fixed; 56 | } 57 | 58 | void solve() { 59 | ll n = rll(); 60 | 61 | /* 62 | i == d1 * d2, d1 <= d2 63 | d(i) % 2 == 1 -> i == d * d 64 | */ 65 | 66 | ll answer = sqrt_ld(n); 67 | cout << answer << ENDL; 68 | } 69 | 70 | int main() { 71 | init_io(); 72 | solve(); 73 | return 0; 74 | } -------------------------------------------------------------------------------- /course/string/B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | using ll = int64_t; 6 | using ld = long double; 7 | 8 | const char SPACE = ' ', ENDL = '\n'; 9 | 10 | ////////////////////////////////////////////////////////////////// 11 | 12 | template 13 | T read() { 14 | T value; 15 | cin >> value; 16 | return value; 17 | } 18 | 19 | int ri() { 20 | return read(); 21 | } 22 | 23 | ll rll() { 24 | return read(); 25 | } 26 | 27 | string rs() { 28 | return read(); 29 | } 30 | 31 | ////////////////////////////////////////////////////////////////// 32 | 33 | bool yn(bool result, string yes = "YES", string no = "NO") { 34 | cout << (result ? yes : no) << ENDL; 35 | return result; 36 | } 37 | 38 | ////////////////////////////////////////////////////////////////// 39 | 40 | ld sqrt_ld(ld value) { 41 | return sqrt(value); 42 | } 43 | 44 | ////////////////////////////////////////////////////////////////// 45 | 46 | void init_io() { 47 | string file_name = ""; 48 | if (!file_name.empty()) { 49 | string input_file_name = file_name + ".in"; 50 | freopen(input_file_name.c_str(), "rt", stdin); 51 | 52 | string output_file_name = file_name + ".out"; 53 | freopen(output_file_name.c_str(), "wt", stdout); 54 | } 55 | 56 | ios::sync_with_stdio(false); 57 | cin.tie(nullptr); 58 | 59 | cout << setprecision(10) << fixed; 60 | } 61 | 62 | void solve() { 63 | string s = rs(); 64 | 65 | string vowels = "aeoyui"; 66 | for (char ch : s) { 67 | ch = tolower(ch); 68 | if (string::npos != vowels.find(ch)) continue; 69 | 70 | cout << "." << ch; 71 | } 72 | 73 | cout << ENDL; 74 | } 75 | 76 | int main() { 77 | init_io(); 78 | solve(); 79 | return 0; 80 | } -------------------------------------------------------------------------------- /course/templates/__Solution.py: -------------------------------------------------------------------------------- 1 | import math 2 | import os.path 3 | import sys 4 | 5 | from typing import List 6 | 7 | filename = '' 8 | input_file_name = filename + '.in' 9 | output_file_name = filename + '.out' 10 | 11 | if not os.path.isfile(input_file_name): 12 | input_file_name = '' 13 | 14 | if len(input_file_name) > 0: 15 | with open(input_file_name, 'r') as file: 16 | input_lines = file.readlines() 17 | else: 18 | input_lines = sys.stdin.readlines() 19 | 20 | 21 | def fast_input(): 22 | for line in input_lines: 23 | yield line 24 | 25 | 26 | fast_input_reader = fast_input() 27 | 28 | 29 | def input(): 30 | return fast_input_reader.__next__() 31 | 32 | 33 | def read_ints(): 34 | return map(int, input().split()) 35 | 36 | 37 | def read_int(): 38 | return int(input()) 39 | 40 | 41 | output_lines = [[]] 42 | 43 | SPACE = ' ' 44 | ENDL = '\n' 45 | 46 | 47 | def print(output, sep=ENDL): 48 | line = str(output) 49 | output_lines[-1].append(line) 50 | if ENDL == sep: 51 | output_lines.append([]) 52 | 53 | 54 | def solve(): 55 | a, b = read_ints() 56 | print(a + b) 57 | 58 | 59 | def main(): 60 | solve() 61 | 62 | output = ENDL.join( 63 | SPACE.join(line_parts) 64 | for line_parts 65 | in output_lines 66 | ) + ENDL 67 | 68 | if len(input_file_name) > 0 and len(output_file_name) > 0: 69 | with open(output_file_name, 'w') as output_file: 70 | output_file.write(output) 71 | else: 72 | sys.stdout.write(output) 73 | 74 | 75 | if __name__ == '__main__': 76 | main() 77 | -------------------------------------------------------------------------------- /src/__Stress.cpp: -------------------------------------------------------------------------------- 1 | #define NSTRESS 2 | 3 | #ifdef STRESS 4 | 5 | typedef uniform_int_distribution<> uid; 6 | typedef mt19937 rnd_t; 7 | 8 | void stress() { 9 | ll seed = 12345; 10 | bool with_time = true; 11 | if (with_time) seed += time(0); 12 | rnd_t rnd(seed); 13 | 14 | uid nGen(1, 10); 15 | uid aGen(0, 999); 16 | 17 | for (int it = 0; it < 100; ++it) { 18 | int n = nGen(rnd); 19 | 20 | vi a(n); 21 | for (int i = 0; i < n; ++i) { 22 | a[i] = aGen(rnd); 23 | } 24 | 25 | auto expected = get_brute_answer(n, a); 26 | auto actual = get_answer(n, a); 27 | 28 | auto print_ans = [&](ans_t ans) { 29 | print(ans); 30 | }; 31 | 32 | if (expected != actual) { 33 | cout << "GOTCHA !!!" << endl; 34 | 35 | print(n); 36 | print_all(a); 37 | 38 | cout << "===" << endl; 39 | print_ans(expected); 40 | print_ans(actual); 41 | cout << "===" << endl; 42 | 43 | break; 44 | } 45 | } 46 | } 47 | 48 | #endif 49 | -------------------------------------------------------------------------------- /tmp/ICPC 2022 Southern and Volga Russia Qualification Contest/Readme.md: -------------------------------------------------------------------------------- 1 | ## Moved to [this directory](https://github.com/Slamur/competitive-programming/tree/master/Codeforces/Gyms/103993) 2 | --------------------------------------------------------------------------------