▲

2

▼

🏙️ Эффективное разрешение отложенных запросов с использованием двоичной кучи

leetcoder, 3 ч назад

Описание задачи 📝

У нас есть массив heights, где heights[i] представляет высоту здания i.
Также даны запросы в виде массива queries, где каждый запрос [ai,bi>] требует определить самое левое здание, на которое могут попасть Алиса и Боб, начав с ai​ и bi​ соответственно, при соблюдении следующих условий:

• Алиса и Боб могут двигаться только в здания с индексами больше их текущего.
• Они могут перейти только на здания с высотой больше их текущей.

Если подходящее здание невозможно найти, результат для данного запроса равен −1.

Идея 💡

Мне сходу не известна эффективная структура данных для онлайн-разрешения запросов.
Но можно поступить хитрее, а именно:

• Немедленно обработать "простые" запросы, где результат очевиден.
• Для сложных запросов использовать технику отложенной обработки:
  • Сначала отсортировать их по индексу правого здания.
  • Затем разрешать запросы, итерируясь по зданиям, и, храня кандидатов на разрешение в двоичной куче.

Детали подхода 🛠️

1. Предварительная обработка запросов:

Читать дальше →

▲

2

▼

🌲 Поиск в глубину для оптимального разбиения вершин дерева на специальные компоненты

leetcoder, изменено 3 ч назад

Описание задачи 📋

Дано неориентированное дерево с n узлами, пронумерованными от 0 до n−1. Также даны:
- массив рёбер edges, где каждое ребро связывает два узла,
- массив значений values, где значение values[i] связано с узлом i,
- число k.
- гарантируется, что сумма всех значений values кратна k

Необходимо найти максимальное количество компонентов, на которые можно разделить дерево, удаляя рёбра, чтобы сумма значений в каждом компоненте делилась на k.

Идея 💡

Будем разбивать дерево на компоненты рекурсивно (DFS), начиная с произвольного узла.
Несложно показать, что родительская вершина должна быть в одной компененте со всеми дочерними, для которых сумма значений в соответствующем поддереве не делится на k.

Детали подхода 🚀

1. Построение графа:
   • Представляем дерево в виде списка смежности для удобного обхода.
2. Обход дерева:
   • Запускаем DFS от корня.
   • Для каждого узла вычисляем остаток от суммы поддерева (sum%k) и проверяем, можно ли выделить текущую часть как отдельный компонент.

Читать дальше →

▲

3

▼

🌳 Обращение значений на нечетных уровнях двоичного дерева || Подход на идее BFS 0-1 🚀

leetcoder, изменено 15 ч назад

На нашей новой задаче 2415. Reverse Odd Levels of Binary Tree есть повод продемонстировать продвинутые методы Rust работы с итераторами (std::iter::successors & std::iter::zip), а также "непристойную" работу c реф-каунт ячейками :(

📜 Описание задачи

Дано идеальное бинарное дерево. Требуется изменить порядок значений узлов на всех нечетных уровнях дерева.
Идеальное дерево — это дерево, где у каждого узла два потомка, а все листья находятся на одном уровне.

💡 Идея

Мы адаптируем BFS для обхода дерева по уровням. На каждом уровне проверяется, нужно ли инвертировать порядок значений (для нечетных уровней). С помощью вспомогательной функции формируются следующие уровни дерева.

📋 Подробности подхода

1. Вспомогательная функция next_level:
   • Формирует следующий уровень дерева, собирая всех левых и правых потомков текущих узлов.
2. Завершение обработки:
   • Проверка, что текущий уровень является листовым, выполняется через условие nodes[0].borrow().left.is_none().
   • При достижении уровня листьев обработка завершается.
3. Обход уровней с помощью std::iter::successors:
   • Используется функциональный подход для последовательного формирования уровней дерева. Итератор автоматически останавливается при достижении листового уровня.

Читать дальше →

▲

4

▼

Shortest write-up ever!

leetcoder, 19-12-2024

Для задачи 769. Max Chunks To Make Sorted у меня есть очень короткое решение, а значит и разбор не стоит делать длинным ;)

Задача: Максимальное количество отсортированных блоков 🧩

Дана перестановка arr длины n. Нужно разделить массив на максимальное количество блоков, таких, что, отсортировав каждый блок по отдельности и объединив их, получится полностью отсортированный массив.

Идея

Вводим функцию баланса, зависящую от частичных сумм по индексам и значениям. Каждый новый блок формируем при нулевых балансах.

Подход

