Leetcode- хэш-таблица

242. Эффективное внематочной буквы слова  https://leetcode-cn.com/problems/valid-anagram/

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

Пример 1:

Входной сигнал: s = "анаграмма", т = "nagaram"
Выход: правда

Пример 2:

Входной сигнал: s = «крыса», т = «автомобиль»
Выход: ложное
Описание:
Можно предположить , строка содержит только строчные буквы.

Дополнительно:
Если входная строка содержит символы Юникода , как это сделать? Вы можете настроить решение для борьбы с этой ситуацией?

Решение:

S и т сортируются для сравнения отсортирован строку. O (NlogN)

класс Решение: 
    Защита isAnagram (сам, с: ул, т: ули) -> Bool: 
        возвращение отсортировано (s) == отсортирован (т)

  

Считает каждую букву строки с HashMap. O (N)

Решение имеет класс: 
    Защита ли isAnagram (я, s это: сделать что - то вроде ул, т является: сделать что - то вроде ул), -> для Его: 
        
        Защиты Are countaph (s есть) ,: 
            АФС = о Словаре есть (), 
            фото обугливается в, s является: 
                АФС, [символ] = aphsget (голец, у 0), +, fan_hui есть 0 # zhao_bu_dao на ключ джиу 1 
            рентабельность АФС 
        
        АФС = countaph (s есть), 
        apht = countaph (т является), 
        
        если в АФС == apht: 
            рентабельность Если установлено значение True , 
        возвращению в Ложные

   

1. Сумма двух чисел  https://leetcode-cn.com/problems/two-sum/

Дано целое число Nums массива и цель целевого значения, и прошу вас, чтобы определить целевое значение двух целых чисел в массиве, и вернуться в индекс массива.

Можно предположить, что каждый вход соответствует только один ответ. Тем не менее, вы не можете повторно использовать один и тот же элемент массива.

Решение:

Насилие решить, через все возможное первое число, второе число вложенной обходе. O (N 2 ), он может тайм - аут

Класс Решение: 
    Защита twoSum (самоповреждения, НУМС: Список [INT], цель: целое) -> Список [INT]: 
        если НУМС не None или LEN (НУМС) <= 1: 
            вернуться [] 
        п = LEN (Nums) 
        для г в диапазоне (N): 
            для J в диапазоне (+ 1, п): 
                если НУМС [I] + НУМС [J] == цель: 
                    возвращение [I, J] 
        возвращение []

  

Хэш-таблицы, у = целевой - х, перечислить х, у запроса. Вы можете пройти через то же самое время, чтобы сохранить хэш-таблицу, а затем перечислить на запрос х у.

Она также может быть сохранен во время прохождения хэш-таблицы, когда запрос немедленно. O (N).

Класс Решение: 
    Защита twoSum (самоповреждения, НУМС: Список [INT], цель: целое) -> Список [INT]: 
        если НУМС не None или LEN (НУМС) <= 1: 
            вернуться [] 
        п = LEN (НУМС) 
        посетил = ДИКТ () 
        для г в интервале (п): 
            посетил [Nums [я]] = я 
        
        для г в интервале (п): 
            у = мишени - Nums [я] , 
            если у в посещаемой и visited.get (у) = я! : # у在哈希表中且不重复利用同样的元素
                вернуться [я, visited.get (у)] 
        возвращение []

  

Класс Решение: 
    Защита twoSum (самоповреждения, НУМС: Список [INT], цель: целое) -> Список [INT]: 
        если НУМС не None или LEN (НУМС) <= 1: 
            вернуться [] 
        п = LEN (НУМС) 
        посетил = ДИКТ () 
        для г в интервале (п): 
            у = мишени - НУМС [я] , 
            если у в посещаемой и visited.get (у) = я: 
                вернуться [visited.get (у), я] #这时候就是索引я在后了
            посетил [НУМС [я]] = я 
        вернуться []

  

15. три числа Нориюки сумма  https://leetcode-cn.com/problems/3sum/

