#hard
Задача: 587. Erect the Fence

Вам дан массив trees, где trees[i] = [xi, yi] представляет местоположение дерева в саду.

Оградите весь сад с использованием минимальной длины веревки, так как это дорого. Сад хорошо огорожен только в том случае, если все деревья окружены.

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

Пример:

Input: trees = [[1,1],[2,2],[2,0],[2,4],[3,3],[4,2]]
Output: [[1,1],[2,0],[4,2],[3,3],[2,4]]
Explanation: All the trees will be on the perimeter of the fence except the tree at [2, 2], which will be inside the fence.

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

1⃣ Сортировка точек и построение нижней оболочки:
Отсортируйте точки по их x-координатам, а в случае совпадения x-координат, по y-координатам.
Постройте нижнюю оболочку, добавляя точки к оболочке и удаляя последние точки, если они не образуют против часовой стрелки поворот.

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

3⃣ Удаление дублирующих элементов и возврат результата:
Используйте HashSet, чтобы удалить дублирующиеся точки из стека.
Преобразуйте результат в массив и верните его.

😎 Решение:

class Solution {
    func orientation(_ p: [Int], _ q: [Int], _ r: [Int]) -> Int {
        return (q[1] - p[1]) * (r[0] - q[0]) - (q[0] - p[0]) * (r[1] - q[1])
    }

    func outerTrees(_ points: [[Int]]) -> [[Int]] {
        let sortedPoints = points.sorted { (p1, p2) -> Bool in
            return p1[0] == p2[0] ? p1[1] < p2[1] : p1[0] < p2[0]
        }

        var hull = [[Int]]()

        for point in sortedPoints {
            while hull.count >= 2 && orientation(hull[hull.count - 2], hull.last!, point) > 0 {
                hull.removeLast()
            }
            hull.append(point)
        }

        hull.removeLast()

        for point in sortedPoints.reversed() {
            while hull.count >= 2 && orientation(hull[hull.count - 2], hull.last!, point) > 0 {
                hull.removeLast()
            }
            hull.append(point)
        }

        return Array(Set(hull))
    }
}

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

#medium
Задача: 304. Range Sum Query 2D - Immutable

Дана двумерная матрица matrix. Обработайте несколько запросов следующего типа:
Вычислите сумму элементов матрицы внутри прямоугольника, определенного его верхним левым углом (row1, col1) и нижним правым углом (row2, col2).
Реализуйте класс NumMatrix:
- NumMatrix(int[][] matrix) Инициализирует объект целочисленной матрицей matrix.- int sumRegion(int row1, int col1, int row2, int col2) Возвращает сумму элементов матрицы внутри прямоугольника, определенного его верхним левым углом (row1, col1) и нижним правым углом (row2, col2).
Необходимо разработать алгоритм, где метод sumRegion работает за O(1) по времени.

Пример:

Input
["NumMatrix", "sumRegion", "sumRegion", "sumRegion"]
[[[[3, 0, 1, 4, 2], [5, 6, 3, 2, 1], [1, 2, 0, 1, 5], [4, 1, 0, 1, 7], [1, 0, 3, 0, 5]]], [2, 1, 4, 3], [1, 1, 2, 2], [1, 2, 2, 4]]

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

1⃣Инициализация:
Создайте двумерный массив sums размером (m + 1) x (n + 1), где m и n — размеры исходной матрицы matrix. Заполните этот массив нулями.

2⃣Предварительное вычисление сумм:
Заполните массив sums, где каждый элемент sums[i][j] будет содержать сумму всех элементов матрицы от начала до позиции (i-1, j-1) включительно.

3⃣Вычисление диапазонной суммы:
Для каждого запроса суммы элементов внутри прямоугольника, определенного его углами (row1, col1) и (row2, col2), используйте предварительно вычисленный массив sums для получения результата за O(1) времени.

😎 Решение:

class NumMatrix {
    private var dp: [[Int]]

    init(_ matrix: [[Int]]) {
        if matrix.isEmpty || matrix[0].isEmpty {
            dp = []
            return
        }
        let m = matrix.count, n = matrix[0].count
        dp = Array(repeating: Array(repeating: 0, count: n + 1), count: m + 1)
        for r in 0..<m {
            for c in 0..<n {
                dp[r + 1][c + 1] = dp[r + 1][c] + dp[r][c + 1] + matrix[r][c] - dp[r][c]
            }
        }
    }

    func sumRegion(_ row1: Int, _ col1: Int, _ row2: Int, _ col2: Int) -> Int {
        return dp[row2 + 1][col2 + 1] - dp[row1][col2 + 1] - dp[row2 + 1][col1] + dp[row1][col1]
    }
}

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