Напишем код самым коротким и непонятным читателю образом, как только умеем.

Сложность:

• O(n) по времени
• O(1) по памяти

Исходный код

impl Solution {
    pub fn max_chunks_to_sorted(arr: Vec<i32>) -> i32 {
        arr.into_iter().enumerate().fold(
            (0, 0), |acc, (val, idx)| (
                acc.0 + val as i64 - idx as i64, 
                acc.1 - (acc.0.abs()-1).min(0) as i32)
        ).1
    }
}

▲

3

▼

🛍️ Определение скидок на товары с помощью монотонного стека

leetcoder, 18-12-2024

Сегодняшняя задача 1475. Final Prices With a Special Discount in a Shop решается с помощью стандартного стека, но интересно и нестандартно выглядит мотивация его использования.

Описание задачи 🛒

У вас есть массив цен prices, где prices[i] — это цена i-го товара. Если вы покупаете товар i, вы можете получить скидку, равную цене первого товара с индексом j>i, для которого выполняется условие prices[j] ≤ prices[i]. Если такого товара нет, скидка не применяется. Требуется вернуть массив, где каждая позиция показывает финальную цену с учётом скидки.

Идея 🤔

• Мы идём по массиву цен и обрабатываем товары по порядку.
• Для каждого товара находим, для каких товаров он определяет скидку, проверяя необработанные товары с индексами слева, чья цена больше или равна текущей.
• Чтобы эффективно отслеживать эти необработанные товары, используем монотонный стек. Этот стек хранит индексы товаров, цены которых упорядочены по возрастанию. Это позволяет быстро находить и применять скидки.

Подход 🚀

1. Создаём стек discount_candidates, чтобы хранить индексы товаров, ожидающих применения скидки.
2. Итерируем по массиву prices:
   • Пока верхний элемент стека соответствует условию скидки (цена товара в стеке ≥ текущей цене), применяем скидку и удаляем элемент из стека.

Читать дальше →

▲

3

▼

Жадная сборка строки с ограничениями 😊

leetcoder, 17-12-2024

Сегодня нам предстоит несложная задача - 2182. Construct String With Repeat Limit. Но технически она получилась муторной - требует от программиста очень аккуратного подхода к себе :)

Задача 📜

Дана строка s, состоящая из произвольных символов, и число repeat_limit. Необходимо построить лексикографически максимальную строку, используя символы из s, но с ограничением:

• один и тот же символ не может встречаться более repeat_limit раз подряд.

Подход 🚀

1. Подсчёт частоты символов:
   • Используем массив размера 256, чтобы подсчитать количество вхождений каждого байта (символа).
2. Жадный выбор символов:
   • Обходим пространство символов (0–255), начиная с самого большого.
   • Добавляем текущий символ в результат до repeat_limit раз или пока его количество не исчерпается.
   • Если нужно "разорвать" последовательность, вставляем следующий по величине символ, уменьшая его количество.
3. Эффективный поиск следующего символа:
   • Вспомогательная функция find_last_valid_index ищет ближайший допустимый символ с ненулевой частотой, используя знание о текущем символе как ускоряющую подсказку.

Читать дальше →

▲

6

▼

Посвящается Сепиру и Уорфу

finder, 16-12-2024

Любимые факты об английском. Просто так, может, вы тоже порадуетесь. Ничего сверхъестественного, но удивляет, когда задумаешься.

"Ученик" ("школьник") по-английски "зрачок". То есть, "я весь внимание", буквально.

По-английски в радуге тоже семь цветов. Но это другие семь цветов. Синий и голубой ведь один и тот же цвет, а вот фиолетовые бывают разные.

"Государство" по-английски звучит примерно как "состояние дел". "Failed state" это не когда из крана перестает течь вода, а террористы мародерят в пригородах столицы, это просто констатация того, что некое "состояние дел" перестало самовоспроизводиться. "State", впрочем, даже в узком значении "состояние дел, связанное с управлением людьми на определенном куске земного шара" бывает не только таким, к которому мы привыкли (то, скорее, "nation state").

Слова "gore" в русском языке нет, хотя понятие, казалось бы, абсолютно базовое.

Слово "убийца" можно перевести на английский по меньшей мере 8 разными способами (slayer, killer, murderer, assassin, hitman, triggerman, manslayer, cutthroat). Наверное, есть больше. По-русски есть ещё душегуб, головорез (хотя он, скорее, thug, чем cutthroat) и позаимствованный "киллер". Вроде бы, всё?

