#medium
Задача: 340. Longest Substring with At Most K Distinct Characters

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

Пример:

Input: n = 27
Output: true
Explanation: 27 = 3^3

👨‍💻 Алгоритм:

1⃣Инициализация
Используйте два указателя (left и right) для отслеживания текущего окна в строке. Создайте словарь для отслеживания количества каждого символа в текущем окне. Инициализируйте переменные для хранения максимальной длины подстроки (max_length).

2⃣Раздвижение окна
Перемещайте правый указатель (right) по строке и обновляйте словарь. Если количество различных символов в словаре превышает k, перемещайте левый указатель (left) вправо, уменьшая счетчик символов, пока количество различных символов снова не станет меньше или равно k.

3⃣Обновление максимальной длины
На каждом шаге проверяйте и обновляйте максимальную длину подстроки, если текущее окно содержит не более k различных символов. В конце верните максимальную длину подстроки.

😎 Решение:

class Solution {
    function lengthOfLongestSubstringKDistinct($s, $k) {
        $left = 0;
        $right = 0;
        $charCount = [];
        $maxLength = 0;
        
        while ($right < strlen($s)) {
            $charCount[$s[$right]] = ($charCount[$s[$right]] ?? 0) + 1;
            while (count($charCount) > $k) {
                $charCount[$s[$left]]--;
                if ($charCount[$s[$left]] == 0) {
                    unset($charCount[$s[$left]]);
                }
                $left++;
            }
            $maxLength = max($maxLength, $right - $left + 1);
            $right++;
        }
        
        return $maxLength;
    }
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 725. Split Linked List in Parts

Учитывая голову односвязного списка и целое число k, разбейте связный список на k последовательных частей связного списка. Длина каждой части должна быть как можно более одинаковой: никакие две части не должны иметь размер, отличающийся более чем на единицу. Это может привести к тому, что некоторые части будут нулевыми. Части должны располагаться в порядке появления во входном списке, и части, появившиеся раньше, всегда должны иметь размер, больший или равный частям, появившимся позже. Возвращается массив из k частей.

Пример:

Input: head = [1,2,3], k = 5
Output: [[1],[2],[3],[],[]]

👨‍💻 Алгоритм:

1⃣Определите общую длину связного списка.

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

3⃣Разделите список на части, присваивая каждую часть в массив результатов.

😎 Решение:

class ListNode {
    public $val = 0;
    public $next = null;
    function __construct($val = 0, $next = null) {
        $this->val = $val;
        $this->next = $next;
    }
}

function splitListToParts($root, $k) {
    $length = 0;
    $node = $root;
    while ($node != null) {
        $length++;
        $node = $node->next;
    }

    $partLength = intdiv($length, $k);
    $extraParts = $length % $k;

    $parts = array_fill(0, $k, null);
    $node = $root;
    for ($i = 0; $i < $k; $i++) {
        $partHead = $node;
        $partSize = $partLength + ($i < $extraParts ? 1 : 0);
        for ($j = 0; $j < $partSize - 1; $j++) {
            if ($node != null) {
                $node = $node->next;
            }
        }
        if ($node != null) {
            $nextPart = $node->next;
            $node->next = null;
            $node = $nextPart;
        }
        $parts[$i] = $partHead;
    }

    return $parts;
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 341. Flatten Nested List Iterator

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

Реализуйте класс NestedIterator:

NestedIterator(List<NestedInteger> nestedList) Инициализирует итератор вложенным списком nestedList.
int next() Возвращает следующий целый элемент вложенного списка.
boolean hasNext() Возвращает true, если в вложенном списке еще остались целые числа, и false в противном случае.

Пример:

Input: nestedList = [[1,1],2,[1,1]]
Output: [1,1,2,1,1]
Explanation: By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1,1,2,1,1].

👨‍💻 Алгоритм:

1⃣Инициализация
Сохраняйте исходный вложенный список в стеке или очереди. Используйте стек для сохранения состояния итерации по вложенным спискам.

2⃣Метод next()
Возвращает следующий целый элемент из стека или очереди. Если текущий элемент является списком, развёртывайте его и добавляйте элементы в стек.

3⃣Метод hasNext()
Проверяет, есть ли в стеке или очереди оставшиеся целые элементы. Если на вершине стека находится список, развёртывайте его до тех пор, пока не встретится целый элемент.

😎 Решение:

class NestedIterator {
    private $stack;
    
    function __construct($nestedList) {
        $this->stack = [];
        $this->flatten($nestedList);
    }
    