Учитывая НУМС массива п содержит целые числа, он определяет, есть ли три элемент, а, б, в НУМСЕ таким образом, что а + B + C = 0?, Удовлетворяющие условию не будут повторяться, чтобы идентифицировать все из троек.

Примечание: Ответ не может содержать повторяющиеся тройки.

Решение:

Насилие решить, три вложенные, O (N 3 ), не пишут.

х + у + г = цель, перечисление х, у, опять же хеш - таблица назначения запроса - х - у. O (N 2 )

Следующий код хранится на столе в хэш-метода, объясняется далее:

класс Решения: 
    DEF threeSum (Self, в НУМСЕ: Список [INT]) -> List [Список [INT]] 
        . If Len (в НУМСЕ) <3: 
            вернуться [] 
        
        nums.sort () # каких - то первый, чтобы облегчить тяжелые детерминации 
        Реза SET = () 
        
        для I, X в Перечислим (в НУМС [: -2]): 
            ЕСЛИ Я> = == х 1 и НУМС [1 -I.]: 
                Продолжить 
            # определяется для каждого х, у и найти г, деградация и количество вопросов в двух 
            D = {} 
            для у в НУМС [I + 1:.]: 
                если не в г д: 
                    . d [-XY] = d 1 # Если у не подходящего шаблона текущего Y Z ( т.е. -XY) в г памяти, так что если пройден в у д, то соответствующая г (т.е. -XY) d находится в постоянной, но НУМС [I + 1:] элементов и меньше , чем у 
                еще : 
                    res.add ((X, -XY, Y)) 
        возвращение List (Карта (Список, RES))

  

сортировать и находить, сортировать O (NlogN), в качестве первого элемента перечисления х, у и г найти остальную часть массива, то есть с обеих сторон , между которыми . O (N 2 ), без дополнительного пространства.

Класс Решение: 
    Защита threeSum (самоповреждения, НУМС: Список [INT]) -> Список [Список [INT]]: 
        если Len (НУМС) <3: 
            вернуться [] 
        Рез = [] 
        nums.sort () 
        п = LEN (НУМС ) 
        для я в диапазоне (п-2): 
            если я> 0 и НУМС [я] == НУМС [I-1]: #去重,如果第一个数相同,跳过
                продолжают 
            л, г = + 1 , п-1 , 
            а л <г: 
                s = НУМС [I] + НУМС [л] + НУМС [г] , 
                если s <0: 
                    L + = 1 
                Элиф s> 0: 
                    г - = 1 
                еще: 
                    res.append (( НУМС [I], НУМС [L], НУМС [г])) #记录解 
                    # предыскажений, если во- вторых, такой же , как третьего числа, пропустить
                    в то время как л <г и НУМС [л] == НУМС [L + 1]: 
                        L + = 1 , 
                    а л <г и НУМС [г] == НУМС [г-1]: 
                        г - = 1 
                    #继续找可能的解
                    L + = 1 
                    г = 1 - 
        возвратное разрешение

  

18. Номер четыре Нориюки сумма  https://leetcode-cn.com/problems/4sum/

Учитывая п массив целых чисел и цели-мишени НУМС, если есть четыре элемента, а, б, в, г и НУМС определяется таким образом, что A + B + C + D равно значению цели? Определить все удовлетворяют условия четырехугольника и не повторяется.

Примечание:

Ответ не может содержать дубликаты четырехугольника.

Решение:

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

класс Решение: 
    Защита fourSum (самость, НУМС: Список [INT], цель: целое) -> List [Список [INT]]: 
        если Len (Nums) <4: 
            вернуться [] 
        
        nums.sort () #先排序一下,便于判重
        Рез = множество () 
        п = Len (НУМС) 
        
        для г в интервале (п-3): 
            если я> 0 и НУМС [я] == НУМС [I-1]: 
                продолжить 
                
            для J в диапазоне (I + 1, п-2): 
                если J> я + 1 и НУМС [J] == НУМС [J-1]: 
                    продолжить 
                d = {} 
                для г в НУМС [J + 1]: 
                    если нет г в д: 
                        д [целевые-НУМС [я] -nums [J] -z] = 1 
                    еще:
                        res.add ((НУМС [I], НУМС [J], мишень-НУМС [I] -nums [J] -z, г)) 

        возвращение лист (карта (список, разреш))

  

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

