PHP | LeetCode

🔒

| 🔒

Please open Telegram to view this post

VIEW IN TELEGRAM

👀1

254 views16:07

#hard
Задача: 87. Scramble String

Мы можем перемешать строку s, чтобы получить строку t, используя следующий алгоритм:

1. Если длина строки равна 1, остановиться.
2. Если длина строки больше 1, выполнить следующее:
- Разделить строку на две непустые подстроки в случайном индексе, например, если строка это s, разделить её на x и y, где s = x + y.
- Случайным образом решить, поменять ли местами две подстроки или оставить их в том же порядке. То есть после этого шага s может стать s = x + y или s = y + x.
- Применить шаг 1 рекурсивно к каждой из двух подстрок x и y.

Для двух строк s1 и s2 одинаковой длины вернуть true, если s2 является перемешанной строкой s1, в противном случае вернуть false.

Пример:

Input: s1 = "great", s2 = "rgeat"
Output: true
Explanation: One possible scenario applied on s1 is:
"great" --> "gr/eat" // divide at random index.
"gr/eat" --> "gr/eat" // random decision is not to swap the two substrings and keep them in order.
"gr/eat" --> "g/r / e/at" // apply the same algorithm recursively on both substrings. divide at random index each of them.
"g/r / e/at" --> "r/g / e/at" // random decision was to swap the first substring and to keep the second substring in the same order.
"r/g / e/at" --> "r/g / e/ a/t" // again apply the algorithm recursively, divide "at" to "a/t".
"r/g / e/ a/t" --> "r/g / e/ a/t" // random decision is to keep both substrings in the same order.
The algorithm stops now, and the result string is "rgeat" which is s2.
As one possible scenario led s1 to be scrambled to s2, we return true.

👨‍💻

Алгоритм:

1️⃣- Итерируйте i от 0 до n-1.
- Итерируйте j от 0 до n-1.
- Установите dp[1][i][j] в булево значение s1[i] == s2[j]. (Базовый случай динамического программирования).

2️⃣- Итерируйте length от 2 до n.
- Итерируйте i от 0 до n + 1 - length.
- Итерируйте j от 0 до n + 1 - length.

3️⃣- Итерируйте newLength от 1 до length - 1.
- Если dp[newLength][i][j] && dp[length-newLength][i+newLength][j+newLength]) || (dp[newLength][i][j+length-newLength] && dp[length-newLength][i+newLength][j]) верно, установите dp[length][i][j] в true.
- Верните dp[n][0][0].

😎

Решение:

function isScramble($s1, $s2) {
    $n = strlen($s1);
    $dp = array_fill(0, $n + 1, []);
    for ($i = 0; $i <= $n; $i++) {
        $dp[$i] = array_fill(0, $n, []);
        for ($j = 0; $j < $n; $j++) {
            $dp[$i][$j] = array_fill(0, $n, false);
        }
    }
    for ($i = 0; $i < $n; $i++) {
        for ($j = 0; $j < $n; $j++) {
            $dp[1][$i][$j] = $s1[$i] === $s2[$j];
        }
    }
    for ($length = 2; $length <= $n; $length++) {
        for ($i = 0; $i <= $n - $length; $i++) {
            for ($j = 0; $j <= $n - $length; $j++) {
                for ($newLength = 1; $newLength < $length; $newLength++) {
                    $dp1 = $dp[$newLength][$i];
                    $dp2 = $dp[$length - $newLength][$i + $newLength];
                    $dp[$length][$i][$j] = $dp[$length][$i][$j] || ($dp1[$j] && $dp2[$j + $newLength]);
                    $dp[$length][$i][$j] = $dp[$length][$i][$j] || ($dp1[$j + $length - $newLength] && $dp2[$j]);
                }
            }
        }
    }
    return $dp[$n][0][0];
}

🔥

🔒

| 🔒

Please open Telegram to view this post

VIEW IN TELEGRAM

243 views09:07

#easy
Задача: 88. Merge Sorted Array

Вам даны два массива целых чисел nums1 и nums2, отсортированных в порядке неубывания, а также два целых числа m и n, представляющих количество элементов в nums1 и nums2 соответственно.

Слейте nums1 и nums2 в один массив, отсортированный в порядке неубывания.

Итоговый отсортированный массив не должен возвращаться функцией, а должен храниться внутри массива nums1. Чтобы это обеспечить, длина nums1 составляет m + n, где первые m элементов обозначают элементы, которые должны быть объединены, а последние n элементов установлены в 0 и должны быть проигнорированы. Длина nums2 составляет n.

Пример:

Input: nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
Output: [1,2,2,3,5,6]
Explanation: The arrays we are merging are [1,2,3] and [2,5,6].
The result of the merge is [1,2,2,3,5,6] with the underlined elements coming from nums1.

👨‍💻

Алгоритм:

1️⃣Самая простая реализация заключалась бы в создании копии значений в nums1, называемой nums1Copy, а затем использовании двух указателей для чтения и одного указателя для записи для чтения значений из nums1Copy и nums2 и записи их в nums1.

2️⃣Инициализируйте nums1Copy новым массивом, содержащим первые m значений nums1.
Инициализируйте указатель для чтения p1 в начале nums1Copy.
Инициализируйте указатель для чтения p2 в начале nums2.

3️⃣Инициализируйте указатель для записи p в начале nums1.
Пока p все еще находится внутри nums1:
Если nums1Copy[p1] существует и меньше или равно nums2[p2]:
Запишите nums1Copy[p1] в nums1[p], и увеличьте p1 на 1.
Иначе
Запишите nums2[p2] в nums1[p], и увеличьте p2 на 1.
Увеличьте p на 1.

😎

Решение:

class Solution {