    private function flatten($nestedList) {
        for ($i = count($nestedList) - 1; $i >= 0; $i--) {
            array_push($this->stack, $nestedList[$i]);
        }
    }
    
    function next() {
        return array_pop($this->stack)->getInteger();
    }
    
    function hasNext() {
        while (!empty($this->stack) && !$this->stack[count($this->stack) - 1]->isInteger()) {
            $this->flatten(array_pop($this->stack)->getList());
        }
        return !empty($this->stack);
    }
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 729. My Calendar I

Вы создаете программу для использования в качестве календаря. Мы можем добавить новое событие, если его добавление не приведет к двойному бронированию. Двойное бронирование происходит, когда два события имеют некоторое непустое пересечение (т.е, Событие можно представить в виде пары целых чисел start и end, которая представляет собой бронирование на полуоткрытом интервале [start, end), диапазоне вещественных чисел x таких, что start <= x < end. Реализация класса MyCalendar: MyCalendar() Инициализирует объект календаря. boolean book(int start, int end) Возвращает true, если событие может быть успешно добавлено в календарь, не вызывая двойного бронирования. В противном случае возвращается false и событие не добавляется в календарь.

Пример:

Input
["MyCalendar", "book", "book", "book"]
[[], [10, 20], [15, 25], [20, 30]]
Output
[null, true, false, true]

👨‍💻 Алгоритм:

1⃣Создайте класс MyCalendar с инициализатором для хранения списка событий.

2⃣Реализуйте метод book(int start, int end) для проверки пересечения нового события с уже существующими событиями.

3⃣Если новое событие не пересекается с существующими событиями, добавьте его в список событий и верните true. В противном случае верните false.

😎 Решение:

class MyCalendar {
    private $events;

    function __construct() {
        $this->events = [];
    }

    function book($start, $end) {
        foreach ($this->events as $event) {
            if ($start < $event[1] && $end > $event[0]) {
                return false;
            }
        }
        $this->events[] = [$start, $end];
        return true;
    }
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 731. My Calendar II

Вы создаете программу для использования в качестве календаря. Мы можем добавить новое событие, если его добавление не приведет к тройному бронированию. Тройное бронирование происходит, когда три события имеют некоторое непустое пересечение (т.е, Событие можно представить в виде пары целых чисел start и end, которая представляет собой бронирование на полуоткрытом интервале [start, end), диапазоне вещественных чисел x таких, что start <= x < end. Реализация класса MyCalendarTwo: MyCalendarTwo() Инициализирует объект календаря. boolean book(int start, int end) Возвращает true, если событие может быть успешно добавлено в календарь, не вызывая тройного бронирования. В противном случае возвращается false и событие не добавляется в календарь.

Пример:

Input
["MyCalendarTwo", "book", "book", "book", "book", "book", "book"]
[[], [10, 20], [50, 60], [10, 40], [5, 15], [5, 10], [25, 55]]
Output
[null, true, true, true, false, true, true]

👨‍💻 Алгоритм:

1⃣Создайте два списка: один для отслеживания всех событий, второй для отслеживания пересечений. подпоследовательностей.

2⃣При добавлении нового события сначала проверьте, не пересекается ли оно с любыми существующими пересечениями.

3⃣Если пересечение не обнаружено, добавьте новое событие и обновите список пересечений при необходимости.

😎 Решение:

class MyCalendarTwo {
    private $events;
    private $overlaps;

    function __construct() {
        $this->events = [];
        $this->overlaps = [];
    }

    function book($start, $end) {
        foreach ($this->overlaps as $overlap) {
            if ($start < $overlap[1] && $end > $overlap[0]) {
                return false;
            }
        }
        foreach ($this->events as $event) {
            if ($start < $event[1] && $end > $event[0]) {
                $this->overlaps[] = [max($start, $event[0]), min($end, $event[1])];
            }
        }
        $this->events[] = [$start, $end];
        return true;
    }
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 735. Asteroid Collision

Нам дан массив asteroids, состоящий из целых чисел, представляющих астероиды в ряд. Для каждого астероида абсолютное значение обозначает его размер, а знак - направление движения (положительное - вправо, отрицательное - влево). Каждый астероид движется с одинаковой скоростью. Определите состояние астероидов после всех столкновений. Если два астероида столкнутся, меньший из них взорвется. Если оба одинакового размера, то взорвутся оба. Два астероида, движущиеся в одном направлении, никогда не встретятся.

Пример:

Input: sentence1 = ["great","acting","skills"], sentence2 = ["fine","drama","talent"], similarPairs = [["great","fine"],["drama","acting"],["skills","talent"]]
Output: true

👨‍💻 Алгоритм:

1⃣Используйте стек для отслеживания движущихся вправо астероидов.

2⃣Пройдите по массиву астероидов: Если астероид движется вправо, добавьте его в стек. Если астероид движется влево, сравните его с последним астероидом в стеке (если он есть и движется вправо): Если движущийся вправо астероид больше, текущий взорвется. Если движущийся влево астероид больше, последний астероид в стеке взорвется, и продолжите сравнение. Если они одинакового размера, оба взорвутся.

3⃣Добавьте оставшиеся астероиды из стека и текущий астероид в результат.

😎 Решение:

function asteroidCollision($asteroids) {
    $stack = [];
    
    foreach ($asteroids as $asteroid) {
        $alive = true;
        while ($alive && $asteroid < 0 && !empty($stack) && end($stack) > 0) {
            $last = array_pop($stack);
            if ($last == -$asteroid) {
                $alive = false;
            } elseif ($last > -$asteroid) {
                $stack[] = $last;
                $alive = false;
            }
        }
        if ($alive) {
            $stack[] = $asteroid;
        }
    }
    
    return $stack;
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 737. Sentence Similarity II

Мы можем представить предложение в виде массива слов, например, предложение "I am happy with leetcode" можно представить как arr = ["I", "am",happy", "with", "leetcode"].

Даны два предложения sentence1 и sentence2, каждое из которых представлено в виде массива строк, и массив пар строк similarPairs, где similarPairs[i] = [xi, yi] указывает, что два слова xi и yi похожи. Возвращается true, если предложения sentence1 и sentence2 похожи, или false, если они не похожи. Два предложения похожи, если: у них одинаковая длина (т.е, Заметьте, что слово всегда похоже само на себя, также обратите внимание, что отношение сходства является транзитивным. Например, если слова a и b похожи, а слова b и c похожи, то a и c похожи.

Пример:

Input: sentence1 = ["great","acting","skills"], sentence2 = ["fine","drama","talent"], similarPairs = [["great","good"],["fine","good"],["drama","acting"],["skills","talent"]]
Output: true

👨‍💻 Алгоритм:

1⃣Проверить, одинаковой ли длины предложения sentence1 и sentence2. Если нет, вернуть false.

2⃣Построить граф схожести слов с использованием словаря.

3⃣Использовать поиск в глубину (DFS) для проверки транзитивной схожести слов в предложениях.

😎 Решение:

function areSentencesSimilar($sentence1, $sentence2, $similarPairs) {
    if (count($sentence1) != count($sentence2)) {
        return false;
    }

    $graph = [];
    foreach ($similarPairs as $pair) {
        $x = $pair[0];
        $y = $pair[1];
        if (!isset($graph[$x])) {
            $graph[$x] = [];
        }
        if (!isset($graph[$y])) {
            $graph[$y] = [];
        }
        $graph[$x][] = $y;
        $graph[$y][] = $x;
    }

    function dfs($word1, $word2, $graph, &$visited) {
        if ($word1 == $word2) {
            return true;
        }
        $visited[$word1] = true;
        foreach ($graph[$word1] as $neighbor) {
            if (!isset($visited[$neighbor]) && dfs($neighbor, $word2, $graph, $visited)) {
                return true;
            }
        }
        return false;
    }

    for ($i = 0; $i < count($sentence1); $i++) {
        if ($sentence1[$i] != $sentence2[$i]) {
            $visited = [];
            if (!dfs($sentence1[$i], $sentence2[$i], $graph, $visited)) {
                return false;
            }
        }
    }

    return true;
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 738. Monotone Increasing Digits

Целое число имеет монотонно возрастающие цифры тогда и только тогда, когда каждая пара соседних цифр x и y удовлетворяет x <= y. Задав целое число n, верните наибольшее число, которое меньше или равно n с монотонно возрастающими цифрами.

Пример:

Input: n = 10
Output: 9

👨‍💻 Алгоритм:

1⃣Преобразуйте число в строку для удобства обработки.

2⃣Найдите позицию, где последовательность перестает быть монотонной.

3⃣Уменьшите соответствующую цифру и установите все последующие цифры в 9.

😎 Решение:

function monotoneIncreasingDigits($N) {
    $digits = str_split($N);
    $marker = count($digits);
    
    for ($i = count($digits) - 1; $i > 0; $i--) {
        if ($digits[$i] < $digits[$i - 1]) {
            $marker = $i;
            $digits[$i - 1] = strval(intval($digits[$i - 1]) - 1);
        }
    }
    
    for ($i = $marker; $i < count($digits); $i++) {
        $digits[$i] = '9';
    }
    
    return intval(implode('', $digits));
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 739. Daily Temperatures

Задав массив целых чисел temperature, представляющих дневные температуры, верните массив answer, такой, что answer[i] - это количество дней, которые нужно подождать после i-го дня, чтобы температура стала теплее. Если в будущем не существует дня, для которого это возможно, сохраните answer[i] == 0.

Пример:

Input: temperatures = [73,74,75,71,69,72,76,73]
Output: [1,1,4,2,1,1,0,0]

👨‍💻 Алгоритм:

1⃣Создайте стек для хранения индексов дней с температурами, для которых еще не найден более теплый день.

2⃣Пройдите по массиву температур и для каждого дня: Пока текущая температура больше температуры дня на вершине стека, обновляйте массив ответов и удаляйте вершину стека. Добавьте текущий день в стек.

3⃣Возвращайте массив ответов.

😎 Решение:

function dailyTemperatures($T) {
    $n = count($T);
    $answer = array_fill(0, $n, 0);
    $stack = [];
    
    for ($i = 0; $i < $n; $i++) {
        while (!empty($stack) && $T[$i] > $T[end($stack)]) {
            $j = array_pop($stack);
            $answer[$j] = $i - $j;
        }
        $stack[] = $i;
    }
    
    return $answer;
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 740. Delete and Earn

Вам дан целочисленный массив nums. Вы хотите максимизировать количество очков, выполнив следующую операцию любое количество раз: Выберите любой элемент nums[i] и удалите его, чтобы заработать nums[i] очков. После этого вы должны удалить каждый элемент, равный nums[i] - 1, и каждый элемент, равный nums[i] + 1. Верните максимальное количество очков, которое вы можете заработать, применив вышеуказанную операцию некоторое количество раз.

Пример:

Input: nums = [3,4,2]
Output: 6

👨‍💻 Алгоритм:

1⃣Подсчитайте количество каждого числа в массиве nums.

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

3⃣Для каждого числа num в nums, учитывайте два случая: не брать число или взять число и добавить его очки.

😎 Решение:

function deleteAndEarn($nums) {
    $count = array_count_values($nums);
    $avoid = $using = 0;
    $prev = -1;
    
    ksort($count);
    foreach ($count as $num => $freq) {
        if ($num - 1 != $prev) {
            $newAvoid = max($avoid, $using);
            $using = $num * $freq + max($avoid, $using);
            $avoid = $newAvoid;
        } else {
            $newAvoid = max($avoid, $using);
            $using = $num * $freq + $avoid;
            $avoid = $newAvoid;
        }
        $prev = $num;
    }
    
    return max($avoid, $using);
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 742. Closest Leaf in a Binary Tree

Если задан корень бинарного дерева, в котором каждый узел имеет уникальное значение, а также задано целое число k, верните значение ближайшего к цели k узла листа дерева. Ближайший к листу узел означает наименьшее количество ребер, пройденных бинарным деревом, чтобы достичь любого листа дерева. Кроме того, узел называется листом, если у него нет дочерних узлов.

Пример:

Input: root = [1,3,2], k = 1
Output: 2

👨‍💻 Алгоритм:

1⃣Пройдите дерево, чтобы найти путь от корня до узла k и сохранить его в список.

2⃣Найдите все листья и минимальное расстояние до них, используя BFS, начиная с найденного узла k.

3⃣Верните значение ближайшего листа.

😎 Решение:

class TreeNode {
    public $val = null;
    public $left = null;
    public $right = null;
    function __construct($val = 0, $left = null, $right = null) {
        $this->val = $val;
        $this->left = $left;
        $this->right = $right;
    }
}

function findClosestLeaf($root, $k) {
    $path = [];
    $leaves = [];
    
    function findPath($node, $k, &$path) {
        if (!$node) return false;
        $path[] = $node;
        if ($node->val == $k) return true;
        if (findPath($node->left, $k, $path) || findPath($node->right, $k, $path)) return true;
        array_pop($path);
        return false;
    }
    
    function findLeaves($node, &$leaves) {
        if (!$node) return;
        if (!$node->left && !$node->right) $leaves[spl_object_hash($node)] = 0;
        findLeaves($node->left, $leaves);
        findLeaves($node->right, $leaves);
    }
    
    findPath($root, $k, $path);
    findLeaves($root, $leaves);
    
    $queue = [[end($path), 0]];
    $visited = [];
    
    while ($queue) {
        list($node, $dist) = array_shift($queue);
        if (isset($leaves[spl_object_hash($node)])) return $node->val;
        $visited[spl_object_hash($node)] = true;
        if ($node->left && !isset($visited[spl_object_hash($node->left)])) $queue[] = [$node->left, $dist + 1];
        if ($node->right && !isset($visited[spl_object_hash($node->right)])) $queue[] = [$node->right, $dist + 1];
        if (count($path) > 1) $queue[] = [array_pop($path), $dist + 1];
    }
    return -1;
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 743. Network Delay Time

Дана сеть из узлов, помеченных от 1 до n. Также дано times - список времен прохождения сигнала в виде направленных ребер times[i] = (ui, vi, wi), где ui - исходный узел, vi - целевой узел, а wi - время прохождения сигнала от источника до цели. Мы пошлем сигнал из заданного узла k. Верните минимальное время, которое потребуется всем узлам, чтобы получить сигнал. Если все узлы не могут получить сигнал, верните -1.

Пример:

Input: times = [[2,1,1],[2,3,1],[3,4,1]], n = 4, k = 2
Output: 2

👨‍💻 Алгоритм:

1⃣Представьте граф в виде списка смежности.

2⃣Используйте алгоритм Дейкстры для нахождения кратчайших путей от узла k до всех других узлов.

3⃣Найдите максимальное значение среди кратчайших путей к узлам. Если какой-либо узел недостижим, верните -1.

😎 Решение:

function networkDelayTime($times, $n, $k) {
    $graph = [];
    for ($i = 1; $i <= $n; $i++) {
        $graph[$i] = [];
    }
    foreach ($times as $time) {
        $graph[$time[0]][] = [$time[1], $time[2]];
    }

    $minHeap = new SplPriorityQueue();
    $minHeap->setExtractFlags(SplPriorityQueue::EXTR_BOTH);
    $minHeap->insert([$k, 0], 0);
    $minTime = array_fill(1, $n, INF);
    $minTime[$k] = 0;

    while (!$minHeap->isEmpty()) {
        $data = $minHeap->extract();
        $time = $data['priority'];
        $node = $data['data'][0];
        foreach ($graph[$node] as $neighbor) {
            $newTime = $time + $neighbor[1];
            if ($newTime < $minTime[$neighbor[0]]) {
                $minTime[$neighbor[0]] = $newTime;
                $minHeap->insert([$neighbor[0], $newTime], -$newTime);
            }
        }
    }

    $maxTime = max($minTime);
    return $maxTime == INF ? -1 : $maxTime;
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 930. Binary Subarrays With Sum

Если задан двоичный массив nums и целочисленная цель, верните количество непустых подмассивов с целью sum. Подмассив - это смежная часть массива.

Пример:

Input: nums = [1,0,1,0,1], goal = 2
Output: 4

👨‍💻 Алгоритм:

1⃣Использовать словарь для хранения количества встреченных сумм префиксов. Инициализировать текущую сумму и счетчик подмассивов с нулевыми значениями.

2⃣Пройти по массиву и обновить текущую сумму. Если текущая сумма минус цель уже в словаре, добавить количество таких префиксов к счетчику подмассивов. Обновить словарь префиксных сумм.

3⃣Вернуть счетчик подмассивов.

😎 Решение:

function numSubarraysWithSum($nums, $goal) {
    $prefixSumCount = [0 => 1];
    $currentSum = 0;
    $count = 0;

    foreach ($nums as $num) {
        $currentSum += $num;

        if (isset($prefixSumCount[$currentSum - $goal])) {
            $count += $prefixSumCount[$currentSum - $goal];
        }

        if (isset($prefixSumCount[$currentSum])) {
            $prefixSumCount[$currentSum]++;
        } else {
            $prefixSumCount[$currentSum] = 1;
        }
    }

    return $count;
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 750. Number Of Corner Rectangles

Дан указатель на начало односвязного списка и два целых числа left и right, где left <= right. Необходимо перевернуть узлы списка, начиная с позиции left и заканчивая позицией right, и вернуть измененный список.

Пример:

Input: grid = [[1,0,0,1,0],[0,0,1,0,1],[0,0,0,1,0],[1,0,1,0,1]]
Output: 1

👨‍💻 Алгоритм:

1⃣Пройдите по строкам матрицы. Для каждой пары строк, найдите все столбцы, где оба значения равны 1.

2⃣Подсчитайте количество таких столбцов. Если их больше одного, то они образуют прямоугольники.

3⃣Для каждой пары строк добавьте количество возможных прямоугольников в общий счетчик.

😎 Решение:

function countCornerRectangles($grid) {
    $count = 0;
    for ($i = 0; $i < count($grid); $i++) {
        for ($j = $i + 1; $j < count($grid); $j++) {
            $numPairs = 0;
            for ($k = 0; $k < count($grid[0]); $k++) {
                if ($grid[$i][$k] == 1 && $grid[$j][$k] == 1) {
                    $numPairs++;
                }
            }
            if ($numPairs > 1) {
                $count += $numPairs * ($numPairs - 1) / 2;
            }
        }
    }
    return $count;
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 751. IP to CIDR

Дан указатель на начало односвязного списка и два целых числа left и right, где left <= right. Необходимо перевернуть узлы списка, начиная с позиции left и заканчивая позицией right, и вернуть измененный список.

Пример:

Input: ip = "255.0.0.7", n = 10
Output: ["255.0.0.7/32","255.0.0.8/29","255.0.0.16/32"]

👨‍💻 Алгоритм:

1⃣Преобразовать начальный IP-адрес в целое число.

2⃣Пока количество оставшихся IP-адресов n больше нуля: Определить наибольший блок, который начинается с текущего IP-адреса и не превышает количество оставшихся IP-адресов. Добавить этот блок к результату. Увеличить текущий IP-адрес на размер блока. Уменьшить количество оставшихся IP-адресов n.

3⃣Преобразовать блоки обратно в формат CIDR и вернуть их.

😎 Решение:

function ipToInt($ip) {
    $parts = explode('.', $ip);
    return ($parts[0] << 24) + ($parts[1] << 16) + ($parts[2] << 8) + $parts[3];
}

function intToIp($num) {
    return (($num >> 24) & 255) . "." . (($num >> 16) & 255) . "." . (($num >> 8) & 255) . "." . ($num & 255);
}

function cidr($ip, $prefixLength) {
    return "$ip/$prefixLength";
}

function findCidrBlocks($startIp, $n) {
    $start = ipToInt($startIp);
    $result = [];
    
    while ($n > 0) {
        $maxSize = 1;
        while ($maxSize <= $start && $maxSize <= $n) {
            $maxSize <<= 1;
        }
        $maxSize >>= 1;
        
        while ($start % $maxSize != 0) {
            $maxSize >>= 1;
        }
        
        $result[] = cidr(intToIp($start), 32 - log($maxSize, 2) + 1);
        $start += $maxSize;
        $n -= $maxSize;
    }
    
    return $result;
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 752. Open the Lock

Перед вами замок с 4 круглыми колесами. Каждое колесо имеет 10 слотов: '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'. Колеса могут свободно вращаться и оборачиваться: например, мы можем повернуть "9" так, чтобы получился "0", или "0" так, чтобы получился "9". Каждый ход состоит из поворота одного колеса на один слот. Изначально замок начинается с '0000', строки, представляющей состояние 4 колес. Вам дан список тупиков, то есть если замок отобразит любой из этих кодов, колеса замка перестанут вращаться, и вы не сможете его открыть. Учитывая цель, представляющую значение колес, которое позволит отпереть замок, верните минимальное общее количество оборотов, необходимое для открытия замка, или -1, если это невозможно.

Пример:

Input: deadends = ["0201","0101","0102","1212","2002"], target = "0202"
Output: 6

👨‍💻 Алгоритм:

1⃣Используйте алгоритм BFS для поиска кратчайшего пути от начального состояния '0000' до целевого состояния, избегая тупиков. Инициализируйте очередь с начальным состоянием '0000' и начальным шагом 0. Используйте множество для отслеживания посещенных состояний, чтобы избежать повторного посещения одного и того же состояния.

2⃣Для каждого состояния в очереди: Проверьте все возможные переходы на следующий шаг, вращая каждое колесо на +1 и -1. Если найденное состояние является целевым, верните количество шагов. Если найденное состояние не является тупиком и не было посещено ранее, добавьте его в очередь и отметьте как посещенное.

3⃣Если очередь пуста и целевое состояние не найдено, верните -1.

😎 Решение:

function openLock($deadends, $target) {
    function neighbors($node) {
        $res = [];
        for ($i = 0; $i < 4; $i++) {
            $x = intval($node[$i]);
            for ($d = -1; $d <= 1; $d += 2) {
                $y = ($x + $d + 10) % 10;
                $res[] = substr($node, 0, $i) . $y . substr($node, $i + 1);
            }
        }
        return $res;
    }

    $dead = array_flip($deadends);
    $queue = [['0000', 0]];
    $visited = ['0000' => true];

    while (!empty($queue)) {
        list($node, $steps) = array_shift($queue);
        if ($node === $target) return $steps;
        if (isset($dead[$node])) continue;
        foreach (neighbors($node) as $neighbor) {
            if (!isset($visited[$neighbor])) {
                $visited[$neighbor] = true;
                $queue[] = [$neighbor, $steps + 1];
            }
        }
    }

    return -1;
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 753. Cracking the Safe

Имеется сейф, защищенный паролем. Пароль представляет собой последовательность из n цифр, каждая из которых может находиться в диапазоне [0, k - 1]. Сейф имеет особый способ проверки пароля. Например, правильный пароль - "345", а вы вводите "012345": после ввода 0 последние 3 цифры - "0", что неверно. После ввода 1 последние 3 цифры - "01", что неверно. После ввода 2 последние 3 цифры - "012", что неверно.
После ввода 3 последние 3 цифры - "123", что неверно. После ввода 4 последние 3 цифры - "234", что неверно. После ввода 5 последние 3 цифры - "345", что верно, и сейф разблокируется. Верните любую строку минимальной длины, которая разблокирует сейф на определенном этапе ввода.

Пример:

Input: n = 1, k = 2
Output: "10"

👨‍💻 Алгоритм:

1⃣Создайте граф, где каждая вершина представляет собой строку длины n-1, а каждое ребро между двумя вершинами представляет собой добавление одной из цифр из диапазона [0, k-1].

2⃣Используйте алгоритм Эйлерова пути или цикла для нахождения пути, который проходит через каждое ребро ровно один раз.

3⃣Составьте итоговую строку, которая включает начальную вершину и все добавленные цифры.

😎 Решение:

function crackSafe($n, $k) {
    $seen = [];
    $result = [];

    function dfs($node, $k, &$seen, &$result) {
        for ($x = 0; $x < $k; $x++) {
            $neighbor = $node . $x;
            if (!in_array($neighbor, $seen)) {
                $seen[] = $neighbor;
                dfs(substr($neighbor, 1), $k, $seen, $result);
                $result[] = $x;
            }
        }
    }

    $startNode = str_repeat("0", $n - 1);
    dfs($startNode, $k, $seen, $result);

    return $startNode . implode('', $result);
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 754. Reach a Number

Вы стоите в позиции 0 на бесконечной числовой прямой. В позиции target находится пункт назначения. Вы можете сделать некоторое количество ходов numMoves так, чтобы: на каждом ходу вы могли пойти либо налево, либо направо. Во время i-го хода (начиная с i == 1 до i == numMoves) вы делаете i шагов в выбранном направлении. Учитывая целое число target, верните минимальное количество ходов (т.е. минимальное numMoves), необходимое для достижения пункта назначения.

Пример:

Input: target = 2
Output: 3

👨‍💻 Алгоритм:

1⃣Инициализируйте переменную для текущей позиции (position) и счетчик шагов (steps).

2⃣Используйте цикл, чтобы добавлять к position текущее количество шагов и увеличивать steps.

3⃣Если position достигает или превышает target и разница между position и target четная, остановите цикл и верните steps.

😎 Решение:

function reachTarget($target) {
    $target = abs($target);
    $position = 0;
    $steps = 0;
    while ($position < $target || ($position - $target) % 2 != 0) {
        $steps += 1;
        $position += $steps;
    }
    return $steps;
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 755. Pour Water

Вам дана карта высот, представленная в виде целочисленного массива heights, где heights[i] - высота местности в точке i. Ширина в каждой точке равна 1. Вам также даны два целых числа volume и k. Единицы объема воды будут падать в точке k. Вода сначала падает в точке k и упирается в самую высокую местность или воду в этой точке. Затем она течет по следующим правилам: если капля в конечном итоге упадет, двигаясь влево, то двигайтесь влево. Иначе, если капля в конечном итоге упадет, двигаясь вправо, то двигайтесь вправо. Иначе поднимайтесь в текущее положение. Здесь "в конечном итоге упадет" означает, что капля в конечном итоге окажется на более низком уровне, если она будет двигаться в этом направлении. Кроме того, уровень означает высоту местности плюс вода в этом столбе. Мы можем предположить, что на двух сторонах, выходящих за пределы массива, есть бесконечно высокая местность. Также не может быть частичного равномерного распределения воды более чем на один блок сетки, и каждая единица воды должна находиться ровно в одном блоке.

Пример:

Input: heights = [2,1,1,2,1,2,2], volume = 4, k = 3
Output: [2,2,2,3,2,2,2]

👨‍💻 Алгоритм:

1⃣Инициализируйте цикл для добавления объема воды.

2⃣Для каждой единицы воды: Проверьте, может ли вода двигаться влево и упасть на более низкий уровень. Если нет, проверьте, может ли вода двигаться вправо и упасть на более низкий уровень. Если нет, добавьте воду в текущую позицию.

3⃣Повторите шаг 2, пока не будет добавлен весь объем воды.

😎 Решение:

function pourWater($heights, $volume, $k) {
    for ($v = 0; $v < $volume; $v++) {
        $dropIndex = $k;
        foreach ([-1, 1] as $d) {
            $i = $k;
            while ($i + $d >= 0 && $i + $d < count($heights) && $heights[$i + $d] <= $heights[$i]) {
                if ($heights[$i + $d] < $heights[$i]) {
                    $dropIndex = $i + $d;
                }
                $i += $d;
            }
            if ($dropIndex != $k) {
                break;
            }
        }
        $heights[$dropIndex]++;
    }
    return $heights;
}

Ставь 👍 и забирай 📚 Базу знаний

#medium
Задача: 756. Pyramid Transition Matrix

Вы складываете блоки так, чтобы получилась пирамида. Каждый блок имеет цвет, который представлен одной буквой. Каждый ряд блоков содержит на один блок меньше, чем ряд под ним, и располагается по центру сверху. Чтобы пирамида выглядела эстетично, допускаются только определенные треугольные узоры. Треугольный узор состоит из одного блока, уложенного поверх двух блоков. Шаблоны задаются в виде списка допустимых трехбуквенных строк, где первые два символа шаблона представляют левый и правый нижние блоки соответственно, а третий символ - верхний блок. Например, "ABC" представляет треугольный шаблон с блоком 'C', уложенным поверх блоков 'A' (слева) и 'B' (справа). Обратите внимание, что это отличается от "BAC", где "B" находится слева внизу, а "A" - справа внизу. Вы начинаете с нижнего ряда блоков bottom, заданного в виде одной строки, который вы должны использовать в качестве основания пирамиды. Учитывая bottom и allowed, верните true, если вы можете построить пирамиду до самой вершины так, чтобы каждый треугольный узор в пирамиде был в allowed, или false в противном случае.

Пример:

Input: bottom = "BCD", allowed = ["BCC","CDE","CEA","FFF"]
Output: true

👨‍💻 Алгоритм:

1⃣Создайте структуру данных для хранения допустимых треугольных узоров.

2⃣Напишите рекурсивную функцию, которая проверяет возможность построения следующего уровня пирамиды.

3⃣Начните с нижнего уровня пирамиды и используйте рекурсию для построения каждого следующего уровня, проверяя каждый треугольный узор на допустимость.

😎 Решение:

function pyramidTransition($bottom, $allowed) {
    $allowedDict = [];

    foreach ($allowed as $pattern) {
        $key = substr($pattern, 0, 2);
        $value = $pattern[2];
        if (!isset($allowedDict[$key])) {
            $allowedDict[$key] = [];
        }
        $allowedDict[$key][] = $value;
    }

    return canBuild($bottom, $allowedDict);
}

function canBuild($currentLevel, $allowedDict) {
    if (strlen($currentLevel) == 1) return true;

    $nextLevelOptions = [];
    for ($i = 0; $i < strlen($currentLevel) - 1; $i++) {
        $key = substr($currentLevel, $i, 2);
        if (!isset($allowedDict[$key])) return false;
        $nextLevelOptions[] = $allowedDict[$key];
    }

    return canBuildNextLevel($nextLevelOptions, 0, "", $allowedDict);
}

function canBuildNextLevel($options, $index, $nextLevel, $allowedDict) {
    if ($index == count($options)) return canBuild($nextLevel, $allowedDict);
    foreach ($options[$index] as $option) {
        if (canBuildNextLevel($options, $index + 1, $nextLevel . $option, $allowedDict)) return true;
    }
    return false;
}

Ставь 👍 и забирай 📚 Базу знаний