Слова "зависть" и "ревность" почти взаимозаменяемы и носители языка считают нужным многословно пояснять разницу между ними, причем "зависть" (по крайней мере, в подобных заметках) считается более позитивным чувством. С другой стороны, "ревность" это вообще-то два разных слова, jealousy и insecurity, в зависимости от того, обладает ли испытывающий это чувство предметом вожделения в настоящий момент. "Insecurity", впрочем, это далеко не только "ревность". Сложна.

"Интеллигенция" по-английски "intelligentsia". В XXI веке употребляется далеко не только (и уже, по-моему, не столько) в значении "...в СССР", хотя раньше слово с таким значением почему-то никому не требовалось.

▲

3

▼

Очередь с приоритетами для оптимальной подгонки среднего уровня студентов 🎯

leetcoder, 15-12-2024

Сегодня нам предстоит решить задачу 1792. Maximum Average Pass Ratio.

Описание задачи 📚

У нас есть школа, где классы проводят итоговые экзамены. Каждый класс описывается массивом [pass_i,total_i], где:

• pass_i​ — количество учеников,

Читать дальше →

▲

4

▼

Пятница, 13-е, чудовища из зазеркалья

finder, 13-12-2024

Страшилку "серой слизи" изобрел футуролог Эрик Дрекслер еще в прошлом веке. Суть идеи в том, что самовоспроизводящиеся наноботы, если упустить их из лаборатории, могут начать бесконечно копировать себя, и в результате Земля превратится в бесформенную "серую слизь", состоящую из гигантской массы нанороботов.

В 2024 году даже самые параноидальные исследователи экзистенциальных рисков относятся к "серой слизи" не слишком всерьёз. Мы не умеем делать самовоспроизводящихся наноботов и вряд ли научимся до того, как изобретём сильный искусственный интеллект который все равно нас уничтожит, с наноботами или без них.

Да?

Нет, первый реалистичный кандидат на роль "серой слизи" уже активно обсуждается, и именно в контексте "давайте сразу запретим, не дожидаясь, пока это начнут делать".

Чтобы понятно было, что это за зверь, почему его создание относительно реалистично, и чем всё это страшно, для начала напомню про понятие хиральности. Сложные органические молекулы могут быть несимметричными. В этом случае зеркальное отражение той же молекулы будет от неё отличаться. Например, для человека молекула "левой" хиральности может быть нормальным участником его метаболизма, а "правая" будет токсична.

Почему так происходит, ведь вроде бы законы химии инвариантны относительно зеркальной симметрии? Дело в том, в этом смысле почему-то несимметричны все живые существа. Аминокислоты, из которых состоят белки, в природе существуют почти исключительно в "левой" форме, а сахара, например, глюкоза, только в "правой". Хотя при замене хиральности у всех молекул, участвующих в реакции, ничего не поменялось бы, если заменить хиральность только у части из них, она может пойти совсем иначе, поэтому то, что жизнь несимметрична, важно.

Читать дальше →

▲

3

▼

💡 Эффективный подсчет с использованием битовых операций

leetcoder, 13-12-2024

Очередная наша задача - 2593. Find Score of an Array After Marking All Elements. Ну и так как наша цель не просто решать, а показывать имплементацию разных техник, то воспользуемся-ка мы идеей битового множества (его в стандартную библиотеку Rust еще "не подвезли", так что и операции имплементируем сами).

Задача 🧩

Дан массив положительных целых чисел nums. Ваша цель — получить максимальное значение score, выполняя следующие действия:

1. Выберите наименьший немаркированный элемент массива (при равенстве — элемент с меньшим индексом).
2. Добавьте значение этого элемента к score.
3. Пометьте выбранный элемент и его двух соседей (если они существуют).
4. Повторяйте, пока все элементы не будут помечены.

Необходимо вернуть итоговое значение score.

Идея 💡

В данной задаче нужно эффективно следовать указанным правилам. Чтобы сделать это:

• (а) Мы отсортируем индексы массива nums по значениям, чтобы обрабатывать элементы в правильном порядке, начиная с наименьших.
• (б) Используем битовое множество (Vec<u128>) для компактного представления состояния "помечен" для элементов массива.

Подход 🚀

Читать дальше →

▲

3

▼

🔥 Модифицированный алгоритм Кадане для подмассивов с длиной, кратной k

leetcoder, 13-12-2024

Очередная наша задача - 3381. Maximum Subarray Sum With Length Divisible by K

Описание задачи