класс Решение: 
    DEF fourSum (Self, в НУМС: Список [INT], цель: целое) -> List [Список [INT]] 
        . If Len (в НУМС) <4: 
            вернуться [] 
        RES = [] 
        nums.sort () 
        n- Len = (в НУМС) 
        для I в диапазоне (3-н.): 
            IF I> 0 и Nums [I] == НУМС [-I 1.]: # предыскажений, если же число первых, пропускаются 
                Продолжить 
            # обрезке если ток х и число оставшихся трех и больше , чем минимум или максимум количества мишени и менее предназначаться три, пропустить , 
            если НУМС [I] + сумма ( НУМС [+ 1: I + 4])> мишень в НУМС или [I] + SUM (в НУМС [-3:]) <цель: 
                Продолжить 
            
            для J в диапазоне (I + 1, N-2-.): 
                ЕСЛИ J>. I + 1 и НУМС [J] == в НУМС [J- 1]: # предыскажений, если же число первых, пропускаются 
                    продолжить
                в НУМС ПЧ [I] + в НУМС [J] + SUM (в НУМС [+ J. 1:. J + 3])> Цель: 
                    Продолжить 
                ЕСЛИ НУМС [I] + в НУМС [J] + SUM (в НУМС [-2:]) <цель : 
                    Продолжить 
                    
                L, R & л Д + = 1 ,. 1-н. 
                это время L <R & л: 
                    S = целевые-то НУМС [I] -nums [Дж] -nums [L] -nums [R & Lt] 
                    Если S <0: число около # большой и 
                        R & л - = 1. 
                    Элиф S> 0: 
                        L = 1 +. 
                    остальное: 
                        res.append ((в НУМС [I], в НУМС [J], то НУМС [L], то НУМС [R & Lt])) # записи решение 
                        # дедупликации Если второй, третий же числа, пропустить в 
                        то время л <г и НУМС [л ] == НУМС [L + 1]:
                            . = 1 + L
                        Л , а <R & л и НУМС [R & л] == в НУМС [-R & л 1.]: 
                            . Р & л - 1 = 
                        # возможных решений продолжают находить 
                        . L = 1 + 
                        . Р & л - = 1 
        возврата RES

  

49. В письме эктопической группировки слова  https://leetcode-cn.com/problems/group-anagrams/

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

Пример:

输入: [ "съесть", "чай", "загар", "съел", "НАТ", "Летучая мышь"],
输出:
[
[ "ели", "съесть", "чай"],
[ "нац", "загар"],
[ "летучая мышь"]
]
说明:

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

Решение:

# 242 расширений, примечание ДИКТ является unhashable не может быть использован в качестве еще одного ключевого словаря, поэтому здесь, чтобы определить, следует ли использовать слово внематочной отсортирован. O (NKlogK)

Класс Решение: 
    Защиту groupAnagrams (самостоятельно, СПО: Список [ул]) -> Список [Список [ул]]: 
        если Len (СПО) <= 1: 
            вернуться [СПО] 
        слова = Dict () 
        для х в STRs: 
            Key = кортежей (упорядоченные (s)) , 
            если не ввести в словах: 
                слова [ключ] = [s] 
            еще: 
                слова [ключ] .append (s) 
        возвращение списка (words.values ())

  

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

Класс Решение: 
    Защиту groupAnagrams (самостоятельно, СПО: Список [ул]) -> Список [Список [ул]]: 
        если Len (STR) , <= 1: 
            вернуться [СПО] 
        слова = Dict () 
        для х в STRs: 
            кол = [0] * 26 
            для с в с: 
                кол [Ord (с) - Ord ( 'а')] + = 1 #避免了用字典
            ключ = кортежа (количество) , 
            если не ключ в словах: 
                слова [ключ] = [ s] 
            еще: 
                слова [ключ] .append (s) 
        возвращение списка (words.values ())

  

 

рекомендация

отwww.cnblogs.com/chaojunwang-ml/p/11353656.html