#hard
Задача: 305. Number of Islands II

Дан пустой двумерный бинарный массив grid размером m x n. Этот массив представляет собой карту, где 0 означает воду, а 1 — сушу. Изначально все ячейки массива — водные (т.е. все ячейки содержат 0).
Вы можете выполнить операцию "добавить землю", которая превращает воду в указанной позиции в сушу. Вам дан массив positions, где positions[i] = [ri, ci] — позиция (ri, ci), в которой следует выполнить i-ю операцию.
Верните массив целых чисел answer, где answer[i] — количество островов после превращения ячейки (ri, ci) в сушу.
Остров окружен водой и образуется путем соединения соседних земель по горизонтали или вертикали. Вы можете считать, что все четыре края сетки окружены водой.

Пример:

Input: m = 1, n = 1, positions = [[0,0]]
Output: [1]

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

1⃣Инициализация:
Создайте массивы x[] = { -1, 1, 0, 0 } и y[] = { 0, 0, -1, 1 }, которые будут использоваться для нахождения соседей ячейки.
Создайте экземпляр UnionFind, например, dsu(m * n). Инициализируйте всех родителей значением -1. Используйте объединение по рангу, инициализируйте все ранги значением 0. Наконец, инициализируйте count = 0.
Создайте список целых чисел answer, где answer[i] будет хранить количество островов, образованных после превращения ячейки positions[i] в сушу.

2⃣Обработка позиций:
Итерация по массиву positions. Для каждой позиции в positions:
Выполните линейное отображение, чтобы преобразовать двумерную позицию ячейки в landPosition = position[0] * n + position[1].
Используйте операцию addLand(landPosition), чтобы добавить landPosition как узел в граф. Эта функция также увеличит count.
Итерация по каждому соседу позиции. Соседа можно определить с помощью neighborX = position[0] + x[i] и neighborY = position[1] + y[i], где neighborX — координата X, а neighborY — координата Y соседней ячейки. Выполните линейное отображение соседней ячейки с помощью neighborPosition = neighborX * n + neighborY. Теперь, если на neighborPosition есть суша, т.е. isLand(neighborPosition) возвращает true, выполните объединение neighborPosition и landPosition. В объединении уменьшите count на 1.

3⃣Определение количества островов:
Выполните операцию numberOfIslands, которая возвращает количество островов, образованных после превращения позиции в сушу. Добавьте это значение в answer.
Верните answer.

😎 Решение

class UnionFind {
    private var parent: [Int], rank: [Int], count = 0
    init(_ size: Int) { parent = Array(repeating: -1, count: size); rank = Array(repeating: 0, count: size) }
    func addLand(_ x: Int) { if parent[x] < 0 { parent[x] = x; count += 1 } }
    func isLand(_ x: Int) -> Bool { return parent[x] >= 0 }
    func find(_ x: Int) -> Int { if parent[x] != x { parent[x] = find(parent[x]) }; return parent[x] }
    func unionSet(_ x: Int, _ y: Int) { let xset = find(x), yset = find(y)
        if xset != yset { if rank[xset] < rank[yset] { parent[xset] = yset }
        else { parent[yset] = xset; if rank[xset] == rank[yset] { rank[xset] += 1 } }; count -= 1 } }
}

class Solution {
    func numIslands2(_ m: Int, _ n: Int, _ positions: [[Int]]) -> [Int] {
        let dsu = UnionFind(m * n), dirs = [(-1, 0), (1, 0), (0, -1), (0, 1)]
        var answer = [Int]()
        for pos in positions {
            let land = pos[0] * n + pos[1]
            dsu.addLand(land)
            for (dx, dy) in dirs {
                let x = pos[0] + dx, y = pos[1] + dy, neighbor = x * n + y
                if x >= 0 && x < m && y >= 0 && y < n && dsu.isLand(neighbor) { dsu.unionSet(land, neighbor) }
            }
            answer.append(dsu.count)
        }
        return answer
    }
}

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

#medium
Задача: 542. 01 Matrix


Дан бинарный матрица размера m x n, верните расстояние до ближайшего нуля для каждой ячейки.

Расстояние между двумя соседними ячейками равно 1.

Пример:

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

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

1⃣Создайте копию матрицы mat, назовем её matrix. Используйте структуру данных seen для пометки уже посещенных узлов и очередь для выполнения BFS. Поместите все узлы с 0 в очередь и отметьте их в seen.

2⃣Выполните BFS:
Пока очередь не пуста, извлекайте текущие row, col, steps из очереди.
Итеративно пройдите по четырем направлениям. Для каждой nextRow, nextCol проверьте, находятся ли они в пределах границ и не были ли они уже посещены в seen.