    public function merge(&$nums1, $m, $nums2, $n) {
        $nums1Copy = array_slice($nums1, 0, $m);
        $p1 = 0;
        $p2 = 0;
        
        for ($p = 0; $p < $n + $m; $p++) {
            if ($p2 >= $n || ($p1 < $m && $nums1Copy[$p1] <= $nums2[$p2])) {
                $nums1[$p] = $nums1Copy[$p1];
                $p1++;
            } else {
                $nums1[$p] = $nums2[$p2];
                $p2++;
            }
        }
    }
}

🔥

🔒

| 🔒

Please open Telegram to view this post

VIEW IN TELEGRAM

234 views16:07

#medium
Задача: 89. Gray Code

Последовательность Грея с n-битами — это последовательность из 2^n целых чисел, где:

1. Каждое число находится в включающем диапазоне от 0 до 2^n - 1,
2. Первое число равно 0,
3. Каждое число встречается в последовательности не более одного раза,
4. Двоичное представление каждой пары соседних чисел отличается ровно на один бит,
5. Двоичное представление первого и последнего чисел отличается ровно на один бит.

Для заданного числа n возвращается любая допустимая последовательность Грея с n-битами.

Пример:

Input: n = 2
Output: [0,1,3,2]
Explanation:
The binary representation of [0,1,3,2] is [00,01,11,10].
- 00 and 01 differ by one bit
- 01 and 11 differ by one bit
- 11 and 10 differ by one bit
- 10 and 00 differ by one bit
[0,2,3,1] is also a valid gray code sequence, whose binary representation is [00,10,11,01].
- 00 and 10 differ by one bit
- 10 and 11 differ by one bit
- 11 and 01 differ by one bit
- 01 and 00 differ by one bit

👨‍💻

Алгоритм:

1️⃣Инициализируйте список результатов для хранения последовательности решений. Добавьте 0 в список перед вызовом вспомогательного метода, так как все последовательности Грея начинаются с 0.

2️⃣Инициализируйте множество visited. Это позволяет отслеживать числа, присутствующие в текущей последовательности, чтобы избежать повторения.
Начните с числа 0.
В функции grayCodeHelper() используйте цикл for, чтобы найти каждое возможное число (next), которое может быть сгенерировано путем изменения одного бита последнего числа в списке результатов (current). Делайте это, переключая i-ый бит на каждой итерации. Поскольку максимально возможное количество битов в любом числе последовательности равно n, необходимо переключить n битов.

3️⃣Если next не присутствует в множестве использованных чисел (isPresent), добавьте его в список результатов и множество isPresent.
Продолжайте поиск с next.
Если grayCodeHelper(next) возвращает true, это означает, что допустимая последовательность найдена. Дальнейший поиск не требуется (ранняя остановка). Это раннее завершение улучшает время выполнения.
Если с next не найдена допустимая последовательность, удаляем его из списка результатов и множества isPresent и продолжаем поиск.
При достижении базового условия, когда длина текущей последовательности равна 2^n, возвращаем true.
Выход из цикла for означает, что с current в качестве последнего числа не найдена допустимая последовательность кода Грея. Поэтому возвращаем false.

😎

Решение:

class Solution {
    public function grayCode($n) {
        $result = [0];
        $isPresent = [0 => true];
        $this->grayCodeHelper($result, $n, $isPresent);
        return $result;
    }

    private function grayCodeHelper(&$result, $n, &$isPresent) {
        if (count($result) === (1 << $n)) {
            return true;
        }
        $current = $result[count($result) - 1];
        for ($i = 0; $i < $n; $i++) {
            $nextNum = $current ^ (1 << $i);
            if (!isset($isPresent[$nextNum])) {
                $isPresent[$nextNum] = true;
                array_push($result, $nextNum);
                if ($this->grayCodeHelper($result, $n, $isPresent)) {
                    return true;
                }
                unset($isPresent[$nextNum]);
                array_pop($result);
            }
        }
        return false;
    }
}

$solution = new Solution();
$n = 2; 
$result = $solution->grayCode($n);
print_r($result);

🔥

🔒

| 🔒

Please open Telegram to view this post

VIEW IN TELEGRAM

215 views09:07

#medium
Задача: 90. Subsets II

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

Результирующий набор не должен содержать дублирующихся подмножеств. Возвращаемый результат может быть в любом порядке.

Пример:

Input: nums = [1,2,2]
Output: [[],[1],[1,2],[1,2,2],[2],[2,2]]

👨‍💻

Алгоритм:

1️⃣Отсортируйте массив nums. Сортировка необходима для того, чтобы все сгенерированные подмножества также были отсортированы. Это помогает идентифицировать дубликаты.

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

Инициализируйте множество, seen, типа string, для хранения всех сгенерированных подмножеств. Добавление всех отсортированных подмножеств в множество дает нам возможность отловить любые дублирующие подмножества.

3️⃣Итерируйте от 0 до maxNumberOfSubsets - 1. Установленные биты в двоичном представлении subsetIndex указывают на позицию элементов в массиве nums, которые присутствуют в текущем подмножестве.

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

Выполните внутренний цикл for от j = 0 до n - 1, чтобы проверить позицию установленных битов в subsetIndex. Если на позиции j установлен бит, добавьте nums[j] в текущее подмножество currentSubset и добавьте nums[j] в строку hashcode.

Добавьте текущее подмножество currentSubset в seen и в список подмножеств, если сгенерированный hashcode еще не в seen.

Верните подмножества.

😎

Решение:

class Solution {
    function subsetsWithDup($nums) {
        $n = count($nums);
        sort($nums);
        $maxNumberOfSubsets = 1 << $n;
        $subsets = [];
        $seen = [];

        for ($subsetIndex = 0; $subsetIndex < $maxNumberOfSubsets; $subsetIndex++) {
            $currentSubset = [];
            $hashcode = "";
            for ($j = 0; $j < $n; $j++) {
                $mask = 1 << $j;
                $isSet = $mask & $subsetIndex;
                if ($isSet !== 0) {
                    array_push($currentSubset, $nums[$j]);
                    $hashcode .= $nums[$j] . ",";
                }
            }
            if (!in_array($hashcode, $seen)) {
                array_push($subsets, $currentSubset);
                array_push($seen, $hashcode);
            }
        }
        return $subsets;
    }
}