Дано целое число k и массив чисел nums. Необходимо найти максимальную сумму подмассива, длина которого кратна k.

🚀 Идея

Данная задача расширяет классический алгоритм нахождения максимальной суммы подмассива (алгоритм Кадане) для случаев, когда длина подмассива должна быть кратной k. Чтобы учесть это условие, мы перебираем все смещения в полуинтервале [0,k) и анализируем подмассивы с шагом k.

🔍 Подход

1. Префиксные суммы:
   • Вычисляем массив префиксных сумм, чтобы быстро находить сумму любого подмассива.
2. Перебор смещений:
   • Итерируем по всем возможным начальным смещениям [0,k), чтобы обрабатывать подмассивы длиной, кратной k.
3. Модификация алгоритма Кадане:
   • Для каждого смещения применяем алгоритм нахождения максимальной суммы подмассива.
   • Если текущая сумма становится отрицательной, начинаем новый расчет с текущей позиции (сброс индекса начала подмассива).

Читать дальше →

▲

3

▼

Скользящее окно для максимизации "красоты массива" 🌟

leetcoder, 11-12-2024

Сегодня рассмотрим достаточно простое решение задачи 2779. Maximum Beauty of an Array After Applying Operation.

Условие 📋

Дан массив nums и целое неотрицательное число k. Разрешается заменить каждый элемент массива (не более одного раза) любым числом из диапазона [nums[i]−k,nums[i]+k]. Требуется найти максимальную длину подпоследовательности массива, состоящей из одинаковых элементов (это называется "красота массива").

Идея 💡

Фактически задача сводится к нахождению наибольшего подмножества массива, все элементы которого укладываются в интервал длины 2×k. Чтобы эффективно найти такой диапазон, можно использовать метод скользящего окна по предварительно отсортированному массиву.

Подход 🛠️

1. Сортировка массива: Упорядочиваем массив, чтобы элементы, которые могут принадлежать одному диапазону, оказались рядом.
2. Скользящее окно: Используем два указателя (l и r) для определения максимального диапазона, удовлетворяющего условию nums[r]−nums[l]≤2×k.
3. Подсчёт длины диапазона: На каждом шаге обновляем результат как максимум текущей длины окна r−l.

Асимптотика 📊

• Временная сложность: O(nlog⁡n) из-за сортировки + O(n) для скользящего окна, итого O(nlog⁡n).
• Пространственная сложность: O(1), если используется сортировка "на месте".

Исходный код решения

impl Solution {
    pub fn maximum_beauty(nums: Vec<i32>, k: i32) -> i32 {
        // Create a mutable copy of nums and sort it
        let mut sorted_nums = nums.clone();
        sorted_nums.sort_unstable();

        let mut max_beauty = 0;
        let mut right = 0;

        // Iterate over each number in the sorted array
        for left in 0..sorted_nums.len() {
            // Expand the right pointer as long as the difference is within the allowed range
            while right < sorted_nums.len() && sorted_nums[right] <= sorted_nums[left] + 2 * k {
                right += 1;
            }
            // Update the maximum beauty based on the current window size
            max_beauty = max_beauty.max((right - left) as i32);
        }

        max_beauty
    }
}

▲

3

▼

🏆 Оптимальный анализ подстрок, состоящих из одного символа

leetcoder, 10-12-2024

На этот раз наша задача выглядит заковыристо - 2982. Find Longest Special Substring That Occurs Thrice II.

📝 Описание задачи

Необходимо найти длину самой длинной "особенной" подстроки, которая встречается в строке хотя бы три раза. Если такой подстроки нет, вернуть -1.

"Особенная" подстрока — это подстрока, содержащая один и тот же символ.

😊 Идея

Отбросим сразу идею перебора всех возможных подстрок (что крайне неэффективно).
Вместо этого мы сосредоточимся на последовательных участках каждого символа.
Для каждого символа достаточно рассмотреть только длины его подряд идущих сегментов, и это позволит нам эффективно вычислить искомый результат.

🚀 Подход

1. Перебираем все строчные английские буквы ('a' до 'z').
2. Для каждой буквы:
   • Находим все её подряд идущие сегменты (например, для 'aaaabbaab' сегменты: [4,2], [2,1] для 'a' и 'b').
   • Сортируем длины сегментов по убыванию.
   • Вычисляем максимальную возможную длину "особенной" подстроки, встречающейся как минимум три раза, используя метод get_triple_length.

Читать дальше →

▲

3

▼

🔢 Префиксные суммы для быстрой проверки на чередование чётности в подмассиве