3⃣Если так, установите matrix[nextRow][nextCol] = steps + 1 и поместите nextRow, nextCol, steps + 1 в очередь. Также отметьте nextRow, nextCol в seen. Верните matrix.

😎 Решение:

class Solution {
    var m: Int = 0
    var n: Int = 0
    let directions = [[0, 1], [1, 0], [0, -1], [-1, 0]]
    
    func updateMatrix(_ mat: [[Int]]) -> [[Int]] {
        m = mat.count
        n = mat[0].count
        var matrix = Array(repeating: Array(repeating: 0, count: n), count: m)
        var seen = Array(repeating: Array(repeating: false, count: n), count: m)
        var queue = [[Int]]()

        for row in 0..<m {
            for col in 0..<n {
                matrix[row][col] = mat[row][col]
                if matrix[row][col] == 0 {
                    queue.append([row, col, 0])
                    seen[row][col] = true
                }
            }
        }
        
        while !queue.isEmpty {
            let curr = queue.removeFirst()
            let row = curr[0], col = curr[1], steps = curr[2]
            
            for direction in directions {
                let nextRow = row + direction[0], nextCol = col + direction[1]
                if valid(nextRow, nextCol) && !seen[nextRow][nextCol] {
                    seen[nextRow][nextCol] = true
                    queue.append([nextRow, nextCol, steps + 1])
                    matrix[nextRow][nextCol] = steps + 1
                }
            }
        }
        
        return matrix
    }
    
    func valid(_ row: Int, _ col: Int) -> Bool {
        return 0 <= row && row < m && 0 <= col && col < n
    }
}

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

#hard
Задача: 588. Design In-Memory File System

Спроектируйте структуру данных, которая симулирует файловую систему в памяти.

Реализуйте класс FileSystem:
FileSystem() Инициализирует объект системы.
List<String> ls(String path)
Если path является путем к файлу, возвращает список, содержащий только имя этого файла.
Если path является путем к директории, возвращает список имен файлов и директорий в этой директории.
Ответ должен быть в лексикографическом порядке.
void mkdir(String path) Создает новую директорию согласно заданному пути. Заданная директория не существует. Если промежуточные директории в пути не существуют, вы также должны создать их.
void addContentToFile(String filePath, String content)
Если filePath не существует, создает файл, содержащий заданный контент.
Если filePath уже существует, добавляет заданный контент к исходному содержимому.
String readContentFromFile(String filePath) Возвращает содержимое файла по пути filePath.

Пример:

Input
["FileSystem", "ls", "mkdir", "addContentToFile", "ls", "readContentFromFile"]
[[], ["/"], ["/a/b/c"], ["/a/b/c/d", "hello"], ["/"], ["/a/b/c/d"]]
Output
[null, [], null, null, ["a"], "hello"]

Explanation
FileSystem fileSystem = new FileSystem();
fileSystem.ls("/");                         // return []
fileSystem.mkdir("/a/b/c");
fileSystem.addContentToFile("/a/b/c/d", "hello");
fileSystem.ls("/");                         // return ["a"]
fileSystem.readContentFromFile("/a/b/c/d"); // return "hello"

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

1⃣ Инициализация файловой системы:
Создайте класс FileSystem, который будет содержать вложенный класс File. Класс File будет представлять либо файл, либо директорию, содержать флаг isfile, словарь files и строку content.

2⃣ Обработка команд:
Реализуйте метод ls, который возвращает список файлов и директорий в указанном пути, либо имя файла, если указанный путь является файлом.
Реализуйте метод mkdir, который создаёт директории по указанному пути. Если промежуточные директории не существуют, создайте их.
Реализуйте метод addContentToFile, который добавляет содержимое в файл по указанному пути. Если файл не существует, создайте его.
Реализуйте метод readContentFromFile, который возвращает содержимое файла по указанному пути.

3⃣ Обработка путей и работа с файлами/директориями:
Используйте метод split для разделения пути на составляющие и навигации по дереву директорий и файлов.
Для каждой команды выполняйте соответствующие операции по созданию, чтению или записи содержимого файлов и директорий.

😎 Решение:

class FileSystem {
    class File {
        var isFile = false
        var files = [String: File]()
        var content = ""
    }

    private var root = File()

    private func navigate(_ path: String) -> File {
        var t = root
        if path != "/" {
            let dirs = path.split(separator: "/")
            for dir in dirs {
                if !dir.isEmpty {
                    if t.files[String(dir)] == nil {
                        t.files[String(dir)] = File()
                    }
                    t = t.files[String(dir)]!
                }
            }
        }
        return t
    }