🔥

🔒

| 🔒

Please open Telegram to view this post

VIEW IN TELEGRAM

218 views16:07

#medium
Задача: 91. Decode Ways

Сообщение, содержащее буквы от A до Z, можно закодировать в числа с использованием следующего соответствия:

- 'A' -> "1"
- 'B' -> "2"
- ...
- 'Z' -> "26"

Для декодирования закодированного сообщения все цифры должны быть сгруппированы и затем отображены обратно в буквы с использованием обратного соответствия (существует несколько способов). Например, "11106" можно представить как:

- "AAJF" с группировкой (1 1 10 6)
- "KJF" с группировкой (11 10 6)

Обратите внимание, что группировка (1 11 06) недопустима, потому что "06" не может быть преобразовано в 'F', так как "6" отличается от "06".

Для данной строки s, содержащей только цифры, верните количество способов декодирования.

Тестовые случаи сформированы таким образом, что ответ укладывается в 32-битное целое число.

Пример:

Input: s = "12"
Output: 2
Explanation: "12" could be decoded as "AB" (1 2) or "L" (12).

👨‍💻

Алгоритм:

1️⃣Входим в рекурсию с данной строкой, начиная с индекса 0.

2️⃣Для окончательного случая рекурсии мы проверяем конец строки. Если мы достигли конца строки, возвращаем 1. Каждый раз, когда мы входим в рекурсию, это для подстроки исходной строки. Если первый символ в подстроке равен 0, то прекращаем этот путь, возвращая 0. Таким образом, этот путь не будет влиять на количество способов.

3️⃣Мемоизация помогает снизить сложность, которая иначе была бы экспоненциальной. Мы проверяем словарь memo, чтобы увидеть, существует ли уже результат для данной подстроки. Если результат уже находится в memo, мы возвращаем этот результат. В противном случае количество способов для данной строки определяется путем рекурсивного вызова функции с индексом +1 для следующей подстроки и индексом +2 после проверки на валидность двузначного декодирования. Результат также сохраняется в memo с ключом как текущий индекс, чтобы сохранить его для будущих пересекающихся подзадач.

😎

Решение:

class Solution {
    private $memo = [];

    private function recursiveWithMemo($index, $s) {
        if ($index == strlen($s)) {
            return 1;
        }

        if ($s[$index] == '0') {
            return 0;
        }

        if ($index == strlen($s) - 1) {
            return 1;
        }

        if (isset($this->memo[$index])) {
            return $this->memo[$index];
        }

        $answer = $this->recursiveWithMemo($index + 1, $s);
        if ($index < strlen($s) - 1) {
            $number = (int)substr($s, $index, 2);
            if ($number <= 26) {
                $answer += $this->recursiveWithMemo($index + 2, $s);
            }
        }

        $this->memo[$index] = $answer;
        return $answer;
    }

    public function numDecodings($s) {
        return $this->recursiveWithMemo(0, $s);
    }
}

🔥

🔒

| 🔒

Please open Telegram to view this post

VIEW IN TELEGRAM

236 views09:07

#medium
Задача: 92. Reverse Linked List II

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

Пример:

Input: head = [1,2,3,4,5], left = 2, right = 4
Output: [1,4,3,2,5]

👨‍💻

Алгоритм:

1️⃣Определяем рекурсивную функцию, которая будет отвечать за переворачивание части односвязного списка. Назовем эту функцию recurse. Функция принимает три параметра: m, начальную точку переворота, n, конечную точку переворота, и указатель right, который начинается с узла n в связанном списке и движется назад вместе с откатом рекурсии. Если это пока не ясно, следующие диаграммы помогут.

2️⃣Также у нас есть указатель left, который начинается с узла m в связанном списке и движется вперед. В Python мы должны использовать глобальную переменную для этого, которая изменяется с каждым вызовом рекурсии. В других языках, где изменения, сделанные в вызовах функций, сохраняются, мы можем рассматривать этот указатель как дополнительную переменную для функции recurse.
В рекурсивном вызове, учитывая m, n и right, мы проверяем, равно ли n единице. Если это так, дальше двигаться не нужно.

3️⃣До тех пор, пока мы не достигнем n = 1, мы продолжаем двигать указатель right на один шаг вперед, после чего делаем рекурсивный вызов с уменьшенным на один значением n. В то же время мы продолжаем двигать указатель left вперед до тех пор, пока m не станет равным 1. Когда мы говорим, что указатель движется вперед, мы имеем в виду pointer.next.
Таким образом, мы откатываемся, как только n достигает 1. В этот момент указатель right находится на последнем узле подсписка, который мы хотим перевернуть, и left уже достиг первого узла этого подсписка. Тогда мы меняем данные и перемещаем указатель left на один шаг вперед с помощью left = left.next. Нам нужно, чтобы это изменение сохранялось в процессе отката.
Оттуда при каждом откате указатель right движется на один шаг назад. Это и есть та симуляция, о которой мы всё время говорили. Обратное движение симулируется откатом.
Мы прекращаем обмены, когда right == left, что происходит, если размер подсписка нечетный, или right.next == left, что происходит в процессе отката для четного подсписка, когда указатель right пересекает left. Мы используем глобальный булевый флаг для остановки обменов, как только эти условия выполнены.

😎

Решение:

class ListNode {
    public $val = 0;
    public $next = null;

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

class Solution {
    private $left;
    private $stop = false;

    public function reverseBetween($head, $m, $n) {
        if ($head === null) {
            return null;
        }

        $this->left = $head;
        $right = $head;
        $this->stop = false;

        $this->recurseAndReverse($right, $m, $n);
        return $head;
    }