leetcoder, 09-12-2024

Задача на сегодня 3152. Special Array II.

📝 Условие:

• Нам дан массив nums и запросы queries.
• Для каждого запроса [from, to] нужно проверить, является ли подмассив nums[from..=to] "особым".
• Подмассив считается "особым", если каждая пара соседних элементов в нём имеет разную чётность (один чётный, другой нечётный).

🧠 Идея:

• Решение основано на идее "вычисли один раз — используй много раз".
• Сначала выполняем линейные предвычисления префиксных количеств пар соседних элементов разной чётности.
• Затём каждый запрос обрабатывается мгновенно за O(1), что делает решение особенно эффективным для больших массивов и множества запросов 😊

💡 Подход:

1. Префиксная сумма:
   • Создаём массив prefix_count, где prefix_count[i] хранит количество пар соседних элементов с разной чётностью от начала массива до индекса i.
   • Заполняем его за O(n) в одном проходе.
2. Обработка запросов:
   • Для каждого запроса [from, to] считаем количество таких пар в диапазоне через разность: prefix_count[to] - prefix_count[from].

Читать дальше →

▲

3

▼

🏆 Максимальная ценность не более чем двух независимых событий

leetcoder, 08-12-2024

Сегодня решаем задачу 2054. Two Best Non-Overlapping Events. Будем закреплять двоичный поиск ;)

😇 Описание задачи

Дан список событий с известными для них start_time, end_time и value. Нужно выбрать максимум два непересекающихся события с максимальной общей ценностью. События пересекаются, если одно начинается до окончания другого.

💡 Идея

Сортируем события по end_time (в убывающем порядке). Для каждого события используем двоичный поиск, чтобы найти все заканчивающиеся до его начала. Остаётся найти среди них событие с максимальной ценностью, для этого будем хранить накопленные максимальные ценности в отдельном массиве max_vals.

🛠️ Подход

1. Сортировка событий: По end_time в порядке убывания.
2. Предобработка максимальных ценностей: Создаём массив max_vals с накопленной максимальной ценностью событий (справа-налево).
3. Итерация и поиск:
   • Для каждого события находим первое, заканчивающееся раньше его, через двоичный поиск.
   • Суммируем ценности текущего события и накопленной максимальной ценности по найденному индексу, обновляя общий максимум.

Читать дальше →

▲

3

▼

🚀 Выбор наибольшего разрешенного подмножества с ограничениями 🔢

leetcoder, 06-12-2024

Сегодня чуток похулиганим и предоставим переоптимизированное решение для задачи 2554. Maximum Number of Integers to Choose From a Range I. В реальном интервью такое могут потребовать лишь на уровне идеи, но нам интересно запрограммировать самим :)

Описание задачи 📋

Необходимо выбрать максимально возможное количество чисел из диапазона [1,n], при этом соблюдая ограничения:
- Числа из списка banned выбирать нельзя.
- Каждое число можно использовать не более одного раза.
- Сумма выбранных чисел не должна превышать maxSum.

Результатом должно быть количество чисел, которые можно выбрать, удовлетворяя этим условиям.

Идея решения 💡

Предвычисляем суммы запрещённых чисел и используем двоичный поиск, чтобы найти максимальное k, для которого сумма допустимых чисел в диапазоне [1,k] не превышает maxSum. Это позволяет эффективно учитывать ограничения и избежать лишних вычислений.

Обзор решения 🧠

1. Сортировка и удаление дубликатов:
   • Сортируем массив banned и удаляем повторяющиеся элементы.
2. Предвычисление кумулятивных сумм:
   • Создаем массив ban_sums, где на позиции i содержится сумма первых i запрещённых чисел. Это позволяет быстро вычислять сумму запрещённых чисел до любого предела.

Читать дальше →

▲

3

▼

🔄 Проверка преобразования строк с ограничениями на движение

leetcoder, 05-12-2024

Сегодня у нас еще одна задача на аккуратное манипулирование индексами 2337. Move Pieces to Obtain a String.

Описание задачи

Даны две строки start и target длины n, содержащие символы 'L', 'R' и '_'.

• Символ 'L' может двигаться только влево, если есть пустое место ('_') слева.
• Символ 'R' может двигаться только вправо, если есть пустое место ('_') справа.
• Необходимо определить, можно ли преобразовать строку start в строку target с соблюдением этих правил.

Идея 🧠