    func ls(_ path: String) -> [String] {
        let t = navigate(path)
        if t.isFile {
            return [String(path.split(separator: "/").last!)]
        }
        return t.files.keys.sorted()
    }

    func mkdir(_ path: String) {
        _ = navigate(path)
    }

    func addContentToFile(_ filePath: String, _ content: String) {
        let t = navigate(filePath)
        t.isFile = true
        t.content += content
    }

    func readContentFromFile(_ filePath: String) -> String {
        return navigate(filePath).content
    }
}

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

#medium
Задача: 397. Integer Replacement

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

Пример:

Input: n = 8
Output: 3
Explanation: 8 -> 4 -> 2 -> 1

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

1⃣Начните с данного числа n и выполните одну из следующих операций:
Если n четное, замените n на n / 2.
Если n нечетное, замените n на n + 1 или n - 1.

2⃣Используйте метод динамического программирования или жадный метод, чтобы найти минимальное количество операций, необходимых для достижения n = 1. Определите, какая операция (n + 1 или n - 1) является более эффективной для минимизации количества шагов.

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

😎 Решение:

class Solution {
    func integerReplacement(_ n: Int) -> Int {
        var memo = [Int: Int]()
        return helper(n, &memo)
    }
    
    func helper(_ n: Int, _ memo: inout [Int: Int]) -> Int {
        if n == 1 { return 0 }
        if let result = memo[n] { return result }
        
        if n % 2 == 0 {
            memo[n] = 1 + helper(n / 2, &memo)
        } else {
            memo[n] = 1 + min(helper(n + 1, &memo), helper(n - 1, &memo))
        }
        
        return memo[n]!
    }
}

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

#medium
Задача: 398. Random Pick Index

Из целочисленного массива nums с возможными дубликатами случайным образом выведите индекс заданного целевого числа. Можно предположить, что заданное целевое число должно существовать в массиве. Реализация класса Solution: Solution(int[] nums) Инициализирует объект с массивом nums. int pick(int target) Выбирает случайный индекс i из nums, где nums[i] == target. Если существует несколько допустимых i, то каждый индекс должен иметь равную вероятность возврата.

Пример:

Input
["Solution", "pick", "pick", "pick"]
[[[1, 2, 3, 3, 3]], [3], [1], [3]]
Output
[null, 4, 0, 2]

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

1⃣Инициализируйте объект с массивом nums. Сохраните этот массив для дальнейшего использования.

2⃣Реализуйте метод pick(target), который выбирает случайный индекс i из массива nums, где nums[i] равен target. Если таких индексов несколько, каждый из них должен иметь равную вероятность быть выбранным.

3⃣Для реализации метода pick используйте алгоритм reservoir sampling для выбора случайного индекса.

😎 Решение:

class Solution {
    private var nums: [Int]

    init(_ nums: [Int]) {
        self.nums = nums
    }

    func pick(_ target: Int) -> Int {
        var count = 0
        var result = -1
        for (i, num) in nums.enumerated() {
            if num == target {
                count += 1
                if Int.random(in: 1...count) == count {
                    result = i
                }
            }
        }
        return result
    }
}

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

#medium
Задача: 399. Evaluate Division

Вам дан массив пар переменных equations и массив вещественных чисел values, где equations[i] = [Ai, Bi] и values[i] представляют уравнение Ai / Bi = values[i]. Каждая Ai или Bi - это строка, представляющая одну переменную. Вам также даны некоторые запросы, где queries[j] = [Cj, Dj] представляет j-й запрос, в котором вы должны найти ответ для Cj / Dj = ?. Верните ответы на все запросы. Если ни один ответ не может быть определен, верните -1.0. Замечание: входные данные всегда действительны. Можно предположить, что вычисление запросов не приведет к делению на ноль и что противоречия нет. Примечание: Переменные, которые не встречаются в списке уравнений, являются неопределенными, поэтому для них ответ не может быть определен.

Пример:

Input: equations = [["a","b"],["b","c"]], values = [2.0,3.0], queries = [["a","c"],["b","a"],["a","e"],["a","a"],["x","x"]]
Output: [6.00000,0.50000,-1.00000,1.00000,-1.00000]

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

1⃣Создание графа:
Представьте каждую переменную как узел в графе.
Используйте уравнения для создания ребер между узлами, где каждое ребро имеет вес, равный значению уравнения (Ai / Bi = values[i]).
Создайте также обратные ребра с обратным весом (Bi / Ai = 1 / values[i]).