    private function recurseAndReverse($right, $m, $n) {
        if ($n == 1) {
            return;
        }

        $right = $right->next;

        if ($m > 1) {
            $this->left = $this->left->next;
        }

        $this->recurseAndReverse($right, $m - 1, $n - 1);

        if ($this->left === $right || ($right->next === $this->left)) {
            $this->stop = true;
        }

        if (!$this->stop) {
            $temp = $this->left->val;
            $this->left->val = $right->val;
            $right->val = $temp;

            $this->left = $this->left->next;
        }
    }
}

🔥

🔒

| 🔒

Please open Telegram to view this post

VIEW IN TELEGRAM

224 views16:07

#medium
Задача: 93. Restore IP Addresses

Сообщение, содержащее буквы от A до Z, можно закодировать в числа с использованием следующего соответствия:

- 'A' -> "1"
- 'B' -> "2"
- ...
- 'Z' -> "26"

Для декодирования закодированного сообщения все цифры должны быть сгруппированы и затем отображены обратно в буквы с использованием обратного соответствия (существует несколько способов). Например, "11106" можно представить как:

- "AAJF" с группировкой (1 1 10 6)
- "KJF" с группировкой (11 10 6)

Обратите внимание, что группировка (1 11 06) недопустима, потому что "06" не может быть преобразовано в 'F', так как "6" отличается от "06".

Для данной строки s, содержащей только цифры, верните количество способов декодирования.

Тестовые случаи сформированы таким образом, что ответ укладывается в 32-битное целое число.

Пример:

Input: s = "12"
Output: 2
Explanation: "12" could be decoded as "AB" (1 2) or "L" (12).

👨‍💻

😎

Решение:

class Solution {
    private function valid($s, $start, $length) {
        if ($length == 1) {
            return true;
        }
        if ($s[$start] == '0') {
            return false;
        }
        if ($length > 3) {
            return false;
        }
        $num = substr($s, $start, $length);
        return (int)$num <= 255;
    }

    private function helper($s, $startIndex, &$dots, &$ans) {
        $remainingLength = strlen($s) - $startIndex;
        $remainingNumberOfIntegers = 4 - count($dots);
        if ($remainingLength > $remainingNumberOfIntegers * 3 || $remainingLength < $remainingNumberOfIntegers) {
            return;
        }
        if (count($dots) == 3) {
            if ($this->valid($s, $startIndex, $remainingLength)) {
                $temp = "";
                $last = 0;
                foreach ($dots as $dot) {
                    $temp .= substr($s, $last, $dot) . ".";
                    $last += $dot;
                }
                $temp .= substr($s, $startIndex);
                $ans[] = $temp;
            }
            return;
        }
        for ($curPos = 1; $curPos <= min(3, $remainingLength); $curPos++) {
            $dots[] = $curPos;
            if ($this->valid($s, $startIndex, $curPos)) {
                $this->helper($s, $startIndex + $curPos, $dots, $ans);
            }
            array_pop($dots);
        }
    }

🔥

🔒

| 🔒

Please open Telegram to view this post

VIEW IN TELEGRAM

228 views09:07

#easy
Задача: 94. Binary Tree Inorder Traversal

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

Пример:

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

👨‍💻

Алгоритм:

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

😎

Решение:

class TreeNode {
    public $val;
    public $left;
    public $right;

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

class Solution {
    public function inorderTraversal($root) {
        $res = [];
        $this->helper($root, $res);
        return $res;
    }

    private function helper($root, &$res) {
        if ($root !== null) {
            $this->helper($root->left, $res);
            $res[] = $root->val;
            $this->helper($root->right, $res);
        }
    }
}

🔥

🔒

| 🔒

Please open Telegram to view this post

VIEW IN TELEGRAM

247 views16:07

#medium
Задача: 95. Unique Binary Search Trees II

Дано целое число n. Верните все структурно уникальные деревья бинарного поиска (BST), которые содержат ровно n узлов с уникальными значениями от 1 до n. Ответ может быть представлен в любом порядке.

Пример:

Input: n = 3
Output: [[1,null,2,null,3],[1,null,3,2],[2,1,3],[3,1,null,null,2],[3,2,null,1]]

👨‍💻

Алгоритм:

1️⃣Создайте хеш-карту memo, где memo[(start, end)] содержит список корневых узлов всех возможных BST (деревьев бинарного поиска) с диапазоном значений узлов от start до end. Реализуем рекурсивную функцию allPossibleBST, которая принимает начальный диапазон значений узлов start, конечный диапазон end и memo в качестве параметров. Она возвращает список TreeNode, соответствующих всем BST, которые могут быть сформированы с этим диапазоном значений узлов. Вызываем allPossibleBST(1, n, memo) и выполняем следующее:

2️⃣Объявляем список TreeNode под названием res для хранения списка корневых узлов всех возможных BST. Если start > end, мы добавляем null в res и возвращаем его. Если мы уже решили эту подзадачу, т.е. memo содержит пару (start, end), мы возвращаем memo[(start, end)].

3️⃣Выбираем значение корневого узла от i = start до end, увеличивая i на 1 после каждой итерации. Рекурсивно вызываем leftSubtrees = allPossibleBST(start, i - 1, memo) и rightSubTrees = allPossibleBST(i + 1, end, memo). Перебираем все пары между leftSubtrees и rightSubTrees и создаем новый корень со значением i для каждой пары. Добавляем корень новообразованного BST в res. Устанавливаем memo[(start, end)] = res и возвращаем res.

😎

Решение:

class TreeNode {
    public $val;
    public $left;
    public $right;

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

class Solution {
    public function allPossibleBST($start, $end, &$memo) {
        $res = [];
        if ($start > $end) {
            $res[] = null;
            return $res;
        }
        if (array_key_exists("{$start},{$end}", $memo)) {
            return $memo["{$start},{$end}"];
        }

        for ($i = $start; $i <= $end; ++$i) {
            $leftSubTrees = $this->allPossibleBST($start, $i - 1, $memo);
            $rightSubTrees = $this->allPossibleBST($i + 1, $end, $memo);
            foreach ($leftSubTrees as $left) {
                foreach ($rightSubTrees as $right) {
                    $root = new TreeNode($i, $left, $right);
                    $res[] = $root;
                }
            }
        }

        $memo["{$start},{$end}"] = $res;
        return $res;
    }