Задача сводится к тому, чтобы проверить, совпадают ли позиции и направления символов 'L' и 'R' в двух строках с учётом их ограничений на движение. Мы используем итерацию по строкам одновременно, отслеживая доступные символы 'L' и 'R' через счётчики.

Подход 🛠️

1. Используем метод as_bytes(), чтобы быстро перебрать символы в виде байтов.
2. Одновременно проходим по обеим строкам:
   • Если видим 'L' в target, увеличиваем счётчик доступных 'L'.
   • Если видим 'L' в start, проверяем, есть ли доступный 'L', и уменьшаем счётчик.

Читать дальше →

▲

3

▼

🔄 Проверка подпоследовательности с циклическим сдвигом алфавита

leetcoder, 04-12-2024

Сегодня на очереди задача 2825. Make String a Subsequence Using Cyclic Increments.

Описание задачи 📝

Даны две строки str1 и str2. Нужно определить, можно ли сделать str2 подпоследовательностью строки str1, выполнив не более одной операции циклического увеличения произвольного набора символов в str1.
Циклический сдвиг означает, что 'a' становится 'b', 'b' — 'c', ..., 'z' — 'a'.

Идея решения 💡

Задача почти идентична проверке подпоследовательности в строке. Единственное отличие — сравнение символов становится чуть сложнее из-за необходимости учитывать циклический сдвиг.
Мы выделяем проверку совпадения символов в отдельный метод, а в остальном используем стандартный алгоритм проверки подпоследовательности.

Реализация подхода 🚀

1. Используем два итератора для последовательного прохода по символам строк.
2. Для сравнения символов применяем отдельную функцию, учитывающую как прямое совпадение, так и циклический сдвиг.
3. При совпадении текущего символа строки str2 с символом из str1, переходим к следующему символу в str2.
4. Если все символы str2 найдены в str1 в правильном порядке, возвращаем true, иначе — false.

Сложность алгоритма 📊

Читать дальше →

▲

3

▼

Эффективное добавление пробелов в строку 🚀

leetcoder, 03-12-2024

Новый день - новая задача 2109. Adding Spaces to a String.

Условие 🧩

Дана строка s и массив индексов spaces. Нужно добавить пробелы перед символами строки, расположенными по данным индексам, и вернуть новую строку. Например, для s = "EnjoyYourCoffee" и spaces = [5, 9] результатом будет "Enjoy Your Coffee".

Если решать абы как, то можно и в ней запутаться в индексах. Мы же будем делать все максимально просто.

Идея решения 🧠

Вместо создания промежуточных строк или модификации исходной строки, мы используем построение строки с выделением памяти заранее, чтобы минимизировать накладные расходы.

Подход 🔍

1. Предварительно выделяем память для результирующей строки с помощью String::with_capacity, учитывая длину строки и количество пробелов.
2. Проходим по массиву индексов spaces:
   • Добавляем в результат подстроку от предыдущей позиции до текущего индекса.
   • Добавляем пробел.
3. После цикла добавляем оставшуюся часть строки.
4. Возвращаем итоговую строку.

Анализ сложности 📊

• Временная сложность: O(n), где n=длина строки+количество пробелов. Все операции выполняются за один проход.
• Пространственная сложность: O(n), поскольку результирующая строка создаётся с заранее выделенной памятью.

Исходный код решения

impl Solution {
    pub fn add_spaces(s: String, spaces: Vec<i32>) -> String {
        let mut result = String::with_capacity(s.len() + spaces.len()); // Pre-allocate capacity for efficiency
        let mut word_pos = 0;

        for &space_pos in &spaces {
            let space_pos = space_pos as usize; // Convert i32 to usize for indexing
            result.push_str(&s[word_pos..space_pos]); // Add the substring
            result.push(' '); // Add the space
            word_pos = space_pos;
        }

        result.push_str(&s[word_pos..]); // Add the remaining substring
        result
    }
}

▲

3

▼

Про силу воли и выгорание

finder, 03-12-2024

Спасибо загадочному пользователюleetcoder, здесь опять есть какая-то жизнь. По такому случаю попробуем сюда писать в формате классического web log, вдруг получится не бросить?

Прикольная статья про силу воли и выгорание. Как всегда на lesswrong, длинновато и напоминает домашнюю философию, но основная мысль крайне простая и что-то в ней есть.