2⃣Поиск пути:
Для каждого запроса используйте поиск в глубину (DFS) или поиск в ширину (BFS) для поиска пути от Cj до Dj.
Если путь найден, вычислите произведение весов вдоль пути, чтобы найти значение Cj / Dj.
Если путь не найден, верните -1.0.

3⃣Обработка запросов:
Пройдитесь по всем запросам и используйте граф для вычисления результатов каждого запроса.

😎 Решение:

class Solution {
    func calcEquation(_ equations: [[String]], _ values: [Double], _ queries: [[String]]) -> [Double] {
        var graph = [String: [String: Double]]()

        for (i, equation) in equations.enumerated() {
            let A = equation[0], B = equation[1]
            let value = values[i]
            graph[A, default: [String: Double]()][B] = value
            graph[B, default: [String: Double]()][A] = 1.0 / value
        }

        func bfs(_ start: String, _ end: String) -> Double {
            guard let _ = graph[start], let _ = graph[end] else { return -1.0 }
            var queue = [(start, 1.0)]
            var visited = Set<String>()
            
            while !queue.isEmpty {
                let (current, curProduct) = queue.removeFirst()
                if current == end { return curProduct }
                visited.insert(current)
                for (neighbor, value) in graph[current, default: [String: Double]()] {
                    if !visited.contains(neighbor) {
                        queue.append((neighbor, curProduct * value))
                    }
                }
            }
            return -1.0
        }

        var results = [Double]()
        for query in queries {
            let C = query[0], D = query[1]
            results.append(bfs(C, D))
        }
        return results
    }
}

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

#medium
Задача: 400. Nth Digit

Дано целое число n, вернуть n-ю цифру бесконечной последовательности чисел [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...].

Пример:

Input: n = 3
Output: 3

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

1⃣Определение диапазона:
Начните с определения количества цифр в числах текущего диапазона (1-9, 10-99, 100-999 и т.д.).
Уменьшайте значение n, вычитая количество цифр в текущем диапазоне, пока не найдете диапазон, в который попадает n-я цифра.

2⃣Нахождение конкретного числа:
Когда определите диапазон, найдите точное число, содержащее n-ю цифру.
Определите индекс цифры в этом числе.

3⃣Возвращение n-й цифры:
Извлеките и верните n-ю цифру из найденного числа.

😎 Решение:

class Solution {
    func findNthDigit(_ n: Int) -> Int {
        var n = n
        var length = 1
        var count = 9
        var start = 1
        
        while n > length * count {
            n -= length * count
            length += 1
            count *= 10
            start *= 10
        }
        
        start += (n - 1) / length
        let s = String(start)
        let index = s.index(s.startIndex, offsetBy: (n - 1) % length)
        return Int(String(s[index]))!
    }
}

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

#easy
Задача: 401. Binary Watch

Бинарные часы имеют 4 светодиода сверху для представления часов (0-11) и 6 светодиодов снизу для представления минут (0-59). Каждый светодиод представляет ноль или единицу, при этом младший разряд находится справа.

Пример:

Input: turnedOn = 1
Output: ["0:01","0:02","0:04","0:08","0:16","0:32","1:00","2:00","4:00","8:00"]

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

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

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

3⃣Форматирование результата:
Если комбинация часов и минут соответствует условию, отформатируйте их в виде строки "часы:минуты" и добавьте в список результатов.

😎 Решение:

class Solution {
    func readBinaryWatch(_ turnedOn: Int) -> [String] {
        var results = [String]()
        for h in 0..<12 {
            for m in 0..<60 {
                if (h.nonzeroBitCount + m.nonzeroBitCount) == turnedOn {
                    results.append(String(format: "%d:%02d", h, m))
                }
            }
        }
        return results
    }
}

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

#medium
Задача: 402. Remove K Digits

Если задана строка num, представляющая неотрицательное целое число num, и целое число k, верните наименьшее возможное целое число после удаления k цифр из num.

Пример:

Input: num = "1432219", k = 3
Output: "1219"

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

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

2⃣Обработка каждой цифры
Перебирайте каждую цифру в строке num.
Если текущая цифра меньше верхней цифры в стеке и у вас есть еще возможность удалить цифры (k > 0), удалите верхнюю цифру из стека.
Добавьте текущую цифру в стек.
Удаление оставшихся цифр:
Если после прохождения всей строки k еще больше нуля, удалите оставшиеся цифры из конца стека

3⃣Формирование результата
Постройте итоговое число из цифр в стеке и удалите ведущие нули.

😎 Решение:

class Solution {
    func removeKdigits(_ num: String, _ k: Int) -> String {
        var stack = [Character]()
        var k = k
        for digit in num {
            while k > 0 && !stack.isEmpty && stack.last! > digit {
                stack.removeLast()
                k -= 1
            }
            stack.append(digit)
        }
        stack = Array(stack[0..<stack.count-k])
        let result = String(stack).trimmingCharacters(in: CharacterSet(charactersIn: "0"))
        return result.isEmpty ? "0" : result
    }
}

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

#hard
Задача: 403. Frog Jump

Если задана строка num, представляющая неотрицательное целое число num, и целое число k, верните наименьшее возможное целое число после удаления k цифр из num.

Пример:

Input: stones = [0,1,3,5,6,8,12,17]
Output: true

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

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

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

3⃣Проверка достижения последнего камня
Если можно достичь последний камень с помощью одного из возможных прыжков, верните True.
Если после всех итераций последний камень не достигнут, верните False.Формирование результата:
Постройте итоговое число из цифр в стеке и удалите ведущие нули.

😎 Решение:

class Solution {
    func canCross(_ stones: [Int]) -> Bool {
        var dp = [Int: Set<Int>]()
        for stone in stones {
            dp[stone] = Set<Int>()
        }
        dp[0]?.insert(0)
        
        for stone in stones {
            for jump in dp[stone]! {
                for step in jump - 1...jump + 1 {
                    if step > 0, let _ = dp[stone + step] {
                        dp[stone + step]?.insert(step)
                    }
                }
            }
        }
        
        return !(dp[stones.last!]!.isEmpty)
    }
}

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

#easy
Задача: 404. Sum of Left Leaves

Если задан корень бинарного дерева, верните сумму всех левых листьев. Лист - это узел, не имеющий детей. Левый лист - это лист, который является левым ребенком другого узла.

Пример:

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

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

1⃣Рекурсивный обход дерева
Обходите дерево с помощью рекурсивной функции, которая принимает текущий узел и флаг, указывающий, является ли узел левым ребенком.

2⃣Проверка листьев
Если текущий узел является листом и флаг указывает, что это левый ребенок, добавьте значение узла к сумме.

3⃣Рекурсивный вызов для детей
Рекурсивно вызовите функцию для левого и правого детей текущего узла, передавая соответствующий флаг.

😎 Решение:

class Solution {
    func sumOfLeftLeaves(_ root: TreeNode?) -> Int {
        return dfs(root, false)
    }
    
    private func dfs(_ node: TreeNode?, _ isLeft: Bool) -> Int {
        guard let node = node else { return 0 }
        if node.left == nil && node.right == nil {
            return isLeft ? node.val : 0
        }
        return dfs(node.left, true) + dfs(node.right, false)
    }
}

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

#medium
Задача: 316. Remove Duplicate Letters

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

Пример:

Input: s = "bcabc"
Output: "abc"

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

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

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

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

😎 Решение:

class Solution {
    func removeDuplicateLetters(_ s: String) -> String {
        var stack = [Character]()
        var seen = Set<Character>()
        let lastOccurrence = Dictionary(uniqueKeysWithValues: s.enumerated().map { ($1, $0) })

        for (i, c) in s.enumerated() {
            if !seen.contains(c) {
                while let last = stack.last, c < last, i < lastOccurrence[last]! {
                    seen.remove(stack.popLast()!)
                }
                seen.insert(c)
                stack.append(c)
            }
        }
        return String(stack)
    }
}

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

#hard
Задача: 317. Shortest Distance from All Buildings

Дана сетка m x n, содержащая значения 0, 1 или 2, где:

каждое 0 обозначает пустую землю, по которой можно свободно проходить,
каждое 1 обозначает здание, через которое нельзя пройти,
каждое 2 обозначает препятствие, через которое нельзя пройти.
Вы хотите построить дом на пустой земле, чтобы он достиг всех зданий с минимальным суммарным расстоянием. Можно перемещаться только вверх, вниз, влево и вправо.

Верните минимальное суммарное расстояние для такого дома. Если построить такой дом невозможно согласно указанным правилам, верните -1.

Суммарное расстояние — это сумма расстояний между домами друзей и точкой встречи.

Пример:

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

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

1⃣Инициализация и запуск BFS
Для каждой пустой ячейки (0) в сетке grid запустите BFS, обходя все соседние ячейки в 4 направлениях, которые не заблокированы и не посещены, отслеживая расстояние от начальной ячейки.

2⃣Обработка BFS и обновление расстояний
При достижении здания (1) увеличьте счетчик достигнутых домов housesReached и суммарное расстояние distanceSum на текущее расстояние. Если housesReached равно общему количеству зданий, верните суммарное расстояние. Если BFS не может достигнуть всех домов, установите значение каждой посещенной пустой ячейки в 2, чтобы не запускать новый BFS из этих ячеек, и верните INT_MAX.