    public function generateTrees($n) {
        $memo = [];
        return $this->allPossibleBST(1, $n, $memo);
    }
}

🔥

🔒

| 🔒

Please open Telegram to view this post

VIEW IN TELEGRAM

218 views09:07

#medium
Задача: 96. Unique Binary Search Trees

Дано целое число n. Верните количество структурно уникальных деревьев бинарного поиска (BST), которые содержат ровно n узлов с уникальными значениями от 1 до n.

Пример:

Input: n = 3
Output: 5

👨‍💻

Алгоритм:

1️⃣Задача состоит в том, чтобы рассчитать количество уникальных BST (бинарных деревьев поиска). Для этого мы можем определить две функции:

G(n): количество уникальных BST для последовательности длины n.

F(i, n): количество уникальных BST, где число i является корнем BST (1 ≤ i ≤ n).

Как видно, G(n) - это именно та функция, которая нам нужна для решения задачи.

2️⃣Позднее мы увидим, что G(n) можно вывести из F(i, n), которая, в свою очередь, рекурсивно относится к G(n).

Следуя идее из раздела "Интуиция", мы видим, что общее количество уникальных BST G(n) равно сумме BST F(i, n) с перечислением каждого числа i (1 ≤ i ≤ n) в качестве корня. Таким образом,

G(n) = ∑ F(i, n) для i от 1 до n.

В частности, для базовых случаев есть только одна комбинация для построения BST из последовательности длиной 1 (только корень) или ничего (пустое дерево). То есть G(0) = 1, G(1) = 1.

3️⃣Дана последовательность от 1 до n, мы выбираем число i из последовательности в качестве корня, тогда количество уникальных BST с указанным корнем, определенным как F(i, n), является декартовым произведением количества BST для его левого и правого поддеревьев, как показано ниже:

Например, F(3,7) - количество уникальных деревьев BST с числом 3 в качестве корня. Для построения уникального BST из всей последовательности [1, 2, 3, 4, 5, 6, 7] с 3 в качестве корня, мы должны построить поддерево из его левой подпоследовательности [1, 2] и другое поддерево из правой подпоследовательности [4, 5, 6, 7], а затем соединить их вместе (то есть декартово произведение). Теперь хитрость заключается в том, что мы можем рассматривать количество уникальных BST из последовательности [1,2] как G(2), и количество уникальных BST из последовательности [4, 5, 6, 7] как G(4). Для G(n) не имеет значения содержание последовательности, а только длина последовательности. Следовательно, F(3,7) = G(2)⋅G(4). Обобщая пример, мы можем вывести следующую формулу:

F(i, n) = G(i−1)⋅G(n−i)

Объединяя формулы (1), (2), мы получаем рекурсивную формулу для G(n), то есть

G(n) = ∑ G(i−1)⋅G(n−i) для i от 1 до n.

Чтобы вычислить результат функции, мы начинаем с меньшего числа, так как значение G(n) зависит от значений G(0)...G(n−1).

😎

Решение:

class Solution {
    function numTrees($n) {
        $G = array_fill(0, $n + 1, 0);
        $G[0] = $G[1] = 1;

        for ($i = 2; $i <= $n; $i++) {
            for ($j = 1; $j <= $i; $j++) {
                $G[$i] += $G[$j - 1] * $G[$i - $j];
            }
        }

        return $G[$n];
    }
}

🔥

🔒

| 🔒

Please open Telegram to view this post

VIEW IN TELEGRAM

235 views16:07

#medium
Задача: 97. Interleaving String

Даны строки s1, s2 и s3. Необходимо определить, может ли строка s3 быть сформирована путем чередования строк s1 и s2.

Чередование двух строк s и t — это конфигурация, при которой s и t делятся на n и m подстрок соответственно так, что:

s = s1 + s2 + ... + sn
t = t1 + t2 + ... + tm
|n - m| ≤ 1
Чередование может быть таким: s1 + t1 + s2 + t2 + s3 + t3 + ... или t1 + s1 + t2 + s2 + t3 + s3 + ...
Примечание: a + b означает конкатенацию строк a и b.

Пример:

Input: s1 = "aabcc", s2 = "dbbca", s3 = "aadbbcbcac"
Output: true
Explanation: One way to obtain s3 is:
Split s1 into s1 = "aa" + "bc" + "c", and s2 into s2 = "dbbc" + "a".
Interleaving the two splits, we get "aa" + "dbbc" + "bc" + "a" + "c" = "aadbbcbcac".

👨‍💻

Алгоритм:

1️⃣В рекурсивном подходе, описанном выше, рассматривается каждая возможная строка, образованная путем чередования двух заданных строк. Однако возникают случаи, когда та же часть s1 и s2 уже была обработана, но в разных порядках (перестановках). Независимо от порядка обработки, если результирующая строка до этого момента совпадает с требуемой строкой (s3), окончательный результат зависит только от оставшихся частей s1 и s2, а не от уже обработанной части. Таким образом, рекурсивный подход приводит к избыточным вычислениям.

2️⃣Эту избыточность можно устранить, используя мемоизацию вместе с рекурсией. Для этого мы поддерживаем три указателя i, j, k, которые соответствуют индексу текущего символа s1, s2, s3 соответственно. Также мы поддерживаем двумерный массив memo для отслеживания обработанных до сих пор подстрок. memo[i][j] хранит 1/0 или -1 в зависимости от того, была ли текущая часть строк, то есть до i-го индекса для s1 и до j-го индекса для s2, уже оценена. Мы начинаем с выбора текущего символа s1 (на который указывает i). Если он совпадает с текущим символом s3 (на который указывает k), мы включаем его в обработанную строку и вызываем ту же функцию рекурсивно как: is_Interleave(s1, i+1, s2, j, s3, k+1, memo).

3️⃣Таким образом, мы вызвали функцию, увеличив указатели i и k, поскольку часть строк до этих индексов уже была обработана. Аналогично, мы выбираем один символ из второй строки и продолжаем. Рекурсивная функция заканчивается, когда одна из двух строк s1 или s2 полностью обработана. Если, скажем, строка s1 полностью обработана, мы напрямую сравниваем оставшуюся часть s2 с оставшейся частью s3. Когда происходит возврат из рекурсивных вызовов, мы сохраняем значение, возвращенное рекурсивными функциями, в массиве мемоизации memo соответственно, так что когда оно встречается в следующий раз, рекурсивная функция не будет вызвана, но сам массив мемоизации вернет предыдущий сгенерированный результат.

😎

Решение:

class Solution {
    function isInterleave($s1, $s2, $s3) {
        if (strlen($s3) != strlen($s1) + strlen($s2)) {
            return false;
        }

        $dp = array_fill(0, strlen($s1) + 1, array_fill(0, strlen($s2) + 1, false));
        for ($i = 0; $i <= strlen($s1); $i++) {
            for ($j = 0; $j <= strlen($s2); $j++) {
                if ($i == 0 && $j == 0) {
                    $dp[$i][$j] = true;
                } elseif ($i == 0) {
                    $dp[$i][$j] = $dp[$i][$j - 1] && $s2[$j - 1] == $s3[$i + $j - 1];
                } elseif ($j == 0) {
                    $dp[$i][$j] = $dp[$i - 1][$j] && $s1[$i - 1] == $s3[$i + $j - 1];
                } else {
                    $dp[$i][$j] = ($dp[$i - 1][$j] && $s1[$i - 1] == $s3[$i + $j - 1]) || 
                                   ($dp[$i][$j - 1] && $s2[$j - 1] == $s3[$i + $j - 1]);
                }
            }
        }

        return $dp[strlen($s1)][strlen($s2)];
    }
}

🔥

🔒

| 🔒

Please open Telegram to view this post

VIEW IN TELEGRAM

233 views09:07

#medium
Задача: 98. Validate Binary Search Tree

Дан корень бинарного дерева. Определите, является ли это дерево допустимым бинарным деревом поиска (BST).

Допустимое BST определяется следующим образом:

Левое поддерево узла содержит только узлы с ключами, меньшими, чем ключ узла.
Правое поддерево узла содержит только узлы с ключами, большими, чем ключ узла.
Оба поддерева — левое и правое — также должны быть бинарными деревьями поиска.

Пример:

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

👨‍💻

Алгоритм:

1️⃣Давайте воспользуемся порядком узлов при симметричном обходе (inorder traversal):

Левый -> Узел -> Правый.

Постордер:

Здесь узлы перечисляются в порядке их посещения, и вы можете следовать последовательности 1-2-3-4-5 для сравнения различных стратегий.

Порядок "Левый -> Узел -> Правый" при симметричном обходе означает, что для BST каждый элемент должен быть меньше следующего.

2️⃣Следовательно, алгоритм с временной сложностью O(N) и пространственной сложностью O(N) может быть простым:

Вычислить список симметричного обхода inorder.

Проверить, меньше ли каждый элемент в списке inorder следующего за ним.

Постордер:

3️⃣Нужно ли сохранять весь список симметричного обхода?

На самом деле, нет. Достаточно последнего добавленного элемента inorder, чтобы на каждом шаге убедиться, что дерево является BST (или нет). Следовательно, можно объединить оба шага в один и уменьшить используемое пространство.

😎

Решение:

class TreeNode {
    public $val;
    public $left;
    public $right;

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

class Solution {
    private $prev;