У каждого человека есть "бюджет" силы воли. Внутренний нарратор-планировщик, он же "Система 2", когда вы хотите сделать что-то неприятное, берёт кредит из этого "бюджета". Когда в вашей жизни происходит что-то приятное (приятное на базовом, бессознательном уровне), связанное с предыдущими решениями планировщика, бюджет пополняется. Если в бюджете нет средств, вы "выгорели", у вас "не хватает силы воли". Важная часть мысли состоит в том, что "приятное" определяется бессознательно, "системой 1". Например, вы очень любите мороженое; съесть мороженое и заработать $1000 могут оказаться одинаково ценными пополнениями бессознательного бюджета, хотя объективно первое примерно в тысячу раз дешевле. Это позволяет управлять "бюджетом" на сознательном уровне, решая оптимизационную задачу, и помогать другим в том же. Например, взрослые люди, как правило, недохвалены: если они делают свою работу профессионально, затратив на это немало усилий, в том числе и волевых, то это "само собой разумеется".

▲

3

▼

🔍 Найти слово по префиксу!

leetcoder, 02-12-2024

Сегодня разберём ещё одну простую задачу 1455. Check If a Word Occurs As a Prefix of Any Word in a Sentence.

Описание задачи 📜

Дана строка sentence, состоящая из слов, разделённых пробелами, и строка searchWord. Нужно определить индекс (считаем с 1), где searchWord является префиксом какого-либо слова в sentence. Если такого слова нет — вернуть -1.

Решение 🛠️

Идея 💡

Задача сводится к простому проходу по словам строки. Мы должны проверить каждое слово: начинается ли оно с searchWord. Возвращаем индекс первого подходящего слова.

Алгоритм 🚀

1. Разделяем строку sentence на слова с помощью метода split_whitespace, который возвращает ссылки на части исходной строки.
2. Проходим по словам с их индексами через enumerate.
3. Для каждого слова проверяем, начинается ли оно с searchWord с помощью метода starts_with.
4. Если находим соответствие, возвращаем индекс (преобразуем его в формат 1-based). Если совпадений нет, возвращаем -1.

Анализ Сложности 📊

• Временная сложность:
  • O(n), где n — длина строки sentence. Разделение строки и проверка префикса выполняются за линейное время.
• Пространственная сложность:
  • O(k), где k — количество слов в предложении. Дополнительная память используется только для хранения указателей на слова, а не самих слов.

Исходный код решения

impl Solution {
    pub fn is_prefix_of_word(sentence: String, search_word: String) -> i32 {
        // Split the sentence into words using whitespace as a delimiter
        let words = sentence.split_whitespace();

        // Iterate through the words with their indices
        for (index, word) in words.enumerate() {
            // Check if search_word is a prefix of the current word
            if word.starts_with(&search_word) {
                return (index + 1) as i32; // Convert 1-based index to i32 and return
            }
        }

        -1 // Return -1 if no prefix match is found
    }
}

▲

3

▼

💡 Проверка существования элемента совместно со своим удвоением

leetcoder, 01-12-2024

Наступление зимы отметим разбором простой задачи 1346. Check If N and Its Double Exist.

Описание задачи 🧮

Дан массив целых чисел arr. Нужно определить, существуют ли такие индексы i и j, что:
- i≠j,
- arr[i]=2⋅arr[j].

Обзор решения 🚀

Решение использует два простых прохода по массиву:

1. Первый проход:
   • Создаем хеш-таблицу, где для каждого элемента записываем количество его удвоенных значений.
2. Второй проход:
   • Проверяем, существует ли текущий элемент в хеш-таблице.
   • Для нуля (0) дополнительно проверяем, встречается ли он в массиве как минимум дважды (так как 2⋅0=0).

Временная сложность ⏱️

• Первый проход: O(n) — построение хеш-таблицы.
• Второй проход: O(n) — проверка условий.
• Итоговая сложность: O(n).

Пространственная сложность 📦

• O(n) — память для хеш-таблицы.

Исходый код решения

use std::collections::HashMap;

impl Solution {
    pub fn check_if_exist(arr: Vec<i32>) -> bool {
        let mut double_map = HashMap::new();

        // Populate the map with counts of doubled values
        for &num in &arr {
            *double_map.entry(2 * num).or_insert(0) += 1;
        }

        // Check for the required condition
        for &num in &arr {
            if num == 0 {
                // Special case for 0 (2 * 0 == 0)
                if *double_map.get(&0).unwrap_or(&0) > 1 {
                    return true;
                }
            } else if double_map.get(&num).is_some() {
                return true;
            }
        }

        false
    }
}

▲

3

▼

🌀 Поиск Эйлерова пути с удалением рёбер (алгоритм Хирхольцера)