3⃣Обновление и возврат минимального расстояния
Обновите минимальное расстояние (minDistance) после каждого вызова BFS. Если возможно достигнуть все дома из любой пустой ячейки, верните найденное минимальное расстояние. В противном случае, верните -1.

😎 Решение:

class Solution {
    private func bfs(_ grid: inout [[Int]], _ row: Int, _ col: Int, _ totalHouses: Int) -> Int {
        let dirs = [(1, 0), (-1, 0), (0, 1), (0, -1)]
        let rows = grid.count
        let cols = grid[0].count
        var distanceSum = 0
        var housesReached = 0
        var q = [(row, col)]
        var vis = Array(repeating: Array(repeating: false, count: cols), count: rows)
        vis[row][col] = true
        var steps = 0

        while !q.isEmpty && housesReached != totalHouses {
            for _ in 0..<q.count {
                let (r, c) = q.removeFirst()

                if grid[r][c] == 1 {
                    distanceSum += steps
                    housesReached += 1
                    continue
                }

                for (dr, dc) in dirs {
                    let nr = r + dr, nc = c + dc
                    if nr >= 0 && nc >= 0 && nr < rows && nc < cols && !vis[nr][nc] && grid[nr][nc] != 2 {
                        vis[nr][nc] = true
                        q.append((nr, nc))
                    }
                }
            }
            steps += 1
        }

        if housesReached != totalHouses {
            for r in 0..<rows {
                for c in 0..<cols {
                    if grid[r][c] == 0 && vis[r][c] {
                        grid[r][c] = 2
                    }
                }
            }
            return Int.max
        }
        return distanceSum
    }

    func shortestDistance(_ grid: [[Int]]) -> Int {
        var grid = grid
        var minDistance = Int.max
        let rows = grid.count
        let cols = grid[0].count
        var totalHouses = 0

        for r in 0..<rows {
            for c in 0..<cols {
                if grid[r][c] == 1 {
                    totalHouses += 1
                }
            }
        }

        for r in 0..<rows {
            for c in 0..<cols {
                if grid[r][c] == 0 {
                    minDistance = min(minDistance, bfs(&grid, r, c, totalHouses))
                }
            }
        }

        return minDistance == Int.max ? -1 : minDistance
    }
}

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

#medium
Задача: 318. Maximum Product of Word Lengths

Дан массив строк words, верните максимальное значение произведения длины word[i] на длину word[j], где два слова не имеют общих букв. Если таких двух слов не существует, верните 0.

Пример:

Input: words = ["abcw","baz","foo","bar","xtfn","abcdef"]
Output: 16
Explanation: The two words can be "abcw", "xtfn".

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

1⃣Предварительная обработка масок и длин
Вычислите битовые маски для всех слов и сохраните их в массиве masks. Сохраните длины всех слов в массиве lens.

2⃣Сравнение слов и проверка общих букв
Сравните каждое слово с каждым последующим словом. Если два слова не имеют общих букв (проверка с использованием масок: (masks[i] & masks[j]) == 0), обновите максимальное произведение maxProd.

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

😎 Решение:

class Solution {
    func maxProduct(_ words: [String]) -> Int {
        let n = words.count
        var masks = [Int](repeating: 0, count: n)
        var lens = [Int](repeating: 0, count: n)
        
        for i in 0..<n {
            var bitmask = 0
            for ch in words[i] {
                bitmask |= 1 << (ch.asciiValue! - Character("a").asciiValue!)
            }
            masks[i] = bitmask
            lens[i] = words[i].count
        }
        
        var maxVal = 0
        for i in 0..<n {
            for j in i+1..<n {
                if masks[i] & masks[j] == 0 {
                    maxVal = max(maxVal, lens[i] * lens[j])
                }
            }
        }
        return maxVal
    }
}

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

#medium
Задача: 319. Bulb Switcher

Есть n лампочек, которые изначально выключены. Сначала вы включаете все лампочки, затем выключаете каждую вторую лампочку.

На третьем раунде вы переключаете каждую третью лампочку (включаете, если она выключена, или выключаете, если она включена). На i-ом раунде вы переключаете каждую i-ую лампочку. На n-ом раунде вы переключаете только последнюю лампочку.

Верните количество лампочек, которые будут включены после n раундов.

Пример:

Input: n = 3
Output: 1
Explanation: At first, the three bulbs are [off, off, off].
After the first round, the three bulbs are [on, on, on].
After the second round, the three bulbs are [on, off, on].
After the third round, the three bulbs are [on, off, off]. 
So you should return 1 because there is only one bulb is on.
Explanation: The two words can be "abcw", "xtfn".

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