    public function __construct() {
        $this->prev = -INF; 
    }

    private function inorder($root) {
        if ($root === null) {
            return true;
        }
        if (!$this->inorder($root->left)) {
            return false;
        }
        if ($root->val <= $this->prev) {
            return false;
        }
        $this->prev = $root->val;
        return $this->inorder($root->right);
    }

    public function isValidBST($root) {
        return $this->inorder($root);
    }
}

🔥

🔒

| 🔒

Please open Telegram to view this post

VIEW IN TELEGRAM

👍1

246 views16:07

#medium
Задача: 99. Recover Binary Search Tree

Вам дан корень бинарного дерева поиска (BST), в котором значения ровно двух узлов дерева были поменяны местами по ошибке. Восстановите дерево, не изменяя его структуру.

Пример:

Input: root = [1,3,null,null,2]
Output: [3,1,null,null,2]
Explanation: 3 cannot be a left child of 1 because 3 > 1. Swapping 1 and 3 makes the BST valid.

👨‍💻

Алгоритм:

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

2️⃣Определите два поменянных местами элемента x и y в почти отсортированном массиве за линейное время.

3️⃣Повторно пройдите по дереву. Измените значение x на y и значение y на x.

😎

Решение:

class TreeNode {
    public $val;
    public $left;
    public $right;

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

class Solution {
    private function inorder($root) {
        if ($root === null) {
            return [];
        }
        return array_merge($this->inorder($root->left), [$root->val], $this->inorder($root->right));
    }

    private function findTwoSwapped($nums) {
        $x = $y = null;
        $n = count($nums);
        for ($i = 0; $i < $n - 1; $i++) {
            if ($nums[$i + 1] < $nums[$i]) {
                $y = $nums[$i + 1];
                if ($x === null) {
                    $x = $nums[$i];
                } else {
                    break;
                }
            }
        }
        return [$x, $y];
    }