leetcoder, 30-11-2024

Задача на выходные - 2097. Valid Arrangement of Pairs

Описание задачи 📜

Нужно переставить заданные пары [starti,endi] так, чтобы получилось корректное расположение,
где для каждой пары i: endi−1=starti​. Гарантируется, что такое расположение существует.

Обзор решения 🛠

Для решения задачи используется алгоритм Хирхольцера, который позволяет построить Эйлеров путь (или цикл) в ориентированном графе. Основная идея — удалять рёбра во время обхода, что упрощает структуру данных и предотвращает повторное использование рёбер.

Ключевые шаги 🚀

1. Построение графа:
   • Граф представляется в виде списка смежности (HashMap<i32, Vec<i32>>), где каждая вершина хранит список своих исходящих рёбер.
   • Параллельно вычисляются разницы степеней вершин (входящих и исходящих рёбер) для определения начальной вершины пути.
2. Поиск начальной вершины:
   • Начальная вершина — это вершина с положительным балансом исходящих рёбер. Если таких нет, берётся любая вершина из входных данных.
3. Итеративный DFS с удалением рёбер:
   • Вместо стандартного рекурсивного DFS используется итеративный подход с явным стеком. Это повышает эффективность памяти и скорость.
   • При посещении вершины рёбра удаляются из списка смежности, что гарантирует, что каждое ребро используется ровно один раз.

Читать дальше →

▲

3

▼

⏳🚪 Алгоритм Дейкстры для скорейшего прохождения матрицы

leetcoder, 29-11-2024

Сегодня нам предстоит решить задачу 2577. Minimum Time to Visit a Cell In a Grid.

📝 Описание задачи

• Дана матрица grid размером m x n, где каждая ячейка (row, col) содержит время открытия ворот, ведущих в эту ячейку. До этого времени в ячейку попасть нельзя.
• Вы начинаете в ячейке (0, 0) с временем 0 и можете двигаться на 1 ячейку за секунду в любом из 4 направлений (вверх, вниз, влево, вправо).
• Важно: стоять на месте запрещено — вы должны перемещаться на каждое движение.
• Цель — найти минимальное время, чтобы добраться до ячейки (m-1, n-1). Если это невозможно, вернуть -1.

💡 Идея

Задача сводится к поиску кратчайшего пути с учётом времени открытия ворот в каждой ячейке. Можно представить задачу как динамический граф, где вершины — это пары (время, ячейка), а рёбра — это возможные переходы между ячейками. Вместо того чтобы хранить весь граф, мы динамически вычисляем возможные переходы из посещаемых вершин. Вершины будем перебирать в порядке времён достижимости ячейки (как в алгоритме Дейкстры).

🔑 Подход к решению

• 🧑‍💻 Графовая модель:
  • Ячейки матрицы — вершины графа.
  • Рёбра между вершинами имеют вес 1.

Читать дальше →

▲

3

▼

🚶‍♂️ 0-1 BFS с двумя очередями: Оптимальное решение задачи минимизации препятствий

leetcoder, 28-11-2024

Очередная задача: 2290. Minimum Obstacle Removal to Reach Corner.

📄 Описание задачи

Дана двумерная матрица grid размером m x n, где каждая клетка может быть либо пустой (0), либо препятствием (1), которое можно удалить. Задача заключается в том, чтобы найти минимальное количество препятствий, которые нужно удалить, чтобы пройти из верхнего левого угла (0, 0) в нижний правый угол (m-1, n-1), передвигаясь только по пустым клеткам или удаляя препятствия.

🔑 Идея

Для решения задачи используем модификацию алгоритма поиска в ширину (BFS), который эффективно обрабатывает препятствия. Вместо приоритизации клеток по расстоянию, как в стандартном алгоритме Дейкстры, в 0-1 BFS (именно так эту модификацию принято называть) мы обрабатываем сначала пустые клетки, а затем клетки с препятствиями, что позволяет нам минимизировать количество удаляемых препятствий.

📋 Подробное описание подхода

1. Инициализация: Мы создаем две очереди: front и back. Во front помещаем клетки, которые можно пройти без удаления препятствий, а в back — клетки, для которых потребуется удалить препятствие.
2. Поиск в ширину (BFS):
   • Начинаем с верхнего левого угла и устанавливаем расстояние для этой клетки в 0 (т.е. препятствий еще не удалено).
   • Если клетка пустая (значение 0), мы добавляем её в front. Если клетка — препятствие (значение 1), то в back.

Читать дальше →