1⃣Инициализация
Лампочка остается включенной, если она переключалась нечетное количество раз. Лампочка будет переключаться на каждом делителе её номера.

2⃣Определение состояния лампочки
Лампочка останется включенной только в том случае, если у нее нечетное количество делителей, что возможно только для квадратных чисел.

3⃣Подсчет включенных лампочек
Количество лампочек, которые будут включены после n раундов.

😎 Решение:

class Solution {
    func bulbSwitch(_ n: Int) -> Int {
        return Int(Double(n).squareRoot())
    }
}

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

#easy
Задача: 543. Diameter of Binary Tree

Учитывая корень бинарного дерева, вернуть длину диаметра дерева.

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

Длина пути между двумя узлами представлена числом ребер между ними.

Пример:

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

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

1⃣Инициализируйте целочисленную переменную diameter для отслеживания самого длинного пути, найденного с помощью DFS.

2⃣Реализуйте рекурсивную функцию longestPath, которая принимает TreeNode в качестве входных данных и рекурсивно исследует дерево: Если узел равен None, вернуть 0. Рекурсивно исследовать левые и правые дочерние узлы, возвращая длины путей leftPath и rightPath. Если сумма leftPath и rightPath больше текущего diameter, обновить diameter. Вернуть большее из leftPath и rightPath плюс 1.

3⃣Вызвать longestPath с root.

😎 Решение:

class Solution {
    private var diameter: Int = 0
    
    func diameterOfBinaryTree(_ root: TreeNode?) -> Int {
        diameter = 0
        _ = longestPath(root)
        return diameter
    }
    
    private func longestPath(_ node: TreeNode?) -> Int {
        guard let node = node else { return 0 }
        
        let leftPath = longestPath(node.left)
        let rightPath = longestPath(node.right)
        
        diameter = max(diameter, leftPath + rightPath)
        
        return max(leftPath, rightPath) + 1
    }
}

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

#medium
Задача: 320. Generalized Abbreviation

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

Например, "abcde" можно сократить следующим образом:

"a3e" ("bcd" заменено на "3")
"1bcd1" ("a" и "e" заменены на "1")
"5" ("abcde" заменено на "5")
"abcde" (без замены подстрок)
Однако следующие аббревиатуры недействительны:

"23" ("ab" заменено на "2" и "cde" заменено на "3") недействительно, так как выбранные подстроки смежные.
"22de" ("ab" заменено на "2" и "bc" заменено на "2") недействительно, так как выбранные подстроки перекрываются.
Дано слово word, верните список всех возможных обобщенных аббревиатур слова. Верните ответ в любом порядке.

Пример:

Input: word = "a"
Output: ["1","a"]

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

1⃣Создание битовых масок
Каждая аббревиатура имеет одно к одному соответствие с n-битным двоичным числом x, где n - длина слова. Используйте эти числа в качестве чертежей для построения соответствующих аббревиатур.

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

3⃣Перебор всех комбинаций
Для каждого числа от 0 до 2^n - 1 используйте его битовое представление для создания соответствующей аббревиатуры. Сканируйте число x побитово, извлекая его последний бит с помощью b = x & 1 и сдвигая x вправо на один бит x >>= 1.

😎 Решение:

class Solution {
    func generateAbbreviations(_ word: String) -> [String] {
        var ans = [String]()
        for x in 0..<(1 << word.count) {
            ans.append(abbr(word, x))
        }
        return ans
    }

    private func abbr(_ word: String, _ x: Int) -> String {
        var builder = ""
        var k = 0
        var x = x
        for i in 0..<word.count {
            if (x & 1) == 0 {
                if k != 0 {
                    builder += "\(k)"
                    k = 0
                }
                builder.append(word[word.index(word.startIndex, offsetBy: i)])
            } else {
                k += 1
            }
            x >>= 1
        }
        if k != 0 {
            builder += "\(k)"
        }
        return builder
    }
}

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

#easy
Задача: 405. Convert a Number to Hexadecimal

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

Пример:

Input: num = 26
Output: "1a"

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

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

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

3⃣Переверните строку результата и удалите ведущие нули, если они есть. Если строка пустая, верните "0".

😎 Решение:

func toHex(_ num: Int) -> String {
    if num == 0 {
        return "0"
    }
    let hexChars = "0123456789abcdef"
    var num = num
    if num < 0 {
        num += 1 << 32
    }
    var result = ""
    while num > 0 {
        result.append(hexChars[hexChars.index(hexChars.startIndex, offsetBy: num % 16)])
        num /= 16
    }
    return String(result.reversed())
}

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