    private function recover($root, $x, $y, &$count) {
        if ($root === null || $count === 0) {
            return;
        }
        if ($root->val === $x || $root->val === $y) {
            $root->val = ($root->val === $x) ? $y : $x;
            $count--;
            if ($count === 0) {
                return;
            }
        }
        $this->recover($root->left, $x, $y, $count);
        $this->recover($root->right, $x, $y, $count);
    }

    public function recoverTree($root) {
        $nums = $this->inorder($root);
        list($x, $y) = $this->findTwoSwapped($nums);
        $count = 2; // To ensure we only swap the two elements once
        $this->recover($root, $x, $y, $count);
    }
}

🔥

🔒

| 🔒

Please open Telegram to view this post

VIEW IN TELEGRAM

212 views09:07

#easy
Задача: 100. Same Tree

Даны корни двух бинарных деревьев p и q. Напишите функцию, чтобы проверить, одинаковы ли они.

Два бинарных дерева считаются одинаковыми, если они структурно идентичны, и узлы имеют одинаковые значения.

Пример:

Input: p = [1,2,3], q = [1,2,3]
Output: true

👨‍💻

Алгоритм:

Самая простая стратегия здесь — использовать рекурсию. Проверьте, не равны ли узлы p и q значению None, и равны ли их значения. Если все проверки пройдены успешно, проделайте то же самое для дочерних узлов рекурсивно.

😎

Решение:

class TreeNode {
    public $val;
    public $left;
    public $right;

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

class Solution {
    function isSameTree($p, $q) {
        if ($p === null && $q === null) {
            return true;
        }
        if ($p === null || $q === null) {
            return false;
        }
        if ($p->val !== $q->val) {
            return false;
        }
        return $this->isSameTree($p->right, $q->right) && $this->isSameTree($p->left, $q->left);
    }
}

🔥

🔒

| 🔒

Please open Telegram to view this post

VIEW IN TELEGRAM

217 views16:07

#easy
Задача: 101. Symmetric Tree

Дан корень бинарного дерева. Проверьте, является ли это дерево зеркальным отражением самого себя (то есть симметричным относительно своего центра).

Пример:

Input: root = [1,2,2,3,4,4,3]
Output: true

👨‍💻

Алгоритм:

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

2️⃣Следовательно, вопрос заключается в том, когда два дерева являются зеркальным отражением друг друга?

Два дерева являются зеркальным отражением друг друга, если:

- Их корни имеют одинаковое значение.
- Правое поддерево каждого дерева является зеркальным отражением левого поддерева другого дерева.

3️⃣Это похоже на человека, смотрящего в зеркало. Отражение в зеркале имеет ту же голову, но правая рука отражения соответствует левой руке настоящего человека и наоборот.

Вышеописанное объяснение естественным образом превращается в рекурсивную функцию.

😎

Решение:

class TreeNode {
    public $val;
    public $left;
    public $right;

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

class Solution {
    function isSymmetric($root) {
        return $this->isMirror($root, $root);
    }

    function isMirror($t1, $t2) {
        if ($t1 === null && $t2 === null) {
            return true;
        }
        if ($t1 === null || $t2 === null) {
            return false;
        }
        return ($t1->val == $t2->val) && $this->isMirror($t1->right, $t2->left) && $this->isMirror($t1->left, $t2->right);
    }
}

🔥

🔒

| 🔒

Please open Telegram to view this post

VIEW IN TELEGRAM

240 views09:07

#medium
Задача: 102. Binary Tree Level Order Traversal

Дан корень бинарного дерева. Верните обход узлов дерева по уровням (то есть слева направо, уровень за уровнем).

Пример:

Input: root = [3,9,20,null,null,15,7]
Output: [[3],[9,20],[15,7]]

👨‍💻

Алгоритм:

1️⃣Самый простой способ решения задачи — использование рекурсии. Сначала убедимся, что дерево не пустое, а затем рекурсивно вызовем функцию helper(node, level), которая принимает текущий узел и его уровень в качестве аргументов.

2️⃣Эта функция выполняет следующее:

Выходной список здесь называется levels, и, таким образом, текущий уровень — это просто длина этого списка len(levels). Сравниваем номер текущего уровня len(levels) с уровнем узла level. Если вы все еще на предыдущем уровне, добавьте новый, добавив новый список в levels.

3️⃣Добавьте значение узла в последний список в levels.

Рекурсивно обработайте дочерние узлы, если они не равны None: helper(node.left / node.right, level + 1).

😎

Решение:

class TreeNode {
    public $val;
    public $left;
    public $right;

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

class Solution {
    function levelOrder($root) {
        $levels = [];
        if ($root === null) {
            return $levels;
        }

        $this->helper($root, 0, $levels);
        return $levels;
    }

    private function helper($node, $level, &$levels) {
        if ($node === null) {
            return;
        }
        if (!isset($levels[$level])) {
            $levels[$level] = [];
        }

        $levels[$level][] = $node->val;

        $this->helper($node->left, $level + 1, $levels);
        $this->helper($node->right, $level + 1, $levels);
    }
}

🔥

🔒

| 🔒

Please open Telegram to view this post

VIEW IN TELEGRAM

229 views16:07

#medium
Задача: 103. Binary Tree Zigzag Level Order Traversal

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

Пример:

Input: root = [3,9,20,null,null,15,7]
Output: [[3],[20,9],[15,7]]

👨‍💻

Алгоритм:

1️⃣Мы также можем реализовать поиск в ширину (BFS) с использованием одного цикла. Трюк заключается в том, что мы добавляем узлы для посещения в очередь, а узлы разных уровней разделяем с помощью какого-то разделителя (например, пустого узла). Разделитель отмечает конец уровня, а также начало нового уровня.

2️⃣Здесь мы принимаем второй подход, описанный выше. Можно начать с обычного алгоритма BFS, к которому мы добавляем элемент порядка зигзага с помощью deque (двусторонней очереди).

3️⃣Для каждого уровня мы начинаем с пустого контейнера deque, который будет содержать все значения данного уровня. В зависимости от порядка каждого уровня, т.е. либо слева направо, либо справа налево, мы решаем, с какого конца deque добавлять новый элемент.

😎

Решение:

class TreeNode {
    public $val;
    public $left;
    public $right;

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

class Solution {
    function zigzagLevelOrder($root) {
        $result = [];
        if ($root === null) {
            return $result;
        }

        $nodeQueue = new SplQueue();
        $nodeQueue->enqueue($root);
        $nodeQueue->enqueue(null);
        $isOrderLeft = true;
        $levelList = [];

        while (!$nodeQueue->isEmpty()) {
            $currentNode = $nodeQueue->dequeue();

            if ($currentNode !== null) {
                if ($isOrderLeft) {
                    $levelList[] = $currentNode->val;
                } else {
                    array_unshift($levelList, $currentNode->val);
                }

                if ($currentNode->left !== null) {
                    $nodeQueue->enqueue($currentNode->left);
                }
                if ($currentNode->right !== null) {
                    $nodeQueue->enqueue($currentNode->right);
                }
            } else {
                $result[] = $levelList;
                $levelList = [];
                if (!$nodeQueue->isEmpty()) {
                    $nodeQueue->enqueue(null);
                }
                $isOrderLeft = !$isOrderLeft;
            }
        }

        return $result;
    }
}

🔥

🔒

| 🔒

Please open Telegram to view this post

VIEW IN TELEGRAM

208 views09:07

#medium
Задача: 105. Construct Binary Tree from Preorder and Inorder Traversal

Даны два массива целых чисел: preorder и inorder, где preorder — это результат преордер обхода бинарного дерева, а inorder — результат инордер обхода того же дерева. Постройте и верните бинарное дерево.

Пример:

Input: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
Output: [3,9,20,null,null,15,7]

👨‍💻

Алгоритм:

1️⃣Создайте хеш-таблицу для записи соотношения значений и их индексов в массиве inorder, чтобы можно было быстро найти позицию корня.

2️⃣Инициализируйте переменную целочисленного типа preorderIndex для отслеживания элемента, который будет использоваться для создания корня. Реализуйте рекурсивную функцию arrayToTree, которая принимает диапазон массива inorder и возвращает построенное бинарное дерево:
Если диапазон пуст, возвращается null;
Инициализируйте корень элементом preorder[preorderIndex], затем увеличьте preorderIndex;
Рекурсивно используйте левую и правую части массива inorder для построения левого и правого поддеревьев.

3️⃣Просто вызовите функцию рекурсии с полным диапазоном массива inorder.

😎

Решение:

function buildTree($preorder, $inorder) {
    static $preorderIndex = 0;
    $inorderIndexMap = [];
    foreach ($inorder as $i => $value) {
        $inorderIndexMap[$value] = $i;
    }
    
    return arrayToTree(0, count($preorder) - 1, $preorder, $inorderIndexMap, $preorderIndex);
}

function arrayToTree($left, $right, &$preorder, &$inorderIndexMap, &$preorderIndex) {
    if ($left > $right) {
        return null;
    }
    
    $rootValue = $preorder[$preorderIndex++];
    $root = new TreeNode($rootValue);
    $root->left = arrayToTree($left, $inorderIndexMap[$rootValue] - 1, $preorder, $inorderIndexMap, $preorderIndex);
    $root->right = arrayToTree($inorderIndexMap[$rootValue] + 1, $right, $preorder, $inorderIndexMap, $preorderIndex);
    return $root;
}

class TreeNode {
    public $val;
    public $left;
    public $right;

    public function __construct($value) {
        $this->val = $value;
        $this->left = null;
        $this->right = null;
    }
}

🔥

🔒

| 🔒

Please open Telegram to view this post

VIEW IN TELEGRAM

222 views16:07

#medium
Задача: 106. Construct Binary Tree from Inorder and Postorder Traversal

Даны два массива целых чисел: inorder и postorder, где inorder — это массив обхода в глубину бинарного дерева слева направо, а postorder — это массив обхода в глубину после обработки всех потомков узла. Постройте и верните соответствующее бинарное дерево.

Пример:

Input: inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]
Output: [3,9,20,null,null,15,7]

👨‍💻

Алгоритм:

1️⃣Создайте хэш-таблицу (hashmap) для хранения соответствия значений и их индексов в массиве обхода inorder.

2️⃣Определите вспомогательную функцию helper, которая принимает границы левой и правой части текущего поддерева в массиве inorder. Эти границы используются для проверки, пусто ли поддерево. Если левая граница больше правой (in_left > in_right), то поддерево пустое и функция возвращает None.

3️⃣Выберите последний элемент в массиве обхода postorder в качестве корня. Значение корня имеет индекс index в обходе inorder. Элементы от in_left до index - 1 принадлежат левому поддереву, а элементы от index + 1 до in_right — правому поддереву. Согласно логике обхода postorder, сначала рекурсивно строится правое поддерево helper(index + 1, in_right), а затем левое поддерево helper(in_left, index - 1). Возвращается корень.

😎

Решение:

function buildTree($inorder, $postorder) {
    $idx_map = [];
    $post_idx = count($postorder) - 1;
    $helper = function($in_left, $in_right) use (&$helper, &$postorder, &$idx_map, &$post_idx) {
        if ($in_left > $in_right) return null;
        $root_val = $postorder[$post_idx];
        $root = new TreeNode($root_val);
        $index = $idx_map[$root_val];
        $post_idx--;
        $root->right = $helper($index + 1, $in_right);
        $root->left = $helper($in_left, $index - 1);
        return $root;
    };
    foreach ($inorder as $i => $val) {
        $idx_map[$val] = $i;
    }
    return $helper(0, count($inorder) - 1);
}

🔥

🔒

| 🔒